@pwrdrvr/agent-acp 0.1.0

package/dist/index.js

@@ -0,0 +1,1973 @@
+// src/acp-stdio-transport.ts
+import { noopLogger } from "@pwrdrvr/agent-core";
+import {
+  JsonRpcConnection,
+  StdioJsonRpcTransport
+} from "@pwrdrvr/agent-transport";
+var DEFAULT_REQUEST_TIMEOUT_MS = 10 * 6e4;
+var AcpStdioJsonRpcTransport = class {
+  connection;
+  notificationListeners = /* @__PURE__ */ new Set();
+  requestHandler;
+  constructor(options) {
+    const logger = options.logger ?? noopLogger;
+    const transport = options.transport ?? new StdioJsonRpcTransport({
+      command: options.command,
+      args: options.args,
+      ...options.env !== void 0 ? { env: options.env } : {},
+      logger
+    });
+    this.connection = new JsonRpcConnection(
+      transport,
+      options.requestTimeoutMs ?? DEFAULT_REQUEST_TIMEOUT_MS,
+      options.observer,
+      { logger, logContext: { owner: "acp-stdio-transport" } }
+    );
+    this.connection.setNotificationHandler((method, params) => {
+      const normalized = asRecord(params) ?? {};
+      for (const listener of this.notificationListeners) {
+        listener(method, normalized);
+      }
+    });
+    this.connection.setRequestHandler(async (method, params, id) => {
+      if (!this.requestHandler) {
+        throw new Error(`ACP request handler unavailable for ${method}`);
+      }
+      return await this.requestHandler(method, asRecord(params) ?? {}, id);
+    });
+  }
+  async connect() {
+    await this.connection.connect();
+  }
+  async request(method, params, timeoutMs) {
+    await this.connection.connect();
+    return await this.connection.request(method, params, timeoutMs);
+  }
+  async notify(method, params) {
+    await this.connection.connect();
+    await this.connection.notify(method, params);
+  }
+  async close() {
+    await this.connection.close();
+  }
+  onNotification(listener) {
+    this.notificationListeners.add(listener);
+    return () => {
+      this.notificationListeners.delete(listener);
+    };
+  }
+  onRequest(listener) {
+    this.requestHandler = listener;
+    return () => {
+      if (this.requestHandler === listener) {
+        this.requestHandler = void 0;
+      }
+    };
+  }
+};
+function asRecord(value) {
+  return value && typeof value === "object" && !Array.isArray(value) ? value : void 0;
+}
+
+// src/acp-client.ts
+import {
+  noopLogger as noopLogger2
+} from "@pwrdrvr/agent-core";
+import { readFile } from "fs/promises";
+import { extname } from "path";
+
+// src/normalizer/acp-normalizer.ts
+import {
+  mergeToolCall,
+  preferSpecificLabel
+} from "@pwrdrvr/agent-core";
+
+// src/normalizer/content.ts
+function asRecord2(value) {
+  return value && typeof value === "object" && !Array.isArray(value) ? value : void 0;
+}
+function readString(record, key) {
+  const value = record?.[key];
+  return typeof value === "string" ? value : void 0;
+}
+function readNonEmptyString(record, key) {
+  const value = record?.[key];
+  return typeof value === "string" && value.trim() ? value.trim() : void 0;
+}
+function readNumber(record, key) {
+  const value = record?.[key];
+  return typeof value === "number" && Number.isFinite(value) ? value : void 0;
+}
+function readBoolean(record, key) {
+  const value = record?.[key];
+  return typeof value === "boolean" ? value : void 0;
+}
+function readFirstString(record, ...keys) {
+  for (const key of keys) {
+    const value = readString(record, key);
+    if (value !== void 0) return value;
+  }
+  return void 0;
+}
+function readKind(update) {
+  return readString(update, "sessionUpdate") ?? readString(update, "session_update") ?? readString(update, "kind") ?? readString(update, "type") ?? "unknown";
+}
+function readAcpContentText(value) {
+  if (typeof value === "string") {
+    return value;
+  }
+  if (Array.isArray(value)) {
+    const parts = value.map((item) => readAcpContentText(item)).filter((item) => Boolean(item));
+    return parts.length > 0 ? parts.join("\n") : void 0;
+  }
+  const content = asRecord2(value);
+  if (!content) {
+    return void 0;
+  }
+  if (content.type === "text" && typeof content.text === "string") {
+    return content.text;
+  }
+  return readAcpContentText(content.content) ?? readAcpContentText(content.text) ?? readAcpContentText(content.output) ?? readAcpContentText(content.result);
+}
+function readContentText(record, key) {
+  return readAcpContentText(record[key]);
+}
+function readToolOutput(record) {
+  return readString(record, "output") ?? readString(record, "stdout") ?? readString(record, "stderr") ?? readString(record, "result") ?? readContentText(record, "content");
+}
+function readFirstLocationPath(record) {
+  const locations = record.locations ?? record.location;
+  if (!Array.isArray(locations)) {
+    return void 0;
+  }
+  for (const location of locations) {
+    const path3 = readString(asRecord2(location), "path");
+    if (path3 && path3.trim()) {
+      return path3;
+    }
+  }
+  return void 0;
+}
+function readUpdateText(update) {
+  return readString(update, "text") ?? readString(update, "outputText") ?? readString(update, "output_text") ?? readContentText(update, "content");
+}
+
+// src/normalizer/tool-activity.ts
+import {
+  inferToolKind
+} from "@pwrdrvr/agent-core";
+function readToolCallId(update, kind, sessionId) {
+  return readFirstString(
+    update,
+    "toolCallId",
+    "tool_call_id",
+    "id",
+    "itemId",
+    "item_id"
+  ) ?? `${kind}:${sessionId}`;
+}
+function normalizeStatus(status) {
+  switch (status) {
+    case "completed":
+    case "failed":
+    case "cancelled":
+    case "in_progress":
+      return status;
+    case "pending":
+      return "in_progress";
+    default:
+      return void 0;
+  }
+}
+function toolKindFor(acpKind, command, path3, label) {
+  switch (acpKind) {
+    case "edit":
+    case "write":
+      return "write";
+    case "execute":
+    case "exec":
+    case "shell":
+      return "command";
+    case "read":
+      return "read";
+    case "search":
+      return "search";
+    case "fetch":
+      return "fetch";
+    default:
+      break;
+  }
+  if (command) return "command";
+  const inferred = inferToolKind(label);
+  if (inferred !== "other") return inferred;
+  return path3 ? "read" : "other";
+}
+function toolCallFromUpdate(update, kind, sessionId) {
+  const id = readToolCallId(update, kind, sessionId);
+  const label = readString(update, "title") ?? readString(update, "name") ?? readString(update, "kind") ?? kind.replaceAll("_", " ");
+  const acpKind = readString(update, "kind");
+  const path3 = readString(update, "path") ?? readFirstLocationPath(update);
+  const command = readString(update, "command");
+  const output = readToolOutput(update);
+  const exitCode = readNumber(update, "exitCode") ?? readNumber(update, "exit_code");
+  const status = normalizeStatus(readString(update, "status"));
+  const toolKind = toolKindFor(acpKind, command, path3, label);
+  const call = {
+    id,
+    name: readString(update, "name") ?? acpKind ?? label,
+    kind: toolKind,
+    label,
+    status: status ?? "in_progress",
+    args: readToolArgs(update)
+  };
+  if (output !== void 0) {
+    call.result = output;
+  }
+  const explicitDisplay = command ?? readString(update, "title");
+  if (command || output !== void 0 || exitCode !== void 0) {
+    const detail = {
+      displayCommand: explicitDisplay ?? label
+    };
+    if (command !== void 0) detail.rawCommand = command;
+    if (output !== void 0) detail.output = output;
+    if (exitCode !== void 0) detail.exitCode = exitCode;
+    call.command = detail;
+  }
+  if ((toolKind === "write" || toolKind === "read") && path3) {
+    if (!call.command) {
+      call.command = { displayCommand: label };
+    }
+  }
+  return call;
+}
+function readToolArgs(update) {
+  const raw = update.rawInput ?? update.raw_input ?? update.input ?? update.arguments ?? update.args;
+  return asRecord2(raw) ?? (raw === void 0 ? void 0 : raw);
+}
+function readToolContentText(value) {
+  return readContentText({ content: value }, "content");
+}
+
+// src/normalizer/acp-normalizer.ts
+var EMPTY_RESULT = { events: [] };
+var AcpSessionNormalizer = class {
+  quirks;
+  // Coalescing state. One "live" assistant message bubble at a time; a tool
+  // call (or any non-text update) clears it so the next text starts a new one.
+  activeAssistantItemId;
+  assistantText = "";
+  assistantSequence = 0;
+  // Tool-call merge state: id → last fully-merged NormalizedToolCall, so a
+  // tool_call_update reconciles labels / fills command output against it.
+  toolCalls = /* @__PURE__ */ new Map();
+  constructor(options) {
+    this.quirks = options.quirks;
+  }
+  /** Reset coalescing state at a turn boundary (new prompt / turn finished). */
+  resetTurn() {
+    this.activeAssistantItemId = void 0;
+    this.assistantText = "";
+  }
+  /** Finalize the in-flight assistant bubble into a terminal `agent_message`, if any. */
+  finalizeAssistantMessage(ctx) {
+    if (this.activeAssistantItemId === void 0 || this.assistantText === "") {
+      this.resetTurn();
+      return [];
+    }
+    const message = {
+      id: this.activeAssistantItemId,
+      role: "assistant",
+      text: this.assistantText
+    };
+    this.resetTurn();
+    return [
+      {
+        kind: "agent_message",
+        threadId: ctx.threadId,
+        turnId: ctx.turnId,
+        message
+      }
+    ];
+  }
+  /** Normalize one ACP session/update into neutral events (+ optional title). */
+  apply(update, ctx) {
+    const kind = readKind(update);
+    const title = this.extractTitle(update, kind);
+    if (title !== void 0) {
+      return { events: [], title };
+    }
+    switch (kind) {
+      case "agent_message_chunk":
+        return { events: this.applyAgentMessageChunk(update, ctx) };
+      case "agent_thought_chunk":
+        return { events: this.applyThoughtChunk(update, ctx) };
+      case "user_message_chunk":
+        return { events: this.applyUserMessageChunk(update, ctx) };
+      case "plan":
+        this.activeAssistantItemId = void 0;
+        return { events: this.applyPlan(update, ctx) };
+      case "tool_call":
+      case "tool_call_update":
+      case "file":
+      case "terminal":
+        this.activeAssistantItemId = void 0;
+        return { events: this.applyToolCall(update, kind, ctx) };
+      case "available_commands_update":
+      case "current_mode_update":
+      case "config_option_update":
+        return EMPTY_RESULT;
+      default:
+        this.activeAssistantItemId = void 0;
+        return EMPTY_RESULT;
+    }
+  }
+  applyAgentMessageChunk(update, ctx) {
+    const text = readUpdateText(update) ?? "";
+    if (text === "" || isModeUpdateMarker(text)) {
+      return [];
+    }
+    const itemId = this.assistantItemIdForChunk(update, ctx);
+    this.assistantText = appendTranscriptChunk(this.assistantText, text);
+    return [
+      {
+        kind: "agent_message_delta",
+        threadId: ctx.threadId,
+        turnId: ctx.turnId,
+        itemId,
+        delta: text
+      }
+    ];
+  }
+  applyThoughtChunk(update, ctx) {
+    if (!this.quirks.surfaceThoughts) {
+      return [];
+    }
+    const text = readUpdateText(update) ?? "";
+    if (text === "") {
+      return [];
+    }
+    const itemId = this.assistantItemIdForChunk(update, ctx);
+    this.assistantText = appendTranscriptChunk(this.assistantText, text);
+    return [
+      {
+        kind: "reasoning_delta",
+        threadId: ctx.threadId,
+        turnId: ctx.turnId,
+        itemId,
+        delta: text
+      }
+    ];
+  }
+  applyUserMessageChunk(update, ctx) {
+    this.activeAssistantItemId = void 0;
+    const text = readUpdateText(update) ?? "";
+    if (text === "") {
+      return [];
+    }
+    const id = readFirstString(update, "messageId", "message_id", "id") ?? `user:${ctx.threadId}:${ctx.turnId}`;
+    const message = { id, role: "user", text };
+    return [
+      {
+        kind: "agent_message",
+        threadId: ctx.threadId,
+        turnId: ctx.turnId,
+        message
+      }
+    ];
+  }
+  applyPlan(update, ctx) {
+    const id = readString(update, "planId") ?? `plan:${ctx.threadId}`;
+    const plan = {
+      id,
+      steps: readPlanSteps(update)
+    };
+    const explanation = readString(update, "explanation");
+    if (explanation !== void 0) plan.explanation = explanation;
+    const markdown = readString(update, "markdown");
+    if (markdown !== void 0) plan.markdown = markdown;
+    return [{ kind: "plan_update", threadId: ctx.threadId, turnId: ctx.turnId, plan }];
+  }
+  applyToolCall(update, kind, ctx) {
+    const incoming = toolCallFromUpdate(update, kind, ctx.threadId);
+    const prev = this.toolCalls.get(incoming.id);
+    if (prev === void 0) {
+      this.toolCalls.set(incoming.id, incoming);
+      return [
+        { kind: "tool_call", threadId: ctx.threadId, turnId: ctx.turnId, toolCall: incoming }
+      ];
+    }
+    const merged = mergeToolCall(prev, incoming);
+    if (merged.command && prev.command) {
+      merged.command = {
+        ...merged.command,
+        displayCommand: preferSpecificLabel(
+          prev.command.displayCommand,
+          merged.command.displayCommand
+        )
+      };
+    }
+    this.toolCalls.set(incoming.id, merged);
+    return [
+      {
+        kind: "tool_call_update",
+        threadId: ctx.threadId,
+        turnId: ctx.turnId,
+        toolCall: merged
+      }
+    ];
+  }
+  assistantItemIdForChunk(update, ctx) {
+    const explicitId = readFirstString(update, "messageId", "message_id");
+    if (explicitId) {
+      if (explicitId !== this.activeAssistantItemId) {
+        this.activeAssistantItemId = explicitId;
+        this.assistantText = "";
+      }
+      return explicitId;
+    }
+    if (this.activeAssistantItemId === void 0) {
+      this.activeAssistantItemId = `assistant:${ctx.turnId}:${this.assistantSequence++}`;
+      this.assistantText = "";
+    }
+    return this.activeAssistantItemId;
+  }
+  /** Strategy-driven title extraction. NO agent-id literal — reads quirks.titleFrom. */
+  extractTitle(update, kind) {
+    const wantsSummary = this.quirks.titleFrom === "session-summary" || this.quirks.titleFrom === "both";
+    const wantsTopic = this.quirks.titleFrom === "topic-update" || this.quirks.titleFrom === "both";
+    if (wantsSummary && kind === "session_summary_generated") {
+      const summary = (readString(update, "session_summary") ?? readString(update, "sessionSummary"))?.trim();
+      return summary || void 0;
+    }
+    if (wantsTopic) {
+      const isToolish = kind === "tool_call" || kind === "tool_call_update" || kind === "think";
+      if (!isToolish) {
+        return void 0;
+      }
+      const titleText = readString(update, "title")?.trim();
+      if (!titleText) {
+        return void 0;
+      }
+      const quoted = /^Update topic to:\s*["“](.+?)["”]\s*$/iu.exec(titleText);
+      const fallback = /^Update topic to:\s*(.+)$/iu.exec(titleText);
+      const topic = (quoted?.[1] ?? fallback?.[1])?.trim();
+      return topic || void 0;
+    }
+    return void 0;
+  }
+};
+function appendTranscriptChunk(existing, next) {
+  if (!existing || !next) {
+    return `${existing}${next}`;
+  }
+  if (shouldSeparateTranscriptChunks(existing, next)) {
+    return `${existing}
+
+${next}`;
+  }
+  return `${existing}${next}`;
+}
+function shouldSeparateTranscriptChunks(existing, next) {
+  if (/\s$/.test(existing)) {
+    return false;
+  }
+  return /^(?:#{1,6}\s|\*\*[^*]+?\*\*(?:\s|$))/.test(next);
+}
+function isModeUpdateMarker(text) {
+  return /^\[MODE_UPDATE\]\s*[A-Za-z0-9_-]+\s*$/.test(text.trim());
+}
+function readPlanSteps(record) {
+  const steps = Array.isArray(record.steps) ? record.steps : [];
+  return steps.flatMap((step) => {
+    if (typeof step === "string") {
+      return [{ step, status: "pending" }];
+    }
+    const stepRecord = asRecord2(step);
+    if (!stepRecord) {
+      return [];
+    }
+    const text = readString(stepRecord, "step") ?? readString(stepRecord, "content");
+    if (!text) {
+      return [];
+    }
+    const status = readString(stepRecord, "status");
+    return [
+      {
+        step: text,
+        status: status === "in_progress" || status === "completed" ? status : "pending"
+      }
+    ];
+  });
+}
+function readPromptText(content) {
+  return readContentText({ content }, "content");
+}
+
+// src/normalizer/runtime-capabilities.ts
+function normalizeAcpRuntimeCapabilities(params) {
+  const record = asRecord2(params.value);
+  if (!record) {
+    return params.initialize;
+  }
+  const configOptions = readConfigOptions(record.configOptions ?? record.config_options);
+  const modes = readModes(record.modes);
+  const models = readModels(record.models);
+  const agentCapabilities = readAgentCapabilities(
+    record.agentCapabilities ?? record.agent_capabilities ?? record.capabilities,
+    record.sessionCapabilities ?? record.session_capabilities
+  );
+  const agentInfo = readAgentInfo(record.agentInfo ?? record.agent_info);
+  const protocolVersion = typeof record.protocolVersion === "number" ? record.protocolVersion : typeof record.protocol_version === "number" ? record.protocol_version : params.initialize?.protocolVersion;
+  const hasRuntimeData = configOptions.length > 0 || Boolean(modes) || Boolean(models) || Boolean(agentCapabilities) || Boolean(agentInfo) || typeof protocolVersion === "number";
+  if (!hasRuntimeData && !params.initialize) {
+    return void 0;
+  }
+  const merged = {
+    source: params.source,
+    discoveredAt: params.initialize?.discoveredAt ?? params.now,
+    checkedAt: params.now
+  };
+  if (typeof protocolVersion === "number") merged.protocolVersion = protocolVersion;
+  if (agentInfo ?? params.initialize?.agentInfo) {
+    merged.agentInfo = { ...params.initialize?.agentInfo, ...agentInfo };
+  }
+  if (agentCapabilities ?? params.initialize?.agentCapabilities) {
+    merged.agentCapabilities = {
+      ...params.initialize?.agentCapabilities,
+      ...agentCapabilities
+    };
+  }
+  if (configOptions.length > 0) {
+    merged.configOptions = configOptions;
+  } else if (params.initialize?.configOptions) {
+    merged.configOptions = params.initialize.configOptions;
+  }
+  if (modes) {
+    merged.modes = modes;
+  } else if (params.initialize?.modes) {
+    merged.modes = params.initialize.modes;
+  }
+  if (models) {
+    merged.models = models;
+  } else if (params.initialize?.models) {
+    merged.models = params.initialize.models;
+  }
+  return merged;
+}
+function acpRuntimeSupportsSessionLoad(capabilities) {
+  return capabilities?.agentCapabilities?.loadSession !== false;
+}
+function acpSessionRuntimeStateFromCapabilities(capabilities, now) {
+  if (!capabilities) {
+    return void 0;
+  }
+  const configValues = Object.fromEntries(
+    (capabilities.configOptions ?? []).flatMap(
+      (option) => typeof option.currentValue === "string" ? [[option.id, option.currentValue]] : []
+    )
+  );
+  const state = { updatedAt: now };
+  if (Object.keys(configValues).length > 0) state.configValues = configValues;
+  if (capabilities.modes?.currentModeId) {
+    state.currentModeId = capabilities.modes.currentModeId;
+  }
+  if (capabilities.models?.currentModelId) {
+    state.currentModelId = capabilities.models.currentModelId;
+  }
+  return Object.keys(state).length > 1 ? state : void 0;
+}
+function acpSessionRuntimeStateFromUpdate(update, now) {
+  const kind = readString(update, "sessionUpdate") ?? readString(update, "session_update") ?? readString(update, "kind") ?? readString(update, "type");
+  if (kind === "agent_message_chunk") {
+    const modeId = readModeUpdateMarker(update);
+    return modeId ? { currentModeId: modeId, updatedAt: now } : void 0;
+  }
+  if (kind === "current_mode_update") {
+    const currentModeId = readString(update, "currentModeId") ?? readString(update, "current_mode_id") ?? readString(update, "modeId") ?? readString(update, "mode_id") ?? readString(update, "id");
+    return currentModeId ? { currentModeId, updatedAt: now } : void 0;
+  }
+  if (kind === "config_option_update") {
+    const configOption = asRecord2(update.configOption ?? update.config_option) ?? update;
+    const id = readString(configOption, "id") ?? readString(configOption, "configOptionId") ?? readString(configOption, "configId");
+    const value = readString(configOption, "currentValue") ?? readString(configOption, "value");
+    return id && value ? { configValues: { [id]: value }, updatedAt: now } : void 0;
+  }
+  return void 0;
+}
+function mergeAcpRuntimeState(existing, update) {
+  return {
+    ...existing,
+    ...update,
+    configValues: {
+      ...existing?.configValues ?? {},
+      ...update.configValues ?? {}
+    }
+  };
+}
+function modeLabelFor(capabilities, modeId) {
+  return capabilities?.modes?.availableModes.find((mode) => mode.id === modeId)?.label;
+}
+function readModeUpdateMarker(update) {
+  const text = readString(update, "content") ?? readString(update, "text");
+  const match = text?.trim().match(/^\[MODE_UPDATE\]\s*([A-Za-z0-9_-]+)\s*$/);
+  return match?.[1];
+}
+function readConfigOptions(value) {
+  if (!Array.isArray(value)) {
+    return [];
+  }
+  return value.flatMap((item) => {
+    const record = asRecord2(item);
+    const id = readString(record, "id") ?? readString(record, "configOptionId") ?? readString(record, "configId");
+    if (!record || !id) {
+      return [];
+    }
+    const values = readConfigOptionValues(record.values ?? record.options);
+    if (values.length === 0) {
+      return [];
+    }
+    const option = {
+      id,
+      label: readString(record, "name") ?? readString(record, "label") ?? readString(record, "title") ?? id,
+      type: "select",
+      values
+    };
+    const description = readString(record, "description");
+    if (description !== void 0) option.description = description;
+    const category = readString(record, "category");
+    if (category !== void 0) option.category = category;
+    const currentValue = readString(record, "currentValue") ?? readString(record, "value");
+    if (currentValue !== void 0) option.currentValue = currentValue;
+    return [option];
+  });
+}
+function readConfigOptionValues(value) {
+  if (!Array.isArray(value)) {
+    return [];
+  }
+  return value.flatMap((item) => {
+    const record = asRecord2(item);
+    const optionValue = readString(record, "value") ?? readString(record, "id") ?? readString(record, "optionId");
+    if (!record || !optionValue) {
+      return [];
+    }
+    const normalized = { value: optionValue };
+    const label = readString(record, "name") ?? readString(record, "label") ?? readString(record, "title");
+    if (label !== void 0) normalized.label = label;
+    const description = readString(record, "description");
+    if (description !== void 0) normalized.description = description;
+    return [normalized];
+  });
+}
+function readModes(value) {
+  const record = asRecord2(value);
+  const modes = Array.isArray(record?.availableModes) ? record.availableModes.flatMap(readMode) : [];
+  if (modes.length === 0) {
+    return void 0;
+  }
+  const result = { availableModes: modes };
+  const currentModeId = readString(record, "currentModeId");
+  if (currentModeId !== void 0) result.currentModeId = currentModeId;
+  return result;
+}
+function readMode(value) {
+  const record = asRecord2(value);
+  const id = readString(record, "id") ?? readString(record, "modeId");
+  if (!record || !id) {
+    return [];
+  }
+  const mode = {
+    id,
+    label: readString(record, "name") ?? readString(record, "label") ?? id
+  };
+  const description = readString(record, "description");
+  if (description !== void 0) mode.description = description;
+  return [mode];
+}
+function readModels(value) {
+  const record = asRecord2(value);
+  const models = Array.isArray(record?.availableModels) ? record.availableModels.flatMap(readModel) : [];
+  if (models.length === 0) {
+    return void 0;
+  }
+  const result = { availableModels: models };
+  const currentModelId = readString(record, "currentModelId") ?? readString(record, "modelId");
+  if (currentModelId !== void 0) result.currentModelId = currentModelId;
+  return result;
+}
+function readModel(value) {
+  const record = asRecord2(value);
+  const id = readString(record, "modelId") ?? readString(record, "id");
+  if (!record || !id) {
+    return [];
+  }
+  const model = { id };
+  const label = readString(record, "name") ?? readString(record, "label");
+  if (label !== void 0) model.label = label;
+  const description = readString(record, "description");
+  if (description !== void 0) model.description = description;
+  return [model];
+}
+function readAgentCapabilities(value, sessionCapabilitiesValue) {
+  const record = asRecord2(value);
+  const sessionCapabilities = asRecord2(sessionCapabilitiesValue);
+  const sessionMeta = asRecord2(sessionCapabilities?._meta);
+  const kimiMeta = asRecord2(sessionMeta?.kimi);
+  if (!record && !sessionCapabilities) {
+    return void 0;
+  }
+  const loadSession = readBoolean(record, "loadSession") ?? readBoolean(record, "load_session") ?? readBoolean(asRecord2(record?.session), "load");
+  const close = readBoolean(asRecord2(record?.session), "close");
+  const cancel = readBoolean(asRecord2(record?.session), "cancel");
+  const sessionHistoryReplay = readBoolean(kimiMeta, "sessionHistoryReplay") ?? readBoolean(kimiMeta, "session_history_replay");
+  const capabilities = {
+    raw: record ?? sessionCapabilities
+  };
+  if (loadSession !== void 0) capabilities.loadSession = loadSession;
+  if (sessionHistoryReplay !== void 0) {
+    capabilities.sessionHistoryReplay = sessionHistoryReplay;
+  }
+  if (close !== void 0 || cancel !== void 0) {
+    capabilities.session = {
+      ...close !== void 0 ? { close } : {},
+      ...cancel !== void 0 ? { cancel } : {}
+    };
+  }
+  return capabilities;
+}
+function readAgentInfo(value) {
+  const record = asRecord2(value);
+  if (!record) {
+    return void 0;
+  }
+  const agentInfo = {};
+  const name = readString(record, "name");
+  if (name !== void 0) agentInfo.name = name;
+  const title = readString(record, "title");
+  if (title !== void 0) agentInfo.title = title;
+  const version = readString(record, "version");
+  if (version !== void 0) agentInfo.version = version;
+  return Object.keys(agentInfo).length > 0 ? agentInfo : void 0;
+}
+
+// src/acp-client.ts
+var ACP_PROTOCOL_VERSION = 1;
+var ACP_PROMPT_REQUEST_TIMEOUT_MS = 60 * 6e4;
+var ACP_REQUEST_TIMEOUT_MS = 3e4;
+var DEFAULT_CLIENT_NAME = "agent-kit";
+function permissionDecisionToken(decision) {
+  switch (decision) {
+    case "approved":
+      return "approve";
+    case "abort":
+    case "denied":
+    default:
+      return "reject";
+  }
+}
+var AcpAgentClient = class {
+  transport;
+  strategy;
+  now;
+  logger;
+  eventListeners = /* @__PURE__ */ new Set();
+  toolCallHandler = null;
+  approvalHandler = null;
+  titleHandler = null;
+  runtimeCapabilitiesHandler = null;
+  // threadId ↔ protocol sessionId mapping + per-session state.
+  sessions = /* @__PURE__ */ new Map();
+  threadIdByProtocolId = /* @__PURE__ */ new Map();
+  unsubscribeNotification = void 0;
+  unsubscribeRequest = void 0;
+  initialized = false;
+  runtimeCapabilities;
+  threadSequence = 0;
+  constructor(options) {
+    this.transport = options.transport;
+    this.strategy = options.strategy;
+    this.now = options.now ?? Date.now;
+    this.logger = options.logger ?? noopLogger2;
+    this.clientName = options.clientName ?? DEFAULT_CLIENT_NAME;
+    this.clientTitle = options.clientTitle ?? this.clientName;
+    this.clientVersion = options.clientVersion ?? "0.0.0";
+    this.defaultCwd = options.cwd;
+    this.defaultMcpServers = options.mcpServers ?? [];
+  }
+  clientName;
+  clientTitle;
+  clientVersion;
+  defaultCwd;
+  defaultMcpServers;
+  // ---- subscriptions (mirror CodexThreadClient) ----
+  onEvent(cb) {
+    this.eventListeners.add(cb);
+    return () => {
+      this.eventListeners.delete(cb);
+    };
+  }
+  onToolCall(handler) {
+    this.toolCallHandler = handler;
+    return () => {
+      if (this.toolCallHandler === handler) this.toolCallHandler = null;
+    };
+  }
+  onApprovalRequest(handler) {
+    this.approvalHandler = handler;
+    return () => {
+      if (this.approvalHandler === handler) this.approvalHandler = null;
+    };
+  }
+  /** Subscribe to title extraction (topic-update / session-summary). */
+  onTitle(handler) {
+    this.titleHandler = handler;
+    return () => {
+      if (this.titleHandler === handler) this.titleHandler = null;
+    };
+  }
+  /** Subscribe to runtime-capabilities (models/modes/config-options) changes. */
+  onRuntimeCapabilities(handler) {
+    this.runtimeCapabilitiesHandler = handler;
+    return () => {
+      if (this.runtimeCapabilitiesHandler === handler) {
+        this.runtimeCapabilitiesHandler = null;
+      }
+    };
+  }
+  // ---- lifecycle ----
+  /**
+   * Public `AgentBackend.startThread`: accepts NEUTRAL `AgentStartThreadOptions`
+   * and maps them onto an ACP `session/new`. ACP supports:
+   *   • `cwd` → `session/new.cwd`.
+   *   • `model` → applied via `session/set_model` after the session opens, when
+   *     the agent advertises model selection (best-effort; debug-logged if not).
+   *   • `instructions` is NOT injected here — ACP `session/new` has no base-
+   *     instructions slot, matching the adapter's existing behavior. A host that
+   *     wants system framing sends it as leading turn text.
+   * Codex-only fields (`approvalPolicy`, `sandbox`, `config`, `environments`,
+   * `tools`, `serviceName`, `modelProvider`, `serviceTier`, `workspaceRoots`) are
+   * IGNORED — logged at debug so it's visible the backend doesn't honor them.
+   */
+  async startThread(options = {}) {
+    const ignored = [];
+    for (const key of [
+      "instructions",
+      "approvalPolicy",
+      "sandbox",
+      "config",
+      "environments",
+      "tools",
+      "serviceName",
+      "modelProvider",
+      "serviceTier",
+      "workspaceRoots"
+    ]) {
+      if (options[key] !== void 0) ignored.push(key);
+    }
+    if (ignored.length > 0) {
+      this.logger.debug("acp startThread: ignoring Codex-only neutral options", {
+        ignored
+      });
+    }
+    const native = {};
+    if (options.cwd !== void 0) native.cwd = options.cwd;
+    const result = await this.startThreadNative(native);
+    if (options.model !== void 0) {
+      await this.setModel(result.threadId, options.model).catch((cause) => {
+        this.logger.debug("acp startThread: model selection not applied", {
+          model: options.model,
+          message: cause instanceof Error ? cause.message : String(cause)
+        });
+      });
+    }
+    return result;
+  }
+  /** ACP-native `session/new`. The neutral `startThread` delegates here after
+   *  mapping cwd + dropping Codex-only fields. Exposed for hosts that need
+   *  ACP-specific control (per-thread `mcpServers`). */
+  async startThreadNative(options = {}) {
+    await this.initialize();
+    const cwd = options.cwd ?? this.defaultCwd ?? process.cwd();
+    const mcpServers = options.mcpServers ?? this.defaultMcpServers;
+    const result = await this.transport.request("session/new", {
+      cwd,
+      mcpServers
+    });
+    const record = asRecord3(result);
+    const protocolSessionId = readString2(record, "sessionId") ?? readString2(record, "session_id");
+    if (!protocolSessionId) {
+      throw new Error("ACP session/new did not return a session id");
+    }
+    const threadId = `acp:${this.strategy.id}:${++this.threadSequence}`;
+    const session = {
+      threadId,
+      protocolSessionId,
+      normalizer: new AcpSessionNormalizer({ quirks: this.strategy.quirks }),
+      turnId: void 0,
+      runtimeState: void 0
+    };
+    this.sessions.set(threadId, session);
+    this.threadIdByProtocolId.set(protocolSessionId, threadId);
+    const runtimeCapabilities = this.captureRuntimeCapabilities("session-new", result);
+    if (runtimeCapabilities) {
+      const runtimeState = acpSessionRuntimeStateFromCapabilities(
+        runtimeCapabilities,
+        this.now()
+      );
+      if (runtimeState) session.runtimeState = runtimeState;
+      this.notifyRuntimeCapabilities({ threadId, runtimeCapabilities, runtimeState });
+      this.emitThreadSettings(session, runtimeCapabilities, runtimeState);
+    }
+    this.logger.debug("acp thread started", { threadId, protocolSessionId });
+    const out = { threadId };
+    const model = runtimeCapabilities?.models?.currentModelId;
+    if (model !== void 0) out.model = model;
+    out.modelProvider = this.strategy.id;
+    return out;
+  }
+  /**
+   * Public `AgentBackend.startTurn`: accepts NEUTRAL `AgentStartTurnOptions` and
+   * maps them onto ACP prompt content blocks — a leading `text` block from
+   * `input.text`, then one `image` block per `input.imagePaths` entry (read from
+   * disk, base64-encoded, mimeType inferred from extension). `reasoning` maps to
+   * an ACP mode/config when the session advertises a matching option, else it is
+   * IGNORED (debug-logged).
+   */
+  async startTurn(options) {
+    const promptContent = [
+      { type: "text", text: options.input.text }
+    ];
+    for (const imagePath of options.input.imagePaths ?? []) {
+      const block = await this.imageBlockFromPath(imagePath).catch((cause) => {
+        this.logger.debug("acp startTurn: skipping unreadable image", {
+          imagePath,
+          message: cause instanceof Error ? cause.message : String(cause)
+        });
+        return void 0;
+      });
+      if (block !== void 0) promptContent.push(block);
+    }
+    if (options.reasoning !== void 0) {
+      await this.applyReasoning(options.threadId, options.reasoning).catch((cause) => {
+        this.logger.debug("acp startTurn: reasoning not applied", {
+          reasoning: options.reasoning,
+          message: cause instanceof Error ? cause.message : String(cause)
+        });
+      });
+    }
+    return this.startTurnNative({ threadId: options.threadId, promptContent });
+  }
+  /** ACP-native `session/prompt`. Takes a plain prompt or pre-built content
+   *  blocks. The neutral `startTurn` delegates here after building blocks. */
+  async startTurnNative(options) {
+    const session = this.requireSession(options.threadId);
+    if (session.turnId !== void 0) {
+      throw new Error("A turn is already active for this ACP session.");
+    }
+    const turnId = `turn:${session.threadId}:${this.now()}`;
+    session.turnId = turnId;
+    session.normalizer.resetTurn();
+    this.emit({ kind: "turn_started", threadId: session.threadId, turnId });
+    const prompt = options.promptContent ?? textPrompt(options.prompt ?? "");
+    try {
+      await this.transport.request(
+        "session/prompt",
+        {
+          sessionId: session.protocolSessionId,
+          prompt
+        },
+        ACP_PROMPT_REQUEST_TIMEOUT_MS
+      );
+    } catch (error) {
+      session.turnId = void 0;
+      this.emit({
+        kind: "turn_completed",
+        threadId: session.threadId,
+        turnId,
+        status: "failed"
+      });
+      this.emit({
+        kind: "error",
+        threadId: session.threadId,
+        turnId,
+        message: errorMessage(error)
+      });
+      throw error;
+    }
+    for (const event of session.normalizer.finalizeAssistantMessage({
+      threadId: session.threadId,
+      turnId
+    })) {
+      this.emit(event);
+    }
+    session.turnId = void 0;
+    this.emit({
+      kind: "turn_completed",
+      threadId: session.threadId,
+      turnId,
+      status: "completed"
+    });
+    return { turnId };
+  }
+  async interruptTurn(threadId) {
+    const session = this.requireSession(threadId);
+    if (this.transport.notify) {
+      await this.transport.notify("session/cancel", {
+        sessionId: session.protocolSessionId
+      });
+    } else {
+      await this.transport.request("session/cancel", {
+        sessionId: session.protocolSessionId
+      });
+    }
+  }
+  async setMode(threadId, modeId) {
+    await this.setRuntimeOption(threadId, "mode", modeId, modeId);
+  }
+  async setModel(threadId, modelId) {
+    await this.setRuntimeOption(threadId, "model", modelId, modelId);
+  }
+  async setConfigOption(threadId, optionId, value) {
+    await this.setRuntimeOption(threadId, "configOption", optionId, value);
+  }
+  async close() {
+    this.unsubscribeNotification?.();
+    this.unsubscribeNotification = void 0;
+    this.unsubscribeRequest?.();
+    this.unsubscribeRequest = void 0;
+    this.sessions.clear();
+    this.threadIdByProtocolId.clear();
+    this.initialized = false;
+    await this.transport.close?.();
+  }
+  // ---- internals ----
+  emit(event) {
+    for (const listener of this.eventListeners) listener(event);
+  }
+  async initialize() {
+    if (this.initialized) return;
+    this.unsubscribeNotification = this.transport.onNotification((method, params) => {
+      this.handleNotification(method, params);
+    });
+    this.unsubscribeRequest = this.transport.onRequest?.(
+      async (method, params, id) => await this.handleAcpRequest(method, params, id)
+    );
+    const result = await this.transport.request(
+      "initialize",
+      {
+        protocolVersion: ACP_PROTOCOL_VERSION,
+        clientCapabilities: {
+          auth: { terminal: false },
+          fs: { readTextFile: false, writeTextFile: false },
+          terminal: false
+        },
+        clientInfo: {
+          name: this.clientName,
+          title: this.clientTitle,
+          version: this.clientVersion
+        }
+      },
+      ACP_REQUEST_TIMEOUT_MS
+    );
+    const runtimeCapabilities = this.captureRuntimeCapabilities("initialize", result);
+    if (runtimeCapabilities) {
+      this.notifyRuntimeCapabilities({ runtimeCapabilities });
+    }
+    this.initialized = true;
+  }
+  handleNotification(method, params) {
+    const vendorMethods = this.strategy.quirks.vendorNotificationMethods ?? [];
+    if (method !== "session/update" && !vendorMethods.includes(method)) {
+      return;
+    }
+    const record = asRecord3(params);
+    if (!record) return;
+    this.applySessionUpdate(record);
+  }
+  applySessionUpdate(params) {
+    const protocolSessionId = readString2(params, "sessionId") ?? readString2(params, "session_id");
+    const update = asRecord3(params.update);
+    if (!protocolSessionId || !update) {
+      return;
+    }
+    const threadId = this.threadIdByProtocolId.get(protocolSessionId);
+    const session = threadId ? this.sessions.get(threadId) : void 0;
+    if (!session) {
+      this.logger.debug("acp session/update for unknown session", { protocolSessionId });
+      return;
+    }
+    const runtimeState = acpSessionRuntimeStateFromUpdate(update, this.now());
+    if (runtimeState) {
+      session.runtimeState = mergeAcpRuntimeState(session.runtimeState, runtimeState);
+      if (this.runtimeCapabilities) {
+        this.notifyRuntimeCapabilities({
+          threadId: session.threadId,
+          runtimeCapabilities: this.runtimeCapabilities,
+          runtimeState: session.runtimeState
+        });
+      }
+      this.emitThreadSettings(session, this.runtimeCapabilities, session.runtimeState);
+      return;
+    }
+    const ctx = {
+      threadId: session.threadId,
+      turnId: session.turnId ?? `turn:${session.threadId}:detached`
+    };
+    const result = session.normalizer.apply(update, ctx);
+    if (result.title !== void 0) {
+      this.titleHandler?.({ threadId: session.threadId, title: result.title });
+      return;
+    }
+    for (const event of result.events) {
+      this.emit(event);
+    }
+  }
+  async handleAcpRequest(method, params, id) {
+    if (method === "session/request_permission") {
+      return await this.handlePermissionRequest(params, id);
+    }
+    if (this.toolCallHandler) {
+      const call = { method, params };
+      return await this.toolCallHandler(call);
+    }
+    throw new Error(`Unsupported ACP request: ${method}`);
+  }
+  async handlePermissionRequest(params, id) {
+    const protocolSessionId = readString2(params, "sessionId") ?? readString2(params, "session_id");
+    const threadId = protocolSessionId ? this.threadIdByProtocolId.get(protocolSessionId) : void 0;
+    const options = readPermissionOptions(params.options);
+    const handler = this.approvalHandler;
+    if (!handler) {
+      return cancelledPermissionOutcome();
+    }
+    const approval = buildApprovalRequest({
+      params,
+      id,
+      threadId,
+      session: threadId ? this.sessions.get(threadId) : void 0,
+      now: this.now
+    });
+    if (threadId) {
+      this.emit({ kind: "approval_request", threadId, approval });
+    }
+    const decision = await handler("session/request_permission", params);
+    return permissionOutcomeFromDecision(decision, options);
+  }
+  async setRuntimeOption(threadId, source, optionId, value) {
+    const session = this.requireSession(threadId);
+    const result = await this.setRuntimeOptionOnTransport(
+      session.protocolSessionId,
+      source,
+      optionId,
+      value
+    );
+    const runtimeCapabilities = this.captureRuntimeCapabilities("session-load", result);
+    const requested = source === "configOption" ? { configValues: { [optionId]: value }, updatedAt: this.now() } : source === "mode" ? { currentModeId: value, updatedAt: this.now() } : { currentModelId: value, updatedAt: this.now() };
+    session.runtimeState = mergeAcpRuntimeState(session.runtimeState, requested);
+    const effectiveCapabilities = runtimeCapabilities ?? this.runtimeCapabilities;
+    if (effectiveCapabilities) {
+      this.notifyRuntimeCapabilities({
+        threadId,
+        runtimeCapabilities: effectiveCapabilities,
+        ...session.runtimeState !== void 0 ? { runtimeState: session.runtimeState } : {}
+      });
+    }
+    this.emitThreadSettings(session, effectiveCapabilities, session.runtimeState);
+  }
+  async setRuntimeOptionOnTransport(protocolSessionId, source, optionId, value) {
+    if (source === "configOption") {
+      return await this.transport.request("session/set_config_option", {
+        sessionId: protocolSessionId,
+        configId: optionId,
+        value
+      });
+    }
+    if (source === "mode") {
+      return await this.transport.request("session/set_mode", {
+        sessionId: protocolSessionId,
+        modeId: value
+      });
+    }
+    return await this.transport.request("session/set_model", {
+      sessionId: protocolSessionId,
+      modelId: value
+    });
+  }
+  /** Map a neutral `reasoning` token onto an ACP runtime option. We try to match
+   *  it to an available MODE (by id or label, case-insensitively) and switch via
+   *  `session/set_mode`. ACP has no first-class "reasoning effort" concept, so if
+   *  no mode matches we leave it alone — the caller's `.catch` debug-logs. */
+  async applyReasoning(threadId, reasoning) {
+    const modes = this.runtimeCapabilities?.modes?.availableModes ?? [];
+    const target = reasoning.toLowerCase();
+    const match = modes.find(
+      (mode) => mode.id.toLowerCase() === target || typeof mode.label === "string" && mode.label.toLowerCase() === target
+    );
+    if (match === void 0) {
+      this.logger.debug("acp reasoning has no matching mode \u2014 ignored", { reasoning });
+      return;
+    }
+    await this.setMode(threadId, match.id);
+  }
+  /** Read an image file and build an ACP `image` content block (base64 + inferred
+   *  mimeType). Throws on read failure; the caller catches + skips. */
+  async imageBlockFromPath(imagePath) {
+    const data = await readFile(imagePath);
+    return {
+      type: "image",
+      mimeType: mimeTypeForImagePath(imagePath),
+      data: data.toString("base64")
+    };
+  }
+  captureRuntimeCapabilities(source, result) {
+    const runtimeCapabilities = normalizeAcpRuntimeCapabilities({
+      value: result,
+      now: this.now(),
+      source,
+      ...this.runtimeCapabilities !== void 0 ? { initialize: this.runtimeCapabilities } : {}
+    });
+    if (runtimeCapabilities) {
+      this.runtimeCapabilities = runtimeCapabilities;
+    }
+    return runtimeCapabilities;
+  }
+  notifyRuntimeCapabilities(event) {
+    this.runtimeCapabilitiesHandler?.({
+      ...event.threadId !== void 0 ? { threadId: event.threadId } : {},
+      runtimeCapabilities: event.runtimeCapabilities,
+      ...event.runtimeState !== void 0 ? { runtimeState: event.runtimeState } : {}
+    });
+  }
+  emitThreadSettings(session, capabilities, runtimeState) {
+    const settings = { threadId: session.threadId };
+    const model = runtimeState?.currentModelId ?? capabilities?.models?.currentModelId;
+    if (model !== void 0) settings.model = model;
+    settings.modelProvider = this.strategy.id;
+    const modeId = runtimeState?.currentModeId ?? capabilities?.modes?.currentModeId;
+    if (modeId !== void 0) {
+      settings.modeId = modeId;
+      const label = modeLabelFor(capabilities, modeId);
+      if (label !== void 0) settings.modeLabel = label;
+    }
+    this.emit({ kind: "thread_settings", settings });
+  }
+  requireSession(threadId) {
+    const session = this.sessions.get(threadId);
+    if (!session) {
+      throw new Error(`Unknown ACP thread: ${threadId}`);
+    }
+    return session;
+  }
+  /** Whether the agent advertises session/load support (for hosts that resume). */
+  supportsSessionLoad() {
+    return acpRuntimeSupportsSessionLoad(this.runtimeCapabilities);
+  }
+};
+function buildApprovalRequest(args) {
+  const toolCall = asRecord3(args.params.toolCall) ?? {};
+  const title = typeof toolCall.title === "string" && toolCall.title.trim() ? toolCall.title.trim() : "ACP tool call";
+  const toolCallId = readString2(toolCall, "toolCallId") ?? readString2(toolCall, "tool_call_id");
+  const requestId = args.id == null ? toolCallId ?? `acp:${args.now()}` : String(args.id);
+  const acpKind = typeof toolCall.kind === "string" ? toolCall.kind : void 0;
+  const approval = {
+    id: requestId,
+    method: "session/request_permission",
+    kind: approvalKindFor(acpKind),
+    params: args.params
+  };
+  approval.summary = acpKind ? `${acpKind}: ${title}` : title;
+  return approval;
+}
+function approvalKindFor(acpKind) {
+  switch (acpKind) {
+    case "execute":
+    case "exec":
+    case "shell":
+      return "exec";
+    case "edit":
+    case "write":
+      return "patch";
+    case "read":
+    case "search":
+    case "fetch":
+      return "tool";
+    default:
+      return "other";
+  }
+}
+function readPermissionOptions(value) {
+  if (!Array.isArray(value)) {
+    return [];
+  }
+  return value.flatMap((option) => {
+    const record = asRecord3(option);
+    const optionId = readString2(record, "optionId");
+    if (!record || !optionId) {
+      return [];
+    }
+    const normalized = { optionId };
+    const name = readString2(record, "name");
+    if (name !== void 0) normalized.name = name;
+    const kind = readString2(record, "kind");
+    if (kind !== void 0) normalized.kind = kind;
+    return [normalized];
+  });
+}
+function permissionOutcomeFromDecision(decision, options) {
+  const token = permissionDecisionToken(decision);
+  const optionId = selectPermissionOptionId(token, options);
+  return optionId ? { outcome: { outcome: "selected", optionId } } : cancelledPermissionOutcome();
+}
+function cancelledPermissionOutcome() {
+  return { outcome: { outcome: "cancelled" } };
+}
+function selectPermissionOptionId(decision, options) {
+  const normalized = decision.toLowerCase();
+  const exact = options.find(
+    (option) => [option.optionId, option.name, option.kind].filter((value) => typeof value === "string").some((value) => value.toLowerCase() === normalized)
+  );
+  if (exact) {
+    return exact.optionId;
+  }
+  if (normalized === "approve" || normalized === "accept" || normalized === "allow") {
+    return (options.find((option) => option.kind === "allow_once") ?? options.find((option) => option.kind === "allow_always") ?? options.find((option) => option.name?.toLowerCase().includes("allow")))?.optionId;
+  }
+  if (normalized === "reject" || normalized === "decline" || normalized === "deny") {
+    return (options.find((option) => option.kind === "reject_once") ?? options.find((option) => option.name?.toLowerCase().includes("reject")))?.optionId;
+  }
+  return void 0;
+}
+function textPrompt(text) {
+  return [{ type: "text", text }];
+}
+function mimeTypeForImagePath(imagePath) {
+  switch (extname(imagePath).toLowerCase()) {
+    case ".jpg":
+    case ".jpeg":
+      return "image/jpeg";
+    case ".gif":
+      return "image/gif";
+    case ".webp":
+      return "image/webp";
+    case ".bmp":
+      return "image/bmp";
+    case ".svg":
+      return "image/svg+xml";
+    case ".png":
+    default:
+      return "image/png";
+  }
+}
+function errorMessage(error) {
+  if (error instanceof Error && error.message.trim()) {
+    return error.message;
+  }
+  const message = String(error).trim();
+  return message || "Turn failed.";
+}
+function readString2(record, key) {
+  const value = record?.[key];
+  return typeof value === "string" ? value : void 0;
+}
+function asRecord3(value) {
+  return value && typeof value === "object" && !Array.isArray(value) ? value : void 0;
+}
+
+// src/strategies/strategy-types.ts
+function buildAcpBackendId(registryId) {
+  return `acp:${registryId}`;
+}
+var DEFAULT_QUIRKS = {
+  surfaceThoughts: true,
+  titleFrom: "topic-update"
+};
+function defaultQuirks(overrides = {}) {
+  return { ...DEFAULT_QUIRKS, ...overrides };
+}
+
+// src/strategies/gemini.ts
+var geminiStrategy = {
+  id: "gemini",
+  backendId: buildAcpBackendId("gemini"),
+  displayName: "Gemini CLI",
+  authors: ["Google"],
+  discoveryProbe: {
+    command: "gemini",
+    versionArgs: ["--version"],
+    helpArgs: ["--help"],
+    helpMatches: /(^|\s)--acp(\s|,|$)/
+  },
+  spawn: {
+    command: "gemini",
+    args: ["--acp"],
+    // Gemini refuses to operate without workspace trust; matching PwrAgnt's
+    // launch-descriptor normalization, append --skip-trust + set the env flag.
+    ensureArgs: ["--skip-trust"],
+    env: { GEMINI_CLI_TRUST_WORKSPACE: "true" }
+  },
+  quirks: defaultQuirks({ surfaceThoughts: true, titleFrom: "topic-update" })
+};
+
+// src/strategies/grok.ts
+import { homedir } from "os";
+import path from "path";
+var grokStrategy = {
+  id: "grok",
+  backendId: buildAcpBackendId("grok"),
+  displayName: "Grok",
+  authors: ["xAI"],
+  discoveryProbe: {
+    command: "grok",
+    versionArgs: ["--version"],
+    helpArgs: ["agent", "stdio", "--help"],
+    helpMatches: /Run the agent over stdio/i,
+    fallbackCommands: [
+      path.join(homedir(), ".grok", "bin", "grok"),
+      "/opt/homebrew/bin/grok",
+      "/usr/local/bin/grok"
+    ]
+  },
+  spawn: {
+    command: "grok",
+    args: ["agent", "stdio"]
+  },
+  // Grok auto-generates the thread title via its vendor notification
+  // `_x.ai/session_notification` carrying `session_summary_generated`.
+  quirks: defaultQuirks({
+    surfaceThoughts: true,
+    titleFrom: "session-summary",
+    vendorNotificationMethods: ["_x.ai/session_notification"]
+  })
+};
+
+// src/strategies/kimi.ts
+var kimiStrategy = {
+  id: "kimi",
+  backendId: buildAcpBackendId("kimi"),
+  displayName: "Kimi Code CLI",
+  authors: ["Moonshot AI"],
+  discoveryProbe: {
+    command: "kimi",
+    versionArgs: ["--version"],
+    helpArgs: ["acp", "--help"],
+    helpMatches: /\bACP server\b/i
+  },
+  spawn: {
+    command: "kimi",
+    args: ["acp"]
+  },
+  quirks: defaultQuirks({ surfaceThoughts: true, titleFrom: "topic-update" })
+};
+
+// src/strategies/qwen.ts
+import { homedir as homedir2 } from "os";
+import path2 from "path";
+var qwenStrategy = {
+  id: "qwen",
+  backendId: buildAcpBackendId("qwen"),
+  displayName: "Qwen Code",
+  authors: ["Qwen Team"],
+  license: "Apache-2.0",
+  repositoryUrl: "https://github.com/QwenLM/qwen-code",
+  discoveryProbe: {
+    command: "qwen",
+    versionArgs: ["--version"],
+    helpArgs: ["--help"],
+    helpMatches: /(^|\s)--acp(\s|,|$)/,
+    fallbackCommands: [
+      path2.join(homedir2(), ".qwen", "bin", "qwen"),
+      "/opt/homebrew/bin/qwen",
+      "/usr/local/bin/qwen"
+    ]
+  },
+  spawn: {
+    command: "qwen",
+    args: ["--acp"]
+  },
+  // Qwen's thought chunks are noisy internal scaffolding — suppress them.
+  quirks: defaultQuirks({ surfaceThoughts: false, titleFrom: "topic-update" })
+};
+
+// src/strategies/index.ts
+var BUILT_IN_ACP_STRATEGIES = [
+  geminiStrategy,
+  kimiStrategy,
+  grokStrategy,
+  qwenStrategy
+];
+function buildStrategyTable(strategies = BUILT_IN_ACP_STRATEGIES) {
+  const table = /* @__PURE__ */ new Map();
+  for (const strategy of strategies) {
+    table.set(strategy.id, strategy);
+  }
+  return table;
+}
+function strategyById(id, table = buildStrategyTable()) {
+  return table.get(id);
+}
+function strategyByBackendId(backendId, strategies = BUILT_IN_ACP_STRATEGIES) {
+  return strategies.find((strategy) => strategy.backendId === backendId);
+}
+
+// src/discovery/acp-local-discovery.ts
+import { execFile as execFileCallback } from "child_process";
+import { promisify } from "util";
+var execFile = promisify(execFileCallback);
+async function discoverLocalAcpAgents(options = {}) {
+  const strategies = options.strategies ?? BUILT_IN_ACP_STRATEGIES;
+  const probe = options.probe ?? defaultProbe;
+  const now = options.now ?? Date.now;
+  const discovered = await Promise.all(
+    strategies.map(
+      (strategy) => discoverStrategy(strategy, probe, now, options.overrides?.[strategy.id])
+    )
+  );
+  return discovered.filter((agent) => agent !== void 0);
+}
+async function discoverStrategy(strategy, probe, now, override) {
+  const candidates = candidateCommands(strategy, override);
+  for (const command of candidates) {
+    const [versionResult, helpResult] = await Promise.all([
+      runProbe(probe, command, strategy.discoveryProbe.versionArgs),
+      runProbe(probe, command, strategy.discoveryProbe.helpArgs)
+    ]);
+    if (!versionResult || !helpResult) {
+      continue;
+    }
+    if (!strategy.discoveryProbe.helpMatches.test(resultText(helpResult))) {
+      continue;
+    }
+    const version = parseCliVersion(resultText(versionResult));
+    const agent = {
+      strategyId: strategy.id,
+      backendId: strategy.backendId,
+      name: strategy.displayName,
+      command,
+      args: ensureArgs(strategy.spawn.args, strategy.spawn.ensureArgs),
+      env: strategy.spawn.env ?? {},
+      discoveredAt: now()
+    };
+    if (version !== void 0) agent.version = version;
+    return agent;
+  }
+  return void 0;
+}
+function candidateCommands(strategy, override) {
+  const candidates = [];
+  if (override && override.trim()) {
+    candidates.push(override.trim());
+  }
+  candidates.push(strategy.discoveryProbe.command);
+  for (const fallback of strategy.discoveryProbe.fallbackCommands ?? []) {
+    candidates.push(fallback);
+  }
+  return [...new Set(candidates)];
+}
+function ensureArgs(args, ensure) {
+  if (!ensure || ensure.length === 0) {
+    return args;
+  }
+  const result = [...args];
+  for (const arg of ensure) {
+    if (!result.includes(arg)) result.push(arg);
+  }
+  return result;
+}
+async function defaultProbe(command, args) {
+  return await execFile(command, args, { timeout: 5e3, maxBuffer: 1024 * 1024 });
+}
+async function runProbe(probe, command, args) {
+  try {
+    return await probe(command, args);
+  } catch {
+    return void 0;
+  }
+}
+function resultText(result) {
+  return [result.stdout, result.stderr].flatMap((value) => value === void 0 ? [] : [value]).map((value) => Buffer.isBuffer(value) ? value.toString("utf8") : value).join("\n");
+}
+function parseCliVersion(output) {
+  const trimmed = output.trim();
+  if (!trimmed) {
+    return void 0;
+  }
+  return trimmed.match(/\d+\.\d+\.\d+(?:[-+][\w.-]+)?/)?.[0] ?? trimmed;
+}
+
+// src/discovery/acp-agent-allowlist.ts
+var BANNED_ACP_REGISTRY_IDS = /* @__PURE__ */ new Set(["codex-acp"]);
+var DEFAULT_ACP_AGENT_ALLOWLIST = [
+  { id: "local-grok-cli", registryId: "grok", distributionKinds: ["local"] },
+  { id: "local-qwen-code-cli", registryId: "qwen", distributionKinds: ["local"] }
+];
+var AcpAgentAllowlist = class {
+  constructor(rules) {
+    this.rules = rules;
+  }
+  rules;
+  evaluate(agent) {
+    if (isBannedAcpRegistryId(agent.id)) {
+      return { allowed: false, reason: "banned" };
+    }
+    const matchingRules = this.rules.filter((rule) => rule.registryId === agent.id);
+    if (matchingRules.length === 0) {
+      return { allowed: false, reason: "not-allowlisted" };
+    }
+    for (const rule of matchingRules) {
+      const denial = evaluateRule(rule, agent);
+      if (!denial) {
+        return {
+          allowed: true,
+          ruleId: rule.id,
+          unverifiedBinaryAllowed: rule.allowUnverifiedBinary === true
+        };
+      }
+    }
+    return { allowed: false, reason: "allowlist-rule-mismatch" };
+  }
+  evaluateDistribution(agent, distribution) {
+    if (isBannedAcpRegistryId(agent.id)) {
+      return { allowed: false, reason: "banned" };
+    }
+    const matchingRules = this.rules.filter((rule) => rule.registryId === agent.id);
+    if (matchingRules.length === 0) {
+      return { allowed: false, reason: "not-allowlisted" };
+    }
+    for (const rule of matchingRules) {
+      const denial = evaluateDistributionRule(rule, agent, distribution);
+      if (!denial) {
+        return {
+          allowed: true,
+          ruleId: rule.id,
+          unverifiedBinaryAllowed: rule.allowUnverifiedBinary === true
+        };
+      }
+    }
+    return { allowed: false, reason: "allowlist-rule-mismatch" };
+  }
+};
+var defaultAcpAgentAllowlist = new AcpAgentAllowlist(
+  DEFAULT_ACP_AGENT_ALLOWLIST
+);
+function isBannedAcpRegistryId(registryId) {
+  return BANNED_ACP_REGISTRY_IDS.has(registryId);
+}
+function evaluateRule(rule, agent) {
+  if (rule.versions && (!agent.version || !rule.versions.includes(agent.version))) {
+    return "version-not-allowed";
+  }
+  if (isGplFamilyLicense(agent.license) && !rule.allowGplFamilyLicense) {
+    return "license-not-allowed";
+  }
+  let distributionDeniedBySource = false;
+  for (const distribution of agent.distributions) {
+    const denial = evaluateDistributionRule(rule, agent, distribution, {
+      skipAgentChecks: true
+    });
+    if (!denial) {
+      return void 0;
+    }
+    if (denial === "distribution-source-not-allowed") {
+      distributionDeniedBySource = true;
+    }
+  }
+  return distributionDeniedBySource ? "distribution-source-not-allowed" : "distribution-not-allowed";
+}
+function evaluateDistributionRule(rule, agent, distribution, options = {}) {
+  if (!options.skipAgentChecks && rule.versions && (!agent.version || !rule.versions.includes(agent.version))) {
+    return "version-not-allowed";
+  }
+  if (!options.skipAgentChecks && isGplFamilyLicense(agent.license) && !rule.allowGplFamilyLicense) {
+    return "license-not-allowed";
+  }
+  if (!distributionAllowedByKind(rule, distribution)) {
+    return "distribution-not-allowed";
+  }
+  if (!distributionSourceAllowed(rule, distribution)) {
+    return "distribution-source-not-allowed";
+  }
+  return void 0;
+}
+function distributionAllowedByKind(rule, distribution) {
+  return !rule.distributionKinds || rule.distributionKinds.includes(distribution.kind);
+}
+function distributionSourceAllowed(rule, distribution) {
+  if (distribution.kind === "npx" || distribution.kind === "uvx") {
+    return !rule.allowedPackageNames || rule.allowedPackageNames.includes(distribution.packageName);
+  }
+  if (distribution.kind !== "binary") {
+    return false;
+  }
+  if (!rule.allowedArchiveHosts) {
+    return true;
+  }
+  try {
+    return rule.allowedArchiveHosts.includes(new URL(distribution.archiveUrl).host);
+  } catch {
+    return false;
+  }
+}
+function isGplFamilyLicense(license) {
+  return /\b(?:GPL|AGPL|LGPL)\b/i.test(license ?? "");
+}
+
+// src/discovery/acp-registry-types.ts
+var ACP_REGISTRY_URL = "https://cdn.agentclientprotocol.com/registry/v1/latest/registry.json";
+
+// src/discovery/acp-registry-service.ts
+var AcpRegistryService = class {
+  allowlist;
+  fetcher;
+  now;
+  registryUrl;
+  constructor(options = {}) {
+    this.allowlist = options.allowlist ?? defaultAcpAgentAllowlist;
+    this.fetcher = options.fetch ?? (async (input, init) => {
+      const response = await globalThis.fetch(input, init);
+      return {
+        ok: response.ok,
+        status: response.status,
+        statusText: response.statusText,
+        json: () => response.json()
+      };
+    });
+    this.now = options.now ?? Date.now;
+    this.registryUrl = options.registryUrl ?? ACP_REGISTRY_URL;
+  }
+  async fetchRegistry() {
+    const response = await this.fetcher(this.registryUrl, {
+      headers: { accept: "application/json" }
+    });
+    if (!response.ok) {
+      throw new Error(
+        `ACP registry request failed: ${response.status} ${response.statusText}`
+      );
+    }
+    const raw = await response.json();
+    return { fetchedAt: this.now(), agents: normalizeRegistry(raw), raw };
+  }
+  applyAllowlist(snapshot) {
+    return snapshot.agents.map((agent) => {
+      const allowlist = this.allowlist.evaluate(agent);
+      const distributionPolicies = agent.distributions.map(
+        (distribution) => this.evaluateDistribution(agent, distribution)
+      );
+      const installablePolicy = distributionPolicies.find((policy) => policy.installable);
+      const firstBlockedAllowedPolicy = distributionPolicies.find(
+        (policy) => policy.allowlist.allowed
+      );
+      const installable = Boolean(installablePolicy);
+      const result = {
+        ...agent,
+        allowlist,
+        installable,
+        verificationStatus: installablePolicy?.verificationStatus ?? firstBlockedAllowedPolicy?.verificationStatus ?? "not-applicable"
+      };
+      const unavailableReason = installable ? void 0 : firstBlockedAllowedPolicy?.unavailableReason ?? (allowlist.allowed ? "distribution-not-installable" : allowlist.reason);
+      if (unavailableReason !== void 0) result.unavailableReason = unavailableReason;
+      return result;
+    });
+  }
+  evaluateDistribution(agent, distribution) {
+    const allowlist = this.allowlist.evaluateDistribution(agent, distribution);
+    return evaluateAcpDistributionPolicy(distribution, allowlist);
+  }
+};
+function evaluateAcpDistributionPolicy(distribution, allowlist) {
+  if (!allowlist.allowed) {
+    return {
+      allowlist,
+      installable: false,
+      verificationStatus: "not-applicable",
+      unavailableReason: allowlist.reason
+    };
+  }
+  if (distribution.kind !== "binary") {
+    return { allowlist, installable: true, verificationStatus: "not-applicable" };
+  }
+  if (distribution.checksum) {
+    return { allowlist, installable: true, verificationStatus: "verified" };
+  }
+  return {
+    allowlist,
+    installable: allowlist.unverifiedBinaryAllowed,
+    verificationStatus: allowlist.unverifiedBinaryAllowed ? "unverified-allowed" : "unverified-blocked",
+    ...allowlist.unverifiedBinaryAllowed ? {} : { unavailableReason: "binary-integrity-metadata-missing" }
+  };
+}
+function normalizeRegistry(raw) {
+  const record = asRecord4(raw);
+  const rawAgents = Array.isArray(record?.agents) ? record.agents : [];
+  return rawAgents.flatMap((item) => {
+    const agent = normalizeAgent(item);
+    return agent ? [agent] : [];
+  });
+}
+function normalizeAgent(raw) {
+  const record = asRecord4(raw);
+  if (!record || typeof record.id !== "string" || typeof record.name !== "string") {
+    return void 0;
+  }
+  const distributions = normalizeDistributions(record.distribution);
+  if (distributions.length === 0) {
+    return void 0;
+  }
+  const agent = {
+    id: record.id,
+    backendId: buildAcpBackendId(record.id),
+    name: record.name,
+    authors: Array.isArray(record.authors) ? record.authors.filter((author) => typeof author === "string") : [],
+    distributions,
+    distributionKinds: [...new Set(distributions.map((d) => d.kind))],
+    auth: normalizeAuth(record.auth),
+    raw
+  };
+  const version = stringValue(record.version);
+  if (version !== void 0) agent.version = version;
+  const description = stringValue(record.description);
+  if (description !== void 0) agent.description = description;
+  const license = stringValue(record.license);
+  if (license !== void 0) agent.license = license;
+  const repositoryUrl = stringValue(record.repository);
+  if (repositoryUrl !== void 0) agent.repositoryUrl = repositoryUrl;
+  const websiteUrl = stringValue(record.website);
+  if (websiteUrl !== void 0) agent.websiteUrl = websiteUrl;
+  const iconUrl = stringValue(record.icon);
+  if (iconUrl !== void 0) agent.iconUrl = iconUrl;
+  return agent;
+}
+function normalizeDistributions(raw) {
+  const record = asRecord4(raw);
+  if (!record) {
+    return [];
+  }
+  const distributions = [];
+  const npx = normalizePackageDistribution("npx", record.npx);
+  if (npx) distributions.push(npx);
+  const uvx = normalizePackageDistribution("uvx", record.uvx);
+  if (uvx) distributions.push(uvx);
+  const binaryRecord = asRecord4(record.binary);
+  if (binaryRecord) {
+    for (const [platform, value] of Object.entries(binaryRecord)) {
+      const binary = normalizeBinaryDistribution(platform, value);
+      if (binary) distributions.push(binary);
+    }
+  }
+  return distributions;
+}
+function normalizePackageDistribution(kind, raw) {
+  const record = asRecord4(raw);
+  if (!record || typeof record.package !== "string") {
+    return void 0;
+  }
+  return {
+    kind,
+    packageName: record.package,
+    args: stringArray(record.args),
+    env: stringRecord(record.env)
+  };
+}
+function normalizeBinaryDistribution(platform, raw) {
+  const record = asRecord4(raw);
+  if (!record || typeof record.archive !== "string" || typeof record.cmd !== "string") {
+    return void 0;
+  }
+  const distribution = {
+    kind: "binary",
+    platform,
+    archiveUrl: record.archive,
+    command: record.cmd,
+    args: stringArray(record.args),
+    env: stringRecord(record.env)
+  };
+  const checksum = stringValue(record.checksum) ?? stringValue(record.sha256);
+  if (checksum !== void 0) distribution.checksum = checksum;
+  const signatureUrl = stringValue(record.signature) ?? stringValue(record.signatureUrl);
+  if (signatureUrl !== void 0) distribution.signatureUrl = signatureUrl;
+  return distribution;
+}
+function normalizeAuth(raw) {
+  if (!raw) {
+    return { required: false, methods: [] };
+  }
+  const record = asRecord4(raw);
+  if (!record) {
+    return { required: true, methods: ["unknown"], raw };
+  }
+  const methods = stringArray(record.methods).map(
+    (method) => method === "agent-managed" || method === "terminal" ? method : "unknown"
+  );
+  return {
+    required: record.required === false ? false : true,
+    methods: methods.length > 0 ? [...new Set(methods)] : ["unknown"],
+    raw
+  };
+}
+function asRecord4(value) {
+  return value && typeof value === "object" && !Array.isArray(value) ? value : void 0;
+}
+function stringValue(value) {
+  return typeof value === "string" && value.trim() ? value : void 0;
+}
+function stringArray(value) {
+  return Array.isArray(value) ? value.filter((item) => typeof item === "string") : [];
+}
+function stringRecord(value) {
+  const record = asRecord4(value);
+  if (!record) {
+    return {};
+  }
+  return Object.fromEntries(
+    Object.entries(record).filter(
+      (entry) => typeof entry[1] === "string"
+    )
+  );
+}
+export {
+  ACP_REGISTRY_URL,
+  AcpAgentAllowlist,
+  AcpAgentClient,
+  AcpRegistryService,
+  AcpSessionNormalizer,
+  AcpStdioJsonRpcTransport,
+  BANNED_ACP_REGISTRY_IDS,
+  BUILT_IN_ACP_STRATEGIES,
+  DEFAULT_ACP_AGENT_ALLOWLIST,
+  acpRuntimeSupportsSessionLoad,
+  acpSessionRuntimeStateFromCapabilities,
+  acpSessionRuntimeStateFromUpdate,
+  asRecord2 as asRecord,
+  buildAcpBackendId,
+  buildStrategyTable,
+  defaultAcpAgentAllowlist,
+  defaultQuirks,
+  discoverLocalAcpAgents,
+  evaluateAcpDistributionPolicy,
+  geminiStrategy,
+  grokStrategy,
+  isBannedAcpRegistryId,
+  kimiStrategy,
+  mergeAcpRuntimeState,
+  modeLabelFor,
+  normalizeAcpRuntimeCapabilities,
+  normalizeRegistry,
+  qwenStrategy,
+  readAcpContentText,
+  readBoolean,
+  readContentText,
+  readFirstLocationPath,
+  readFirstString,
+  readKind,
+  readNonEmptyString,
+  readNumber,
+  readPromptText,
+  readString,
+  readToolCallId,
+  readToolContentText,
+  readToolOutput,
+  readUpdateText,
+  strategyByBackendId,
+  strategyById,
+  toolCallFromUpdate
+};
+//# sourceMappingURL=index.js.map