@amalgm/chat 0.1.2 → 0.2.0

package/host/adapters/acp-client.js

@@ -0,0 +1,156 @@
+// Generic Agent Client Protocol client.
+
+import { spawn } from 'node:child_process';
+
+/**
+ * Minimal Agent Client Protocol (ACP) client: JSON-RPC 2.0 over the stdio of a
+ * spawned agent process. This is the amalgm *client* side; the CLI (cursor-agent,
+ * gemini, ...) is the ACP agent. One instance per native agent process.
+ *
+ * The reader is tolerant of non-JSON stdout lines because young ACP servers are
+ * known to corrupt stdout with log output.
+ */
+class AcpClient {
+  constructor({ binary, args = [], cwd, env, label = 'acp' }) {
+    this.label = label;
+    this.id = 1;
+    this.pending = new Map();
+    this.notificationHandlers = new Set();
+    this.requestHandler = null;
+    this.buffer = '';
+    this.closed = false;
+    this.closeError = null;
+    this.child = spawn(binary, args, {
+      cwd,
+      env,
+      stdio: ['pipe', 'pipe', 'pipe'],
+      detached: process.platform !== 'win32',
+      windowsHide: true,
+    });
+    this.child.stdout.setEncoding('utf8');
+    this.child.stdout.on('data', (chunk) => this.onData(chunk));
+    this.child.stderr.setEncoding('utf8');
+    this.child.stderr.on('data', (chunk) => {
+      const text = String(chunk || '').trim();
+      if (text && process.env.AMALGM_CHAT_DEBUG) console.warn(`[${this.label}]`, text.slice(0, 1000));
+    });
+    this.child.on('error', (err) => this.failAll(err));
+    this.child.on('exit', (code, signal) => {
+      this.failAll(new Error(`${this.label} agent exited (${code ?? signal ?? 'unknown'})`));
+    });
+    this.child.stdin.on('error', (err) => this.failAll(err));
+  }
+
+  failAll(err) {
+    this.closed = true;
+    this.closeError = err;
+    for (const pending of this.pending.values()) pending.reject(err);
+    this.pending.clear();
+  }
+
+  onData(chunk) {
+    this.buffer += chunk;
+    const lines = this.buffer.split('\n');
+    this.buffer = lines.pop() || '';
+    for (const line of lines) {
+      if (!line.trim()) continue;
+      let msg;
+      try { msg = JSON.parse(line); } catch { continue; }
+      if (process.env.AMALGM_CHAT_DEBUG_ACP === '1') {
+        console.log(`[${this.label}:recv]`, JSON.stringify(msg).slice(0, 4000));
+      }
+      this.dispatch(msg);
+    }
+  }
+
+  dispatch(msg) {
+    if (msg.id !== undefined && (msg.result !== undefined || msg.error !== undefined)) {
+      const pending = this.pending.get(msg.id);
+      if (!pending) return;
+      this.pending.delete(msg.id);
+      if (msg.error) {
+        const err = new Error(msg.error.data?.message || msg.error.message || JSON.stringify(msg.error));
+        err.code = msg.error.code;
+        pending.reject(err);
+      } else {
+        pending.resolve(msg.result);
+      }
+      return;
+    }
+    if (msg.id !== undefined && msg.method) {
+      this.handleServerRequest(msg);
+      return;
+    }
+    if (msg.method) {
+      for (const handler of this.notificationHandlers) handler(msg);
+    }
+  }
+
+  async handleServerRequest(msg) {
+    if (!this.requestHandler) {
+      this.write({ jsonrpc: '2.0', id: msg.id, error: { code: -32601, message: `Method not supported: ${msg.method}` } });
+      return;
+    }
+    try {
+      const result = await this.requestHandler(msg.method, msg.params || {});
+      this.write({ jsonrpc: '2.0', id: msg.id, result: result ?? {} });
+    } catch (err) {
+      this.write({ jsonrpc: '2.0', id: msg.id, error: { code: -32603, message: err.message || 'Internal error' } });
+    }
+  }
+
+  write(payload) {
+    if (this.closed || this.child.exitCode !== null || this.child.signalCode !== null) return;
+    try {
+      this.child.stdin.write(`${JSON.stringify(payload)}\n`, (err) => {
+        if (err) this.failAll(err);
+      });
+    } catch (err) {
+      this.failAll(err);
+    }
+  }
+
+  request(method, params = {}, timeoutMs = 180000) {
+    if (this.closeError) return Promise.reject(this.closeError);
+    if (this.closed || this.child.exitCode !== null || this.child.signalCode !== null) {
+      return Promise.reject(new Error(`${this.label} agent is not running`));
+    }
+    const id = this.id++;
+    return new Promise((resolve, reject) => {
+      const timer = timeoutMs > 0
+        ? setTimeout(() => {
+            this.pending.delete(id);
+            reject(new Error(`${method} timed out`));
+          }, timeoutMs)
+        : null;
+      this.pending.set(id, {
+        resolve: (value) => { if (timer) clearTimeout(timer); resolve(value); },
+        reject: (err) => { if (timer) clearTimeout(timer); reject(err); },
+      });
+      this.write({ jsonrpc: '2.0', id, method, params });
+    });
+  }
+
+  notify(method, params) {
+    this.write(params === undefined ? { jsonrpc: '2.0', method } : { jsonrpc: '2.0', method, params });
+  }
+
+  onNotification(handler) {
+    this.notificationHandlers.add(handler);
+    return () => this.notificationHandlers.delete(handler);
+  }
+
+  onRequest(handler) {
+    this.requestHandler = handler;
+  }
+
+  close() {
+    try { this.child.stdin.end(); } catch {}
+    try {
+      if (process.platform !== 'win32' && this.child.pid) process.kill(-this.child.pid, 'SIGTERM');
+      else this.child.kill('SIGTERM');
+    } catch {}
+  }
+}
+
+export { AcpClient };

