Build a node based voice agent editor with Node.js

git clone https://github.com/MiraiMinds/node-flow-builder.git
cd node-flow-builder
npm ci
cp .env.example .env
npm run dev

MIRAI_MODE=live
MIRAI_API_KEY=your_workspace_key
MIRAI_BASE_URL=https://sandbox.voice.miraiminds.co

import { createMiraiClient } from "./server/mirai.js";
import { example, exampleTool, exampleVariables } from "./shared/example.js";

const client = createMiraiClient({
  baseUrl: process.env.MIRAI_BASE_URL || "https://sandbox.voice.miraiminds.co",
  apiKey: process.env.MIRAI_API_KEY,
});
const api = async (method, path, body, key) =>
  (await client(method, `/v2${path}`, body, key)).body;

const flow = {
  nodes: [
    {
      id: "hello",
      type: "startCall",
      position: { x: 0, y: 100 },
      data: {
        name: "Say hello",
        greeting: "Hello {{customer_name}}, how can I help with your delivery?",
        prompt:
          "Find out what delivery help the caller needs. Ask one question at a time.",
      },
    },
    {
      id: "delivery",
      type: "agentNode",
      position: { x: 360, y: 100 },
      data: {
        name: "Check delivery",
        prompt:
          "Ask for an order number. If lookup_order is available, use it and explain the returned status. Otherwise explain that a lookup is not configured. Never invent a status.",
        tools: [],
        extraction_enabled: true,
        extraction_variables: [
          {
            name: "needs_follow_up",
            type: "boolean",
            prompt: "True if the caller still needs help with the delivery.",
          },
        ],
      },
    },
    {
      id: "goodbye",
      type: "endCall",
      position: { x: 720, y: 100 },
      data: {
        name: "Finish",
        prompt: "Thank the caller and say goodbye briefly.",
      },
    },
  ],
  edges: [
    {
      id: "help",
      source: "hello",
      target: "delivery",
      data: {
        label: "check_delivery",
        condition: "The caller wants help with a delivery.",
      },
    },
    {
      id: "skip",
      source: "hello",
      target: "goodbye",
      data: {
        label: "finish_greeting",
        condition: "The caller needs no help or wants to end the call.",
      },
    },
    {
      id: "done",
      source: "delivery",
      target: "goodbye",
      data: {
        label: "finish_delivery",
        condition:
          "The question is answered, follow-up is needed, or the caller wants to stop.",
      },
    },
  ],
};

const toApiGraph = (nodes, edges) => ({
  nodes: nodes.map(({ id, type, position, data }) => ({
    id,
    type,
    position,
    data,
  })),
  edges: edges.map(({ id, source, target, data }) => ({
    id,
    source,
    target,
    data,
  })),
});

const validation = await api("POST", "/agents/flow/validate", flow);
// { ok: true, flow_revision: "…", nodes: 3, edges: 3 }

let agent = await api("POST", "/agents", {
  name: "Delivery check-in",
  language: "en",
  voice: { voice_id: "neha", language: "en" },
  draft: true,
  input_schema: example.input_schema,
  tools: [],
  flow,
});
console.log(agent.id, agent.revision);

curl --fail-with-body "$MIRAI_BASE_URL/v2/agents" \
  -H "Authorization: Bearer $MIRAI_API_KEY" \
  -H 'Content-Type: application/json' \
  --data-binary @mirai-agent.json

const editedFlow = structuredClone(agent.flow);
editedFlow.nodes.find((node) => node.id === "delivery").data.prompt +=
  " Repeat the order number back before looking it up.";

agent = await api("PATCH", `/agents/${agent.id}`, {
  if_revision: agent.revision,
  flow: editedFlow,
});

const view = await api("GET", `/agents/${agent.id}/flow`);
// view.agent_revision is numeric; view.flow_revision is a graph hash.
agent = await api(
  "PUT",
  `/agents/${agent.id}/flow?if_revision=${view.agent_revision}`,
  view.flow,
);

await api("PUT", "/secrets/order_service_token", {
  value: process.env.TOOL_SHARED_SECRET,
});

const lookupOrder = structuredClone(exampleTool);
lookupOrder.request.url =
  "https://your-public-tool-host.example/tools/lookup-order";
lookupOrder.request.headers = {
  Authorization: "Bearer {{ secrets.order_service_token }}",
};

const withTool = structuredClone(agent.flow);
withTool.nodes.find((node) => node.id === "delivery").data.tools = [
  "lookup_order",
];
agent = await api("PATCH", `/agents/${agent.id}`, {
  if_revision: agent.revision,
  tools: [
    ...agent.tools.filter((tool) => tool.name !== "lookup_order"),
    lookupOrder,
  ],
  flow: withTool,
});

const receipt = await api(
  "POST",
  `/agents/${agent.id}/tools/lookup_order/test`,
  {
    vars: exampleVariables,
    args: { order_id: "DEMO-1042" },
  },
);
console.log(receipt);

agent = await api("PATCH", `/agents/${agent.id}`, {
  if_revision: agent.revision,
  input_schema: {
    type: "object",
    properties: {
      customer_name: { type: "string", default: "there" },
      order_id: { type: "string", default: "" },
    },
    additionalProperties: false,
  },
});

const variables = { customer_name: "Sam", order_id: "DEMO-1042" };
const preview = await api("POST", `/agents/${agent.id}/preview`, { variables });
console.log(preview.variables);

agent = await api("POST", `/agents/${agent.id}/publish`, {
  if_revision: agent.revision,
});
console.log(agent.revision, agent.draft); // new revision, false

const page = await api("GET", "/phone-numbers");
console.log(page.data);
// Follow page.next_cursor when page.has_more is true.

const integration = await api("POST", "/telephony/connections", {
  provider: "plivo",
  name: "Delivery support",
  auth_id: process.env.PLIVO_AUTH_ID,
  auth_token: process.env.PLIVO_AUTH_TOKEN,
});
const inventory = await api(
  "GET",
  `/telephony/connections/${integration.id}/numbers`,
);
console.log(inventory.data);

// Use a number returned by that inventory, in E.164 format.
let number = await api("POST", "/phone-numbers", {
  connection_id: integration.id,
  number: process.env.PLIVO_NUMBER,
});

// Or fetch an existing number: GET /v2/phone-numbers/{id}.
number = await api("PATCH", `/phone-numbers/${number.id}`, {
  version: number.version,
  agent_id: agent.id,
});

if (number.state !== "ready" || number.connection_state !== "verified") {
  number = await api("POST", `/phone-numbers/${number.id}/activate`, {
    version: number.version,
    replace_existing_application: false,
  });
}

const callBody = {
  agent_id: agent.id,
  agent_revision: agent.revision,
  phone_number_id: number.id, // Omit for the platform default route.
  channel: "phone",
  to: process.env.TEST_PHONE_NUMBER,
  variables,
  max_duration_secs: 120,
  recording_enabled: false,
  final_results: true,
};

// Persist both values BEFORE sending in a hosted application.
const idempotencyKey = crypto.randomUUID();
const call = await api("POST", "/calls", callBody, idempotencyKey);
console.log(call.id, call.status);

const result = await api("GET", `/calls/${call.id}`);
const toolRuns = await api("GET", `/calls/${call.id}/tool_runs`);
console.log(result.status, result.flow, toolRuns.data);