@absolutejs/voice 0.0.22-beta.520 → 0.0.22-beta.522

package/dist/index.d.ts

@@ -71,6 +71,8 @@ export { createVoiceSessionListRoutes, createVoiceSessionReplayHTMLHandler, crea
 export { createVoiceAgent, createVoiceAgentSquad, createVoiceAgentTool, } from "./agent";
 export { createPersonaVoiceCaller, createScriptedVoiceCaller, renderVoiceSimulationTranscript, runVoiceConversationSimulation, } from "./conversationSimulator";
 export type { RunVoiceConversationSimulationInput, VoiceConversationSimulationEndedReason, VoiceConversationSimulationResult, VoicePersonaCallerCompletion, VoiceScriptedCallerStep, VoiceSimulatedSpeaker, VoiceSimulatedTurn, VoiceSimulatorCaller, VoiceSimulatorCallerModel, VoiceSimulatorCallerReply, } from "./conversationSimulator";
+export { createVoiceMCPToolset } from "./mcpToolset";
+export type { CreateVoiceMCPToolsetOptions, MCPClientLike, MCPToolCallResult, MCPToolContentBlock, MCPToolDefinition, VoiceMCPToolResult, } from "./mcpToolset";
 export { createAIVoiceModel } from "./aiVoiceModel";
 export type { CreateAIVoiceModelOptions } from "./aiVoiceModel";
 export { createVoiceAIJudgeCompletion, createVoiceLLMJudge, } from "./llmJudge";
@@ -353,6 +355,8 @@ export { compileVoicePathwayToAssistant } from "./pathwayCompiler";
 export type { CompileVoicePathwayOptions, VoicePathwayCompiledAssistant, VoicePathwayCompilerToolDefinition, } from "./pathwayCompiler";
 export { renderVoicePathwayMermaid, renderVoicePathwayText, visualizeVoicePathway, } from "./pathwayVisualizer";
 export type { VoicePathwayVisualization } from "./pathwayVisualizer";
+export { generateVoicePathwayFromPrompt } from "./pathwayGenerator";
+export type { GenerateVoicePathwayInput, GenerateVoicePathwayResult, VoicePathwayGeneratorCompletion, } from "./pathwayGenerator";
 export { createVoiceCRMRegistry } from "./crmContract";
 export type { CreateVoiceCRMRegistryOptions, VoiceCRMCallActivityInput, VoiceCRMContactSummary, VoiceCRMContract, VoiceCRMLeadInput, VoiceCRMNoteInput, VoiceCRMRegistry, VoiceCRMTaskInput, } from "./crmContract";
 export { createInMemoryVoiceCallerCRMLinkCache, createVoiceCallerCRMLinker, } from "./callerCRMLinker";

package/dist/index.js

@@ -35415,6 +35415,52 @@ Respond with only your spoken line. When your goal is met or you want to hang up
     persona: options.persona
   };
 };