package/host/adapters/acp.js

@@ -0,0 +1,284 @@
+/** Generic ACP agent adapter. Agent-specific launch data comes from the resolved revision. */
+
+import { PROTOCOL_VERSION } from '@agentclientprotocol/sdk';
+import { toAcpMcpServers } from '../tooling/mcp-bundle.js';
+import { prepareHarnessRuntime } from '../tooling/runtime-home.js';
+import { composeSystemPrompt } from '../tooling/system-prompt.js';
+import { requestPermission } from '../permissions.js';
+import { AcpClient } from './acp-client.js';
+import { assertAcpMcpCapabilities, assertAcpPromptCapabilities } from './acp-capabilities.js';
+import { nativeInputCapabilities, UnsupportedExecutionInputError } from './input-capabilities.js';
+import { acpPromptParts } from './prompt.js';
+
+function record(value) {
+  return value && typeof value === 'object' && !Array.isArray(value) ? value : null;
+}
+
+function launchFor(contract) {
+  const launch = record(contract.acpLaunch);
+  if (!launch) throw new UnsupportedExecutionInputError('acp', 'agent revision', 'missing acpLaunch descriptor');
+  const command = String(launch.command || '').trim();
+  if (!command) throw new UnsupportedExecutionInputError('acp', 'agent revision', 'acpLaunch.command is required');
+  if (!Array.isArray(launch.args) || launch.args.some((arg) => typeof arg !== 'string')) {
+    throw new UnsupportedExecutionInputError('acp', 'agent revision', 'acpLaunch.args must be a string array');
+  }
+  const supportedAuthModes = Array.isArray(launch.supportedAuthModes) ? launch.supportedAuthModes : [];
+  if (!supportedAuthModes.includes(contract.auth.mode)) {
+    throw new UnsupportedExecutionInputError('acp', 'auth.mode', `${contract.auth.mode} is not declared by this agent revision`);
+  }
+  return { ...launch, command, args: [...launch.args] };
+}
+
+function authEnvironment(contract, launch) {
+  const configured = record(record(launch.auth)?.[contract.auth.mode]) || {};
+  const out = { ...(record(launch.env) || {}) };
+  if (contract.auth.mode !== 'subscription') {
+    const tokenEnv = String(configured.tokenEnv || '').trim();
+    if (!tokenEnv) {
+      throw new UnsupportedExecutionInputError('acp', 'auth', `${contract.auth.mode} requires acpLaunch.auth.${contract.auth.mode}.tokenEnv`);
+    }
+    out[tokenEnv] = contract.auth.tokenRef || '';
+    const baseUrlEnv = String(configured.baseUrlEnv || '').trim();
+    if (baseUrlEnv && contract.auth.baseUrl) out[baseUrlEnv] = contract.auth.baseUrl;
+  }
+  return out;
+}
+
+function optionValues(option) {
+  if (!option || option.type !== 'select' || !Array.isArray(option.options)) return [];
+  return option.options.flatMap((entry) => Array.isArray(entry?.options) ? entry.options : [entry]);
+}
+
+function matchingValue(option, candidates) {
+  const wanted = new Set(candidates.filter(Boolean));
+  return optionValues(option).find((entry) => wanted.has(entry?.value))?.value || null;
+}
+
+async function setConfig(client, sessionId, option, value) {
+  const request = { sessionId, configId: option.id, value };
+  if (option.type === 'boolean') request.type = 'boolean';
+  return client.request('session/set_config_option', request, 30000);
+}
+
+async function applyConfiguration(client, sessionId, response, contract, launch) {
+  let options = Array.isArray(response?.configOptions) ? response.configOptions : [];
+  const modelOption = options.find((option) => option?.category === 'model')
+    || options.find((option) => option?.id === 'model');
+  if (!modelOption) {
+    if (launch.modelConfiguredAtLaunch !== true) {
+      throw new UnsupportedExecutionInputError('acp', 'provider + model', 'agent exposes no ACP model config option');
+    }
+  } else {
+    const value = matchingValue(modelOption, [
+      `${contract.providerId}/${contract.providerModelId}`,
+      contract.providerModelId,
+      contract.cliModel,
+    ]);
+    if (!value) {
+      throw new UnsupportedExecutionInputError(
+        'acp',
+        'provider + model',
+        `${contract.providerId}/${contract.providerModelId} is not offered by the agent`,
+      );
+    }
+    if (modelOption.currentValue !== value) {
+      const updated = await setConfig(client, sessionId, modelOption, value);
+      if (Array.isArray(updated?.configOptions)) options = updated.configOptions;
+    }
+  }
+
+  for (const selection of contract.modelSettings) {
+    const option = options.find((candidate) => candidate?.id === selection.configId);
+    if (!option) {
+      throw new UnsupportedExecutionInputError('acp', `model.settings.${selection.configId}`, 'agent did not advertise this ACP config option');
+    }
+    if (option.type === 'boolean' && selection.type !== 'boolean') {
+      throw new UnsupportedExecutionInputError('acp', `model.settings.${selection.configId}`, 'agent requires a boolean value');
+    }
+    if (option.type !== 'boolean' && !matchingValue(option, [selection.value])) {
+      throw new UnsupportedExecutionInputError('acp', `model.settings.${selection.configId}`, `agent does not offer ${selection.value}`);
+    }
+    if (option.currentValue !== selection.value) {
+      const updated = await setConfig(client, sessionId, option, selection.value);
+      if (Array.isArray(updated?.configOptions)) options = updated.configOptions;
+    }
+  }
+}
+
+function choosePermission(options, outcome) {
+  const kind = outcome === 'allow_always'
+    ? 'allow_always'
+    : outcome === 'allow_once'
+      ? 'allow_once'
+      : outcome === 'deny'
+        ? 'reject_once'
+        : null;
+  return options.find((option) => option?.kind === kind) || null;
+}
+
+export class AcpAdapter {
+  constructor(options = {}) {
+    this.clientFactory = options.clientFactory || ((input) => new AcpClient(input));
+    this.permissionPort = options.requestPermission || null;
+    this.outputType = 'acp';
+    this.inputCapabilities = nativeInputCapabilities({
+      authModes: ['platform', 'subscription', 'byok'],
+      modelSettings: 'negotiated',
+      tools: true,
+    });
+  }
+
+  validatePrepared(contract) {
+    const launch = launchFor(contract);
+    authEnvironment(contract, launch);
+  }
+
+  async create(contract) {
+    const launch = launchFor(contract);
+    const runtime = prepareHarnessRuntime(contract);
+    const client = this.clientFactory({
+      binary: launch.command,
+      args: launch.args,
+      cwd: contract.cwd,
+      env: { ...runtime.env, ...authEnvironment(contract, launch) },
+      label: launch.label || 'ACP',
+    });
+    const session = {
+      sessionId: contract.sessionId,
+      providerSessionId: contract.providerSessionId || null,
+      client,
+      capabilities: {},
+      permissionMode: contract.permissionMode,
+      needsSystemPrompt: false,
+      activePrompt: false,
+    };
+    client.onRequest((method, params) => this.handleRequest(session, method, params));
+    const initialized = await client.request('initialize', {
+      protocolVersion: PROTOCOL_VERSION,
+      clientInfo: { name: 'amalgm-chat', version: '0.1.2' },
+      clientCapabilities: {
+        fs: { readTextFile: false, writeTextFile: false },
+        session: { configOptions: { boolean: {} } },
+      },
+    });
+    if (initialized?.protocolVersion !== PROTOCOL_VERSION) {
+      throw new UnsupportedExecutionInputError('acp', 'protocol', `agent negotiated version ${initialized?.protocolVersion}`);
+    }
+    session.capabilities = initialized.agentCapabilities || {};
+    const methodId = record(launch.authMethodIds)?.[contract.auth.mode];
+    if (methodId) await client.request('authenticate', { methodId }, 120000);
+
+    const mcpServers = toAcpMcpServers(contract);
+    assertAcpMcpCapabilities('acp', session.capabilities, mcpServers);
+    const sessionParams = { cwd: contract.cwd, mcpServers };
+    let response;
+    if (session.providerSessionId) {
+      if (session.capabilities.loadSession === true) {
+        response = await client.request('session/load', {
+          ...sessionParams,
+          sessionId: session.providerSessionId,
+        }, 600000);
+      } else if (session.capabilities.sessionCapabilities?.resume != null) {
+        response = await client.request('session/resume', {
+          ...sessionParams,
+          sessionId: session.providerSessionId,
+        }, 600000);
+      } else {
+        throw new UnsupportedExecutionInputError('acp', 'resume', 'agent cannot load or resume its provider session');
+      }
+    } else {
+      response = await client.request('session/new', sessionParams, 600000);
+      session.providerSessionId = response?.sessionId || null;
+      session.needsSystemPrompt = true;
+    }
+    if (!session.providerSessionId) throw new Error('ACP agent did not return a sessionId');
+    await applyConfiguration(client, session.providerSessionId, response, contract, launch);
+    return session;
+  }
+
+  async handleRequest(session, method, params) {
+    if (method !== 'session/request_permission') throw new Error(`Method not supported: ${method}`);
+    if (session.permissionMode === 'full_access') {
+      const selected = choosePermission(params.options || [], 'allow_always')
+        || choosePermission(params.options || [], 'allow_once');
+      return selected
+        ? { outcome: { outcome: 'selected', optionId: selected.optionId } }
+        : { outcome: { outcome: 'cancelled' } };
+    }
+    const decision = await requestPermission(this.permissionPort, {
+      adapterId: 'acp',
+      providerSessionId: session.providerSessionId,
+      kind: 'tool',
+      title: params.title || 'Agent requests permission',
+      input: params,
+    });
+    const selected = choosePermission(params.options || [], decision.outcome);
+    return selected
+      ? { outcome: { outcome: 'selected', optionId: selected.optionId } }
+      : { outcome: { outcome: 'cancelled' } };
+  }
+
+  async stop(session) {
+    if (session.activePrompt) {
+      session.client.notify('session/cancel', { sessionId: session.providerSessionId });
+    }
+  }
+
+  async destroy(session) {
+    if (session.capabilities.sessionCapabilities?.close != null) {
+      await session.client.request('session/close', { sessionId: session.providerSessionId }, 30000).catch(() => {});
+    }
+    session.client.close();
+  }
+
+  async *prompt(session, prompt, contract) {
+    assertAcpPromptCapabilities('acp', session.capabilities, prompt);
+    const queue = [];
+    let wake = null;
+    let finished = false;
+    let failure = null;
+    const wakeLoop = () => { if (wake) { wake(); wake = null; } };
+    const off = session.client.onNotification((message) => {
+      if (message.method !== 'session/update') return;
+      if (message.params?.sessionId && message.params.sessionId !== session.providerSessionId) return;
+      if (message.params?.update) queue.push(message.params.update);
+      wakeLoop();
+    });
+    let preamble = '';
+    if (session.needsSystemPrompt) {
+      const systemPrompt = composeSystemPrompt(contract);
+      if (systemPrompt) preamble = `<system-instructions>\n${systemPrompt}\n</system-instructions>`;
+      session.needsSystemPrompt = false;
+    }
+    session.activePrompt = true;
+    session.client.request('session/prompt', {
+      sessionId: session.providerSessionId,
+      prompt: acpPromptParts(prompt, preamble),
+    }, 0).then(() => {
+      finished = true;
+      wakeLoop();
+    }).catch((error) => {
+      failure = error;
+      finished = true;
+      wakeLoop();
+    });
+    try {
+      while (!finished || queue.length) {
+        if (queue.length) yield queue.shift();
+        else await new Promise((resolve) => { wake = resolve; });
+      }
+      if (failure) throw failure;
+    } finally {
+      off();
+      session.activePrompt = false;
+    }
+  }
+}
+
+export const __private = {
+  applyConfiguration,
+  assertMcpCapabilities: (capabilities, servers) => assertAcpMcpCapabilities('acp', capabilities, servers),
+  assertPromptCapabilities: (capabilities, prompt) => assertAcpPromptCapabilities('acp', capabilities, prompt),
+  authEnvironment,
+  launchFor,
+};

