@agentproto/adapter-mastra-agent 0.5.5 → 0.6.0

package/dist/{chunk-6ILIPWNM.mjs → chunk-BOEMDDBC.mjs}

@@ -17,6 +17,8 @@ import { ProviderHistoryCompat } from '@mastra/core/processors';
 import { AgentController } from '@mastra/core/agent-controller';
 import { Workspace } from '@mastra/core/workspace';
 import { createNotificationInboxTool } from '@mastra/core/notifications';
+import { Client } from '@modelcontextprotocol/sdk/client/index.js';
+import { StreamableHTTPClientTransport } from '@modelcontextprotocol/sdk/client/streamableHttp.js';
 import { SignalProvider } from '@mastra/core/signals';
 import { PROTOCOL_VERSION, ndJsonStream, AgentSideConnection } from '@agentclientprotocol/sdk';
 import { Writable, Readable } from 'stream';
@@ -787,6 +789,61 @@ function resolveMastraModel(ref, env = process.env) {
   }
   return modelId;
 }
+async function connectDaemonMcpClient(opts = {}) {
+  const endpoint = await discoverDaemonEndpoint(opts);
+  if (!endpoint) throw new DaemonNotFoundError();
+  const env = opts.env ?? process.env;
+  const url = new URL(`${endpoint.url}/mcp`);
+  if (env.AGENTPROTO_SESSION_ID) url.searchParams.set("callerSessionId", env.AGENTPROTO_SESSION_ID);
+  const client = new Client({ name: "agentproto-mastra-agent", version: "0.1.0" }, { capabilities: {} });
+  const transport = new StreamableHTTPClientTransport(url, {
+    ...endpoint.token ? { requestInit: { headers: { authorization: `Bearer ${endpoint.token}` } } } : {}
+  });
+  await client.connect(transport);
+  return client;
+}
+async function listDaemonMcpTools(client) {
+  const { tools } = await client.listTools();
+  return tools.map((t) => ({
+    name: t.name,
+    ...t.description !== void 0 ? { description: t.description } : {},
+    inputSchema: t.inputSchema ?? { type: "object" }
+  }));
+}
+function injectAppId(toolName, args, appId) {
+  if (!appId) return args;
+  if (!toolName.startsWith("app_")) return args;
+  if (args.appId !== void 0) return args;
+  return { ...args, appId };
+}
+function relaxAppIdRequirement(inputSchema, toolName, appId) {
+  if (!appId || !toolName.startsWith("app_")) return inputSchema;
+  if (!Array.isArray(inputSchema.required) || !inputSchema.required.includes("appId")) return inputSchema;
+  return { ...inputSchema, required: inputSchema.required.filter((id) => id !== "appId") };
+}
+function extractText(content) {
+  if (!Array.isArray(content)) return "";
+  return content.filter(
+    (block) => !!block && typeof block === "object" && block.type === "text" && typeof block.text === "string"
+  ).map((block) => block.text).join("\n");
+}
+function makeDaemonMcpProxyTool(def, opts) {
+  const config = {
+    id: def.name,
+    description: def.description ?? `Daemon tool "${def.name}", proxied via the daemon's MCP gateway.`,
+    inputSchema: relaxAppIdRequirement(def.inputSchema, def.name, opts.appId),
+    execute: async (input) => {
+      const client = await opts.getClient();
+      const args = injectAppId(def.name, input ?? {}, opts.appId);
+      const result = await client.callTool({ name: def.name, arguments: args });
+      if (result.isError) {
+        throw new Error(`daemon tool "${def.name}" failed: ${extractText(result.content) || "(no error detail)"}`);
+      }
+      return result.structuredContent ?? extractText(result.content);
+    }
+  };
+  return createTool(config);
+}
 var WATCHED_EVENT_KINDS = [
   "turn-end",
   "error",
@@ -1431,6 +1488,26 @@ function makeAgentFactory(opts = {}) {
       allowExec: opts.allowExec,
       extraTools: opts.extraTools
     });
