@agentproto/adapter-mastra-agent 0.5.5 → 0.7.0

package/dist/{chunk-6ILIPWNM.mjs → chunk-2FKFITFT.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';
@@ -334,6 +336,19 @@ function makeWorkspaceTools(opts) {
   const cwd = resolve(opts.cwd);
   const allowExec = opts.allowExec ?? true;
   const execTimeoutMs = opts.execTimeoutMs ?? 12e4;
+  const additionalReadPaths = new Set(
+    (opts.additionalReadPaths ?? []).filter(isAbsolute).map((p) => resolve(p))
+  );
+  const resolveForWrite = (p) => resolveInCwd(cwd, p);
+  const resolveForRead = (p) => {
+    try {
+      return resolveInCwd(cwd, p);
+    } catch (err) {
+      const target = isAbsolute(p) ? resolve(p) : resolve(cwd, p);
+      if (additionalReadPaths.has(target)) return target;
+      throw err;
+    }
+  };
   const execEnv = { ...process.env, GIT_CEILING_DIRECTORIES: resolve(cwd, "..") };
   const guard = (id, execute) => withTimeoutGuard(id, execTimeoutMs, execute);
   const doListDir = async (input) => {
@@ -344,11 +359,11 @@ function makeWorkspaceTools(opts) {
     };
   };
   const doReadFile = async (input) => {
-    const file = resolveInCwd(cwd, input.path);
+    const file = resolveForRead(input.path);
     return { content: await promises.readFile(file, "utf8") };
   };
   const doWriteFile = async (input) => {
-    const file = resolveInCwd(cwd, input.path);
+    const file = resolveForWrite(input.path);
     await promises.mkdir(resolve(file, ".."), { recursive: true });
     await promises.writeFile(file, input.content, "utf8");
     return { path: input.path, bytes: Buffer.byteLength(input.content, "utf8") };
@@ -419,7 +434,7 @@ function makeWorkspaceTools(opts) {
     }),
     outputSchema: z.object({ path: z.string(), replaced: z.boolean() }),
     execute: guard("edit_file", async (input) => {
-      const file = resolveInCwd(cwd, input.path);
+      const file = resolveForWrite(input.path);
       const current = await promises.readFile(file, "utf8");
       const count = current.split(input.old_string).length - 1;
       if (count === 0) throw new Error(`old_string not found in '${input.path}'.`);
@@ -445,7 +460,7 @@ function makeWorkspaceTools(opts) {
       created: z.string()
     }),
     execute: guard("file_info", async (input) => {
-      const abs = resolveInCwd(cwd, input.path);
+      const abs = resolveForRead(input.path);
       const info = await promises.stat(abs);
       return {
         name: abs.split(sep).pop() ?? input.path,
@@ -552,7 +567,7 @@ function makeWorkspaceTools(opts) {
       outputSchema: z.object({ diff: z.string() }),
       execute: guard("read_diff", async (input) => {
         const relPaths = (input.paths ?? []).map((p) => {
-          const abs = resolveInCwd(cwd, p);
+          const abs = resolveForRead(p);
           return relative(cwd, abs) || ".";
         });
         const args = [
@@ -583,7 +598,7 @@ function makeWorkspaceTools(opts) {
       outputSchema: z.object({ applied: z.boolean(), output: z.string() }),
       execute: guard("apply_patch", async (input) => {
         for (const p of extractPatchPaths(input.patch)) {
-          resolveInCwd(cwd, p);
+          resolveForWrite(p);
         }
         const patchFile = join(tmpdir(), `mastra-agent-patch-${randomUUID()}.diff`);
         await promises.writeFile(patchFile, input.patch, "utf8");
@@ -787,6 +802,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",
@@ -1352,6 +1422,18 @@ var DEFAULT_TOOL_IDS = [
 function envFlag(value) {
   return Boolean(value);
 }
+function parseAdditionalReadPathsEnv(env = process.env) {
+  const raw = env.AGENTPROTO_ADDITIONAL_READ_PATHS;
+  if (!raw) return void 0;
+  try {
+    const parsed = JSON.parse(raw);
+    if (!Array.isArray(parsed)) return void 0;
+    const paths = parsed.filter((p) => typeof p === "string" && p.length > 0);
+    return paths.length > 0 ? paths : void 0;
+  } catch {
+    return void 0;
+  }
+}
 function defaultAgentManifest(model) {
   return [
     "---",
@@ -1429,8 +1511,31 @@ function makeAgentFactory(opts = {}) {
     const workspaceTools = makeWorkspaceTools({
       cwd,
       allowExec: opts.allowExec,
+      // The daemon's exact-file AGENTS.md read grant (pointer-mode contract)
+      // — explicit option wins, else the driver-set env var.
+      additionalReadPaths: opts.additionalReadPaths ?? parseAdditionalReadPathsEnv(),
       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 +1544,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 +1583,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 })
@@ -1628,6 +1748,7 @@ var SUSPENSION_OPTIONS = [
 var META_SUSPEND_PAYLOAD = "mastra-agent/suspendPayload";
 var META_RESUME_SCHEMA = "mastra-agent/resumeSchema";
 var META_RESUME_DATA = "mastra-agent/resumeData";
+var META_FEEDBACK = "agentproto/feedback";
 function emptySessionState() {
   return {
     session: null,
@@ -1781,6 +1902,19 @@ var MastraAcpAgent = class {
     state.turn = turn;
     const { text, files } = promptContent(params);
     try {
+      if (!interrupted && state.suspensions.size > 0) {
+        await this.#conn.sessionUpdate({
+          sessionId: params.sessionId,
+          update: {
+            sessionUpdate: "agent_message_chunk",
+            content: {
+              type: "text",
+              text: "\n[mastra-agent] run is suspended awaiting approval \u2014 resolve the pending permission request (or cancel the session) before sending another prompt.\n"
+            }
+          }
+        });
+        return { stopReason: "refusal" };
+      }
       const session = await this.#ensureSession(params.sessionId, state);
       const map = createEventMapper();
       let endReason;
@@ -1798,6 +1932,21 @@ var MastraAcpAgent = class {
         if (event.type === "agent_end") {
           endReason = event.reason ?? "complete";
           resolveAgentEnd?.();
+          if (event.reason === "suspended") {
+            relay = relay.then(
+              () => this.#conn.sessionUpdate({
+                sessionId: params.sessionId,
+                update: {
+                  sessionUpdate: "agent_message_chunk",
+                  content: {
+                    type: "text",
+                    text: "\n[mastra-agent] run suspended \u2014 waiting for approval before continuing.\n"
+                  }
+                }
+              })
+            ).catch(() => {
+            });
+          }
           return;
         }
         if (event.type === "tool_approval_required") {
@@ -1994,7 +2143,11 @@ var MastraAcpAgent = class {
       if (pending.cancelled) return;
       if (outcome.outcome !== "selected") return;
       const meta = outcome._meta;
-      const resumeData = meta && META_RESUME_DATA in meta ? meta[META_RESUME_DATA] : { approved: outcome.optionId === "approve" };
+      const feedback = meta && typeof meta[META_FEEDBACK] === "string" ? meta[META_FEEDBACK] : void 0;
+      const resumeData = meta && META_RESUME_DATA in meta ? meta[META_RESUME_DATA] : {
+        approved: outcome.optionId === "approve",
+        ...feedback ? { feedback } : {}
+      };
       await session.respondToToolSuspension({
         resumeData,
         toolCallId: event.toolCallId
@@ -2028,6 +2181,12 @@ var MastraAcpAgent = class {
       threadId: acpSessionId
     });
     session.subscribe((event) => {
+      if (event.type === "tool_suspension_cancelled") {
+        const pending = state.suspensions.get(event.toolCallId);
+        if (pending) pending.cancelled = true;
+        state.suspensions.delete(event.toolCallId);
+        return;
+      }
       if (event.type === "mode_changed") {
         void this.#conn.sessionUpdate({
           sessionId: acpSessionId,
@@ -2091,5 +2250,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-2FKFITFT.mjs.map
+//# sourceMappingURL=chunk-2FKFITFT.mjs.map