package/host/adapters/claude.js

@@ -0,0 +1,235 @@
+// Claude Code Agent SDK adapter.
+//
+// Event constructors, normalization, and usage laws come from the SDK.
+// Effectful tooling (runtime
+// homes, mcp bundle, native binaries, system prompt, package import) and the
+// recorder are sibling host modules.
+//
+// Hook settings are provided through the injected constructor option
+// `options.renderers.toClaudeSettings`; rendering stays inside the adapter.
+// The uninjected default renders no settings (an agentConfig without hooks).
+
+import path from 'node:path';
+import { createEventConstructors } from '../../dist/events/index.js';
+import {
+  createClaudeNormalizer,
+  usageFromClaude,
+  usageRecordsFromClaudeResult,
+} from '../../dist/normalizers/claude.js';
+import { recordNativeEvent } from '../recorder.js';
+import { toClaudeMcpServers } from '../tooling/mcp-bundle.js';
+import { bundledClaudeBinary } from '../tooling/native-binaries.js';
+import { importPackage } from '../tooling/package-import.js';
+import { prepareHarnessRuntime } from '../tooling/runtime-home.js';
+import { composeSystemPrompt } from '../tooling/system-prompt.js';
+import { allowed, requestPermission } from '../permissions.js';
+import {
+  COMMON_REASONING_SETTINGS,
+  COMMON_SPEED_SETTINGS,
+  nativeInputCapabilities,
+} from './input-capabilities.js';
+import { claudePrompt } from './prompt.js';
+
+const events = createEventConstructors({ clockMs: () => Date.now() });
+const { done, errorEvent, reasoningStarted, usageFinal } = events;
+const { normalizeClaudeMessage } = createClaudeNormalizer(events);
+
+// Engine default: require('../../amalgm-mcp/agent-config/renderers/hooks').
+const defaultRenderers = {
+  toClaudeSettings: () => ({}),
+};
+
+function redactSecrets(text) {
+  return String(text || '')
+    .replace(/\b(npm_[A-Za-z0-9]{20,})\b/g, '[REDACTED_NPM_TOKEN]')
+    .replace(/\b(sk-[A-Za-z0-9_-]{20,})\b/g, '[REDACTED_API_KEY]')
+    .replace(/\b(sk-ant-[A-Za-z0-9_-]{20,})\b/g, '[REDACTED_ANTHROPIC_KEY]')
+    .replace(/\b(Bearer\s+)[A-Za-z0-9._~+/=-]{20,}/gi, '$1[REDACTED_TOKEN]');
+}
+
+class ClaudeAdapter {
+  constructor(options = {}) {
+    this.renderers = { ...defaultRenderers, ...(options.renderers || {}) };
+    this.permissionPort = options.requestPermission || null;
+    this.inputCapabilities = nativeInputCapabilities({
+      authModes: ['platform', 'subscription', 'byok'],
+      modelSettings: [...COMMON_REASONING_SETTINGS, ...COMMON_SPEED_SETTINGS],
+      tools: true,
+    });
+  }
+
+  async create(contract) {
+    return {
+      sessionId: contract.sessionId,
+      providerSessionId: contract.providerSessionId || null,
+      currentCliModel: contract.cliModel,
+      currentQuery: null,
+      closed: false,
+    };
+  }
+
+  options(contract, extra = {}) {
+    const runtime = prepareHarnessRuntime(contract);
+    const systemPrompt = composeSystemPrompt(contract);
+    const pathToClaudeCodeExecutable = process.env.CLAUDE_CODE_BINARY || bundledClaudeBinary();
+    const settings = {
+      ...this.renderers.toClaudeSettings(contract.agentConfig),
+      ...(contract.fastMode ? { fastMode: true } : {}),
+    };
+    const fullAccess = contract.permissionMode === 'full_access';
+    const canUseTool = fullAccess ? undefined : async (toolName, input, context) => {
+      const decision = await requestPermission(this.permissionPort, {
+        adapterId: 'claude_code',
+        providerSessionId: contract.providerSessionId,
+        kind: 'tool',
+        title: context.title || context.displayName || `Claude requests ${toolName}`,
+        description: context.description || context.decisionReason || null,
+        toolName,
+        toolUseId: context.toolUseID,
+        input,
+      });
+      if (!allowed(decision)) {
+        return { behavior: 'deny', message: 'Denied by the user', toolUseID: context.toolUseID };
+      }
+      return {
+        behavior: 'allow',
+        updatedInput: decision.updatedInput || input,
+        ...(decision.outcome === 'allow_always' && context.suggestions
+          ? { updatedPermissions: context.suggestions }
+          : {}),
+        toolUseID: context.toolUseID,
+      };
+    };
+    return {
+      cwd: contract.cwd,
+      env: runtime.env,
+      model: contract.cliModel,
+      ...(contract.reasoningEffort ? { effort: contract.reasoningEffort } : {}),
+      ...(Object.keys(settings).length > 0 ? { settings } : {}),
+      ...(pathToClaudeCodeExecutable ? { pathToClaudeCodeExecutable } : {}),
+      ...(systemPrompt ? { systemPrompt: { type: 'preset', preset: 'claude_code', append: systemPrompt } } : {}),
+      mcpServers: toClaudeMcpServers(contract),
+      permissionMode: fullAccess ? 'bypassPermissions' : 'default',
+      ...(canUseTool ? { canUseTool } : {}),
+      ...(fullAccess ? { allowDangerouslySkipPermissions: true } : {}),
+      includePartialMessages: true,
+      ...(process.env.AMALGM_CHAT_DEBUG_CLAUDE === '1'
+        ? { debug: true, debugFile: path.join(runtime.runtimeHome, 'claude-debug.log') }
+        : {}),
+      settingSources: [],
+      strictMcpConfig: false,
+      ...extra,
+    };
+  }
+
+  async resume(session, contract) {
+    session.currentCliModel = contract.cliModel;
+    session.closed = false;
+    return session;
+  }
+
+  async stop(session) {
+    session.currentQuery?.close?.();
+    session.currentQuery = null;
+    session.closed = true;
+  }
+
+  async destroy(session) {
+    session.currentQuery?.close?.();
+    session.currentQuery = null;
+    session.closed = true;
+  }
+
+  async *prompt(session, input, contract) {
+    const contextLimit = Number(contract.contextWindow || 0) || undefined;
+    const state = {
+      providerSessionId: session.providerSessionId,
+      contextLimit,
+      claudeTools: new Map(),
+      claudeCompletedTools: new Set(),
+      claudeUsageSnapshotFingerprints: new Set(),
+    };
+    const stderrChunks = [];
+    const captureStderr = (chunk) => {
+      const text = redactSecrets(String(chunk || ''));
+      if (!text) return;
+      stderrChunks.push(text);
+      while (stderrChunks.length > 20) stderrChunks.shift();
+      if (process.env.AMALGM_CHAT_DEBUG_CLAUDE === '1' && text.trim()) {
+        console.warn('[Claude]', text.trim().slice(0, 2000));
+      }
+    };
+    try {
+      const sdk = await importPackage('@anthropic-ai/claude-agent-sdk');
+      const query = sdk.query({
+        prompt: claudePrompt(input),
+        options: {
+          ...this.options(contract, { stderr: captureStderr }),
+          ...(session.providerSessionId ? { resume: session.providerSessionId } : {}),
+        },
+      });
+      session.currentQuery = query;
+      session.closed = false;
+      yield reasoningStarted({ providerSessionId: state.providerSessionId });
+      for await (const message of query) {
+        recordNativeEvent('claude.sdk.message', message, {
+          providerSessionId: state.providerSessionId,
+          sessionId: contract.sessionId,
+          assistantMessageId: contract.assistantMessageId,
+        });
+        if (message.session_id) {
+          session.providerSessionId = message.session_id;
+          state.providerSessionId = message.session_id;
+        }
+        const normalized = normalizeClaudeMessage(message, state);
+        if (normalized.length > 0) {
+          for (const e of normalized) yield e;
+          continue;
+        }
+        if (message.type === 'result') {
+          const usageRecords = usageRecordsFromClaudeResult(message, contextLimit);
+          if (usageRecords.length === 0) {
+            usageRecords.push(usageFromClaude(message.usage, contextLimit));
+          }
+          for (const [index, usageRecord] of usageRecords.entries()) {
+            yield usageFinal({
+              ...usageRecord,
+              costUsd: usageRecords.length === 1 ? message.total_cost_usd ?? null : null,
+            }, {
+              providerSessionId: state.providerSessionId,
+              raw: {
+                source: 'claude.sdk.message',
+                method: 'claude/result',
+                payload: {
+                  ...message,
+                  usageRecordIndex: index,
+                  usageRecordCount: usageRecords.length,
+                },
+              },
+            });
+          }
+          if (message.is_error) {
+            yield errorEvent(message.errors?.join('\n') || message.stop_reason || 'Claude turn failed', {
+              providerSessionId: state.providerSessionId,
+              raw: { source: 'claude.sdk.message', method: 'claude/result', payload: message },
+            });
+          }
+          yield done({
+            providerSessionId: state.providerSessionId,
+            stopReason: message.stop_reason || 'end_turn',
+            raw: { source: 'claude.sdk.message', method: 'claude/result', payload: message },
+          });
+        }
+      }
+    } catch (err) {
+      const stderrTail = stderrChunks.join('').trim().slice(-3000);
+      const message = stderrTail ? `${err.message}\n${stderrTail}` : err.message;
+      yield errorEvent(message, { providerSessionId: session.providerSessionId });
+      yield done({ providerSessionId: session.providerSessionId, stopReason: session.closed ? 'cancelled' : 'error' });
+    } finally {
+      session.currentQuery = null;
+    }
+  }
+}
+
+export { ClaudeAdapter };