+    const modesEnabled = opts.modes !== false && !envFlag(process.env.AGENTPROTO_MASTRA_NO_MODES);
+    const daemonClient = new DaemonClient({ cwd });
+    const daemonSubAgentTools = modesEnabled ? makeDaemonTools({ client: daemonClient }) : {};
+    let daemonMcpClient;
+    let daemonMcpToolDefsPromise;
+    const resolvedDaemonMcpTools = {};
+    const appId = opts.appId ?? process.env.AGENTPROTO_APP_ID;
+    async function getDaemonMcpToolDefs() {
+      if (!daemonMcpToolDefsPromise) {
+        daemonMcpToolDefsPromise = (async () => {
+          try {
+            daemonMcpClient = opts.daemonMcp?.client ?? await connectDaemonMcpClient({ cwd, ...opts.daemonMcp?.discoverOptions });
+            return await listDaemonMcpTools(daemonMcpClient);
+          } catch {
+            return [];
+          }
+        })();
+      }
+      return daemonMcpToolDefsPromise;
+    }
     const store = buildSqliteStore();
     let memory;
     const historyCompat = new ProviderHistoryCompat({
@@ -1439,21 +1516,38 @@ function makeAgentFactory(opts = {}) {
     const { agent } = await buildMastraAgent(handle, {
       inputProcessors: [historyCompat],
       resolveModel: (ref) => resolveMastraModel(ref),
-      // Match each declared tool ref against the workspace toolset by id. A
-      // ref with no matching executor still resolves — to a stub that fails
-      // fast and clearly on call — rather than being dropped: a dropped ref
-      // leaves the model unable to see it at all, and (if the model still
-      // tries the name from AGENT.md prose) surfaces as an opaque provider
-      // NoSuchToolError this adapter's ACP layer silently swallows (see
-      // tool-call-map.ts), which is how a declared-but-unwired tool used to
-      // hang a turn with zero recorded tool calls instead of failing fast.
-      resolveTool: (ref) => {
+      // Match each declared tool ref, in order: the workspace toolset, the
+      // curated daemon sub-agent tools, then (modes-on only) the generic
+      // daemon MCP proxy — ONLY for a ref an AGENT.md actually declares,
+      // which is what keeps the proxy an allowlist rather than a blanket
+      // grant of the daemon's whole toolset. A ref matching none of those
+      // still resolves — to a stub that fails fast and clearly on call —
+      // rather than being dropped: a dropped ref leaves the model unable to
+      // see it at all, and (if the model still tries the name from AGENT.md
+      // prose) surfaces as an opaque provider NoSuchToolError this adapter's
+      // ACP layer silently swallows (see tool-call-map.ts), which is how a
+      // declared-but-unwired tool used to hang a turn with zero recorded
+      // tool calls instead of failing fast.
+      resolveTool: async (ref) => {
         const id = toolRefId(ref);
         if (!id) return void 0;
-        const tool = workspaceTools[id];
-        if (tool) return { name: id, tool };
+        const workspaceTool = workspaceTools[id];
+        if (workspaceTool) return { name: id, tool: workspaceTool };
+        const daemonSubAgentTool = daemonSubAgentTools[id];
+        if (daemonSubAgentTool) return { name: id, tool: daemonSubAgentTool };
+        if (modesEnabled) {
+          const def = (await getDaemonMcpToolDefs()).find((d) => d.name === id);
+          if (def) {
+            const tool = makeDaemonMcpProxyTool(def, {
+              getClient: async () => daemonMcpClient,
+              ...appId !== void 0 ? { appId } : {}
+            });
+            resolvedDaemonMcpTools[id] = tool;
+            return { name: id, tool };
+          }
+        }
         console.warn(
-          `[@agentproto/adapter-mastra-agent] agent '${handle.id}' declares tool '${id}' but no executor is wired for it in this adapter's workspace toolset \u2014 calls to it will fail immediately instead of hanging. Wire it in workspace-tools.ts or pass it via extraTools.`
+          `[@agentproto/adapter-mastra-agent] agent '${handle.id}' declares tool '${id}' but no executor is wired for it (not in the workspace toolset, the daemon sub-agent tools, or the daemon's own MCP tool list) \u2014 calls to it will fail immediately instead of hanging. Wire it in workspace-tools.ts, pass it via extraTools, or expose it from the daemon.`
         );
         return { name: id, tool: makeUnwiredToolStub(id) };
       },
@@ -1461,12 +1555,10 @@ function makeAgentFactory(opts = {}) {
       // The markdown body is the agent's primary system prompt (AIP-42).
       body
     });
-    const modesEnabled = opts.modes !== false && !envFlag(process.env.AGENTPROTO_MASTRA_NO_MODES);
     const { modes, defaultModeId } = modesEnabled ? resolveModes(body) : { modes: [{ id: "main", metadata: { default: true } }], defaultModeId: "main" };
     let tools = workspaceTools;
     if (modesEnabled) {
-      const daemonClient = new DaemonClient({ cwd });
-      tools = { ...workspaceTools, ...makeDaemonTools({ client: daemonClient }) };
+      tools = { ...workspaceTools, ...daemonSubAgentTools, ...resolvedDaemonMcpTools };
       const signalProvider = new AgentprotoSignalProvider({
         client: daemonClient,
         stateEmitter: new DaemonStateEmitter({ client: daemonClient, cwd })
@@ -2091,5 +2183,5 @@ function runAcpOverStdio(buildController) {
 }
 
 export { DEFAULT_MODEL, DEFAULT_MODEL_CATALOG, DEFAULT_TOOL_IDS, DISABLED_BUILTIN_TOOL_IDS, DaemonClient, DaemonHttpError, DaemonNotFoundError, MastraAcpAgent, buildSqliteMemory, buildSqliteStore, createEventMapper, defaultAgentManifest, discoverDaemonEndpoint, makeAgentFactory, makeDaemonTools, makeWorkspaceTools, messageText, modelRefToString, promptContent, promptText, providerOf, resolveInCwd, resolveMastraModel, resolveMemoryDbPath, runAcpOverStdio, toolCallTitle, toolKindFor };
-//# sourceMappingURL=chunk-6ILIPWNM.mjs.map
-//# sourceMappingURL=chunk-6ILIPWNM.mjs.map
+//# sourceMappingURL=chunk-BOEMDDBC.mjs.map
+//# sourceMappingURL=chunk-BOEMDDBC.mjs.map