@agentproto/adapter-mastracode-inprocess 0.2.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 agentproto contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/MASTRACODE-INPROCESS.md

@@ -0,0 +1,128 @@
+---
+name: mastracode-inprocess
+id: mastracode-inprocess
+description: Mastra Code driven in-process via the mastracode SDK — no subprocess spawn.
+version: 0.1.0
+bin: in-process
+install:
+  - method: npm
+    package: "@agentproto/adapter-mastracode-inprocess"
+version_check:
+  cmd: npm view mastracode version
+  parse: '(\d+\.\d+\.\d+)'
+  range: ">=0.27.0"
+  timeout_ms: 15000
+sandbox:
+  model: in-process
+  note: >-
+    Runs inside the host process — no subprocess boundary. File/shell tool
+    access is whatever Mastra Code's own tool policy grants for the session,
+    with the host process's OS permissions.
+protocol: proprietary
+adapter: "@agentproto/adapter-mastracode-inprocess"
+tags: ["mastracode", "mastra", "proprietary", "in-process", "agent-runtime", "coding"]
+---
+
+# Mastra Code (in-process) adapter
+
+This adapter drives Mastra Code directly through its `mastracode` /
+`mastracode/headless` SDK (`createMastraCode` + `runMC`) instead of spawning
+`npx mastracode` as a subprocess. It implements the AIP-45 `protocol:
+"proprietary"` arm contract: `createAgentCliRuntime` skips the subprocess
+spawn entirely for this manifest and dynamic-imports this package, calling
+its exported `createAgentCliClient(definition)` factory (see
+`src/client.ts`).
+
+## Why a separate package instead of extending `@agentproto/adapter-mastracode`
+
+`@agentproto/adapter-mastracode` is a `protocol: "print"` arm: every turn
+spawns a fresh `npx mastracode --prompt ... --output jsonl` process and
+resumes prior turns via `--thread <id>`. This package wraps the *same*
+underlying agent but through its SDK surface, in the host's own process.
+Those are genuinely different runtime shapes, not a config toggle on one
+package:
+
+- **Dependency surface.** The print arm has zero npm dependency on
+  `mastracode`/`@mastra/core` — it only needs the CLI binary on `PATH` (or
+  fetched on demand via `npx`). This package takes `mastracode` and
+  `@mastra/core` as real `dependencies`, pinned to versions this adapter is
+  tested against. Merging them would force every consumer of the print arm
+  to pull in the full SDK even when they never use it, or force every
+  in-process consumer onto whatever CLI version happens to be on `PATH`.
+- **Process lifecycle.** The print arm's `AgentCliClient` has no live
+  connection between turns — `connect()`/`close()` are no-ops and each
+  `send()` spawns and tears down its own child. This package's client holds
+  a long-lived `MastraCodeHandle` (`controller` + `session`) across
+  `connect()` → many `send()`s → `close()`, and that handle's lifecycle
+  rules (in particular the resourceId/threadId binding documented below)
+  don't map onto a stateless one-shot-per-turn model at all.
+- **Session-id shape.** The print arm's resumable id is a bare Mastra
+  thread id, passed straight through `--thread <id>`. This package's
+  `sessionId` is a composite `"<resourceId>:<threadId>"` (see below) — a
+  format specific to how `runMC()` resolves threads for a live, in-process
+  `AgentController`. Encoding two incompatible id formats behind one
+  `protocol` field would require a runtime discriminator the AIP-45 spec
+  doesn't have a slot for, and would silently break resume for whichever
+  shape wasn't the one actually in use.
+- **Independent versioning/failure domain.** The print arm can keep
+  shipping fixes to its subprocess/argv handling without ever touching (or
+  re-testing) the in-process SDK surface, and vice versa. A shared package
+  would couple their release cadence and blast radius for no shared code —
+  `mapMastraEvent`/`createMastraMapperState` (the only genuinely shared
+  logic, the wire-event → `StreamEvent` mapper) is exported from
+  `@agentproto/driver-agent-cli` precisely so both packages can reuse it
+  without merging everything else around it.
+
+A new adapter slug (`mastracode-inprocess`) keeps both discoverable
+independently via `adapter_list` / `agentproto install`, lets a host pick
+whichever runtime shape it actually wants (subprocess isolation vs.
+in-process, no `npx` cold-start), and keeps this package's `dependencies`
+honest about what it actually needs.
+
+## The composite sessionId
+
+A single Mastra Code `AgentController` auto-binds a session to whatever
+thread `session.thread` currently points at, and (verified against
+mastracode 0.27.0 / @mastra/core 1.48.0) `runMC()` only rebinds that
+pointer when a thread is explicitly passed. Two unrelated conversations
+sharing this arm's dedicated storage file would otherwise silently land on
+the same thread, because Mastra Code resolves the initial thread lookup by
+`resourceId` and every conversation was defaulting to the same one.
+
+The fix: a distinct `resourceId` per *conversation* (not per process, not
+via a global env var, which would race across concurrent in-process
+conversations in the same daemon). A fresh conversation mints a random
+`resourceId`; resuming one must reuse the exact `resourceId` the thread was
+created under, since thread-by-id resolution is scoped to the session's
+current `resourceId`. So this arm's public `sessionId` is
+`"<resourceId>:<threadId>"` — hosts only need to persist and echo back
+whatever string `sessionId` returns, per the generic `AgentCliClient`
+contract; the composite format is this arm's own implementation detail.
+
+Cross-process resume (kill the process, start a new one, reattach via the
+same composite `sessionId` against the same dedicated storage file) has
+been verified to preserve conversation memory end-to-end.
+
+## Isolation
+
+- **Storage**: a dedicated libsql file under
+  `$AGENTPROTO_HOME/mastracode-inprocess/storage.db` (default
+  `~/.agentproto/...`), never the ambient global `mastracode` storage a
+  developer's own interactive CLI use would touch.
+- **Home dir**: a dedicated, empty home directory for Mastra Code's global
+  config discovery (`~/.claude/skills`, `~/.mastracode/*`, `~/.agents/skills`),
+  so this arm never implicitly inherits an operator's personal Claude
+  Code / Mastra Code setup. A target repo's own project-local
+  `.claude/skills` (relative to `cwd`) is unaffected — that's the repo's
+  own content, not the operator's personal config.
+
+## Modes and options
+
+Mode selection has no argv to append to (there's no spawn) — modes patch
+env instead, the one channel `composeSpawn` threads through for every
+protocol regardless of whether a subprocess exists. `plan` / `build` /
+`fast` set `AGENTPROTO_MASTRACODE_MODE`, which `client.ts` reads and
+applies via `session.mode.switch(...)` before the next turn. `model` and
+`effort` are declared as options so a host's generic
+`agent_start({ model, effort })` passthrough works without the runtime
+config validator rejecting them as unknown.

package/README.md

@@ -0,0 +1,77 @@
+# @agentproto/adapter-mastracode-inprocess
+
+Mastra Code driven **in-process** via its `mastracode` / `mastracode/headless`
+SDK, instead of spawning `npx mastracode` as a subprocess. Implements the
+AIP-45 `protocol: "proprietary"` arm contract directly — no child process,
+no argv, no JSONL pipe.
+
+```ts
+import { mastracodeInprocessRuntime } from "@agentproto/adapter-mastracode-inprocess"
+
+const runtime = mastracodeInprocessRuntime()
+const session = await runtime.start({ cwd: process.cwd() })
+
+for await (const evt of session.send("Fix the failing test in src/foo.ts")) {
+  console.log(evt)
+}
+await session.close()
+
+// Resume later — same process or a fresh one — via the sessionId the
+// first session returned:
+const resumed = await runtime.start({ resumeSessionId: session.sessionId })
+```
+
+See `@agentproto/driver-agent-cli`'s `createAgentCliRuntime` for the generic
+`AgentCliRuntime`/`AgentCliClient` contract this package implements.
+
+## How it works
+
+```
+manifest (src/index.ts, protocol: "proprietary")
+        │ createAgentCliRuntime skips the subprocess spawn
+        ▼
+createProprietaryProtocolArm  ──dynamic import──▶  this package
+        │                                                │
+        │                              createAgentCliClient(definition)
+        ▼                                                ▼
+   AgentCliClient  ◀── src/client.ts ── createMastraCode() + runMC()
+        │
+        │ mapMastraEvent (reused from @agentproto/driver-agent-cli's print arm)
+        ▼
+    StreamEvent
+```
+
+## Why this is a separate package from `@agentproto/adapter-mastracode`
+
+That package spawns the CLI (`protocol: "print"`) per turn; this one holds
+a live in-process `AgentController` across turns and never shells out.
+Different dependency surface, different process lifecycle, different
+session-id shape — see **MASTRACODE-INPROCESS.md** for the full rationale.
+
+## Session ids
+
+`sessionId` is a composite `"<resourceId>:<threadId>"` string — an
+implementation detail of how Mastra Code resolves threads for a live
+`AgentController`, documented in full in **MASTRACODE-INPROCESS.md**. Hosts
+should treat it as an opaque string: persist whatever `sessionId` returns
+and pass it back as `resumeSessionId` to resume, including across a
+process restart.
+
+## Isolation
+
+Storage and Mastra Code's global home-dir config discovery are both
+redirected to a dedicated location under `$AGENTPROTO_HOME` (default
+`~/.agentproto/mastracode-inprocess/`), so this arm's sessions never
+collide with — or leak into — a developer's own interactive `mastracode`
+usage. See MASTRACODE-INPROCESS.md for specifics and a known limitation
+around `homeDir` propagation.
+
+## Modes and options
+
+`modes` (`plan` / `build` / `fast`) and `options` (`model` / `effort`) are
+declared on the manifest; see MASTRACODE-INPROCESS.md for how they reach
+`client.ts` (env-carried mode selection, direct model/effort passthrough).
+
+## Spec
+
+See [AIP-45](https://agentproto.sh/docs/aip-45).

package/dist/index.d.ts

@@ -0,0 +1,67 @@
+import { AgentCliHandle, AgentCliClient, AgentCliRuntime } from '@agentproto/driver-agent-cli';
+export { AgentCliHandle, AgentCliRuntime } from '@agentproto/driver-agent-cli';
+
+/**
+ * `AgentCliClient` implementation wrapping Mastra Code's in-process SDK
+ * (`mastracode` / `mastracode/headless`) instead of spawning a subprocess.
+ *
+ * ## Why a composite sessionId
+ *
+ * A single Mastra Code `AgentController` instance auto-binds a *fresh*
+ * session to whatever thread `session.thread` currently points at, and
+ * (empirically verified against mastracode 0.27.0 / @mastra/core 1.48.0)
+ * `runMC()` only rebinds that pointer when `thread.id` / `thread.continueLatest`
+ * is explicitly passed. Two unrelated conversations that share both a
+ * `cwd` and this arm's dedicated storage file would otherwise silently
+ * land on the SAME thread — Mastra Code resolves the initial thread by
+ * `resourceId`, and every conversation was defaulting to the same one.
+ *
+ * The fix (also verified live): pass a distinct `resourceId` to `runMC()`
+ * per *conversation*, not per process and not globally via
+ * `MASTRA_RESOURCE_ID` (a global env var would race across concurrent
+ * in-process conversations in the same daemon). A fresh conversation
+ * mints a random resourceId; a resumed one must reuse the EXACT
+ * resourceId the thread was created under, because `session.thread.list()`
+ * — which `runMC`'s thread-by-id resolution calls internally — is scoped
+ * to the session's current resourceId by default. So this arm's public
+ * `sessionId` is `"<resourceId>:<threadId>"`, and resume splits it back
+ * apart. This composite format is this arm's own implementation detail;
+ * hosts only ever need to persist and echo back whatever string
+ * `sessionId` returns, per the generic AgentCliClient contract.
+ *
+ * Cross-process resume (kill the process, start a new one, reattach via
+ * the same composite sessionId against the same dedicated storage file)
+ * has been verified to preserve conversation memory end-to-end.
+ */
+
+declare function createAgentCliClient(definition: AgentCliHandle): AgentCliClient;
+
+/**
+ * @agentproto/adapter-mastracode-inprocess — AIP-45 adapter for Mastra Code,
+ * driven in-process via the `mastracode` / `mastracode/headless` SDK
+ * instead of spawning a subprocess.
+ *
+ * This is a `protocol: "proprietary"` manifest: `createAgentCliRuntime`
+ * skips the subprocess spawn entirely for this protocol and instead
+ * dynamic-imports `adapter` (this very package) and calls its exported
+ * `createAgentCliClient(definition)` factory — see
+ * `createProprietaryProtocolArm` in `@agentproto/driver-agent-cli`. The
+ * factory itself lives in `./client.ts`; this file only builds and
+ * exports the manifest handle.
+ *
+ *   import { mastracodeInprocess, mastracodeInprocessRuntime } from "@agentproto/adapter-mastracode-inprocess"
+ *   const session = await mastracodeInprocessRuntime().start()
+ *   for await (const evt of session.send({ role: "user", content: "..." })) {
+ *     console.log(evt)
+ *   }
+ *   await session.close()
+ *
+ * Why a separate package from `@agentproto/adapter-mastracode` (the
+ * `print` arm) rather than a second export of it — see
+ * MASTRACODE-INPROCESS.md.
+ */
+
+declare const mastracodeInprocess: AgentCliHandle;
+declare function mastracodeInprocessRuntime(): AgentCliRuntime;
+
+export { createAgentCliClient, mastracodeInprocess, mastracodeInprocessRuntime };

package/dist/index.mjs

@@ -0,0 +1,272 @@
+import { defineAgentCli, createMastraMapperState, mapMastraEvent, toFileBasedMcpServers, createAgentCliRuntime } from '@agentproto/driver-agent-cli';
+import { randomUUID } from 'crypto';
+import { homedir } from 'os';
+import { dirname, join } from 'path';
+import { mkdirSync } from 'fs';
+import { createMastraCode } from 'mastracode';
+import { runMC } from 'mastracode/headless';
+
+/**
+ * @agentproto/adapter-mastracode-inprocess v0.1.0
+ * AIP-45 proprietary protocol arm for Mastra Code, driven in-process
+ * via the mastracode SDK instead of a spawned subprocess.
+ */
+
+var MODE_ENV_KEY = "AGENTPROTO_MASTRACODE_MODE";
+var VALID_THINKING_LEVELS = /* @__PURE__ */ new Set(["off", "low", "medium", "high", "xhigh"]);
+var VALID_RUN_MODES = /* @__PURE__ */ new Set(["build", "plan", "fast"]);
+function resolveAgentprotoHome() {
+  return process.env.AGENTPROTO_HOME ?? join(homedir(), ".agentproto");
+}
+function resolveStoragePath() {
+  return join(resolveAgentprotoHome(), "mastracode-inprocess", "storage.db");
+}
+function resolveIsolatedHomeDir() {
+  return join(resolveAgentprotoHome(), "mastracode-inprocess", "home");
+}
+function parseSessionId(sessionId) {
+  const idx = sessionId.indexOf(":");
+  if (idx <= 0 || idx === sessionId.length - 1) {
+    throw new Error(
+      `mastracode-inprocess: malformed resumeSessionId '${sessionId}' \u2014 expected "<resourceId>:<threadId>", the format this arm's own sessionId getter produces.`
+    );
+  }
+  return { resourceId: sessionId.slice(0, idx), threadId: sessionId.slice(idx + 1) };
+}
+function createAgentCliClient(definition) {
+  let handle;
+  let resourceId;
+  let threadId;
+  let connectEnv = {};
+  let connectModel;
+  let connectEffort;
+  const pendingByTurn = /* @__PURE__ */ new Map();
+  return {
+    get sessionId() {
+      return resourceId && threadId ? `${resourceId}:${threadId}` : void 0;
+    },
+    async connect(opts) {
+      const isolatedHome = resolveIsolatedHomeDir();
+      const storagePath = resolveStoragePath();
+      mkdirSync(isolatedHome, { recursive: true });
+      mkdirSync(dirname(storagePath), { recursive: true });
+      handle = await createMastraCode({
+        cwd: opts.cwd,
+        homeDir: isolatedHome,
+        initialState: { homeDir: isolatedHome },
+        disablePlugins: true,
+        storage: { backend: "libsql", url: `file:${storagePath}`, isRemote: false },
+        ...opts.mcpServers?.length ? { mcpServers: toFileBasedMcpServers(opts.mcpServers) } : {}
+      });
+      if (handle.mcpManager?.hasServers()) {
+        try {
+          await handle.mcpManager.initInBackground();
+        } catch {
+        }
+      }
+      connectEnv = opts.env;
+      connectModel = opts.model;
+      connectEffort = opts.effort;
+      if (opts.resumeSessionId) {
+        ({ resourceId, threadId } = parseSessionId(opts.resumeSessionId));
+      } else {
+        resourceId = `agentproto-mastracode-inprocess-${randomUUID()}`;
+        threadId = void 0;
+      }
+    },
+    async send(turnId, message) {
+      if (!handle || !resourceId) {
+        throw new Error("mastracode-inprocess: send() called before connect()");
+      }
+      const prompt = extractPromptText(message);
+      const requestedMode = connectEnv[MODE_ENV_KEY];
+      if (requestedMode && VALID_RUN_MODES.has(requestedMode)) {
+        if (handle.session.mode.get() !== requestedMode) {
+          await handle.session.mode.switch({ modeId: requestedMode });
+        }
+      }
+      const thinkingLevel = connectEffort && VALID_THINKING_LEVELS.has(connectEffort) ? connectEffort : void 0;
+      const run = runMC({
+        controller: handle.controller,
+        session: handle.session,
+        prompt,
+        resourceId,
+        thread: threadId ? { id: threadId } : void 0,
+        ...connectModel ? { model: connectModel } : {},
+        ...thinkingLevel ? { thinkingLevel } : {},
+        ...definition.session?.max_turns ? { maxTurns: definition.session.max_turns } : {}
+      });
+      pendingByTurn.set(turnId, run);
+    },
+    async *events() {
+      const run = Array.from(pendingByTurn.values()).at(-1);
+      if (!run) return;
+      const state = createMastraMapperState();
+      for await (const evt of run) {
+        if (evt.type === "thread_created") threadId = evt.thread.id;
+        else if (evt.type === "thread_changed") threadId = evt.threadId;
+        const sid = resourceId && threadId ? `${resourceId}:${threadId}` : "";
+        const mapped = mapMastraEvent(
+          evt,
+          sid,
+          [],
+          state
+        );
+        if (mapped) yield mapped;
+      }
+      const result = await run.result;
+      if (result.threadId) threadId = result.threadId;
+    },
+    async cancel(turnId) {
+      pendingByTurn.get(turnId)?.abort();
+    },
+    async close() {
+      await handle?.controller.destroy();
+    }
+  };
+}
+function extractPromptText(message) {
+  if (typeof message === "string") return message;
+  if (Array.isArray(message)) {
+    return message.filter((b) => b.type === "text" && typeof b.text === "string").map((b) => b.text).join("\n");
+  }
+  if (message !== null && typeof message === "object") {
+    const m = message;
+    if (typeof m.text === "string") return m.text;
+  }
+  return JSON.stringify(message);
+}
+
+// src/index.ts
+var mastracodeInprocess = defineAgentCli({
+  name: "Mastra Code (in-process)",
+  id: "mastracode-inprocess",
+  description: "Mastra Code terminal coding agent driven in-process via the `mastracode` SDK (createMastraCode + runMC) instead of spawning the CLI as a subprocess. Same underlying agent as @agentproto/adapter-mastracode, no child process.",
+  version: "0.1.0",
+  // No binary is ever spawned for a proprietary arm — `bin` is required by
+  // the AIP-45 schema regardless, so this is a documented placeholder
+  // rather than a real executable. `createAgentCliRuntime` checks
+  // `protocol === "proprietary"` and never reads this field.
+  bin: "in-process",
+  install: [{ method: "npm", package: "@agentproto/adapter-mastracode-inprocess" }],
+  version_check: {
+    cmd: "npm view mastracode version",
+    parse: "(\\d+\\.\\d+\\.\\d+)",
+    // Matches this package's pinned `mastracode` dependency (see package.json).
+    range: ">=0.27.0",
+    timeout_ms: 15e3
+  },
+  auth: {
+    state: {
+      env: [
+        "ANTHROPIC_API_KEY",
+        "OPENAI_API_KEY",
+        "OPENROUTER_API_KEY",
+        "GOOGLE_GENERATIVE_AI_API_KEY"
+      ]
+    }
+  },
+  sandbox: {
+    model: "in-process",
+    note: "Runs inside the host process \u2014 there is no subprocess boundary to sandbox. File and shell tool access is whatever Mastra Code's own tool policy grants for this session, with the host process's OS permissions (not a separately confined child). Storage and home dir ARE isolated per MASTRACODE-INPROCESS.md so this arm's sessions never collide with a developer's own interactive mastracode usage, but that isolation is not a security sandbox."
+  },
+  protocol: "proprietary",
+  adapter: "@agentproto/adapter-mastracode-inprocess",
+  session: {
+    mode: "resumable",
+    idle_timeout_ms: 18e5,
+    context_carryover: true
+  },
+  models: {
+    default: "anthropic/claude-sonnet-4-5",
+    allowed: [
+      "anthropic/claude-sonnet-4-5",
+      "anthropic/claude-sonnet-4-6",
+      "openai/gpt-5.1",
+      "openai/gpt-5.1-mini",
+      "google/gemini-2.5-flash",
+      "openrouter/anthropic/claude-sonnet-4-6"
+    ],
+    env: {
+      anthropic: "ANTHROPIC_API_KEY",
+      openai: "OPENAI_API_KEY",
+      openrouter: "OPENROUTER_API_KEY",
+      google: "GOOGLE_GENERATIVE_AI_API_KEY"
+    }
+  },
+  capabilities: {
+    streaming: true,
+    tool_calls: true,
+    sub_agents: true,
+    file_io: true,
+    multimodal: false,
+    // The composite "<resourceId>:<threadId>" sessionId round-trips through
+    // `client.ts`'s connect(resumeSessionId) and has been verified to
+    // recall prior-turn context across a fresh process (see README.md).
+    resumable: true,
+    bidirectional: false
+  },
+  // Mode selection has no argv to append to (no spawn) — modes patch the
+  // one channel `composeSpawn` threads through for every protocol
+  // regardless: env. `client.ts` reads `AGENTPROTO_MASTRACODE_MODE` off
+  // the composed env and switches the live session's mode before send().
+  modes: [
+    {
+      id: "default",
+      description: "Default headless mode. Mastra Code defaults to build mode when omitted."
+    },
+    {
+      id: "plan",
+      description: "Plan-only mode \u2014 analyze architecture and propose implementation plans before writing code.",
+      env: { AGENTPROTO_MASTRACODE_MODE: "plan" }
+    },
+    {
+      id: "build",
+      description: "Build mode \u2014 file edits and shell commands use Mastra Code's configured permissions.",
+      env: { AGENTPROTO_MASTRACODE_MODE: "build" }
+    },
+    {
+      id: "fast",
+      description: "Fast mode \u2014 lower-latency answers and small edits.",
+      env: { AGENTPROTO_MASTRACODE_MODE: "fast" }
+    }
+  ],
+  // `model`/`effort` here are the two ids `createAgentCliRuntime` always
+  // reads off `config.options` for the generic model/effort passthrough
+  // (see `define-agent-cli.ts`) — declaring them is what lets a host pass
+  // `agent_start({ model, effort })` without composeSpawn rejecting the
+  // config as an unknown option. Both travel to `client.ts`'s connect()
+  // directly (not via bin_args/env), so no `bin_args_template`/`env` patch
+  // is declared on either.
+  options: [
+    {
+      id: "model",
+      type: "string",
+      description: "Provider/model override for this operator binding (e.g. `anthropic/claude-sonnet-4-5`)."
+    },
+    {
+      id: "effort",
+      type: "enum",
+      enum: ["off", "low", "medium", "high", "xhigh"],
+      description: "Thinking level, mapped 1:1 to Mastra Code's `thinkingLevel` run option."
+    }
+  ],
+  continuation: {
+    default: "none",
+    supported: ["none", "transcript", "native-resume"]
+  },
+  metadata: {
+    proprietary: {
+      checked: "2026-07-02",
+      result: "Verified in-process against mastracode 0.27.0 / @mastra/core 1.48.0: a turn returns real streamed content, and cross-process resume (kill the process, start a fresh one, reattach via the composite sessionId) recalls prior-turn context. See MASTRACODE-INPROCESS.md for the composite sessionId format."
+    }
+  },
+  tags: ["mastracode", "mastra", "proprietary", "in-process", "agent-runtime", "coding"]
+});
+function mastracodeInprocessRuntime() {
+  return createAgentCliRuntime(mastracodeInprocess);
+}
+
+export { createAgentCliClient, mastracodeInprocess, mastracodeInprocessRuntime };
+//# sourceMappingURL=index.mjs.map
+//# sourceMappingURL=index.mjs.map

package/dist/index.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/client.ts","../src/index.ts"],"names":[],"mappings":"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","file":"index.mjs","sourcesContent":["/**\n * `AgentCliClient` implementation wrapping Mastra Code's in-process SDK\n * (`mastracode` / `mastracode/headless`) instead of spawning a subprocess.\n *\n * ## Why a composite sessionId\n *\n * A single Mastra Code `AgentController` instance auto-binds a *fresh*\n * session to whatever thread `session.thread` currently points at, and\n * (empirically verified against mastracode 0.27.0 / @mastra/core 1.48.0)\n * `runMC()` only rebinds that pointer when `thread.id` / `thread.continueLatest`\n * is explicitly passed. Two unrelated conversations that share both a\n * `cwd` and this arm's dedicated storage file would otherwise silently\n * land on the SAME thread — Mastra Code resolves the initial thread by\n * `resourceId`, and every conversation was defaulting to the same one.\n *\n * The fix (also verified live): pass a distinct `resourceId` to `runMC()`\n * per *conversation*, not per process and not globally via\n * `MASTRA_RESOURCE_ID` (a global env var would race across concurrent\n * in-process conversations in the same daemon). A fresh conversation\n * mints a random resourceId; a resumed one must reuse the EXACT\n * resourceId the thread was created under, because `session.thread.list()`\n * — which `runMC`'s thread-by-id resolution calls internally — is scoped\n * to the session's current resourceId by default. So this arm's public\n * `sessionId` is `\"<resourceId>:<threadId>\"`, and resume splits it back\n * apart. This composite format is this arm's own implementation detail;\n * hosts only ever need to persist and echo back whatever string\n * `sessionId` returns, per the generic AgentCliClient contract.\n *\n * Cross-process resume (kill the process, start a new one, reattach via\n * the same composite sessionId against the same dedicated storage file)\n * has been verified to preserve conversation memory end-to-end.\n */\n\nimport { randomUUID } from \"node:crypto\"\nimport { homedir } from \"node:os\"\nimport { join, dirname } from \"node:path\"\nimport { mkdirSync } from \"node:fs\"\nimport { createMastraCode } from \"mastracode\"\nimport { runMC, type MCRun } from \"mastracode/headless\"\nimport {\n  mapMastraEvent,\n  createMastraMapperState,\n  toFileBasedMcpServers,\n  type AgentCliClient,\n  type AgentCliConnectOptions,\n  type AgentCliHandle,\n  type StreamEvent,\n} from \"@agentproto/driver-agent-cli\"\n\n/** Env var carrying a manifest `modes[].env` patch through to `send()` —\n *  there's no argv for a `proprietary` arm to append `bin_args_append`\n *  to, so mode selection travels the one channel `composeSpawn` already\n *  threads through for every protocol: env. See `../MASTRACODE-INPROCESS.md`. */\nconst MODE_ENV_KEY = \"AGENTPROTO_MASTRACODE_MODE\"\n\nconst VALID_THINKING_LEVELS = new Set([\"off\", \"low\", \"medium\", \"high\", \"xhigh\"])\nconst VALID_RUN_MODES = new Set([\"build\", \"plan\", \"fast\"])\n\nfunction resolveAgentprotoHome(): string {\n  return process.env.AGENTPROTO_HOME ?? join(homedir(), \".agentproto\")\n}\n\n/** Dedicated per-machine storage — NOT the ambient global mastracode\n *  default (which is shared across every mastracode invocation on the\n *  host, subprocess or not). Isolating it here means this arm's threads\n *  never collide with a developer's own interactive `mastracode` usage. */\nfunction resolveStoragePath(): string {\n  return join(resolveAgentprotoHome(), \"mastracode-inprocess\", \"storage.db\")\n}\n\n/** Dedicated, empty home directory so Mastra Code's global config\n *  discovery (`~/.claude/skills`, `~/.mastracode/{hooks,commands,skills}`,\n *  `~/.agents/skills`) does not implicitly inherit the operator's own\n *  personal Claude Code / Mastra Code setup.\n *\n *  KNOWN LIMITATION (verified against 0.27.0, not assumed): passing\n *  `homeDir` at the top level of `MastraCodeConfig` is NOT sufficient —\n *  `createMastraCodeAgentController` resolves `homeDir` for hooks/plugin\n *  wiring but does not copy it into `initialState`, and the workspace's\n *  skill-path builder reads `state.homeDir`, falling back to the real\n *  `os.homedir()` when that's unset. Both `homeDir` AND\n *  `initialState: { homeDir }` must be passed for the override to\n *  actually reach skill discovery. This does not affect a target repo's\n *  own PROJECT-LOCAL `.claude/skills` (relative to `cwd`) — that's the\n *  repo's own content, not the operator's personal config, and is\n *  intentionally left reachable (mirrors the ACP arm reading a target\n *  repo's own `.claude/settings.json`). */\nfunction resolveIsolatedHomeDir(): string {\n  return join(resolveAgentprotoHome(), \"mastracode-inprocess\", \"home\")\n}\n\nfunction parseSessionId(sessionId: string): { resourceId: string; threadId: string } {\n  const idx = sessionId.indexOf(\":\")\n  if (idx <= 0 || idx === sessionId.length - 1) {\n    throw new Error(\n      `mastracode-inprocess: malformed resumeSessionId '${sessionId}' — expected ` +\n        `\"<resourceId>:<threadId>\", the format this arm's own sessionId getter produces.`,\n    )\n  }\n  return { resourceId: sessionId.slice(0, idx), threadId: sessionId.slice(idx + 1) }\n}\n\n/** Narrow shape of `createMastraCode`'s resolved return value this arm\n *  actually uses — kept local (not re-exported from `mastracode`) so this\n *  file only depends on what it reads. */\ninterface MastraCodeHandle {\n  controller: { destroy(): Promise<void> }\n  session: {\n    thread: { getId(): string | null }\n    mode: { get(): string; switch(args: { modeId: string }): Promise<void> }\n  }\n  /** Present when `bootLocalAgentController` builds an MCP manager (i.e.\n   *  MCP servers were configured). `createMastraCode` does NOT initialize\n   *  it automatically — verified against mastracode's own headless CLI\n   *  entrypoint (`runMCCli` in `dist/chunk-HADE25EX.cjs`), which explicitly\n   *  calls `mcpManager.initInBackground()` itself right after boot, before\n   *  running any prompt. Skipping this step (as an earlier version of this\n   *  arm did) leaves `mcpServers` connected-but-never-initialized: the\n   *  config is accepted, but no MCP tools ever reach the agent's toolset. */\n  mcpManager?: {\n    hasServers(): boolean\n    initInBackground(): Promise<unknown>\n  }\n}\n\nexport function createAgentCliClient(definition: AgentCliHandle): AgentCliClient {\n  let handle: MastraCodeHandle | undefined\n  let resourceId: string | undefined\n  let threadId: string | undefined\n  let connectEnv: Record<string, string> = {}\n  let connectModel: string | undefined\n  let connectEffort: string | undefined\n  const pendingByTurn = new Map<string, MCRun>()\n\n  return {\n    get sessionId(): string | undefined {\n      return resourceId && threadId ? `${resourceId}:${threadId}` : undefined\n    },\n\n    async connect(opts: AgentCliConnectOptions): Promise<void> {\n      const isolatedHome = resolveIsolatedHomeDir()\n      const storagePath = resolveStoragePath()\n      mkdirSync(isolatedHome, { recursive: true })\n      mkdirSync(dirname(storagePath), { recursive: true })\n\n      handle = (await createMastraCode({\n        cwd: opts.cwd,\n        homeDir: isolatedHome,\n        initialState: { homeDir: isolatedHome },\n        disablePlugins: true,\n        storage: { backend: \"libsql\", url: `file:${storagePath}`, isRemote: false },\n        ...(opts.mcpServers?.length\n          ? { mcpServers: toFileBasedMcpServers(opts.mcpServers) }\n          : {}),\n      })) as unknown as MastraCodeHandle\n\n      // `createMastraCode` builds the MCP manager but does not initialize\n      // it — mirror mastracode's own headless CLI (`runMCCli`), which\n      // explicitly awaits this before running any prompt. Without it, MCP\n      // servers are configured but never connected, so their tools never\n      // reach the agent. Best-effort: a failed MCP connection shouldn't\n      // fail the whole session (matches the CLI's own warn-and-continue).\n      if (handle.mcpManager?.hasServers()) {\n        try {\n          await handle.mcpManager.initInBackground()\n        } catch {\n          // Best-effort — the session still starts on its non-MCP tools.\n        }\n      }\n\n      connectEnv = opts.env\n      connectModel = opts.model\n      connectEffort = opts.effort\n\n      if (opts.resumeSessionId) {\n        ;({ resourceId, threadId } = parseSessionId(opts.resumeSessionId))\n      } else {\n        resourceId = `agentproto-mastracode-inprocess-${randomUUID()}`\n        threadId = undefined\n      }\n    },\n\n    async send(turnId: string, message: unknown): Promise<void> {\n      if (!handle || !resourceId) {\n        throw new Error(\"mastracode-inprocess: send() called before connect()\")\n      }\n      const prompt = extractPromptText(message)\n\n      const requestedMode = connectEnv[MODE_ENV_KEY]\n      if (requestedMode && VALID_RUN_MODES.has(requestedMode)) {\n        if (handle.session.mode.get() !== requestedMode) {\n          await handle.session.mode.switch({ modeId: requestedMode })\n        }\n      }\n\n      const thinkingLevel =\n        connectEffort && VALID_THINKING_LEVELS.has(connectEffort)\n          ? (connectEffort as \"off\" | \"low\" | \"medium\" | \"high\" | \"xhigh\")\n          : undefined\n\n      const run = runMC({\n        controller: handle.controller as never,\n        session: handle.session as never,\n        prompt,\n        resourceId,\n        thread: threadId ? { id: threadId } : undefined,\n        ...(connectModel ? { model: connectModel } : {}),\n        ...(thinkingLevel ? { thinkingLevel } : {}),\n        ...(definition.session?.max_turns\n          ? { maxTurns: definition.session.max_turns }\n          : {}),\n      })\n      pendingByTurn.set(turnId, run)\n    },\n\n    async *events(): AsyncIterable<StreamEvent> {\n      const run = Array.from(pendingByTurn.values()).at(-1)\n      if (!run) return\n      const state = createMastraMapperState()\n      for await (const evt of run) {\n        // Track the thread id live from in-band events, synchronously\n        // with the loop that's about to map+yield them — no race against\n        // `run.result` resolving on a separate microtask.\n        if (evt.type === \"thread_created\") threadId = evt.thread.id\n        else if (evt.type === \"thread_changed\") threadId = evt.threadId\n        const sid = resourceId && threadId ? `${resourceId}:${threadId}` : \"\"\n        const mapped = mapMastraEvent(\n          evt as unknown as Record<string, unknown>,\n          sid,\n          [],\n          state,\n        )\n        if (mapped) yield mapped\n      }\n      // Fallback for the (unverified) case where a fresh thread's first\n      // binding happens inside `sendMessage()` without an in-band\n      // `thread_created`/`thread_changed` event — `result.threadId` is\n      // always populated once the run settles, so this is authoritative\n      // even if the loop above never fired.\n      const result = await run.result\n      if (result.threadId) threadId = result.threadId\n    },\n\n    async cancel(turnId: string): Promise<void> {\n      pendingByTurn.get(turnId)?.abort()\n    },\n\n    async close(): Promise<void> {\n      await handle?.controller.destroy()\n    },\n  }\n}\n\nfunction extractPromptText(message: unknown): string {\n  if (typeof message === \"string\") return message\n  if (Array.isArray(message)) {\n    return (message as Array<Record<string, unknown>>)\n      .filter(b => b.type === \"text\" && typeof b.text === \"string\")\n      .map(b => b.text as string)\n      .join(\"\\n\")\n  }\n  if (message !== null && typeof message === \"object\") {\n    const m = message as Record<string, unknown>\n    if (typeof m.text === \"string\") return m.text\n  }\n  return JSON.stringify(message)\n}\n","/**\n * @agentproto/adapter-mastracode-inprocess — AIP-45 adapter for Mastra Code,\n * driven in-process via the `mastracode` / `mastracode/headless` SDK\n * instead of spawning a subprocess.\n *\n * This is a `protocol: \"proprietary\"` manifest: `createAgentCliRuntime`\n * skips the subprocess spawn entirely for this protocol and instead\n * dynamic-imports `adapter` (this very package) and calls its exported\n * `createAgentCliClient(definition)` factory — see\n * `createProprietaryProtocolArm` in `@agentproto/driver-agent-cli`. The\n * factory itself lives in `./client.ts`; this file only builds and\n * exports the manifest handle.\n *\n *   import { mastracodeInprocess, mastracodeInprocessRuntime } from \"@agentproto/adapter-mastracode-inprocess\"\n *   const session = await mastracodeInprocessRuntime().start()\n *   for await (const evt of session.send({ role: \"user\", content: \"...\" })) {\n *     console.log(evt)\n *   }\n *   await session.close()\n *\n * Why a separate package from `@agentproto/adapter-mastracode` (the\n * `print` arm) rather than a second export of it — see\n * MASTRACODE-INPROCESS.md.\n */\n\nimport {\n  createAgentCliRuntime,\n  defineAgentCli,\n  type AgentCliHandle,\n  type AgentCliRuntime,\n} from \"@agentproto/driver-agent-cli\"\n\nexport const mastracodeInprocess: AgentCliHandle = defineAgentCli({\n  name: \"Mastra Code (in-process)\",\n  id: \"mastracode-inprocess\",\n  description:\n    \"Mastra Code terminal coding agent driven in-process via the `mastracode` SDK \" +\n    \"(createMastraCode + runMC) instead of spawning the CLI as a subprocess. Same \" +\n    \"underlying agent as @agentproto/adapter-mastracode, no child process.\",\n  version: \"0.1.0\",\n  // No binary is ever spawned for a proprietary arm — `bin` is required by\n  // the AIP-45 schema regardless, so this is a documented placeholder\n  // rather than a real executable. `createAgentCliRuntime` checks\n  // `protocol === \"proprietary\"` and never reads this field.\n  bin: \"in-process\",\n  install: [{ method: \"npm\", package: \"@agentproto/adapter-mastracode-inprocess\" }],\n  version_check: {\n    cmd: \"npm view mastracode version\",\n    parse: \"(\\\\d+\\\\.\\\\d+\\\\.\\\\d+)\",\n    // Matches this package's pinned `mastracode` dependency (see package.json).\n    range: \">=0.27.0\",\n    timeout_ms: 15_000,\n  },\n  auth: {\n    state: {\n      env: [\n        \"ANTHROPIC_API_KEY\",\n        \"OPENAI_API_KEY\",\n        \"OPENROUTER_API_KEY\",\n        \"GOOGLE_GENERATIVE_AI_API_KEY\",\n      ],\n    },\n  },\n  sandbox: {\n    model: \"in-process\",\n    note:\n      \"Runs inside the host process — there is no subprocess boundary to sandbox. \" +\n      \"File and shell tool access is whatever Mastra Code's own tool policy grants \" +\n      \"for this session, with the host process's OS permissions (not a separately \" +\n      \"confined child). Storage and home dir ARE isolated per MASTRACODE-INPROCESS.md \" +\n      \"so this arm's sessions never collide with a developer's own interactive \" +\n      \"mastracode usage, but that isolation is not a security sandbox.\",\n  },\n  protocol: \"proprietary\",\n  adapter: \"@agentproto/adapter-mastracode-inprocess\",\n  session: {\n    mode: \"resumable\",\n    idle_timeout_ms: 1_800_000,\n    context_carryover: true,\n  },\n  models: {\n    default: \"anthropic/claude-sonnet-4-5\",\n    allowed: [\n      \"anthropic/claude-sonnet-4-5\",\n      \"anthropic/claude-sonnet-4-6\",\n      \"openai/gpt-5.1\",\n      \"openai/gpt-5.1-mini\",\n      \"google/gemini-2.5-flash\",\n      \"openrouter/anthropic/claude-sonnet-4-6\",\n    ],\n    env: {\n      anthropic: \"ANTHROPIC_API_KEY\",\n      openai: \"OPENAI_API_KEY\",\n      openrouter: \"OPENROUTER_API_KEY\",\n      google: \"GOOGLE_GENERATIVE_AI_API_KEY\",\n    },\n  },\n  capabilities: {\n    streaming: true,\n    tool_calls: true,\n    sub_agents: true,\n    file_io: true,\n    multimodal: false,\n    // The composite \"<resourceId>:<threadId>\" sessionId round-trips through\n    // `client.ts`'s connect(resumeSessionId) and has been verified to\n    // recall prior-turn context across a fresh process (see README.md).\n    resumable: true,\n    bidirectional: false,\n  },\n  // Mode selection has no argv to append to (no spawn) — modes patch the\n  // one channel `composeSpawn` threads through for every protocol\n  // regardless: env. `client.ts` reads `AGENTPROTO_MASTRACODE_MODE` off\n  // the composed env and switches the live session's mode before send().\n  modes: [\n    {\n      id: \"default\",\n      description: \"Default headless mode. Mastra Code defaults to build mode when omitted.\",\n    },\n    {\n      id: \"plan\",\n      description:\n        \"Plan-only mode — analyze architecture and propose implementation plans before writing code.\",\n      env: { AGENTPROTO_MASTRACODE_MODE: \"plan\" },\n    },\n    {\n      id: \"build\",\n      description:\n        \"Build mode — file edits and shell commands use Mastra Code's configured permissions.\",\n      env: { AGENTPROTO_MASTRACODE_MODE: \"build\" },\n    },\n    {\n      id: \"fast\",\n      description: \"Fast mode — lower-latency answers and small edits.\",\n      env: { AGENTPROTO_MASTRACODE_MODE: \"fast\" },\n    },\n  ],\n  // `model`/`effort` here are the two ids `createAgentCliRuntime` always\n  // reads off `config.options` for the generic model/effort passthrough\n  // (see `define-agent-cli.ts`) — declaring them is what lets a host pass\n  // `agent_start({ model, effort })` without composeSpawn rejecting the\n  // config as an unknown option. Both travel to `client.ts`'s connect()\n  // directly (not via bin_args/env), so no `bin_args_template`/`env` patch\n  // is declared on either.\n  options: [\n    {\n      id: \"model\",\n      type: \"string\",\n      description:\n        \"Provider/model override for this operator binding (e.g. `anthropic/claude-sonnet-4-5`).\",\n    },\n    {\n      id: \"effort\",\n      type: \"enum\",\n      enum: [\"off\", \"low\", \"medium\", \"high\", \"xhigh\"],\n      description:\n        \"Thinking level, mapped 1:1 to Mastra Code's `thinkingLevel` run option.\",\n    },\n  ],\n  continuation: {\n    default: \"none\",\n    supported: [\"none\", \"transcript\", \"native-resume\"],\n  },\n  metadata: {\n    proprietary: {\n      checked: \"2026-07-02\",\n      result:\n        \"Verified in-process against mastracode 0.27.0 / @mastra/core 1.48.0: a turn \" +\n        \"returns real streamed content, and cross-process resume (kill the process, \" +\n        \"start a fresh one, reattach via the composite sessionId) recalls prior-turn \" +\n        \"context. See MASTRACODE-INPROCESS.md for the composite sessionId format.\",\n    },\n  },\n  tags: [\"mastracode\", \"mastra\", \"proprietary\", \"in-process\", \"agent-runtime\", \"coding\"],\n})\n\nexport function mastracodeInprocessRuntime(): AgentCliRuntime {\n  return createAgentCliRuntime(mastracodeInprocess)\n}\n\nexport { createAgentCliClient } from \"./client.js\"\nexport type { AgentCliHandle, AgentCliRuntime }\n"]}