+// src/mcpToolset.ts
+var flattenContent = (result) => {
+  const blocks = result.content ?? [];
+  const text = blocks.filter((block) => block.type === "text" && typeof block.text === "string").map((block) => block.text).join(`
+`).trim();
+  if (text.length > 0)
+    return text;
+  if (result.structuredContent !== undefined) {
+    return JSON.stringify(result.structuredContent);
+  }
+  return "";
+};
+var createVoiceMCPToolset = async (options) => {
+  const prefix = options.namePrefix ?? "";
+  const allowed = options.allowedTools ? new Set(options.allowedTools) : undefined;
+  const blocked = options.blockedTools ? new Set(options.blockedTools) : undefined;
+  const listed = await Promise.resolve(options.client.listTools());
+  const tools = [];
+  for (const definition of listed.tools) {
+    if (allowed && !allowed.has(definition.name))
+      continue;
+    if (blocked && blocked.has(definition.name))
+      continue;
+    const exposedName = `${prefix}${definition.name}`;
+    tools.push(createVoiceAgentTool({
+      ...definition.description !== undefined ? { description: definition.description } : {},
+      execute: async ({ args }) => {
+        const raw = await Promise.resolve(options.client.callTool({
+          arguments: args,
+          name: definition.name
+        }));
+        const result = {
+          isError: raw.isError === true,
+          raw,
+          text: flattenContent(raw),
+          ...raw.structuredContent !== undefined ? { structuredContent: raw.structuredContent } : {}
+        };
+        return result;
+      },
+      name: exposedName,
+      ...definition.inputSchema !== undefined ? { parameters: definition.inputSchema } : {},
+      resultToMessage: options.resultToMessage ?? ((result) => result.isError ? `Tool error: ${result.text || "unknown error"}` : result.text || "(no output)")
+    }));
+  }
+  return tools;
+};
 // src/aiVoiceModel.ts
 var toProviderMessages = (messages) => {
   const out = [];
@@ -51531,6 +51577,119 @@ var visualizeVoicePathway = (pathway) => ({
   mermaid: renderVoicePathwayMermaid(pathway),
   text: renderVoicePathwayText(pathway)
 });
+// src/pathwayGenerator.ts
+var SYSTEM_PROMPT = `You design conversation pathways for voice agents as strict JSON.
+
+A pathway is a state machine. Output ONLY a JSON object with this shape:
+{
+  "id": "kebab-case-id",
+  "label": "Human readable label",
+  "entryStateId": "<id of the first state>",
+  "slots": [
+    { "id": "slot_id", "type": "string|number|boolean|date|time|phone|email|currency|choice", "prompt": "what to ask", "required": true, "choices": ["a","b"] }
+  ],
+  "states": [
+    {
+      "id": "state_id",
+      "label": "Label",
+      "kind": "entry|collect|branch|action|terminal",
+      "actions": [
+        { "kind": "say", "text": "..." },
+        { "kind": "collect-slot", "slotId": "slot_id" },
+        { "kind": "call-tool", "toolId": "tool_id", "argsFromSlots": ["slot_id"] },
+        { "kind": "transfer", "destination": "..." },
+        { "kind": "end-call", "reason": "..." }
+      ],
+      "transitions": [
+        { "to": "next_state", "condition": { "kind": "always" } },
+        { "to": "x", "condition": { "kind": "slot-filled", "slotId": "slot_id" } },
+        { "to": "y", "condition": { "kind": "slot-equals", "slotId": "slot_id", "value": "yes" } },
+        { "to": "z", "condition": { "kind": "fallback" } }
+      ]
+    }
+  ],
+  "tools": [ { "id": "tool_id", "description": "..." } ]
+}
+
+Hard rules:
+- Exactly one entry state; entryStateId must reference a real state.
+- At least one terminal state (kind "terminal" or a state with no transitions) must be reachable from entry.
+- Every transition "to" must reference a defined state id.
+- Every slotId referenced in actions/conditions must be defined in "slots".
+- A "fallback" transition, if present, must be the LAST transition in its state.
+- Do not invent extra fields. Output JSON only \u2014 no prose, no markdown fences.`;
+var slugify = (value) => value.toLowerCase().trim().replace(/[^a-z0-9]+/gu, "-").replace(/^-+|-+$/gu, "").slice(0, 60) || "generated-pathway";
+var extractJson4 = (raw) => {
+  const trimmed = raw.trim();
+  if (!trimmed)
+    throw new Error("Pathway generator returned an empty response");
+  const fenced = /```(?:json)?\s*([\s\S]*?)```/iu.exec(trimmed);
+  const candidate = fenced ? fenced[1].trim() : trimmed;
+  try {
+    return JSON.parse(candidate);
+  } catch {
+    const start = candidate.indexOf("{");
+    const end = candidate.lastIndexOf("}");
+    if (start >= 0 && end > start) {
+      return JSON.parse(candidate.slice(start, end + 1));
+    }
+    throw new Error(`Pathway generator response was not valid JSON: ${raw.slice(0, 200)}`);
+  }
+};
+var coercePathway = (parsed, fallbackId) => {
+  if (!parsed || typeof parsed !== "object") {
+    throw new Error("Pathway generator response is not a JSON object");
+  }
+  const root = parsed;
+  return {
+    entryStateId: String(root.entryStateId ?? ""),
+    id: typeof root.id === "string" && root.id.length > 0 ? root.id : fallbackId,
+    label: String(root.label ?? "Generated pathway"),
+    slots: Array.isArray(root.slots) ? root.slots : [],
+    states: Array.isArray(root.states) ? root.states : [],
+    ...Array.isArray(root.tools) ? { tools: root.tools } : {},
+    ...root.metadata && typeof root.metadata === "object" ? { metadata: root.metadata } : {}
+  };
+};
+var generateVoicePathwayFromPrompt = async (input) => {
+  const fallbackId = input.id ?? slugify(input.description);
+  const maxRepairs = input.maxRepairAttempts ?? 2;
+  const systemPrompt = input.guidance ? `${SYSTEM_PROMPT}
+
+Additional guidance:
+${input.guidance}` : SYSTEM_PROMPT;
+  const rawOutputs = [];
+  let lastReport = null;
+  let lastPathway = null;
+  for (let attempt = 0;attempt <= maxRepairs; attempt += 1) {
+    const prompt = attempt === 0 ? `Build a voice pathway for:
+${input.description}
+
+Suggested id: ${fallbackId}` : `The previous pathway JSON failed validation with these errors:
+${lastReport.issues.filter((issue) => issue.severity === "error").map((issue) => `- ${issue.message}`).join(`
+`)}
+
+Here was your previous output:
+${rawOutputs.at(-1)}
+
+Return a corrected pathway JSON that fixes every error.`;
+    const raw = await input.completion({ prompt, systemPrompt });
+    rawOutputs.push(raw);
+    const pathway = coercePathway(extractJson4(raw), fallbackId);
+    const report = validateVoicePathway(pathway);
+    lastReport = report;
+    lastPathway = pathway;
+    if (report.valid) {
+      return { attempts: attempt + 1, pathway, rawOutputs, report };
+    }
+  }
+  return {
+    attempts: rawOutputs.length,
+    pathway: lastPathway,
+    rawOutputs,
+    report: lastReport
+  };
+};
 // src/crmContract.ts
 var createVoiceCRMRegistry = (options) => {
   const byVendor = new Map;
@@ -51970,6 +52129,7 @@ export {
   getLatestVoiceTelephonyMediaReport,
   getLatestVoiceBrowserMediaReport,
   getDefaultVoiceTelephonyBenchmarkScenarios,
+  generateVoicePathwayFromPrompt,
   generateVoiceCalendarSlots,
   fromVapiAssistantConfig,
   formatVoiceProofTrendAge,
@@ -52275,6 +52435,7 @@ export {
   createVoiceMemoryAuditEventStore,
   createVoiceMemoryAssistantMemoryStore,
   createVoiceMediaPipelineRoutes,
+  createVoiceMCPToolset,
   createVoiceLiveOpsRoutes,
   createVoiceLiveOpsController,
   createVoiceLiveMonitorRoutes,

package/dist/mcpToolset.d.ts

@@ -0,0 +1,58 @@
+import { type VoiceAgentTool } from "./agent";
+import type { VoiceSessionRecord } from "./types";
+/**
+ * Minimal structural shapes from the Model Context Protocol. Any MCP client
+ * (`@modelcontextprotocol/sdk` over stdio / SSE / streamable-HTTP, or a custom
+ * transport) that exposes `listTools` + `callTool` satisfies this — voice does
+ * not bundle an MCP SDK.
+ */
+export type MCPToolDefinition = {
+    name: string;
+    description?: string;
+    inputSchema?: Record<string, unknown>;
+};
+export type MCPToolContentBlock = {
+    type: "text";
+    text: string;
+} | {
+    type: string;
+    [key: string]: unknown;
+};
+export type MCPToolCallResult = {
+    content?: MCPToolContentBlock[];
+    structuredContent?: unknown;
+    isError?: boolean;
+};
+export type MCPClientLike = {
+    listTools: () => Promise<{
+        tools: MCPToolDefinition[];
+    }> | {
+        tools: MCPToolDefinition[];
+    };
+    callTool: (input: {
+        name: string;
+        arguments?: Record<string, unknown>;
+    }) => Promise<MCPToolCallResult> | MCPToolCallResult;
+};
+export type VoiceMCPToolResult = {
+    text: string;
+    structuredContent?: unknown;
+    isError: boolean;
+    raw: MCPToolCallResult;
+};
+export type CreateVoiceMCPToolsetOptions = {
+    client: MCPClientLike;
+    /** Prefix applied to every exposed tool name (e.g. "mcp_"). */
+    namePrefix?: string;
+    /** Only expose tools whose (unprefixed) name is in this allow-list. */
+    allowedTools?: ReadonlyArray<string>;
+    /** Drop tools whose (unprefixed) name is in this block-list. */
+    blockedTools?: ReadonlyArray<string>;
+    /** Override how an MCP result is flattened to the assistant-visible string. */
+    resultToMessage?: (result: VoiceMCPToolResult) => string;
+};
+/**
+ * Bridges the tools exposed by an MCP server into `VoiceAgentTool`s. Call once
+ * at setup; the returned array spreads straight into `createVoiceAgent({ tools })`.
+ */
+export declare const createVoiceMCPToolset: <TContext = unknown, TSession extends VoiceSessionRecord = VoiceSessionRecord>(options: CreateVoiceMCPToolsetOptions) => Promise<VoiceAgentTool<TContext, TSession, Record<string, unknown>, VoiceMCPToolResult>[]>;

package/dist/pathwayGenerator.d.ts

@@ -0,0 +1,27 @@
+import { type VoicePathway, type VoicePathwayValidationReport } from "./pathway";
+export type VoicePathwayGeneratorCompletion = (input: {
+    prompt: string;
+    systemPrompt: string;
+}) => Promise<string>;
+export type GenerateVoicePathwayInput = {
+    /** Plain-text description of the agent / flow to build. */
+    description: string;
+    completion: VoicePathwayGeneratorCompletion;
+    /** Suggested pathway id (slugified). Defaults to "generated-pathway". */
+    id?: string;
+    /** Extra guidance appended to the system prompt. */
+    guidance?: string;
+    /**
+     * If the first attempt fails validation, retry this many times feeding the
+     * issues back to the model. Defaults to 2.
+     */
+    maxRepairAttempts?: number;
+};
+export type GenerateVoicePathwayResult = {
+    pathway: VoicePathway;
+    report: VoicePathwayValidationReport;
+    attempts: number;
+    /** Raw model outputs from each attempt, for debugging. */
+    rawOutputs: string[];
+};
+export declare const generateVoicePathwayFromPrompt: (input: GenerateVoicePathwayInput) => Promise<GenerateVoicePathwayResult>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@absolutejs/voice",
-  "version": "0.0.22-beta.520",
+  "version": "0.0.22-beta.522",
   "description": "Voice primitives and Elysia plugin for AbsoluteJS",
   "repository": {
     "type": "git",