@absolutejs/voice 0.0.22-beta.521 → 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";

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 = [];
@@ -52389,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/package.json

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