package/package.json

@@ -0,0 +1,64 @@
+{
+  "name": "@agentproto/adapter-mastracode-inprocess",
+  "version": "0.2.0",
+  "description": "@agentproto/adapter-mastracode-inprocess — AIP-45 AGENT-CLI adapter for Mastra Code driven in-process via the `mastracode`/`mastracode/headless` SDK, instead of spawning a subprocess. Implements the `protocol: \"proprietary\"` arm contract directly.",
+  "keywords": [
+    "agentproto",
+    "aip-45",
+    "mastracode",
+    "mastra",
+    "proprietary",
+    "in-process",
+    "agent-cli",
+    "adapter"
+  ],
+  "homepage": "https://agentproto.sh/docs/aip-45",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/agentproto/ts",
+    "directory": "adapters/mastracode-inprocess"
+  },
+  "license": "MIT",
+  "type": "module",
+  "main": "dist/index.mjs",
+  "module": "dist/index.mjs",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.mjs",
+      "default": "./dist/index.mjs"
+    },
+    "./MASTRACODE-INPROCESS.md": "./MASTRACODE-INPROCESS.md",
+    "./package.json": "./package.json"
+  },
+  "files": [
+    "dist",
+    "MASTRACODE-INPROCESS.md",
+    "README.md",
+    "LICENSE"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "@mastra/core": "1.48.0",
+    "mastracode": "0.27.0",
+    "@agentproto/driver-agent-cli": "0.3.0"
+  },
+  "devDependencies": {
+    "@types/node": "^25.6.2",
+    "tsup": "^8.5.1",
+    "typescript": "^5.9.3",
+    "vitest": "^3.2.4",
+    "@agentproto/tooling": "0.1.0-alpha.0"
+  },
+  "scripts": {
+    "dev": "tsup --watch",
+    "build": "tsup",
+    "clean": "rm -rf dist",
+    "check-types": "tsc --noEmit",
+    "test": "vitest run --passWithNoTests",
+    "test:watch": "vitest"
+  }
+}