@openma/deepseek-harness-acp 0.1.0-beta.0

package/dist/bridge.js

@@ -0,0 +1,1334 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __esm = (fn, res, err) => function __init() {
+  if (err) throw err[0];
+  try {
+    return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+  } catch (e) {
+    throw err = [e], e;
+  }
+};
+var __export = (target, all) => {
+  for (var name3 in all)
+    __defProp(target, name3, { get: all[name3], enumerable: true });
+};
+
+// src/bridge/self-harness.ts
+var self_harness_exports = {};
+__export(self_harness_exports, {
+  selfHarness: () => selfHarness
+});
+import { createUserMessage, errorChain } from "@deepseek-ai/dsh-llm";
+import { SessionId } from "@deepseek-ai/dsh-session";
+import { foldSessionTitle } from "@deepseek-ai/dsh-session-title";
+import { SANDBOX_MODES, setSandboxMode } from "@deepseek-ai/dsh-sandbox-policy";
+import { credentialRef } from "@deepseek-ai/dsh-credentials";
+import * as mcpClient from "@deepseek-ai/dsh-mcp-client";
+function selfHarness() {
+  return {
+    createUserMessage,
+    errorChain,
+    sessionId: SessionId,
+    foldSessionTitle,
+    setSandboxMode,
+    sandboxModes: SANDBOX_MODES,
+    credentialRef,
+    mcpClient
+  };
+}
+var init_self_harness = __esm({
+  "src/bridge/self-harness.ts"() {
+    "use strict";
+  }
+});
+
+// src/bridge/index.ts
+import { randomUUID } from "node:crypto";
+import { isAbsolute } from "node:path";
+import { Readable, Writable } from "node:stream";
+import {
+  AgentSideConnection,
+  ndJsonStream,
+  PROTOCOL_VERSION,
+  RequestError
+} from "@agentclientprotocol/sdk";
+
+// src/version.ts
+var VERSION = "0.1.0";
+
+// src/log.ts
+var PREFIX = "[dsh-acp]";
+function logWarn(message) {
+  process.stderr.write(`${PREFIX} warn: ${message}
+`);
+}
+function logDebug(message) {
+  if (process.env["DSH_ACP_DEBUG"]) process.stderr.write(`${PREFIX} debug: ${message}
+`);
+}
+
+// src/bridge/translate.ts
+var MAX_TITLE_LENGTH = 80;
+var MAX_RESULT_TEXT = 2e4;
+function firstLine(text, limit = MAX_TITLE_LENGTH) {
+  const line = text.split("\n", 1)[0] ?? "";
+  return line.length > limit ? `${line.slice(0, limit - 1)}\u2026` : line;
+}
+function asString(value) {
+  return typeof value === "string" && value.length > 0 ? value : void 0;
+}
+function pathLocations(args) {
+  const locations = [];
+  for (const key of ["path", "file_path", "filePath", "file"]) {
+    const path = asString(args[key]);
+    if (path !== void 0) {
+      locations.push({ path });
+      break;
+    }
+  }
+  return locations;
+}
+function classifyToolCall(name3, rawArguments) {
+  let args = {};
+  try {
+    const parsed = JSON.parse(rawArguments);
+    if (parsed !== null && typeof parsed === "object" && !Array.isArray(parsed)) {
+      args = parsed;
+    }
+  } catch {
+    args = { arguments: rawArguments };
+  }
+  const locations = pathLocations(args);
+  const path = locations[0]?.path;
+  const facts = (kind, title) => ({
+    kind,
+    title,
+    locations,
+    rawInput: args
+  });
+  switch (name3) {
+    case "bash": {
+      const command = asString(args["command"]);
+      const restart = args["restart"] === true;
+      return facts("execute", command !== void 0 ? firstLine(command) : restart ? "Restart bash" : "bash");
+    }
+    case "read":
+      return facts("read", path !== void 0 ? `Read ${path}` : "Read file");
+    case "write":
+      return facts("edit", path !== void 0 ? `Write ${path}` : "Write file");
+    case "edit":
+      return facts("edit", path !== void 0 ? `Edit ${path}` : "Edit file");
+    case "str_replace_editor": {
+      const command = asString(args["command"]) ?? "edit";
+      const kind = command === "view" ? "read" : "edit";
+      return facts(kind, path !== void 0 ? `${command} ${path}` : command);
+    }
+    case "todo_write":
+      return facts("think", "Update plan");
+    case "subagent":
+    case "subagent_fork": {
+      const task = asString(args["task"]) ?? asString(args["prompt"]);
+      return facts("other", task !== void 0 ? `Subagent: ${firstLine(task, 60)}` : "Subagent");
+    }
+    case "skill": {
+      const skillName = asString(args["name"]) ?? asString(args["skill"]);
+      return facts("other", skillName !== void 0 ? `Skill: ${skillName}` : "Skill");
+    }
+    default:
+      break;
+  }
+  const lowered = name3.toLowerCase();
+  if (/(^|_)(grep|glob|find|search|ls|list)($|_)/.test(lowered)) {
+    const query = asString(args["query"]) ?? asString(args["pattern"]);
+    return facts("search", query !== void 0 ? `Search for '${firstLine(query, 50)}'` : name3);
+  }
+  if (/(fetch|web|http|browse)/.test(lowered)) {
+    const url = asString(args["url"]) ?? asString(args["query"]);
+    return facts("fetch", url !== void 0 ? `Fetch ${firstLine(url, 60)}` : name3);
+  }
+  if (/(job|task|run|exec)/.test(lowered)) return facts("execute", name3);
+  return facts("other", name3);
+}
+function diffsFromToolMeta(meta) {
+  if (meta === null || typeof meta !== "object") return [];
+  const diffs = meta["diffs"];
+  if (!Array.isArray(diffs)) return [];
+  const result = [];
+  for (const entry of diffs) {
+    if (entry === null || typeof entry !== "object") continue;
+    const diff = entry;
+    const path = asString(diff["path"]);
+    const newText = diff["newText"];
+    const oldText = diff["oldText"];
+    if (path === void 0 || typeof newText !== "string") continue;
+    result.push({ path, oldText: typeof oldText === "string" ? oldText : null, newText });
+  }
+  return result;
+}
+function extractToolResult(data) {
+  let failed = data["error"] !== void 0 && data["error"] !== null;
+  const parts = [];
+  const message = data["message"];
+  const content = message !== null && typeof message === "object" ? message["content"] : void 0;
+  if (Array.isArray(content)) {
+    for (const block of content) {
+      if (block === null || typeof block !== "object") continue;
+      const b = block;
+      if (b["type"] !== "tool-result") continue;
+      if (b["isError"] === true) failed = true;
+      const inner = b["content"];
+      if (!Array.isArray(inner)) continue;
+      for (const innerBlock of inner) {
+        if (innerBlock === null || typeof innerBlock !== "object") continue;
+        const ib = innerBlock;
+        if (ib["type"] === "text" && typeof ib["text"] === "string") parts.push(ib["text"]);
+      }
+    }
+  }
+  let text = parts.join("");
+  if (text.length > MAX_RESULT_TEXT) text = `${text.slice(0, MAX_RESULT_TEXT)}
+\u2026 (truncated)`;
+  return { failed, text, diffs: diffsFromToolMeta(data["meta"]) };
+}
+function extractMessageTexts(message) {
+  const texts = [];
+  const reasoning = [];
+  const content = message !== null && typeof message === "object" ? message["content"] : void 0;
+  if (Array.isArray(content)) {
+    for (const block of content) {
+      if (block === null || typeof block !== "object") continue;
+      const b = block;
+      if (b["type"] === "text" && typeof b["text"] === "string") texts.push(b["text"]);
+      else if (b["type"] === "reasoning" && typeof b["text"] === "string") reasoning.push(b["text"]);
+      else if (b["type"] === "image") texts.push("[image attachment]");
+    }
+  }
+  return { text: texts.join(""), reasoning: reasoning.join("") };
+}
+function planEntries(data) {
+  const todos = data["todos"];
+  if (!Array.isArray(todos)) return [];
+  const entries = [];
+  for (const todo of todos) {
+    if (todo === null || typeof todo !== "object") continue;
+    const t = todo;
+    const content = asString(t["content"]);
+    const status = t["status"];
+    if (content === void 0) continue;
+    entries.push({
+      content,
+      priority: "medium",
+      status: status === "in_progress" || status === "completed" ? status : "pending"
+    });
+  }
+  return entries;
+}
+function turnEndToStopReason(reason) {
+  switch (reason?.kind) {
+    case "completed":
+      return "end_turn";
+    case "max-tokens":
+      return "max_tokens";
+    case "blocked":
+      return "refusal";
+    case "interrupted":
+      return "cancelled";
+    case "aborted": {
+      const cause = reason.reason?.kind;
+      return cause === "user" || cause === "disposed" ? "cancelled" : "end_turn";
+    }
+    default:
+      return "end_turn";
+  }
+}
+function emptyWindow() {
+  return {
+    usage: { input: 0, output: 0, cachedRead: 0, cachedWrite: 0, thought: 0 },
+    sawUsage: false,
+    turnEnds: /* @__PURE__ */ new Map(),
+    lastTurnEnd: void 0,
+    error: void 0
+  };
+}
+var SessionProjection = class {
+  /** Context capacity from the latest `request/context` event, when known. */
+  contextWindow;
+  /** Latest `session/title` text observed on the log. */
+  title;
+  streamedText = /* @__PURE__ */ new Set();
+  streamedReasoning = /* @__PURE__ */ new Set();
+  toolCalls = /* @__PURE__ */ new Map();
+  window = emptyWindow();
+  lastContextUse;
+  constructor(contextWindow) {
+    this.contextWindow = contextWindow;
+  }
+  /** Reset per-prompt accumulators; call when a new `session/prompt` starts. */
+  beginPrompt() {
+    this.window = emptyWindow();
+  }
+  /** The captured ending for a specific turn, when it already ended. */
+  turnEndFor(turn) {
+    return this.window.turnEnds.get(turn);
+  }
+  /** The last turn ending inside the current prompt window. */
+  get lastTurnEnd() {
+    return this.window.lastTurnEnd;
+  }
+  /** The first failed-turn error inside the current prompt window. */
+  get turnError() {
+    return this.window.error;
+  }
+  /** Accumulated ACP usage for the current prompt window. */
+  promptUsage() {
+    if (!this.window.sawUsage) return void 0;
+    const { input, output, cachedRead, cachedWrite, thought } = this.window.usage;
+    return {
+      totalTokens: input + output + cachedRead + cachedWrite,
+      inputTokens: input,
+      outputTokens: output,
+      ...thought > 0 ? { thoughtTokens: thought } : {},
+      ...cachedRead > 0 ? { cachedReadTokens: cachedRead } : {},
+      ...cachedWrite > 0 ? { cachedWriteTokens: cachedWrite } : {}
+    };
+  }
+  /**
+   * Project one session event onto zero or more ACP updates.
+   */
+  onEvent(event) {
+    const data = event.data ?? {};
+    switch (event.type) {
+      case "assistant/chunk":
+        return this.onChunk(data);
+      case "assistant/message":
+        return this.onAssistantMessage(data);
+      case "tool/call":
+        return this.onToolCall(data);
+      case "tool/result":
+        return this.onToolResult(data);
+      case "todo/write": {
+        const entries = planEntries(data);
+        return entries.length > 0 ? [{ sessionUpdate: "plan", entries }] : [];
+      }
+      case "turn/end":
+        return this.onTurnEnd(data);
+      case "request/context": {
+        const contextWindow = data["contextWindow"];
+        if (typeof contextWindow === "number" && contextWindow > 0) this.contextWindow = contextWindow;
+        return [];
+      }
+      case "session/title": {
+        const title = asString(data["title"]);
+        if (title === void 0 || title === this.title) return [];
+        this.title = title;
+        return [{ sessionUpdate: "session_info_update", title, updatedAt: (/* @__PURE__ */ new Date()).toISOString() }];
+      }
+      default:
+        return [];
+    }
+  }
+  stepKey(data) {
+    return `${String(data["turn"])}:${String(data["step"])}`;
+  }
+  onChunk(data) {
+    const chunk = data["chunk"];
+    if (chunk === null || typeof chunk === "undefined" || typeof chunk !== "object") return [];
+    const c = chunk;
+    const text = c["text"];
+    if (typeof text !== "string" || text.length === 0) return [];
+    if (c["type"] === "text-delta") {
+      this.streamedText.add(this.stepKey(data));
+      return [{ sessionUpdate: "agent_message_chunk", content: { type: "text", text } }];
+    }
+    if (c["type"] === "reasoning-delta") {
+      this.streamedReasoning.add(this.stepKey(data));
+      return [{ sessionUpdate: "agent_thought_chunk", content: { type: "text", text } }];
+    }
+    return [];
+  }
+  onAssistantMessage(data) {
+    const updates = [];
+    const key = this.stepKey(data);
+    const { text, reasoning } = extractMessageTexts(data["message"]);
+    if (reasoning.length > 0 && !this.streamedReasoning.has(key)) {
+      updates.push({ sessionUpdate: "agent_thought_chunk", content: { type: "text", text: reasoning } });
+    }
+    if (text.length > 0 && !this.streamedText.has(key)) {
+      updates.push({ sessionUpdate: "agent_message_chunk", content: { type: "text", text } });
+    }
+    this.streamedText.delete(key);
+    this.streamedReasoning.delete(key);
+    const usage = data["usage"];
+    if (usage !== null && typeof usage === "object") {
+      const u = usage;
+      const num = (v) => typeof v === "number" && Number.isFinite(v) && v > 0 ? v : 0;
+      const input = num(u["inputTokens"]);
+      const output = num(u["outputTokens"]);
+      const cachedRead = num(u["cacheReadTokens"]);
+      const cachedWrite = num(u["cacheWriteTokens"]);
+      this.window.usage.input += input;
+      this.window.usage.output += output;
+      this.window.usage.cachedRead += cachedRead;
+      this.window.usage.cachedWrite += cachedWrite;
+      this.window.usage.thought += num(u["reasoningTokens"]);
+      this.window.sawUsage = true;
+      this.lastContextUse = input + cachedRead + cachedWrite + output;
+      if (this.contextWindow !== void 0 && this.lastContextUse > 0) {
+        updates.push({
+          sessionUpdate: "usage_update",
+          used: this.lastContextUse,
+          size: this.contextWindow
+        });
+      }
+    }
+    return updates;
+  }
+  onToolCall(data) {
+    const callId = asString(data["callId"]);
+    const name3 = asString(data["name"]) ?? "tool";
+    if (callId === void 0) return [];
+    const rawArguments = typeof data["arguments"] === "string" ? data["arguments"] : "{}";
+    const facts = classifyToolCall(name3, rawArguments);
+    this.toolCalls.set(callId, facts);
+    return [
+      {
+        sessionUpdate: "tool_call",
+        toolCallId: callId,
+        title: facts.title,
+        name: name3,
+        kind: facts.kind,
+        status: "in_progress",
+        rawInput: facts.rawInput,
+        ...facts.locations.length > 0 ? { locations: facts.locations } : {}
+      }
+    ];
+  }
+  onToolResult(data) {
+    const message = data["message"];
+    const callId = asString(
+      message !== null && typeof message === "object" ? (() => {
+        const content2 = message["content"];
+        if (!Array.isArray(content2)) return void 0;
+        const block = content2.find(
+          (b) => b !== null && typeof b === "object" && b["type"] === "tool-result"
+        );
+        return block === void 0 ? void 0 : block["toolCallId"];
+      })() : void 0
+    ) ?? asString(data["callId"]);
+    if (callId === void 0) return [];
+    const { failed, text, diffs } = extractToolResult(data);
+    const content = diffs.map((diff) => ({
+      type: "diff",
+      path: diff.path,
+      ...diff.oldText !== null ? { oldText: diff.oldText } : {},
+      newText: diff.newText
+    }));
+    if (text.length > 0 && diffs.length === 0) {
+      const block = { type: "text", text };
+      content.push({ type: "content", content: block });
+    }
+    this.toolCalls.delete(callId);
+    return [
+      {
+        sessionUpdate: "tool_call_update",
+        toolCallId: callId,
+        status: failed ? "failed" : "completed",
+        ...content.length > 0 ? { content } : {},
+        ...text.length > 0 ? { rawOutput: { output: text, isError: failed } } : {}
+      }
+    ];
+  }
+  onTurnEnd(data) {
+    const reason = data["reason"];
+    const turn = data["turn"];
+    if (reason !== null && typeof reason === "object") {
+      const r = reason;
+      if (typeof turn === "number") this.window.turnEnds.set(turn, r);
+      this.window.lastTurnEnd = r;
+      if (r.kind === "error" && this.window.error === void 0) {
+        this.window.error = { message: r.error?.message ?? "model turn failed" };
+      }
+    }
+    return [];
+  }
+};
+
+// src/bridge/history.ts
+function userText(data) {
+  if (data === void 0) return void 0;
+  const source = data["source"];
+  const kind = source !== null && typeof source === "object" ? source["kind"] : void 0;
+  if (kind !== "user") return void 0;
+  const content = data["content"];
+  if (!Array.isArray(content)) return void 0;
+  const parts = [];
+  for (const block of content) {
+    if (block !== null && typeof block === "object") {
+      const b = block;
+      if (b["type"] === "text" && typeof b["text"] === "string") parts.push(b["text"]);
+    }
+  }
+  const text = parts.join("");
+  return text.length > 0 ? text : void 0;
+}
+function buildReplay(events) {
+  const projection = new SessionProjection();
+  const updates = [];
+  let plan;
+  let title;
+  for (const event of events) {
+    if (event.type === "user/message") {
+      const text = userText(event.data);
+      if (text !== void 0) {
+        updates.push({ sessionUpdate: "user_message_chunk", content: { type: "text", text } });
+      }
+      continue;
+    }
+    if (event.type === "session/title") {
+      const t = event.data?.["title"];
+      if (typeof t === "string" && t.length > 0) title = t;
+      continue;
+    }
+    for (const update of projection.onEvent(event)) {
+      if (update.sessionUpdate === "usage_update") continue;
+      if (update.sessionUpdate === "plan") {
+        plan = update;
+        continue;
+      }
+      updates.push(update);
+    }
+  }
+  if (plan !== void 0) updates.push(plan);
+  return { updates, title, contextWindow: projection.contextWindow };
+}
+
+// src/bridge/prompt.ts
+var UnsupportedPromptContentError = class extends Error {
+  constructor(contentType) {
+    super(`unsupported prompt content type: ${contentType}`);
+    this.contentType = contentType;
+  }
+  contentType;
+};
+function contextBlock(uri, text) {
+  return `<context ref=${JSON.stringify(uri)}>
+${text}
+</context>`;
+}
+function convertPrompt(prompt) {
+  const parts = [];
+  const display = [];
+  for (const block of prompt) {
+    switch (block.type) {
+      case "text":
+        parts.push(block.text);
+        display.push(block.text);
+        break;
+      case "resource_link":
+        parts.push(`
+[resource_link name=${JSON.stringify(block.name)} uri=${JSON.stringify(block.uri)}]
+`);
+        display.push(`@${block.name}`);
+        break;
+      case "resource": {
+        const resource = block.resource;
+        if ("text" in resource && typeof resource.text === "string") {
+          parts.push(`
+${contextBlock(resource.uri, resource.text)}
+`);
+          display.push(`@${resource.uri}`);
+          break;
+        }
+        throw new UnsupportedPromptContentError("resource (binary)");
+      }
+      default:
+        throw new UnsupportedPromptContentError(block.type);
+    }
+  }
+  const text = parts.join("");
+  return {
+    blocks: text.length > 0 ? [{ type: "text", text }] : [],
+    displayText: display.join(" ").trim()
+  };
+}
+
+// src/bridge/index.ts
+var name = "acp-bridge";
+var inject = ["agents"];
+function invalidParams(detail) {
+  return RequestError.invalidParams(void 0, detail);
+}
+function internalError(detail) {
+  return RequestError.internalError(void 0, detail);
+}
+function authRequired(detail) {
+  return RequestError.authRequired(void 0, detail);
+}
+function envCredentialPresent() {
+  return Boolean(process.env["DEEPSEEK_API_KEY"] || process.env["DEEPSEEK_BASE_URL"]);
+}
+var MODE_LABELS = {
+  "read-only": { name: "Read-only", description: "Bash and file mutations are denied by the sandbox" },
+  "workspace-write": {
+    name: "Workspace write",
+    description: "Writes are confined to the session workspace; wider access asks for permission"
+  },
+  "danger-full-access": {
+    name: "Full access",
+    description: "No sandbox confinement and no permission prompts"
+  }
+};
+async function apply(ctx, config = {}) {
+  const agents = ctx.agents;
+  const harness = config.harness ?? (await Promise.resolve().then(() => (init_self_harness(), self_harness_exports))).selfHarness();
+  const { createUserMessage: createUserMessage2, errorChain: errorChain2, sessionId: SessionId2, foldSessionTitle: foldSessionTitle2, setSandboxMode: setSandboxMode2 } = harness;
+  const SANDBOX_MODES2 = harness.sandboxModes;
+  const sessions = /* @__PURE__ */ new Map();
+  let closed = false;
+  let conn;
+  const modelCandidates = () => {
+    const seen = /* @__PURE__ */ new Set();
+    if (config.model !== void 0) seen.add(config.model);
+    for (const model of config.models ?? []) if (model.trim().length > 0) seen.add(model.trim());
+    return [...seen];
+  };
+  const defaultSelection = () => {
+    const service = ctx.get("agentDefaultModel");
+    if (service === void 0) return {};
+    try {
+      return service.currentSelection();
+    } catch (error) {
+      logDebug(`agentDefaultModel.currentSelection failed: ${String(error)}`);
+      return {};
+    }
+  };
+  const defaultProvider = () => config.provider ?? defaultSelection().provider;
+  const encodeChoice = (provider, model) => provider === void 0 || provider === defaultProvider() ? model : `${provider}::${model}`;
+  const decodeChoice = (value) => {
+    const i = value.indexOf("::");
+    if (i <= 0) return { provider: defaultProvider(), model: value };
+    return { provider: value.slice(0, i), model: value.slice(i + 2) };
+  };
+  let liveCatalog;
+  const discoverModels = async () => {
+    if (liveCatalog !== void 0) return liveCatalog;
+    const llm = ctx.get("llm");
+    const found = [];
+    if (llm !== void 0) {
+      try {
+        const providers = llm.listProviders();
+        const multi = providers.length > 1;
+        for (const provider of providers) {
+          const models = await llm.listModels(provider.id).catch((error) => {
+            logDebug(`listModels(${provider.id}) failed: ${String(error)}`);
+            return [];
+          });
+          for (const model of models) {
+            found.push({
+              provider: provider.id,
+              model: model.id,
+              label: multi ? `${model.name} (${provider.name})` : model.name
+            });
+          }
+        }
+      } catch (error) {
+        logDebug(`model discovery failed: ${String(error)}`);
+      }
+    }
+    liveCatalog = found;
+    return found;
+  };
+  ctx.on("llm/adapters-updated", () => {
+    liveCatalog = void 0;
+  });
+  const credentialPresent = async () => {
+    if (envCredentialPresent()) return true;
+    const brand = harness.credentialRef;
+    if (brand === void 0) return false;
+    const deadline = Date.now() + 5e3;
+    for (; ; ) {
+      const seam = ctx.get("credentials");
+      if (seam !== void 0) {
+        try {
+          return await seam.resolve(brand("DEEPSEEK_API_KEY")) !== void 0;
+        } catch (error) {
+          logWarn(`credential lookup failed: ${String(error)}`);
+          return false;
+        }
+      }
+      if (Date.now() >= deadline) {
+        logDebug("credential gate: no credentials service registered within 5s");
+        return false;
+      }
+      await new Promise((resolve) => setTimeout(resolve, 100));
+    }
+  };
+  const agentOptionsFor = (model, provider) => ({
+    ...provider !== void 0 ? { provider } : config.provider !== void 0 ? { provider: config.provider } : {},
+    ...model !== void 0 ? { model } : {},
+    ...config.maxTokens !== void 0 ? { maxTokens: config.maxTokens } : {}
+  });
+  const ownedRecord = (agent) => {
+    const record = sessions.get(String(agent.session.id));
+    return record?.agent === agent ? record : void 0;
+  };
+  const requireSession = (sessionId) => {
+    const record = sessions.get(sessionId);
+    if (record === void 0) throw invalidParams(`unknown session: ${sessionId}`);
+    return record;
+  };
+  const assertOpen = () => {
+    if (closed) throw internalError("the ACP bridge has been disposed");
+  };
+  const notify = (sessionId, update) => {
+    void conn.sessionUpdate({ sessionId, update }).catch((error) => {
+      logWarn(`session/update failed: ${String(error)}`);
+    });
+  };
+  const settlePrompt = (record, reason) => {
+    const inflight = record.inflight;
+    if (inflight === void 0) return;
+    record.inflight = void 0;
+    inflight.resolve(reason);
+  };
+  const modeState = (record) => ({
+    currentModeId: record.modeId,
+    availableModes: SANDBOX_MODES2.map((mode) => {
+      const label = MODE_LABELS[mode] ?? { name: mode, description: "" };
+      return { id: mode, name: label.name, description: label.description };
+    })
+  });
+  const configOptions = async (record) => {
+    const seen = /* @__PURE__ */ new Set();
+    const options = [];
+    const push = (value, name3) => {
+      if (seen.has(value)) return;
+      seen.add(value);
+      options.push({ value, name: name3 });
+    };
+    const current = encodeChoice(
+      record.provider,
+      record.model ?? config.model ?? defaultSelection().model ?? record.agent.options.model ?? ""
+    );
+    if (current.length === 0) return [];
+    const discovered = await discoverModels();
+    push(current, discovered.find((c) => encodeChoice(c.provider, c.model) === current)?.label ?? current);
+    for (const choice of discovered) {
+      push(encodeChoice(choice.provider, choice.model), choice.label);
+    }
+    for (const model of modelCandidates()) push(encodeChoice(void 0, model), model);
+    if (options.length < 2) return [];
+    return [
+      {
+        type: "select",
+        id: "model",
+        name: "Model",
+        category: "model",
+        currentValue: current,
+        options
+      }
+    ];
+  };
+  const publishCommands = (sessionId) => {
+    notify(sessionId, {
+      sessionUpdate: "available_commands_update",
+      availableCommands: [
+        { name: "status", description: "Show adapter, model, mode, and token status" },
+        {
+          name: "login",
+          description: "Save a DeepSeek API key into the harness credential store (~/.dsh/.credentials.yaml)",
+          input: { hint: "<api-key>" }
+        },
+        { name: "logout", description: "Remove the API key stored in the harness credential store" }
+      ]
+    });
+  };
+  const credentialStore = () => {
+    const brand = harness.credentialRef;
+    const store = ctx.get("credentials");
+    if (brand === void 0 || store === void 0) return void 0;
+    return { store, ref: brand("DEEPSEEK_API_KEY") };
+  };
+  const maskKey = (value) => value.length <= 8 ? "\u2026" : `${value.slice(0, 4)}\u2026${value.slice(-4)}`;
+  const describeCredential = async () => {
+    if (envCredentialPresent()) {
+      const viaEnv = process.env["DEEPSEEK_API_KEY"] !== void 0 ? "DEEPSEEK_API_KEY" : "DEEPSEEK_BASE_URL";
+      return `process environment (${viaEnv})`;
+    }
+    const cs = credentialStore();
+    if (cs === void 0) return "not configured";
+    try {
+      const info = await cs.store.describe(cs.ref);
+      if (!info.configured) return "not configured";
+      return info.source ?? "credential store";
+    } catch (error) {
+      logWarn(`credential describe failed: ${String(error)}`);
+      return "unknown";
+    }
+  };
+  const loginText = async (rawArgument) => {
+    const key = rawArgument.trim();
+    const cs = credentialStore();
+    if (cs === void 0) {
+      return "This composition has no writable credential store; export DEEPSEEK_API_KEY in the environment that launches the agent instead.";
+    }
+    if (key.length === 0) {
+      return [
+        "Usage: `/login <api-key>` \u2014 stores the key in the harness credential store",
+        "(`~/.dsh/.credentials.yaml`, the same file the dsh Web UI writes; mode 600).",
+        "",
+        `Current credential source: ${await describeCredential()}.`,
+        "",
+        "Note: text entered here also lands in your client's chat history. If you",
+        "prefer to keep the key out of it, save the key in the dsh Web UI instead."
+      ].join("\n");
+    }
+    try {
+      await cs.store.set(cs.ref, key);
+    } catch (error) {
+      return [
+        `Could not store the key: ${error instanceof Error ? error.message : String(error)}`,
+        "",
+        "A read-only source (usually the process environment) is currently supplying",
+        "this credential, so a stored value would be shadowed. Unset DEEPSEEK_API_KEY",
+        "in the launching environment, or keep using it as the credential."
+      ].join("\n");
+    }
+    return `Saved DEEPSEEK_API_KEY (${maskKey(key)}) to the harness credential store \u2014 source now: ${await describeCredential()}. The dsh Web UI sees the same key.`;
+  };
+  const logoutText = async () => {
+    const cs = credentialStore();
+    if (cs === void 0) return "This composition has no writable credential store; nothing to remove.";
+    try {
+      await cs.store.unset(cs.ref);
+    } catch (error) {
+      return `Could not remove the stored key: ${error instanceof Error ? error.message : String(error)}`;
+    }
+    const remaining = await describeCredential();
+    return remaining === "not configured" ? "Removed the stored DEEPSEEK_API_KEY. No credential is configured now." : `Removed the stored DEEPSEEK_API_KEY; requests now authenticate via: ${remaining}.`;
+  };
+  const statusText = async (record) => {
+    const used = record.projection.contextWindow;
+    const lines = [
+      `**dsh-acp** ${VERSION} \u2014 DeepSeek Harness ACP bridge`,
+      "",
+      `| | |`,
+      `|---|---|`,
+      `| Provider | ${record.provider ?? defaultProvider() ?? "(composition default)"} |`,
+      `| Model | ${record.model ?? config.model ?? defaultSelection().model ?? record.agent.options.model ?? "(composition default)"} |`,
+      `| Credential | ${await describeCredential()} |`,
+      `| Permission mode | ${record.modeId} |`,
+      `| Workspace | ${record.agent.session.header.cwd ?? process.cwd()} |`,
+      `| Session | ${String(record.agent.session.id)} |`,
+      ...used !== void 0 ? [`| Context window | ${used.toLocaleString()} tokens |`] : []
+    ];
+    return lines.join("\n");
+  };
+  const registerRecord = (sessionId, agent, dispose, model, modeId, projection) => {
+    const record = {
+      agent,
+      dispose,
+      projection: projection ?? new SessionProjection(),
+      modeId,
+      model,
+      cancelled: false,
+      inflight: void 0
+    };
+    sessions.set(sessionId, record);
+    return record;
+  };
+  ctx.on("session/event", (session, event) => {
+    const sessionId = String(session.header.id);
+    const record = sessions.get(sessionId);
+    if (record === void 0 || record.agent.session !== session) return;
+    try {
+      for (const update of record.projection.onEvent(event)) {
+        notify(sessionId, update);
+      }
+    } finally {
+      const inflight = record.inflight;
+      if (inflight !== void 0 && event.type === "turn/end" && inflight.turn === event.data.turn) {
+        if (event.data.reason.kind === "error") {
+          record.inflight = void 0;
+          inflight.reject(internalError(`turn failed: ${event.data.reason.error.message}`));
+        }
+      }
+    }
+  });
+  ctx.on("agent/inbox/claimed", ({ agent, message, turn }) => {
+    const record = ownedRecord(agent);
+    const inflight = record?.inflight;
+    if (inflight !== void 0 && inflight.messageId === message.id) inflight.turn = turn;
+  });
+  ctx.on("agent/error", ({ agent, turn, error }) => {
+    const record = ownedRecord(agent);
+    const inflight = record?.inflight;
+    if (record === void 0 || inflight === void 0 || inflight.turn === turn) return;
+    record.inflight = void 0;
+    inflight.reject(internalError(`turn failed: ${errorChain2(error)}`));
+  });
+  ctx.on("approval/request", (request, next) => {
+    const record = ownedRecord(request.agent);
+    if (record === void 0 || request.callId === void 0) return next();
+    return conn.requestPermission({
+      sessionId: String(record.agent.session.id),
+      toolCall: { toolCallId: request.callId },
+      options: [
+        { optionId: "allow-once", name: "Allow once", kind: "allow_once" },
+        { optionId: "allow-always", name: "Always allow (this session)", kind: "allow_always" },
+        { optionId: "reject-once", name: "Reject", kind: "reject_once" }
+      ]
+    }).then(({ outcome }) => {
+      if (outcome.outcome === "cancelled") return "cancelled";
+      if (outcome.optionId === "allow-always") {
+        try {
+          ctx.get("approval")?.setPolicy?.(record.agent, "never");
+        } catch (error) {
+          logWarn(`approval policy switch failed: ${String(error)}`);
+        }
+        return "allowed-once";
+      }
+      return outcome.optionId === "allow-once" ? "allowed-once" : "rejected";
+    });
+  });
+  const makeAgent = (connection) => {
+    conn = connection;
+    return {
+      initialize(params) {
+        const hasPersistence = ctx.get("sessionPersistence") !== void 0;
+        const requested = params.protocolVersion;
+        return Promise.resolve({
+          protocolVersion: typeof requested === "number" && requested >= 1 && requested < PROTOCOL_VERSION ? requested : PROTOCOL_VERSION,
+          agentInfo: { name: "dsh-acp", title: "DeepSeek Harness", version: VERSION },
+          agentCapabilities: {
+            loadSession: hasPersistence,
+            promptCapabilities: { image: false, audio: false, embeddedContext: true },
+            // Stdio servers always work; streamable HTTP maps onto
+            // mcp-client's second transport. Legacy SSE does not.
+            mcpCapabilities: { http: true, sse: false },
+            ...hasPersistence ? { sessionCapabilities: { list: {} } } : {}
+          },
+          authMethods: []
+        });
+      },
+      async authenticate(_params) {
+        if (!await credentialPresent()) {
+          throw authRequired(
+            "no DeepSeek credential found: save one in the dsh Web UI (Settings \u2192 Models) or set DEEPSEEK_API_KEY"
+          );
+        }
+      },
+      async newSession(params) {
+        assertOpen();
+        validateCwd(params.cwd);
+        syncMcpServers(params.mcpServers, params.cwd);
+        const sessionId = SessionId2(randomUUID());
+        const handle = await agents.create({
+          sessionId,
+          meta: { cwd: params.cwd },
+          agentOptions: agentOptionsFor(config.model)
+        });
+        if (closed) {
+          await handle.dispose();
+          throw internalError("connection closed during session/new");
+        }
+        const record = registerRecord(
+          String(sessionId),
+          handle.agent,
+          () => handle.dispose(),
+          config.model,
+          config.permissionMode ?? "workspace-write"
+        );
+        queueMicrotask(() => publishCommands(String(sessionId)));
+        const options = await configOptions(record);
+        return {
+          sessionId: String(sessionId),
+          modes: modeState(record),
+          ...options.length > 0 ? { configOptions: options } : {}
+        };
+      },
+      async loadSession(params) {
+        assertOpen();
+        validateCwd(params.cwd);
+        syncMcpServers(params.mcpServers, params.cwd);
+        const persistence = requirePersistence();
+        const sessionId = params.sessionId;
+        const existing = sessions.get(sessionId);
+        if (existing !== void 0) {
+          sessions.delete(sessionId);
+          existing.agent.cancel({ kind: "user" });
+          settlePrompt(existing, "cancelled");
+          await existing.dispose().catch((error) => {
+            logWarn(`dispose before reload failed: ${String(error)}`);
+          });
+        }
+        let events;
+        try {
+          ({ events } = await persistence.inspect(SessionId2(sessionId)));
+        } catch (error) {
+          throw invalidParams(`session not found: ${sessionId} (${errorChain2(error)})`);
+        }
+        const replay = buildReplay(events);
+        for (const update of replay.updates) notify(sessionId, update);
+        if (replay.title !== void 0) {
+          notify(sessionId, {
+            sessionUpdate: "session_info_update",
+            title: replay.title
+          });
+        }
+        const handle = await agents.resume({
+          resumeSessionId: SessionId2(sessionId),
+          agentOptions: agentOptionsFor(config.model)
+        });
+        const projection = new SessionProjection(replay.contextWindow);
+        projection.title = replay.title;
+        const record = registerRecord(
+          sessionId,
+          handle.agent,
+          () => handle.dispose(),
+          config.model,
+          config.permissionMode ?? "workspace-write",
+          projection
+        );
+        queueMicrotask(() => publishCommands(sessionId));
+        const options = await configOptions(record);
+        return {
+          modes: modeState(record),
+          ...options.length > 0 ? { configOptions: options } : {}
+        };
+      },
+      async listSessions(params) {
+        assertOpen();
+        const persistence = requirePersistence();
+        const headers = await persistence.list();
+        headers.sort((a, b) => (b.createdAt ?? 0) - (a.createdAt ?? 0));
+        const filtered = params.cwd !== void 0 && params.cwd !== null ? headers.filter((header) => header.cwd === params.cwd) : headers;
+        const page = filtered.slice(0, 100);
+        const withTitles = await Promise.allSettled(
+          page.slice(0, 20).map(async (header) => {
+            const { events } = await persistence.inspect(header.id);
+            return foldSessionTitle2(events)?.title;
+          })
+        );
+        const sessionsInfo = page.map((header, index) => {
+          const settled = withTitles[index];
+          const title = settled !== void 0 && settled.status === "fulfilled" ? settled.value : void 0;
+          return {
+            sessionId: String(header.id),
+            cwd: header.cwd ?? "",
+            ...title !== void 0 ? { title } : {},
+            ...header.createdAt !== void 0 ? { updatedAt: new Date(header.createdAt).toISOString() } : {}
+          };
+        });
+        return { sessions: sessionsInfo };
+      },
+      async prompt(params) {
+        assertOpen();
+        const record = requireSession(params.sessionId);
+        if (record.inflight !== void 0) {
+          throw invalidParams("a prompt is already in flight for this session");
+        }
+        let converted;
+        try {
+          converted = convertPrompt(params.prompt);
+        } catch (error) {
+          if (error instanceof UnsupportedPromptContentError) throw invalidParams(error.message);
+          throw error;
+        }
+        if (converted.blocks.length === 0) throw invalidParams("empty prompt");
+        const trimmed = converted.displayText.trim();
+        const commandMatch = trimmed.match(/^\/(\w[\w-]*)\b/);
+        const respond = (text) => {
+          notify(params.sessionId, {
+            sessionUpdate: "agent_message_chunk",
+            content: { type: "text", text }
+          });
+          return { stopReason: "end_turn" };
+        };
+        if (commandMatch?.[1] === "status") return respond(await statusText(record));
+        if (commandMatch?.[1] === "login") {
+          return respond(await loginText(trimmed.slice(commandMatch[0].length)));
+        }
+        if (commandMatch?.[1] === "logout") return respond(await logoutText());
+        if (!await credentialPresent()) {
+          return respond(
+            [
+              "No DeepSeek credential is configured, so this prompt was not sent to the model.",
+              "",
+              "Configure one of:",
+              "- `/login <api-key>` \u2014 store a key in the harness credential store right here,",
+              "- the dsh Web UI (`dsh web`, Settings \u2192 Models),",
+              "- `DEEPSEEK_API_KEY` in the environment that launches this agent."
+            ].join("\n")
+          );
+        }
+        if (agents.get(record.agent.id) !== record.agent) {
+          throw internalError("prompt was not queued: the agent was disposed outside the bridge");
+        }
+        record.cancelled = false;
+        record.projection.beginPrompt();
+        const message = createUserMessage2({
+          content: converted.blocks,
+          source: { kind: "user" }
+        });
+        const stopReason = await new Promise((resolve, reject) => {
+          const inflight = { resolve, reject, messageId: message.id, turn: void 0 };
+          record.inflight = inflight;
+          try {
+            record.agent.followup(message);
+          } catch (error) {
+            record.inflight = void 0;
+            const detail = error instanceof Error ? error.message : String(error);
+            throw internalError(`prompt was not queued: ${detail}`);
+          }
+          void record.agent.whenIdle().then(() => {
+            if (record.inflight !== inflight) return;
+            record.inflight = void 0;
+            if (record.cancelled) {
+              resolve("cancelled");
+              return;
+            }
+            const end = inflight.turn !== void 0 ? record.projection.turnEndFor(inflight.turn) ?? record.projection.lastTurnEnd : record.projection.lastTurnEnd;
+            resolve(end === void 0 ? "cancelled" : turnEndToStopReason(end));
+          });
+        });
+        const usage = record.projection.promptUsage();
+        return { stopReason, ...usage !== void 0 ? { usage } : {} };
+      },
+      setSessionMode(params) {
+        const record = requireSession(params.sessionId);
+        const mode = SANDBOX_MODES2.find((candidate) => candidate === params.modeId);
+        if (mode === void 0) throw invalidParams(`unknown mode: ${params.modeId}`);
+        setSandboxMode2(record.agent.session, mode);
+        try {
+          ctx.get("approval")?.setPolicy?.(record.agent, mode === "danger-full-access" ? "never" : "ask");
+        } catch (error) {
+          logWarn(`approval policy switch failed: ${String(error)}`);
+        }
+        record.modeId = mode;
+        notify(params.sessionId, { sessionUpdate: "current_mode_update", currentModeId: mode });
+        return Promise.resolve({});
+      },
+      async setSessionConfigOption(params) {
+        const record = requireSession(params.sessionId);
+        if (params.configId !== "model") throw invalidParams(`unknown config option: ${params.configId}`);
+        if (record.inflight !== void 0) {
+          throw invalidParams("cannot switch models while a prompt is running");
+        }
+        const value = typeof params.value === "string" ? params.value : void 0;
+        if (value === void 0) throw invalidParams(`unknown model: ${String(params.value)}`);
+        const choice = decodeChoice(value);
+        const known = /* @__PURE__ */ new Set([
+          ...modelCandidates().map((model) => encodeChoice(void 0, model)),
+          ...(await discoverModels()).map((entry) => encodeChoice(entry.provider, entry.model)),
+          encodeChoice(record.provider, record.model ?? "")
+        ]);
+        if (!known.has(value)) throw invalidParams(`unknown model: ${value}`);
+        if (choice.model !== record.model || choice.provider !== (record.provider ?? defaultProvider())) {
+          const sessionId = record.agent.session.id;
+          await record.dispose().catch((error) => {
+            logWarn(`dispose during model switch failed: ${String(error)}`);
+          });
+          let handle;
+          try {
+            handle = await agents.resume({
+              resumeSessionId: sessionId,
+              agentOptions: agentOptionsFor(choice.model, choice.provider)
+            });
+          } catch (error) {
+            sessions.delete(params.sessionId);
+            throw internalError(`model switch failed: ${errorChain2(error)}`);
+          }
+          record.agent = handle.agent;
+          record.dispose = () => handle.dispose();
+          record.model = choice.model;
+          if (choice.provider !== void 0 && choice.provider !== defaultProvider()) {
+            record.provider = choice.provider;
+          } else {
+            delete record.provider;
+          }
+        }
+        return { configOptions: await configOptions(record) };
+      },
+      async closeSession(params) {
+        const record = sessions.get(params.sessionId);
+        if (record === void 0) return;
+        sessions.delete(params.sessionId);
+        record.agent.cancel({ kind: "user" });
+        settlePrompt(record, "cancelled");
+        await record.dispose().catch((error) => {
+          logWarn(`session close failed: ${String(error)}`);
+        });
+      },
+      cancel(params) {
+        const record = sessions.get(params.sessionId);
+        if (record === void 0) return Promise.resolve();
+        record.cancelled = true;
+        record.agent.cancel({ kind: "user" });
+        settlePrompt(record, "cancelled");
+        return Promise.resolve();
+      }
+    };
+  };
+  function requirePersistence() {
+    const persistence = getPersistence();
+    if (persistence === void 0) {
+      throw internalError("session persistence is not composed; session history is unavailable");
+    }
+    return persistence;
+  }
+  function getPersistence() {
+    return ctx.get("sessionPersistence");
+  }
+  function validateCwd(cwd) {
+    if (!isAbsolute(cwd)) throw invalidParams(`cwd must be an absolute path: ${cwd}`);
+  }
+  const mcpMounts = /* @__PURE__ */ new Map();
+  let warnedNoMcpClient = false;
+  const sanitizeServerName = (raw) => {
+    const cleaned = raw.replace(/[^A-Za-z0-9_-]/g, "_").slice(0, 32);
+    return cleaned.length > 0 ? cleaned : "server";
+  };
+  const mcpConfigFor = (server, cwd, serverName) => {
+    const envList = (list) => Object.fromEntries(
+      (Array.isArray(list) ? list : []).map((e) => [
+        e.name,
+        e.value
+      ])
+    );
+    if (typeof server["command"] === "string") {
+      return {
+        transport: "stdio",
+        serverName,
+        command: server["command"],
+        args: Array.isArray(server["args"]) ? server["args"] : [],
+        env: envList(server["env"]),
+        cwd: typeof server["cwd"] === "string" ? server["cwd"] : cwd,
+        // A dead or misconfigured server must not take the session
+        // down; the client surfaces missing tools on its own.
+        failOnStartupError: false
+      };
+    }
+    if (server["type"] === "http" && typeof server["url"] === "string") {
+      return {
+        transport: "streamable-http",
+        serverName,
+        url: server["url"],
+        headers: envList(server["headers"]),
+        failOnStartupError: false
+      };
+    }
+    return void 0;
+  };
+  const syncMcpServers = (servers, cwd) => {
+    if (servers === void 0 || servers.length === 0) return;
+    const mcpClient2 = harness.mcpClient;
+    if (mcpClient2 === void 0) {
+      if (!warnedNoMcpClient) {
+        warnedNoMcpClient = true;
+        logWarn(
+          `ignoring ${servers.length} MCP server(s): this DeepSeek Harness installation lacks @deepseek-ai/dsh-mcp-client`
+        );
+      }
+      return;
+    }
+    const taken = /* @__PURE__ */ new Set();
+    for (const entry of servers) {
+      const server = entry;
+      const base = sanitizeServerName(typeof server["name"] === "string" ? server["name"] : "server");
+      let serverName = base;
+      for (let n = 2; taken.has(serverName); n += 1) serverName = `${base.slice(0, 28)}_${n}`;
+      const cfg = mcpConfigFor(server, cwd, serverName);
+      if (cfg === void 0) {
+        logWarn(`skipping MCP server "${serverName}": unsupported transport`);
+        continue;
+      }
+      const configJson = JSON.stringify(cfg);
+      const existing = mcpMounts.get(serverName);
+      if (existing !== void 0) {
+        if (existing.configJson === configJson) {
+          taken.add(serverName);
+          continue;
+        }
+        try {
+          void existing.fiber.dispose();
+        } catch (error) {
+          logWarn(`disposing MCP server "${serverName}": ${String(error)}`);
+        }
+        mcpMounts.delete(serverName);
+      }
+      try {
+        const fiber = ctx.plugin(mcpClient2, cfg);
+        mcpMounts.set(serverName, { configJson, fiber });
+        taken.add(serverName);
+        logDebug(`mounted MCP server "${serverName}" (${String(cfg["transport"])})`);
+      } catch (error) {
+        logWarn(`failed to mount MCP server "${serverName}": ${String(error)}`);
+      }
+    }
+  };
+  const stream = config.stream ?? ndJsonStream(
+    Writable.toWeb(process.stdout),
+    Readable.toWeb(process.stdin)
+  );
+  conn = new AgentSideConnection(makeAgent, stream);
+  let quiescing;
+  const quiesce = () => {
+    if (quiescing !== void 0) return quiescing;
+    closed = true;
+    const records = [...sessions.values()];
+    sessions.clear();
+    for (const record of records) {
+      record.agent.cancel({ kind: "user" });
+      settlePrompt(record, "cancelled");
+    }
+    quiescing = (async () => {
+      const subagents = ctx.get("subagents");
+      if (subagents !== void 0) {
+        try {
+          await subagents.drainContinuableDescendants(records.map((record) => record.agent));
+        } catch (error) {
+          logWarn(`continuable subagent teardown failed: ${String(error)}`);
+        }
+      }
+      const disposals = await Promise.allSettled(records.map((record) => record.dispose()));
+      const failures = disposals.filter(
+        (result) => result.status === "rejected"
+      );
+      if (failures.length > 0) {
+        const detail = failures.map((failure) => errorChain2(failure.reason)).join("; ");
+        throw new AggregateError(
+          failures.map((failure) => failure.reason),
+          `ACP agent teardown failed for ${failures.length} session(s): ${detail}`
+        );
+      }
+    })();
+    return quiescing;
+  };
+  void conn.closed.catch((error) => {
+    logWarn(`connection closed with an error: ${String(error)}`);
+  }).then(quiesce).catch((error) => {
+    logWarn(`connection-close teardown failed: ${String(error)}`);
+  });
+  ctx.effect(() => quiesce, "acp-bridge.connection");
+}
+
+// src/bundle.ts
+init_self_harness();
+var name2 = name;
+var inject2 = inject;
+function apply2(ctx, config) {
+  apply(ctx, {
+    ...config.provider !== void 0 ? { provider: config.provider } : {},
+    ...config.model !== void 0 ? { model: config.model } : {},
+    ...config.models !== void 0 ? { models: config.models } : {},
+    ...config.maxTokens !== void 0 ? { maxTokens: config.maxTokens } : {},
+    ...config.permissionMode !== void 0 ? { permissionMode: config.permissionMode } : {},
+    harness: selfHarness()
+  });
+}
+export {
+  apply2 as apply,
+  inject2 as inject,
+  name2 as name
+};