@agentproto/adapter-mastra-agent 0.4.1 → 0.5.0

package/dist/chunk-ZVLJDGI4.mjs

@@ -1,602 +0,0 @@
-import { mkdirSync, promises } from 'fs';
-import { homedir, tmpdir } from 'os';
-import { join, resolve, isAbsolute, relative, sep } from 'path';
-import { LibSQLStore } from '@mastra/libsql';
-import { Memory } from '@mastra/memory';
-import { exec, execFile } from 'child_process';
-import { randomUUID } from 'crypto';
-import { promisify } from 'util';
-import { createTool } from '@mastra/core/tools';
-import { z } from 'zod';
-import { readFile } from 'fs/promises';
-import { parseAgentManifest, agentFromManifest } from '@agentproto/agent';
-import { buildMastraAgent } from '@agentproto/mastra';
-import { PROTOCOL_VERSION, ndJsonStream, AgentSideConnection } from '@agentclientprotocol/sdk';
-import { Writable, Readable } from 'stream';
-
-/**
- * @agentproto/adapter-mastra-agent v0.1.0-alpha
- * First-party agentproto agent: AGENT.md -> Mastra agent -> ACP server.
- */
-
-function resolveMemoryDbPath(env = process.env) {
-  const override = env.AGENTPROTO_MASTRA_MEMORY_DB;
-  if (override) return override;
-  const dir = join(homedir(), ".agentproto", "mastra-agent");
-  mkdirSync(dir, { recursive: true });
-  return join(dir, "memory.db");
-}
-function buildSqliteMemory(config, env = process.env) {
-  if (config?.scope === "none") return void 0;
-  const dbPath = resolveMemoryDbPath(env);
-  const lastMessages = typeof config?.retention_turns === "number" && config.retention_turns > 0 ? config.retention_turns : 20;
-  return new Memory({
-    storage: new LibSQLStore({ id: "mastra-agent-memory", url: `file:${dbPath}` }),
-    options: {
-      lastMessages,
-      semanticRecall: false,
-      workingMemory: { enabled: false }
-    }
-  });
-}
-
-// src/model-resolver.ts
-var PROVIDER_ENV = {
-  openai: "OPENAI_API_KEY",
-  anthropic: "ANTHROPIC_API_KEY",
-  openrouter: "OPENROUTER_API_KEY",
-  google: "GOOGLE_GENERATIVE_AI_API_KEY",
-  groq: "GROQ_API_KEY",
-  xai: "XAI_API_KEY",
-  mistral: "MISTRAL_API_KEY",
-  deepseek: "DEEPSEEK_API_KEY"
-};
-function modelRefToString(ref) {
-  if (typeof ref === "string") return ref.trim();
-  if (ref && typeof ref === "object" && typeof ref.ref === "string") {
-    return ref.ref.trim();
-  }
-  throw new Error(
-    "mastra-agent: AGENT.md `model` must be a `provider/model` string (or { ref }); inline model objects are not supported by this adapter."
-  );
-}
-function providerOf(modelId) {
-  const slash = modelId.indexOf("/");
-  return slash > 0 ? modelId.slice(0, slash) : modelId;
-}
-function normalizeModelId(modelId) {
-  if (modelId.includes("/")) return modelId;
-  if (/^claude[-.]/i.test(modelId)) return `anthropic/${modelId}`;
-  return modelId;
-}
-function resolveMastraModel(ref, env = process.env) {
-  const modelId = normalizeModelId(modelRefToString(ref));
-  if (!modelId) {
-    throw new Error("mastra-agent: empty `model` ref.");
-  }
-  const provider = providerOf(modelId);
-  const envKey = PROVIDER_ENV[provider];
-  if (envKey && !env[envKey]) {
-    throw new Error(
-      `mastra-agent: model '${modelId}' needs ${envKey} in the environment (provider '${provider}'). Set it on the spawn env or export it.`
-    );
-  }
-  return modelId;
-}
-var execAsync = promisify(exec);
-var execFileAsync = promisify(execFile);
-var ALLOWED_TEST_ARGV0 = /* @__PURE__ */ new Set(["npm", "pnpm", "yarn", "node", "npx"]);
-function tail(s, maxChars = 4e3) {
-  return s.length > maxChars ? s.slice(-maxChars) : s;
-}
-function extractPatchPaths(patch) {
-  const paths = /* @__PURE__ */ new Set();
-  for (const line of patch.split("\n")) {
-    const m = /^(?:\+\+\+|---) (?:a\/|b\/)?(.+?)(?:\t.*)?$/.exec(line);
-    if (!m) continue;
-    const p = m[1].trim();
-    if (p === "/dev/null") continue;
-    paths.add(p);
-  }
-  return [...paths];
-}
-function resolveInCwd(cwd, p) {
-  const base = resolve(cwd);
-  const target = isAbsolute(p) ? resolve(p) : resolve(base, p);
-  const rel = relative(base, target);
-  if (rel === "") return target;
-  if (rel.startsWith("..") || isAbsolute(rel) && !target.startsWith(base + sep)) {
-    throw new Error(
-      `path '${p}' escapes the workspace (resolved to '${target}', outside '${base}').`
-    );
-  }
-  return target;
-}
-function makeWorkspaceTools(opts) {
-  const cwd = resolve(opts.cwd);
-  const allowExec = opts.allowExec ?? true;
-  const execTimeoutMs = opts.execTimeoutMs ?? 12e4;
-  const execEnv = { ...process.env, GIT_CEILING_DIRECTORIES: resolve(cwd, "..") };
-  const list_dir = createTool({
-    id: "list_dir",
-    description: "List the entries of a directory in the workspace. Returns names with a trailing '/' for directories. Path is relative to the workspace root (default '.').",
-    inputSchema: z.object({
-      path: z.string().default(".").describe("Directory path, relative to the workspace root.")
-    }),
-    outputSchema: z.object({ entries: z.array(z.string()) }),
-    execute: async (input) => {
-      const dir = resolveInCwd(cwd, input.path ?? ".");
-      const dirents = await promises.readdir(dir, { withFileTypes: true });
-      return {
-        entries: dirents.map((d) => d.isDirectory() ? `${d.name}/` : d.name).sort()
-      };
-    }
-  });
-  const read_file = createTool({
-    id: "read_file",
-    description: "Read a UTF-8 text file from the workspace. Path is relative to the workspace root.",
-    inputSchema: z.object({
-      path: z.string().describe("File path, relative to the workspace root.")
-    }),
-    outputSchema: z.object({ content: z.string() }),
-    execute: async (input) => {
-      const file = resolveInCwd(cwd, input.path);
-      return { content: await promises.readFile(file, "utf8") };
-    }
-  });
-  const write_file = createTool({
-    id: "write_file",
-    description: "Write (creating or overwriting) a UTF-8 text file in the workspace. Creates parent directories as needed. Path is relative to the workspace root.",
-    inputSchema: z.object({
-      path: z.string().describe("File path, relative to the workspace root."),
-      content: z.string().describe("Full file contents to write.")
-    }),
-    outputSchema: z.object({ path: z.string(), bytes: z.number() }),
-    execute: async (input) => {
-      const file = resolveInCwd(cwd, 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") };
-    }
-  });
-  const edit_file = createTool({
-    id: "edit_file",
-    description: "Replace an exact substring in a workspace file. `old_string` must occur exactly once. Use for targeted edits instead of rewriting the whole file.",
-    inputSchema: z.object({
-      path: z.string().describe("File path, relative to the workspace root."),
-      old_string: z.string().describe("Exact text to replace (must be unique in the file)."),
-      new_string: z.string().describe("Replacement text.")
-    }),
-    outputSchema: z.object({ path: z.string(), replaced: z.boolean() }),
-    execute: async (input) => {
-      const file = resolveInCwd(cwd, 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}'.`);
-      if (count > 1) {
-        throw new Error(`old_string occurs ${count}\xD7 in '${input.path}' \u2014 make it unique.`);
-      }
-      await promises.writeFile(file, current.replace(input.old_string, input.new_string), "utf8");
-      return { path: input.path, replaced: true };
-    }
-  });
-  const tools = {
-    list_dir,
-    read_file,
-    write_file,
-    edit_file
-  };
-  if (allowExec) {
-    tools.run_command = createTool({
-      id: "run_command",
-      description: "Run a shell command in the workspace directory and return its stdout/stderr/exit code. Runs with a timeout; use for builds, tests, git, etc.",
-      inputSchema: z.object({
-        command: z.string().describe("The shell command to run (executed in the workspace root).")
-      }),
-      outputSchema: z.object({
-        stdout: z.string(),
-        stderr: z.string(),
-        exitCode: z.number()
-      }),
-      execute: async (input) => {
-        try {
-          const { stdout, stderr } = await execAsync(input.command, {
-            cwd,
-            timeout: execTimeoutMs,
-            maxBuffer: 10 * 1024 * 1024,
-            env: execEnv
-          });
-          return { stdout, stderr, exitCode: 0 };
-        } catch (err) {
-          const e = err;
-          return {
-            stdout: e.stdout ?? "",
-            stderr: e.stderr ?? e.message ?? String(err),
-            exitCode: typeof e.code === "number" ? e.code : 1
-          };
-        }
-      }
-    });
-    tools.read_diff = createTool({
-      id: "read_diff",
-      description: "Show `git diff` for the workspace \u2014 staged and unstaged changes against HEAD (or against `base` if given), as unified diff text. Optionally scoped to `paths`.",
-      inputSchema: z.object({
-        paths: z.array(z.string()).optional().describe("Restrict the diff to these paths, relative to the workspace root."),
-        base: z.string().optional().describe("Git ref to diff against. Defaults to HEAD.")
-      }),
-      outputSchema: z.object({ diff: z.string() }),
-      execute: async (input) => {
-        const relPaths = (input.paths ?? []).map((p) => {
-          const abs = resolveInCwd(cwd, p);
-          return relative(cwd, abs) || ".";
-        });
-        const args = [
-          "diff",
-          input.base ?? "HEAD",
-          ...relPaths.length ? ["--", ...relPaths] : []
-        ];
-        try {
-          const { stdout } = await execFileAsync("git", args, {
-            cwd,
-            timeout: execTimeoutMs,
-            maxBuffer: 10 * 1024 * 1024,
-            env: execEnv
-          });
-          return { diff: stdout };
-        } catch (err) {
-          const e = err;
-          throw new Error(`git diff failed: ${e.stderr ?? e.message ?? String(err)}`);
-        }
-      }
-    });
-    tools.apply_patch = createTool({
-      id: "apply_patch",
-      description: "Apply a unified diff to files in the workspace (`git apply --whitespace=nowarn`). Paths in the patch that escape the workspace are rejected.",
-      inputSchema: z.object({
-        patch: z.string().describe("Unified diff text to apply.")
-      }),
-      outputSchema: z.object({ applied: z.boolean(), output: z.string() }),
-      execute: async (input) => {
-        for (const p of extractPatchPaths(input.patch)) {
-          resolveInCwd(cwd, p);
-        }
-        const patchFile = join(tmpdir(), `mastra-agent-patch-${randomUUID()}.diff`);
-        await promises.writeFile(patchFile, input.patch, "utf8");
-        try {
-          const { stdout, stderr } = await execFileAsync(
-            "git",
-            ["apply", "--whitespace=nowarn", patchFile],
-            { cwd, timeout: execTimeoutMs, maxBuffer: 10 * 1024 * 1024, env: execEnv }
-          );
-          return { applied: true, output: stdout || stderr || "" };
-        } catch (err) {
-          const e = err;
-          throw new Error(`git apply failed: ${e.stderr ?? e.stdout ?? e.message ?? String(err)}`);
-        } finally {
-          await promises.unlink(patchFile).catch(() => {
-          });
-        }
-      }
-    });
-    tools.run_tests = createTool({
-      id: "run_tests",
-      description: "Run the workspace's test command (default `npm test`, overridable via `command` or the MASTRA_AGENT_TEST_CMD env) and return its exit code + output tail.",
-      inputSchema: z.object({
-        command: z.string().optional().describe("Override the test command. Its argv0 must be one of npm, pnpm, yarn, node, npx.")
-      }),
-      outputSchema: z.object({ exitCode: z.number(), output: z.string() }),
-      execute: async (input) => {
-        const commandStr = input.command ?? process.env.MASTRA_AGENT_TEST_CMD ?? "npm test";
-        const argv0 = commandStr.trim().split(/\s+/)[0];
-        if (!argv0 || !ALLOWED_TEST_ARGV0.has(argv0)) {
-          throw new Error(
-            `run_tests: command '${commandStr}' is not allowed \u2014 argv0 must be one of ${[...ALLOWED_TEST_ARGV0].join(", ")}.`
-          );
-        }
-        try {
-          const { stdout, stderr } = await execAsync(commandStr, {
-            cwd,
-            timeout: execTimeoutMs,
-            maxBuffer: 10 * 1024 * 1024,
-            env: execEnv
-          });
-          return { exitCode: 0, output: tail(stdout + stderr) };
-        } catch (err) {
-          const e = err;
-          return {
-            exitCode: typeof e.code === "number" ? e.code : 1,
-            output: tail((e.stdout ?? "") + (e.stderr ?? e.message ?? String(err)))
-          };
-        }
-      }
-    });
-  }
-  return {
-    ...tools,
-    ...opts.extraTools
-  };
-}
-var DEFAULT_MODEL = "openrouter/z-ai/glm-5.2";
-var DEFAULT_TOOL_IDS = [
-  "list_dir",
-  "read_file",
-  "write_file",
-  "edit_file",
-  "run_command"
-];
-function defaultAgentManifest(model) {
-  return [
-    "---",
-    "schema: agent/v1",
-    "id: mastra-agent",
-    "description: A first-party agentproto agent powered by Mastra.",
-    `model: ${model}`,
-    "version: 0.1.0",
-    "tools:",
-    ...DEFAULT_TOOL_IDS.map((id) => `  - ${id}`),
-    "memory:",
-    "  scope: per-conversation",
-    "  retention_turns: 20",
-    "---",
-    "",
-    "You are a capable, concise coding agent operating inside a workspace ",
-    "directory. You can list, read, write, and edit files and run shell ",
-    "commands there using your tools. Do exactly what the user asks \u2014 when ",
-    "asked to reply with an exact string, reply with only that string.",
-    ""
-  ].join("\n");
-}
-function toolRefId(ref) {
-  if (typeof ref === "string") return ref;
-  if (ref && typeof ref === "object" && typeof ref.ref === "string") {
-    return ref.ref;
-  }
-  return void 0;
-}
-async function resolveAgentSource(opts = {}) {
-  if (opts.agentFile) return readFile(opts.agentFile, "utf8");
-  return defaultAgentManifest(opts.model ?? DEFAULT_MODEL);
-}
-function makeAgentFactory(opts = {}) {
-  return async () => {
-    const source = await resolveAgentSource(opts);
-    const { frontmatter, body } = parseAgentManifest(source);
-    const handle = agentFromManifest({ frontmatter, body });
-    const cwd = opts.cwd ?? process.cwd();
-    const workspaceTools = makeWorkspaceTools({
-      cwd,
-      allowExec: opts.allowExec,
-      extraTools: opts.extraTools
-    });
-    const { agent } = await buildMastraAgent(handle, {
-      resolveModel: (ref) => resolveMastraModel(ref),
-      // Match each declared tool ref against the workspace toolset by id.
-      resolveTool: (ref) => {
-        const id = toolRefId(ref);
-        const tool = id ? workspaceTools[id] : void 0;
-        return tool ? { name: id, tool } : void 0;
-      },
-      buildMemory: (config) => buildSqliteMemory(config),
-      // The markdown body is the agent's primary system prompt (AIP-42).
-      body
-    });
-    return agent;
-  };
-}
-
-// src/tool-call-map.ts
-function toolKindFor(toolName) {
-  switch (toolName) {
-    case "read_file":
-    case "list_dir":
-      return "read";
-    case "write_file":
-    case "edit_file":
-      return "edit";
-    case "run_command":
-      return "execute";
-    default:
-      return "other";
-  }
-}
-function toolCallTitle(toolName, args) {
-  if (args && typeof args === "object") {
-    const { command, path, file } = args;
-    const hint = typeof command === "string" && command || typeof path === "string" && path || typeof file === "string" && file || "";
-    if (hint) return `${toolName}: ${hint}`;
-  }
-  return toolName;
-}
-function chunkToSessionUpdate(chunk) {
-  switch (chunk.type) {
-    case "text-delta": {
-      const text = chunk.payload?.text;
-      if (!text) return null;
-      return {
-        sessionUpdate: "agent_message_chunk",
-        content: { type: "text", text }
-      };
-    }
-    case "tool-call": {
-      const toolCallId = chunk.payload?.toolCallId;
-      if (!toolCallId) return null;
-      const toolName = chunk.payload?.toolName ?? "tool";
-      const args = chunk.payload?.args;
-      return {
-        sessionUpdate: "tool_call",
-        toolCallId,
-        title: toolCallTitle(toolName, args),
-        kind: toolKindFor(toolName),
-        status: "in_progress",
-        rawInput: args
-      };
-    }
-    case "tool-result": {
-      const toolCallId = chunk.payload?.toolCallId;
-      if (!toolCallId) return null;
-      return {
-        sessionUpdate: "tool_call_update",
-        toolCallId,
-        status: chunk.payload?.isError ? "failed" : "completed",
-        rawOutput: chunk.payload?.result
-      };
-    }
-    default:
-      return null;
-  }
-}
-function promptText(params) {
-  const blocks = Array.isArray(params.prompt) ? params.prompt : [];
-  return blocks.filter(
-    (b) => Boolean(b) && b.type === "text" && typeof b.text === "string"
-  ).map((b) => b.text).join("").trim();
-}
-var MastraAcpAgent = class {
-  #conn;
-  #buildAgent;
-  #resource;
-  #sessions = /* @__PURE__ */ new Map();
-  #agent = null;
-  constructor(conn, buildAgent, resource = "mastra-agent") {
-    this.#conn = conn;
-    this.#buildAgent = buildAgent;
-    this.#resource = resource;
-  }
-  async initialize(_params) {
-    return {
-      protocolVersion: PROTOCOL_VERSION,
-      agentCapabilities: {
-        // Stateless per-prompt for now; no resume/replay surface.
-        loadSession: false
-      }
-    };
-  }
-  async authenticate(_params) {
-    return {};
-  }
-  async newSession(_params) {
-    const sessionId = randomId();
-    this.#sessions.set(sessionId, { prompt: null });
-    return { sessionId };
-  }
-  async prompt(params) {
-    const session = this.#sessions.get(params.sessionId);
-    if (!session) throw new Error(`unknown session ${params.sessionId}`);
-    session.prompt?.abort();
-    const ac = new AbortController();
-    session.prompt = ac;
-    const text = promptText(params);
-    try {
-      const agent = await this.#ensureAgent();
-      const result = await agent.stream(text, {
-        abortSignal: ac.signal,
-        memory: { thread: params.sessionId, resource: this.#resource },
-        maxSteps: 200
-      });
-      if (result.fullStream) {
-        await this.#pumpFullStream(params.sessionId, result.fullStream, ac);
-      } else if (result.textStream) {
-        await this.#pumpTextStream(params.sessionId, result.textStream, ac);
-      }
-    } catch (err) {
-      if (ac.signal.aborted) return { stopReason: "cancelled" };
-      await this.#conn.sessionUpdate({
-        sessionId: params.sessionId,
-        update: {
-          sessionUpdate: "agent_message_chunk",
-          content: {
-            type: "text",
-            text: `
-[mastra-agent error] ${err.message}
-`
-          }
-        }
-      });
-      session.prompt = null;
-      return { stopReason: "refusal" };
-    }
-    const cancelled = ac.signal.aborted;
-    session.prompt = null;
-    return { stopReason: cancelled ? "cancelled" : "end_turn" };
-  }
-  async cancel(params) {
-    this.#sessions.get(params.sessionId)?.prompt?.abort();
-  }
-  /**
-   * The host applies the `model` (and other operator options) as a `--model`
-   * spawn arg via the manifest `bin_args_template`, then ALSO calls this ACP
-   * config hook (the daemon's default "config" apply path). The model is
-   * already in effect, so this is a no-op that just reports our (empty) set of
-   * runtime-configurable options. Without it the spawn fails with
-   * "Method not found: session/set_config_option".
-   */
-  async setSessionConfigOption(_params) {
-    return { configOptions: [] };
-  }
-  /** No agent-specific modes; accept and ignore so a host that sets one
-   *  doesn't error. */
-  async setSessionMode(_params) {
-    return {};
-  }
-  /** Drain Mastra's typed `fullStream`, mapping each chunk to an ACP
-   *  `session/update` (text deltas + tool_call / tool_call_update). */
-  async #pumpFullStream(sessionId, stream, ac) {
-    const reader = stream.getReader();
-    try {
-      for (; ; ) {
-        const { value, done } = await reader.read();
-        if (done || ac.signal.aborted) break;
-        if (!value) continue;
-        const update = chunkToSessionUpdate(value);
-        if (update) await this.#conn.sessionUpdate({ sessionId, update });
-      }
-    } finally {
-      reader.releaseLock();
-    }
-  }
-  /** Fallback drain for an agent exposing only a plain text stream. */
-  async #pumpTextStream(sessionId, stream, ac) {
-    const reader = stream.getReader();
-    try {
-      for (; ; ) {
-        const { value, done } = await reader.read();
-        if (done || ac.signal.aborted) break;
-        if (value) {
-          await this.#conn.sessionUpdate({
-            sessionId,
-            update: {
-              sessionUpdate: "agent_message_chunk",
-              content: { type: "text", text: value }
-            }
-          });
-        }
-      }
-    } finally {
-      reader.releaseLock();
-    }
-  }
-  async #ensureAgent() {
-    if (!this.#agent) this.#agent = await this.#buildAgent();
-    return this.#agent;
-  }
-};
-function randomId() {
-  const bytes = new Uint8Array(16);
-  crypto.getRandomValues(bytes);
-  return Array.from(bytes, (b) => b.toString(16).padStart(2, "0")).join("");
-}
-function runAcpOverStdio(buildAgent) {
-  const toClient = Writable.toWeb(process.stdout);
-  const fromClient = Readable.toWeb(
-    process.stdin
-  );
-  const stream = ndJsonStream(toClient, fromClient);
-  return new AgentSideConnection(
-    (conn) => new MastraAcpAgent(conn, buildAgent),
-    stream
-  );
-}
-
-export { DEFAULT_MODEL, DEFAULT_TOOL_IDS, MastraAcpAgent, buildSqliteMemory, chunkToSessionUpdate, defaultAgentManifest, makeAgentFactory, makeWorkspaceTools, modelRefToString, promptText, providerOf, resolveInCwd, resolveMastraModel, resolveMemoryDbPath, runAcpOverStdio, toolCallTitle, toolKindFor };
-//# sourceMappingURL=chunk-ZVLJDGI4.mjs.map
-//# sourceMappingURL=chunk-ZVLJDGI4.mjs.map