@agentskit/adapters 0.16.0 → 0.17.0

package/README.md

@@ -39,6 +39,7 @@ Docs: [package guide](https://www.agentskit.io/docs/reference/packages/adapters)
 - **Embedder functions built in** — the same adapter pattern covers text embeddings, so you can reuse provider config for both chat and RAG
 - **One-line local AI** — `ollama({ model: 'llama3.1' })` for fully offline agents with no API key required
 - **CLI-backed agents** — `@agentskit/adapters/cli` normalizes text, JSON, and ACP-based local LLM CLIs
+- **LangChain bridge** — `@agentskit/adapters/langchain-bridge` turns any adapter into a LangChain `BaseChatModel` for `createAgent`
 
 ## Install
 
@@ -106,8 +107,8 @@ const adapter = createCliAdapter(resolveCliManifest(manifest, { mode: 'review-sa
 
 The generic factories are `createCliAdapter` (`exec-text`),
 `createJsonCliAdapter` (`exec-json`), and `createAcpCliAdapter` (ACP v1 over
-JSON lines). The built-in manifests cover Codex, Claude Code, Grok CLI, and
-OpenCode. `resolveCliManifest` keeps command, argv, protocol, provider id, and
+JSON lines). The built-in manifests cover Codex, Claude Code (text and JSON
+output), Grok CLI, and OpenCode. `resolveCliManifest` keeps command, argv, protocol, provider id, and
 mode explicit; `diagnoseCliProviderManifest` verifies availability and an
 optional version pattern. `review-safe` is the default: no shell, automatic
 installation, native login, MCP, plugins, or terminal tools. Use
@@ -121,6 +122,92 @@ is awaited before the adapter finishes, including when input or output fails.
 an OS, filesystem, process, or network sandbox. Use `@agentskit/sandbox` when a
 real isolation boundary is required.
 
+### `exec-text` vs `exec-json`: what each protocol can return
+
+The protocol decides which stream chunks a manifest can produce. Pick the
+manifest by what you need back, not by the CLI name:
+
+| Protocol    | Factory                | Chunks emitted                          | Not available                                  |
+| ----------- | ---------------------- | --------------------------------------- | ---------------------------------------------- |
+| `exec-text` | `createCliAdapter`     | `text` (streamed), `done`               | `structuredOutput`, `reasoning`, `tool_call`, usage |
+| `exec-json` | `createJsonCliAdapter` | `text`, `reasoning`, `tool_call`, `usage`, `done` | streaming (one response per process)   |
+| `acp`       | `createAcpCliAdapter`  | `text`, `reasoning` (streamed), `done`  | tool calls (rejected), MCP, plugins, terminal  |
+
+`validateCliProviderManifest` rejects a manifest that claims a capability its
+protocol cannot deliver, and `requiredCapabilities` fails before spawning for
+the same reason. In practice: the `claude-code` and `codex` manifests are
+`exec-text` and only ever yield plain text. For tool calls, usage, or
+structured output from Claude Code use `claude-code-json` instead.
+
+The same table is enforced at compile time. `CliProviderManifest` is a union
+discriminated by `protocol`, `capabilities` is typed as
+`CliCapabilitiesFor<protocol>`, and `getCliProviderManifest('claude-code')`
+returns `CliProviderManifestFor<'exec-text'>`, so this does not type-check:
+
+```ts
+const manifest = getCliProviderManifest('claude-code')!
+resolveCliManifest(manifest, { requiredCapabilities: { tools: true } })
+//                                                    ^^^^^ not assignable: exec-text has no tools/structuredOutput
+```
+
+### Claude Code
+
+Two first-party manifests wrap the `claude` executable:
+
+- `claude-code` — `claude -p`, `exec-text`. Streams the final answer as text.
+- `claude-code-json` — `claude -p --output-format json`, `exec-json`. Parses
+  the result envelope into `text`, `tool_call`, and `usage` chunks with
+  `session_id`, `total_cost_usd`, `duration_ms`, and `num_turns` as metadata.
+  `is_error` or a non-`success` subtype fails closed.
+
+```ts
+import { createJsonCliAdapter, getCliProviderManifest, resolveCliManifest } from '@agentskit/adapters/cli'
+
+const manifest = getCliProviderManifest('claude-code-json')
+if (!manifest) throw new Error('provider manifest is unavailable')
+const adapter = createJsonCliAdapter(resolveCliManifest(manifest, { mode: 'trusted-local' }))
+```
+
+When the request carries `context.tools`, the tool list and a
+`{ text?, toolCalls }` reply contract are appended to Claude Code's system
+prompt via `--append-system-prompt`; `claude-code-json` recognizes that object
+(fenced or bare) in the `result` string and emits `tool_call` chunks. Plain prose results stay `text`.
+`structured_output` from `--json-schema` is honored the same way. Tool
+execution itself remains the consumer's responsibility: the adapter never
+enables Claude Code's own tools, MCP, or plugins.
+
+### Prompt serialization
+
+`createCliAdapter` and `createJsonCliAdapter` default to writing the raw
+`AdapterRequest` as one JSON line on stdin. That is the right contract for a
+purpose-built CLI, but agentic CLIs read stdin as a user prompt, and Claude
+Code refuses a raw JSON request containing `systemPrompt` as an apparent
+prompt-injection attempt. The first-party manifests therefore use two
+exported serializers:
+
+- `serializeCliPrompt` (used by `codex`) writes labelled blocks:
+
+  ```text
+  [system]
+  You are a reviewer.
+
+  [user]
+  review this
+  ```
+
+- `serializeCliMessages` plus `claudeCodeRequestArgs` (used by `claude-code`
+  and `claude-code-json`) writes only the conversation to stdin (a single user
+  message is written bare) and passes the system prompt and the tool contract
+  through `--append-system-prompt`. Verified live against Claude Code 2.1:
+  the same instructions inside the user prompt, even as labelled `[system]`
+  blocks, are flagged as an injection attempt, whereas through the system
+  flag a request with `context.tools` comes back as a `tool_call` chunk.
+
+A manifest may declare `serializeRequest`, `requestArgs` (extra per-request
+argv, appended after `args`), `parseOutput`, and `parse`; `resolveCliManifest`
+forwards them to the factory. `buildCliSystemPrompt(request)` returns the
+system prompt plus tool contract for other CLIs with a system-prompt flag.
+
 Use `buildArgs(request)` only for CLIs that require the prompt in argv; it is
 request-aware and still uses direct, shell-free spawning. Set
 `serializeRequest: () => ''` when the provider does not consume stdin. For
@@ -129,6 +216,46 @@ before the normal `parse(value)` callback runs.
 For CLIs that write the final response to a file, `outputFile` reads that file
 after process completion with the same byte limit and abort handling.
 
+## LangChain bridge: use any adapter as a LangChain chat model
+
+`langchain()` and `langgraph()` expose a LangChain runnable as an
+`AdapterFactory`. The `@agentskit/adapters/langchain-bridge` subpath goes the
+other way: `adapterToLangChainModel(adapter)` wraps any `AdapterFactory`
+(mock, Ollama, a CLI-backed adapter, ...) as a real `BaseChatModel`, so it can
+replace `ChatAnthropic`/`ChatOpenAI` in `createAgent`, `AgentNode`, or a plain
+chain. It needs `@langchain/core` (optional peer dependency).
+
+```ts
+import { createAgent } from 'langchain'
+import { tool } from '@langchain/core/tools'
+import { mockAdapter } from '@agentskit/adapters'
+import { adapterToLangChainModel } from '@agentskit/adapters/langchain-bridge'
+
+const add = tool(async ({ a, b }) => String(a + b), {
+  name: 'add',
+  description: 'Add two numbers',
+  schema: { type: 'object', properties: { a: { type: 'number' }, b: { type: 'number' } }, required: ['a', 'b'] },
+})
+const model = adapterToLangChainModel(mockAdapter({ response: [/* ... */] }), { modelName: 'mock' })
+const agent = createAgent({ model, tools: [add] })
+```
+
+- `bindTools()` forwards LangChain tools (structured tools, OpenAI-format
+  definitions, runnable tools) as AgentsKit `ToolDefinition`s on
+  `context.tools`; `tool_choice` lands in `context.metadata.toolChoice`.
+- System messages become both a `system` message and `context.systemPrompt`;
+  AI messages keep `tool_calls`; tool messages keep `tool_call_id`.
+- `tool_call` chunks become `AIMessage.tool_calls` (args parsed from JSON),
+  `usage` chunks become `usage_metadata`, `reasoning` chunks land in
+  `additional_kwargs.reasoning`, `error` chunks throw, and `.stream()` yields
+  `AIMessageChunk`s with `tool_call_chunks`.
+- Every response is a real `AIMessage`/`AIMessageChunk` instance, so
+  `wrapModelCall` middleware and `responseFormat` work together. The default
+  `profile` reports `toolCalling` and no native `structuredOutput`, so
+  `createAgent` uses its tool strategy, which any tool-calling adapter can
+  satisfy. Pass `profile: { structuredOutput: true }` only for adapters that
+  honour a provider-side JSON schema.
+
 ## Stream guarantees
 
 - A stream terminates exactly once with `done` or `error`; terminal errors carry an `Error` in `metadata.error`.

package/dist/cli/index.cjs

@@ -366,6 +366,162 @@ async function abortableWrite(handle, input, signal) {
     if (onError) handle.child.stdin.removeListener("error", onError);
   }
 }
+var cliError = (message, cause) => new core.AdapterError({ code: core.ErrorCodes.AK_ADAPTER_STREAM_FAILED, message, cause });
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function parseCliJsonResponse(value) {
+  if (!isRecord(value)) throw cliError("CLI JSON response must be an object");
+  const chunks = [];
+  if (typeof value.text === "string") chunks.push({ type: "text", content: value.text });
+  if (typeof value.reasoning === "string") chunks.push({ type: "reasoning", content: value.reasoning });
+  if (Array.isArray(value.toolCalls)) {
+    for (const item of value.toolCalls) {
+      if (!isRecord(item) || typeof item.id !== "string" || typeof item.name !== "string" || typeof item.args !== "string") {
+        throw cliError("CLI JSON toolCalls must contain string id, name, and args fields");
+      }
+      JSON.parse(item.args);
+      chunks.push({ type: "tool_call", toolCall: { id: item.id, name: item.name, args: item.args } });
+    }
+  }
+  if (value.usage !== void 0) {
+    if (!isRecord(value.usage)) {
+      throw cliError("CLI JSON usage must contain numeric promptTokens, completionTokens, and totalTokens");
+    }
+    const promptTokens = value.usage.promptTokens;
+    const completionTokens = value.usage.completionTokens;
+    const totalTokens = value.usage.totalTokens;
+    if (typeof promptTokens !== "number" || typeof completionTokens !== "number" || typeof totalTokens !== "number") {
+      throw cliError("CLI JSON usage must contain numeric promptTokens, completionTokens, and totalTokens");
+    }
+    chunks.push({ type: "usage", usage: { promptTokens, completionTokens, totalTokens } });
+  }
+  if (value.metadata !== void 0) {
+    if (!isRecord(value.metadata)) throw cliError("CLI JSON metadata must be an object");
+    if (chunks.length === 0) throw cliError("CLI JSON response contains no semantic output");
+    chunks[chunks.length - 1] = { ...chunks[chunks.length - 1], metadata: value.metadata };
+  }
+  if (chunks.length === 0) throw cliError("CLI JSON response contains no semantic output");
+  return chunks;
+}
+
+// src/cli/prompt.ts
+function serializeCliPrompt(request, options = {}) {
+  const blocks = [];
+  const system = request.context?.systemPrompt;
+  if (options.system !== false && system) blocks.push(`[system]
+${system}`);
+  const tools = request.context?.tools;
+  if (options.tools !== false && tools && tools.length > 0) blocks.push(`[tools]
+${describeTools(tools)}`);
+  const messages = request.messages.filter((message) => message.role !== "system" || options.system !== false);
+  if (blocks.length === 0 && messages.length === 1 && messages[0].role === "user") return `${messages[0].content}
+`;
+  for (const message of messages) blocks.push(`[${message.role}]
+${message.content}`);
+  return `${blocks.join("\n\n")}
+`;
+}
+function serializeCliMessages(request) {
+  return serializeCliPrompt(request, { system: false, tools: false });
+}
+function buildCliSystemPrompt(request) {
+  const parts = [];
+  if (request.context?.systemPrompt) parts.push(request.context.systemPrompt);
+  const tools = request.context?.tools;
+  if (tools && tools.length > 0) parts.push(describeTools(tools));
+  return parts.length > 0 ? parts.join("\n\n") : void 0;
+}
+function claudeCodeRequestArgs(request) {
+  const system = buildCliSystemPrompt(request);
+  return system ? ["--append-system-prompt", system] : [];
+}
+var TOOL_CONTRACT = [
+  "The application running you exposes the tools listed below; it executes them, not you.",
+  "To call one or more of them, reply with only a single JSON object",
+  '{"text"?: string, "toolCalls": [{"id": string, "name": string, "args": string}]} where `args` is a JSON-encoded',
+  "string of the tool arguments and `id` is any unique string. When no tool call is needed, reply with plain text."
+].join(" ");
+function describeTools(tools) {
+  const definitions = tools.map((tool) => ({ name: tool.name, description: tool.description, schema: tool.schema }));
+  return `${TOOL_CONTRACT}
+${JSON.stringify(definitions, null, 2)}`;
+}
+function isRecord2(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function claudeCodeError(message, cause) {
+  return new core.AdapterError({
+    code: core.ErrorCodes.AK_ADAPTER_STREAM_FAILED,
+    message,
+    cause,
+    hint: 'Run `claude -p --output-format json "ping"` manually to inspect the envelope emitted by the installed Claude Code version.'
+  });
+}
+function number(value) {
+  return typeof value === "number" && Number.isFinite(value) ? value : 0;
+}
+var RESPONSE_KEYS = ["text", "reasoning", "toolCalls"];
+var FENCE = "```";
+function unfence(text) {
+  if (!text.startsWith(FENCE) || !text.endsWith(FENCE) || text.length < FENCE.length * 2) return text;
+  let inner = text.slice(FENCE.length, text.length - FENCE.length);
+  if (inner.startsWith("json")) inner = inner.slice("json".length);
+  return inner.trim();
+}
+function embeddedResponse(result) {
+  const candidate = unfence(result.trim());
+  if (!candidate.startsWith("{") || !candidate.endsWith("}")) return void 0;
+  let value;
+  try {
+    value = JSON.parse(candidate);
+  } catch {
+    return void 0;
+  }
+  if (!isRecord2(value) || !RESPONSE_KEYS.some((key) => key in value)) return void 0;
+  return value;
+}
+function parseClaudeCodeJsonResponse(value) {
+  if (!isRecord2(value) || value.type !== "result") throw claudeCodeError("Claude Code JSON output must be a `result` envelope");
+  const result = typeof value.result === "string" ? value.result : "";
+  if (value.is_error === true || typeof value.subtype === "string" && value.subtype !== "success") {
+    throw claudeCodeError(`Claude Code returned ${String(value.subtype ?? "error")}${result ? `: ${result}` : ""}`);
+  }
+  const chunks = [];
+  const structured = isRecord2(value.structured_output) ? value.structured_output : void 0;
+  if (structured && RESPONSE_KEYS.some((key) => key in structured)) {
+    chunks.push(...parseCliJsonResponse(structured));
+  } else if (structured) {
+    chunks.push({ type: "text", content: JSON.stringify(structured) });
+  } else {
+    const embedded = embeddedResponse(result);
+    if (embedded) chunks.push(...parseCliJsonResponse(embedded));
+    else if (result) chunks.push({ type: "text", content: result });
+  }
+  if (isRecord2(value.usage)) {
+    const promptTokens = number(value.usage.input_tokens) + number(value.usage.cache_creation_input_tokens) + number(value.usage.cache_read_input_tokens);
+    const completionTokens = number(value.usage.output_tokens);
+    chunks.push({ type: "usage", usage: { promptTokens, completionTokens, totalTokens: promptTokens + completionTokens } });
+  }
+  if (chunks.length === 0) throw claudeCodeError("Claude Code JSON output contains no semantic output");
+  const metadata = {};
+  for (const key of ["session_id", "total_cost_usd", "duration_ms", "num_turns", "subtype"]) {
+    if (value[key] !== void 0) metadata[key] = value[key];
+  }
+  const last = chunks[chunks.length - 1];
+  chunks[chunks.length - 1] = { ...last, metadata: { ...last.metadata, ...metadata } };
+  return chunks;
+}
+function parseClaudeCodeJsonOutput(stdout) {
+  const trimmed = stdout.trim();
+  try {
+    return JSON.parse(trimmed);
+  } catch (error) {
+    const start = trimmed.lastIndexOf("\n{");
+    if (start < 0) throw claudeCodeError(`Claude Code stdout is not a JSON envelope: ${error instanceof Error ? error.message : String(error)}`, error);
+    return JSON.parse(trimmed.slice(start + 1));
+  }
+}
 var MODES = ["review-safe", "trusted-local", "restricted-environment"];
 var CAPABILITIES = /* @__PURE__ */ new Set([
   "streaming",
@@ -388,9 +544,13 @@ var manifests = [
     capabilities: { streaming: true, nativeAuth: true },
     supportedModes: MODES,
     credentialEnv: ["OPENAI_API_KEY", "CODEX_API_KEY"],
-    docsUrl: "https://github.com/openai/codex"
+    docsUrl: "https://github.com/openai/codex",
+    serializeRequest: serializeCliPrompt
   },
   {
+    // Plain-text transport: streams Claude Code's final answer as text.
+    // No structured output, reasoning, or tool calls; use `claude-code-json`
+    // for those.
     id: "claude-code",
     name: "Claude Code",
     command: "claude",
@@ -400,7 +560,27 @@ var manifests = [
     capabilities: { streaming: true, nativeAuth: true },
     supportedModes: MODES,
     credentialEnv: ["ANTHROPIC_API_KEY"],
-    docsUrl: "https://docs.anthropic.com/en/docs/claude-code/cli-usage"
+    docsUrl: "https://docs.anthropic.com/en/docs/claude-code/cli-usage",
+    serializeRequest: serializeCliMessages,
+    requestArgs: claudeCodeRequestArgs
+  },
+  {
+    // Structured transport: one `claude -p --output-format json` envelope per
+    // request, parsed into text, tool_call, and usage chunks. Not streaming.
+    id: "claude-code-json",
+    name: "Claude Code (JSON output)",
+    command: "claude",
+    args: ["-p", "--output-format", "json"],
+    diagnosticArgs: ["--version"],
+    protocol: "exec-json",
+    capabilities: { structuredOutput: true, nativeAuth: true },
+    supportedModes: MODES,
+    credentialEnv: ["ANTHROPIC_API_KEY"],
+    docsUrl: "https://docs.anthropic.com/en/docs/claude-code/cli-usage",
+    serializeRequest: serializeCliMessages,
+    requestArgs: claudeCodeRequestArgs,
+    parseOutput: parseClaudeCodeJsonOutput,
+    parse: parseClaudeCodeJsonResponse
   },
   {
     id: "grok",
@@ -443,13 +623,14 @@ function validateArgs(values, label) {
     if (value.includes("\0")) throw manifestError(`CLI manifest ${label} contains a null byte`);
   }
 }
-function isRecord(value) {
+function isRecord3(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function validateCapabilities(manifest) {
-  for (const capability of Object.keys(manifest.capabilities)) {
+  const declared = manifest.capabilities;
+  for (const capability of Object.keys(declared)) {
     if (!CAPABILITIES.has(capability)) throw manifestError(`CLI manifest declares unknown capability: ${capability}`);
-    if (manifest.capabilities[capability] !== true) throw manifestError(`CLI manifest capability ${capability} must be true or omitted`);
+    if (declared[capability] !== true) throw manifestError(`CLI manifest capability ${capability} must be true or omitted`);
   }
   const unsupportedByProtocol = {
     "exec-text": ["structuredOutput", "reasoning", "tools", "mcp", "plugins", "terminal"],
@@ -457,11 +638,11 @@ function validateCapabilities(manifest) {
     acp: ["tools", "mcp", "plugins", "terminal"]
   };
   for (const capability of unsupportedByProtocol[manifest.protocol]) {
-    if (manifest.capabilities[capability] === true) throw manifestError(`CLI manifest ${manifest.id} declares unsupported ${capability} for ${manifest.protocol}`);
+    if (declared[capability] === true) throw manifestError(`CLI manifest ${manifest.id} declares unsupported ${capability} for ${manifest.protocol}`);
   }
 }
 function validateCliProviderManifest(manifest) {
-  if (!isRecord(manifest)) throw manifestError("CLI manifest must be an object");
+  if (!isRecord3(manifest)) throw manifestError("CLI manifest must be an object");
   if (typeof manifest.id !== "string" || typeof manifest.name !== "string" || typeof manifest.command !== "string") {
     throw manifestError("CLI manifest id, name, and command must be strings");
   }
@@ -471,7 +652,7 @@ function validateCliProviderManifest(manifest) {
   if (manifest.protocol !== "exec-text" && manifest.protocol !== "exec-json" && manifest.protocol !== "acp") {
     throw manifestError("CLI manifest protocol is unsupported");
   }
-  if (!isRecord(manifest.capabilities) || !Array.isArray(manifest.supportedModes)) throw manifestError("CLI manifest capabilities and supportedModes are required");
+  if (!isRecord3(manifest.capabilities) || !Array.isArray(manifest.supportedModes)) throw manifestError("CLI manifest capabilities and supportedModes are required");
   if (!manifest.supportedModes.every((value) => typeof value === "string")) throw manifestError("CLI manifest supportedModes must be a string array");
   const candidate = manifest;
   nonEmpty(candidate.id, "id");
@@ -498,6 +679,12 @@ function validateCliProviderManifest(manifest) {
     }
   }
   if (candidate.docsUrl !== void 0 && typeof candidate.docsUrl !== "string") throw manifestError(`CLI manifest ${candidate.id} docsUrl must be a string`);
+  for (const key of ["serializeRequest", "requestArgs", "parseOutput", "parse"]) {
+    if (candidate[key] !== void 0 && typeof candidate[key] !== "function") throw manifestError(`CLI manifest ${candidate.id} ${key} must be a function`);
+    if ((key === "parseOutput" || key === "parse") && candidate[key] !== void 0 && candidate.protocol !== "exec-json") {
+      throw manifestError(`CLI manifest ${candidate.id} declares ${key}, which only applies to the exec-json protocol`);
+    }
+  }
   validateCapabilities(candidate);
 }
 function listCliProviderManifests() {
@@ -517,9 +704,12 @@ function resolveCliManifest(manifest, options = {}) {
   validateCliProviderManifest(manifest);
   const mode = options.mode ?? "review-safe";
   if (!manifest.supportedModes.includes(mode)) throw manifestError(`CLI manifest ${manifest.id} does not support mode: ${mode}`);
+  const args = [...manifest.args, ...options.args ?? []];
+  const requestArgs = manifest.requestArgs;
   return {
     command: manifest.command,
-    args: [...manifest.args, ...options.args ?? []],
+    args,
+    buildArgs: requestArgs ? (request) => [...args, ...requestArgs(request)] : void 0,
     mode,
     cwd: options.cwd,
     env: options.env,
@@ -529,7 +719,10 @@ function resolveCliManifest(manifest, options = {}) {
     providerId: manifest.id,
     protocol: manifest.protocol,
     onDiagnostic: options.onDiagnostic,
-    requiredCapabilities: options.requiredCapabilities
+    requiredCapabilities: options.requiredCapabilities,
+    serializeRequest: manifest.serializeRequest,
+    parseOutput: manifest.parseOutput,
+    parse: manifest.parse
   };
 }
 function adapterCapabilities(manifest) {
@@ -555,7 +748,6 @@ function manifestCapabilities(manifest) {
 // src/cli/index.ts
 var defaultSerialize = (request) => `${JSON.stringify(request)}
 `;
-var cliError = (message, cause) => new core.AdapterError({ code: core.ErrorCodes.AK_ADAPTER_STREAM_FAILED, message, cause });
 function createFactory(capabilities, run) {
   return {
     capabilities,
@@ -639,43 +831,6 @@ async function* runText(request, signal, options) {
     await closeProcess(handle);
   }
 }
-function isRecord2(value) {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-function standardJsonParser(value) {
-  if (!isRecord2(value)) throw cliError("CLI JSON response must be an object");
-  const chunks = [];
-  if (typeof value.text === "string") chunks.push({ type: "text", content: value.text });
-  if (typeof value.reasoning === "string") chunks.push({ type: "reasoning", content: value.reasoning });
-  if (Array.isArray(value.toolCalls)) {
-    for (const item of value.toolCalls) {
-      if (!isRecord2(item) || typeof item.id !== "string" || typeof item.name !== "string" || typeof item.args !== "string") {
-        throw cliError("CLI JSON toolCalls must contain string id, name, and args fields");
-      }
-      JSON.parse(item.args);
-      chunks.push({ type: "tool_call", toolCall: { id: item.id, name: item.name, args: item.args } });
-    }
-  }
-  if (value.usage !== void 0) {
-    if (!isRecord2(value.usage)) {
-      throw cliError("CLI JSON usage must contain numeric promptTokens, completionTokens, and totalTokens");
-    }
-    const promptTokens = value.usage.promptTokens;
-    const completionTokens = value.usage.completionTokens;
-    const totalTokens = value.usage.totalTokens;
-    if (typeof promptTokens !== "number" || typeof completionTokens !== "number" || typeof totalTokens !== "number") {
-      throw cliError("CLI JSON usage must contain numeric promptTokens, completionTokens, and totalTokens");
-    }
-    chunks.push({ type: "usage", usage: { promptTokens, completionTokens, totalTokens } });
-  }
-  if (value.metadata !== void 0) {
-    if (!isRecord2(value.metadata)) throw cliError("CLI JSON metadata must be an object");
-    if (chunks.length === 0) throw cliError("CLI JSON response contains no semantic output");
-    chunks[chunks.length - 1] = { ...chunks[chunks.length - 1], metadata: value.metadata };
-  }
-  if (chunks.length === 0) throw cliError("CLI JSON response contains no semantic output");
-  return chunks;
-}
 function normalizeJsonChunks(chunks) {
   if (chunks.length === 0) throw cliError("CLI JSON parser returned no chunks");
   if (chunks.some((chunk) => !isStreamChunk(chunk))) throw cliError("CLI JSON parser returned an invalid stream chunk");
@@ -687,7 +842,7 @@ function normalizeJsonChunks(chunks) {
   return last.type === "done" || last.type === "error" ? [...chunks] : [...chunks, { type: "done" }];
 }
 function isStreamChunk(value) {
-  return isRecord2(value) && typeof value.type === "string" && (/* @__PURE__ */ new Set([
+  return isRecord(value) && typeof value.type === "string" && (/* @__PURE__ */ new Set([
     "text",
     "tool_call",
     "tool_result",
@@ -712,20 +867,20 @@ async function* runJson(request, signal, options) {
     } catch (error) {
       throw cliError(`CLI returned malformed JSON: ${error instanceof Error ? error.message : String(error)}`, error);
     }
-    const chunks = normalizeJsonChunks((options.parse ?? standardJsonParser)(value));
+    const chunks = normalizeJsonChunks((options.parse ?? parseCliJsonResponse)(value));
     for (const chunk of chunks) yield chunk;
   } finally {
     await closeProcess(handle);
   }
 }
 function parseAcpMessage(value) {
-  if (!isRecord2(value) || value.jsonrpc !== "2.0") throw cliError("ACP message must be a JSON-RPC 2.0 object");
+  if (!isRecord(value) || value.jsonrpc !== "2.0") throw cliError("ACP message must be a JSON-RPC 2.0 object");
   if (typeof value.method === "string") {
     if (value.id === void 0) return { kind: "notification", method: value.method, params: value.params };
     return { kind: "request", method: value.method };
   }
   if (typeof value.id === "string" || typeof value.id === "number" || value.id === null) {
-    if (value.error !== void 0 && !isRecord2(value.error)) throw cliError("ACP error response is malformed");
+    if (value.error !== void 0 && !isRecord(value.error)) throw cliError("ACP error response is malformed");
     return { kind: "response", id: value.id, result: value.result, error: value.error };
   }
   throw cliError("ACP message has no method or response id");
@@ -778,12 +933,12 @@ ${request.context.systemPrompt}
 ${message.content}`).join("\n\n");
 }
 function acpUpdateChunk(params, sessionId) {
-  if (!isRecord2(params) || params.sessionId !== sessionId || !isRecord2(params.update)) return void 0;
+  if (!isRecord(params) || params.sessionId !== sessionId || !isRecord(params.update)) return void 0;
   const update = params.update;
-  if (update.sessionUpdate === "agent_message_chunk" && isRecord2(update.content) && update.content.type === "text" && typeof update.content.text === "string") {
+  if (update.sessionUpdate === "agent_message_chunk" && isRecord(update.content) && update.content.type === "text" && typeof update.content.text === "string") {
     return { type: "text", content: update.content.text };
   }
-  if (update.sessionUpdate === "agent_thought_chunk" && isRecord2(update.content) && update.content.type === "text" && typeof update.content.text === "string") {
+  if (update.sessionUpdate === "agent_thought_chunk" && isRecord(update.content) && update.content.type === "text" && typeof update.content.text === "string") {
     return { type: "reasoning", content: update.content.text };
   }
   if (update.sessionUpdate === "tool_call" || update.sessionUpdate === "tool_call_update") {
@@ -806,14 +961,14 @@ async function* runAcp(request, signal, options) {
       clientInfo: options.clientInfo ?? { name: "@agentskit/adapters", version: "0.16.0" }
     }), signal);
     const initialize = await nextAcpResponse(iterator, initializeId);
-    if (!isRecord2(initialize.result) || initialize.result.protocolVersion !== 1) throw cliError("ACP agent did not negotiate protocol version 1");
+    if (!isRecord(initialize.result) || initialize.result.protocolVersion !== 1) throw cliError("ACP agent did not negotiate protocol version 1");
     const sessionIdRequest = nextId();
     await abortableWrite(handle, acpRequest(sessionIdRequest, "session/new", {
       cwd: options.cwd ?? process.cwd(),
       mcpServers: []
     }), signal);
     const sessionResponse = await nextAcpResponse(iterator, sessionIdRequest);
-    if (!isRecord2(sessionResponse.result) || typeof sessionResponse.result.sessionId !== "string") throw cliError("ACP session/new response has no sessionId");
+    if (!isRecord(sessionResponse.result) || typeof sessionResponse.result.sessionId !== "string") throw cliError("ACP session/new response has no sessionId");
     const sessionId = sessionResponse.result.sessionId;
     const promptId = nextId();
     await abortableWrite(handle, acpRequest(promptId, "session/prompt", {
@@ -826,7 +981,7 @@ async function* runAcp(request, signal, options) {
       if (next.done) throw cliError("ACP process closed before session/prompt completed");
       if (next.value.kind === "response" && next.value.id === promptId) {
         if (next.value.error) throw cliError(`ACP prompt failed: ${next.value.error.message ?? "unknown error"}`);
-        if (!isRecord2(next.value.result) || next.value.result.stopReason !== "end_turn") throw cliError("ACP prompt did not complete with end_turn");
+        if (!isRecord(next.value.result) || next.value.result.stopReason !== "end_turn") throw cliError("ACP prompt did not complete with end_turn");
         break;
       }
       if (next.value.kind === "request") throw cliError(`ACP agent request is unsupported in this adapter: ${next.value.method}`);
@@ -871,6 +1026,8 @@ function createAcpCliAdapter(options) {
   }, (request, signal) => runAcp(request, signal, options));
 }
 
+exports.buildCliSystemPrompt = buildCliSystemPrompt;
+exports.claudeCodeRequestArgs = claudeCodeRequestArgs;
 exports.createAcpCliAdapter = createAcpCliAdapter;
 exports.createCliAdapter = createCliAdapter;
 exports.createJsonCliAdapter = createJsonCliAdapter;
@@ -879,8 +1036,12 @@ exports.diagnoseCliProviderManifest = diagnoseCliProviderManifest;
 exports.getCliProviderManifest = getCliProviderManifest;
 exports.listCliProviderManifests = listCliProviderManifests;
 exports.manifestCapabilities = manifestCapabilities;
-exports.parseCliJsonResponse = standardJsonParser;
+exports.parseClaudeCodeJsonOutput = parseClaudeCodeJsonOutput;
+exports.parseClaudeCodeJsonResponse = parseClaudeCodeJsonResponse;
+exports.parseCliJsonResponse = parseCliJsonResponse;
 exports.resolveCliManifest = resolveCliManifest;
+exports.serializeCliMessages = serializeCliMessages;
+exports.serializeCliPrompt = serializeCliPrompt;
 exports.validateCliProviderManifest = validateCliProviderManifest;
 //# sourceMappingURL=index.cjs.map
 //# sourceMappingURL=index.cjs.map