@agentskit/adapters 0.16.0 → 0.17.0

package/dist/cli/index.js

@@ -318,6 +318,162 @@ async function abortableWrite(handle, input, signal) {
     if (onError) handle.child.stdin.removeListener("error", onError);
   }
 }
+var cliError = (message, cause) => new AdapterError({ code: 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 AdapterError({
+    code: 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",
@@ -340,9 +496,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",
@@ -352,7 +512,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",
@@ -395,13 +575,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"],
@@ -409,11 +590,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");
   }
@@ -423,7 +604,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");
@@ -450,6 +631,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() {
@@ -469,9 +656,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,
@@ -481,7 +671,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) {
@@ -507,7 +700,6 @@ function manifestCapabilities(manifest) {
 // src/cli/index.ts
 var defaultSerialize = (request) => `${JSON.stringify(request)}
 `;
-var cliError = (message, cause) => new AdapterError({ code: ErrorCodes.AK_ADAPTER_STREAM_FAILED, message, cause });
 function createFactory(capabilities, run) {
   return {
     capabilities,
@@ -591,43 +783,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");
@@ -639,7 +794,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",
@@ -664,20 +819,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");
@@ -730,12 +885,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") {
@@ -758,14 +913,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", {
@@ -778,7 +933,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}`);
@@ -823,6 +978,6 @@ function createAcpCliAdapter(options) {
   }, (request, signal) => runAcp(request, signal, options));
 }
 
-export { createAcpCliAdapter, createCliAdapter, createJsonCliAdapter, diagnoseCliProvider, diagnoseCliProviderManifest, getCliProviderManifest, listCliProviderManifests, manifestCapabilities, standardJsonParser as parseCliJsonResponse, resolveCliManifest, validateCliProviderManifest };
+export { buildCliSystemPrompt, claudeCodeRequestArgs, createAcpCliAdapter, createCliAdapter, createJsonCliAdapter, diagnoseCliProvider, diagnoseCliProviderManifest, getCliProviderManifest, listCliProviderManifests, manifestCapabilities, parseClaudeCodeJsonOutput, parseClaudeCodeJsonResponse, parseCliJsonResponse, resolveCliManifest, serializeCliMessages, serializeCliPrompt, validateCliProviderManifest };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map