lody 0.90.0 → 0.91.0

package/dist/deepseek-acp.js

@@ -2,7 +2,7 @@ import { randomUUID, createHash } from "node:crypto";
 import { isAbsolute } from "node:path";
 import { Readable, Writable } from "node:stream";
 import { n as ndJsonStream, A as AgentSideConnection, R as RequestError, P as PROTOCOL_VERSION } from "./chunks/acp-DBqkNziA.js";
-import { D as DEEPSEEK_HARNESS_PERMISSION_MODES, c as DEEPSEEK_HARNESS_REASONING_OPTIONS, e as ACP_EXTENSION_DSH_VERSION, a as DEEPSEEK_HARNESS_AGENT_PRESETS } from "./chunks/profile-CPDWaQXE.js";
+import { j as DEEPSEEK_HARNESS_BASE_URL_ENV, k as DEEPSEEK_HARNESS_API_KEY_ENV, b as ACP_EXTENSION_DSH_VERSION, a as DEEPSEEK_HARNESS_AGENT_PRESETS } from "./chunks/profile-DLuYzIs8.js";
 import "./chunks/schemas-Du3qLZPS.js";
 const name = "acp-extension-dsh";
 const inject = [
@@ -22,10 +22,15 @@ const MODEL_CONFIG_ID = "model";
 const MODE_CONFIG_ID = "mode";
 const REASONING_EFFORT_CONFIG_ID = "reasoning_effort";
 const AGENT_PRESET_CONFIG_ID = "agent_preset";
+const PERMISSION_EVENT_TYPES = /* @__PURE__ */ new Set(["permission/preset", "sandbox/mode", "approval/policy"]);
 const MCP_CLIENT_PACKAGE = "@deepseek-ai/dsh-mcp-client";
 const MCP_TOOL_CALL_TIMEOUT_MS = 6e4;
 const MCP_SERVER_NAME_MAX_LENGTH = 32;
 const MCP_SERVER_NAME_HASH_LENGTH = 8;
+const MODEL_DISCOVERY_TIMEOUT_MS = 15e3;
+const MODEL_DISCOVERY_MAX_BYTES = 1024 * 1024;
+const MODEL_DISCOVERY_MAX_MODELS = 1e3;
+const MODEL_ID_MAX_LENGTH = 512;
 const INVALID_MCP_SERVER_NAME_CHARS = /[^A-Za-z0-9_-]/gu;
 const IMAGE_MEDIA_TYPES = [
   "image/png",
@@ -45,8 +50,6 @@ const IMAGE_ADMISSION_ERROR_CODES = /* @__PURE__ */ new Set([
   "IMAGE_TOO_MANY_PIXELS",
   "IMAGE_DIMENSION_TOO_LARGE"
 ]);
-const PERMISSION_MODE_IDS = new Set(DEEPSEEK_HARNESS_PERMISSION_MODES.map((mode) => mode.id));
-const REASONING_EFFORT_IDS = new Set(DEEPSEEK_HARNESS_REASONING_OPTIONS.map((effort) => effort.value));
 function invalidParams(detail) {
   return RequestError.invalidParams(void 0, detail);
 }
@@ -59,23 +62,19 @@ function nonEmptyString(value, fallback) {
 function resolveAdapterConfig(config) {
   const provider = nonEmptyString(config?.provider, "deepseek-official");
   const model = nonEmptyString(config?.model, "deepseek-v4-pro");
-  const reasoningEffort = config?.reasoningEffort ?? "max";
-  if (!REASONING_EFFORT_IDS.has(reasoningEffort)) {
-    throw new Error(`acp-extension-dsh: unsupported reasoning effort ${JSON.stringify(reasoningEffort)}`);
-  }
   return {
     provider,
     model,
-    reasoningEffort,
+    ...config?.reasoningEffort ? { reasoningEffort: config.reasoningEffort } : {},
     ...config?.stream ? { stream: config.stream } : {}
   };
 }
-async function loadHarnessModels(ctx, provider) {
-  const llm = ctx.get("llm");
-  if (!llm)
-    throw new Error("acp-extension-dsh: no Harness LLM catalog is mounted");
-  const listed = await llm.listModels(provider);
-  const models = [];
+async function loadHarnessModels(llm, provider, configuredModel, endpoint) {
+  const listed = endpoint ? (await discoverDeepSeekModelIds(endpoint.baseUrl, endpoint.apiKey)).map((id) => ({
+    provider,
+    id
+  })) : await llm.listModels(provider);
+  const modelIds = [];
   const ids = /* @__PURE__ */ new Set();
   for (const model of listed) {
     if (model.provider !== provider || !model.id.trim())
@@ -84,12 +83,101 @@ async function loadHarnessModels(ctx, provider) {
       throw new Error(`acp-extension-dsh: duplicate model ${JSON.stringify(model.id)} for provider ${JSON.stringify(provider)}`);
     }
     ids.add(model.id);
-    models.push({
-      ...model,
-      ...model.inputModalities ? { inputModalities: [...model.inputModalities] } : {}
+    modelIds.push(model.id);
+  }
+  if (endpoint && modelIds.length === 0) {
+    throw new Error("the endpoint returned no usable models");
+  }
+  if (!endpoint && !ids.has(configuredModel))
+    modelIds.unshift(configuredModel);
+  const initialModel = endpoint ? modelIds[0] : configuredModel;
+  return {
+    models: await Promise.all(modelIds.map((modelId) => resolveHarnessModel(llm, provider, modelId))),
+    initialModel
+  };
+}
+function modelDiscoveryUrl(baseUrl) {
+  const url = new URL(baseUrl);
+  url.pathname = `${url.pathname.replace(/\/+$/u, "")}/models`;
+  url.hash = "";
+  return url;
+}
+async function readLimitedResponse(response) {
+  const declaredLength = Number(response.headers.get("content-length"));
+  if (Number.isFinite(declaredLength) && declaredLength > MODEL_DISCOVERY_MAX_BYTES) {
+    throw new Error("model discovery response is too large");
+  }
+  if (!response.body)
+    return "";
+  const reader = response.body.getReader();
+  const decoder = new TextDecoder();
+  let text = "";
+  let bytes = 0;
+  while (true) {
+    const { done, value } = await reader.read();
+    if (done)
+      break;
+    bytes += value.byteLength;
+    if (bytes > MODEL_DISCOVERY_MAX_BYTES) {
+      await reader.cancel();
+      throw new Error("model discovery response is too large");
+    }
+    text += decoder.decode(value, { stream: true });
+  }
+  return text + decoder.decode();
+}
+async function discoverDeepSeekModelIds(baseUrl, apiKey) {
+  const headers = new Headers({ accept: "application/json" });
+  if (apiKey)
+    headers.set("authorization", `Bearer ${apiKey}`);
+  let response;
+  try {
+    response = await fetch(modelDiscoveryUrl(baseUrl), {
+      method: "GET",
+      headers,
+      redirect: "error",
+      signal: AbortSignal.timeout(MODEL_DISCOVERY_TIMEOUT_MS)
+    });
+  } catch (error) {
+    throw new Error(`unable to request the endpoint model list: ${errorChain(error)}`, {
+      cause: error
+    });
+  }
+  if (!response.ok) {
+    throw new Error(`model discovery failed with HTTP ${response.status}`);
+  }
+  let body;
+  try {
+    body = JSON.parse(await readLimitedResponse(response));
+  } catch (error) {
+    throw new Error(`model discovery returned invalid JSON: ${errorChain(error)}`, {
+      cause: error
     });
   }
-  return models;
+  if (typeof body !== "object" || body === null || !("data" in body) || !Array.isArray(body.data) || body.data.length > MODEL_DISCOVERY_MAX_MODELS) {
+    throw new Error("model discovery returned an invalid OpenAI-compatible response");
+  }
+  const ids = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const entry of body.data) {
+    if (typeof entry !== "object" || entry === null || !("id" in entry))
+      continue;
+    const id = typeof entry.id === "string" ? entry.id.trim() : "";
+    if (!id || id.length > MODEL_ID_MAX_LENGTH || seen.has(id))
+      continue;
+    seen.add(id);
+    ids.push(id);
+  }
+  return ids;
+}
+async function resolveHarnessModel(llm, provider, modelId, signal) {
+  if (!modelId.trim())
+    throw invalidParams("model id must not be empty");
+  const model = await llm.resolveModelInfo(provider, modelId, signal);
+  if (model.provider !== provider || model.id !== modelId || !model.name?.trim()) {
+    throw new Error(`acp-extension-dsh: invalid exact model metadata for ${JSON.stringify(provider)} / ${JSON.stringify(modelId)}`);
+  }
+  return model;
 }
 async function loadMcpClientPlugin(agentContext) {
   const module = agentContext.loader.unwrapExports(await agentContext.loader.import(MCP_CLIENT_PACKAGE));
@@ -175,12 +263,9 @@ async function mountMcpServers(agentContext, servers, serverNames, cwd) {
   });
   await Promise.all(handles.map((handle) => handle.await()));
 }
-function cloneSelection(selection) {
-  return { ...selection };
-}
 function installModelSelection(agentContext, selection) {
   agentContext.on("system-prompt/assemble", async (_assembly, _context, next) => {
-    const selected = cloneSelection(selection.current);
+    const selected = { ...selection.current };
     const assembled = await next();
     selection.assembled = selected;
     return {
@@ -200,12 +285,12 @@ function installModelSelection(agentContext, selection) {
       ...withoutInheritedEffort,
       provider: selected.provider,
       model: selected.model,
-      reasoningEffort: selected.reasoningEffort
+      ...selected.reasoningEffort ? { reasoningEffort: selected.reasoningEffort } : {}
     };
   });
 }
 function configOptions(record) {
-  return [
+  const options = [
     {
       id: MODE_CONFIG_ID,
       name: "Permission",
@@ -213,8 +298,8 @@ function configOptions(record) {
       category: "mode",
       type: "select",
       currentValue: record.permissionMode,
-      options: DEEPSEEK_HARNESS_PERMISSION_MODES.map((mode) => ({
-        value: mode.id,
+      options: record.permissionOptions.map((mode) => ({
+        value: mode.value,
         name: mode.name,
         description: mode.description ?? null
       }))
@@ -242,39 +327,81 @@ function configOptions(record) {
       category: "model",
       type: "select",
       currentValue: record.selection.current.model,
-      options: record.models.map((model) => ({
-        value: model.id,
-        name: model.name ?? model.id,
-        description: model.description ?? null
+      options: record.models.map((model2) => ({
+        value: model2.id,
+        name: model2.name,
+        description: model2.description ?? null
       }))
-    },
-    {
+    }
+  ];
+  const model = record.models.find((candidate) => candidate.id === record.selection.current.model);
+  if (model?.reasoning && record.selection.current.reasoningEffort) {
+    options.push({
       id: REASONING_EFFORT_CONFIG_ID,
       name: "Reasoning effort",
       description: "How much reasoning effort the model should use",
       category: "thought_level",
       type: "select",
       currentValue: record.selection.current.reasoningEffort,
-      options: DEEPSEEK_HARNESS_REASONING_OPTIONS.map((effort) => ({
-        value: effort.value,
+      options: model.reasoning.efforts.map((effort) => ({
+        value: effort.id,
         name: effort.name,
         description: effort.description ?? null
       }))
-    }
-  ];
+    });
+  }
+  return options;
+}
+function legacyModels(record) {
+  return {
+    currentModelId: record.selection.current.model,
+    availableModels: record.models.flatMap((model) => [
+      {
+        modelId: model.id,
+        name: model.name,
+        description: model.description ?? null
+      },
+      ...model.reasoning?.efforts.map((effort) => ({
+        modelId: `${model.id}[${effort.id}]`,
+        name: `${model.name} (${effort.name})`,
+        description: model.description ?? null
+      })) ?? []
+    ])
+  };
 }
 function modeState(record) {
   return {
     currentModeId: record.permissionMode,
-    availableModes: DEEPSEEK_HARNESS_PERMISSION_MODES.map((mode) => ({
-      id: mode.id,
+    availableModes: record.permissionOptions.map((mode) => ({
+      id: mode.value,
       name: mode.name,
       description: mode.description ?? null
     }))
   };
 }
-function modelSupportsImages(models, modelId) {
-  return models.some((model) => model.id === modelId && model.inputModalities?.includes("image"));
+function supportsAcpImagePrompts(attachments, models) {
+  return attachments !== void 0 && attachments.imageLimits.mediaTypes.some((mediaType) => IMAGE_MEDIA_TYPES.includes(mediaType)) && models.some((model) => model.inputModalities?.includes("image"));
+}
+function resolveReasoningEffort(model, requested) {
+  const reasoning = model.reasoning;
+  if (!reasoning) {
+    if (requested) {
+      throw invalidParams(`model ${JSON.stringify(model.id)} does not support reasoning effort ${JSON.stringify(requested)}`);
+    }
+    return void 0;
+  }
+  const effort = requested ?? reasoning.defaultEffort;
+  if (!effort)
+    return void 0;
+  assertAllowed(effort, new Set(reasoning.efforts.map((candidate) => candidate.id)), `reasoning effort for model ${model.id}`);
+  return effort;
+}
+function permissionState(ctx, currentMode) {
+  const options = ctx.permissionPresets.names.map((mode) => ctx.permissionPresets.optionOf(mode));
+  if (!ctx.permissionPresets.names.includes(currentMode)) {
+    options.push(ctx.permissionPresets.optionOf(currentMode));
+  }
+  return options;
 }
 function imageMediaType(value) {
   return IMAGE_MEDIA_TYPES.includes(value) ? value : void 0;
@@ -296,7 +423,7 @@ function decodePromptImage(block) {
 function isImageAdmissionError(error) {
   return error instanceof Error && "code" in error && typeof error.code === "string" && IMAGE_ADMISSION_ERROR_CODES.has(error.code);
 }
-async function admitAcpPrompt(prompt, models, modelId, attachments) {
+async function admitAcpPrompt(prompt, llm, selection, attachments, imagePromptEnabled, signal) {
   const images = [];
   for (const block of prompt) {
     switch (block.type) {
@@ -304,8 +431,8 @@ async function admitAcpPrompt(prompt, models, modelId, attachments) {
       case "resource_link":
         break;
       case "image":
-        if (!modelSupportsImages(models, modelId)) {
-          throw invalidParams(`model ${JSON.stringify(modelId)} does not support image input`);
+        if (!imagePromptEnabled) {
+          throw invalidParams("inline image prompts were not advertised by this connection");
         }
         images.push(decodePromptImage(block));
         break;
@@ -321,6 +448,17 @@ async function admitAcpPrompt(prompt, models, modelId, attachments) {
   if (images.length > 0) {
     if (!attachments)
       throw internalError("no Harness attachment store is mounted");
+    signal.throwIfAborted();
+    let model;
+    try {
+      model = await resolveHarnessModel(llm, selection.provider, selection.model, signal);
+    } catch (error) {
+      throw internalError(`unable to verify the current image model: ${errorChain(error)}`);
+    }
+    if (!model.inputModalities?.includes("image")) {
+      throw invalidParams(`model ${JSON.stringify(selection.model)} does not support image input`);
+    }
+    signal.throwIfAborted();
     try {
       refs = await attachments.saveImages(images);
     } catch (error) {
@@ -328,6 +466,7 @@ async function admitAcpPrompt(prompt, models, modelId, attachments) {
         throw invalidParams(error.message);
       throw internalError("unable to persist the prompt image batch");
     }
+    signal.throwIfAborted();
   }
   const content = [];
   let pendingText = "";
@@ -359,6 +498,28 @@ async function admitAcpPrompt(prompt, models, modelId, attachments) {
   }
   return content;
 }
+async function assistantBlockToAcp(block, attachments) {
+  if (block.type === "text" && "text" in block) {
+    return block.text.length > 0 ? { type: "text", text: block.text } : void 0;
+  }
+  if (block.type !== "image" || !("attachment" in block))
+    return void 0;
+  if (!attachments)
+    throw new Error("cannot deliver assistant image: no attachment store is mounted");
+  let stored;
+  try {
+    stored = await attachments.readImage(block.attachment);
+  } catch (error) {
+    throw new Error("cannot deliver assistant image: the attachment is unavailable or corrupt", {
+      cause: error
+    });
+  }
+  return {
+    type: "image",
+    data: Buffer.from(stored.data).toString("base64"),
+    mimeType: stored.ref.mediaType
+  };
+}
 function createUserMessage(id, content) {
   return Object.freeze({
     id,
@@ -367,22 +528,6 @@ function createUserMessage(id, content) {
     source: Object.freeze({ kind: "user" })
   });
 }
-function turnEndToStopReason(reason) {
-  switch (reason.kind) {
-    case "completed":
-      return "end_turn";
-    case "max-tokens":
-      return "max_tokens";
-    case "interrupted":
-      return "cancelled";
-    case "aborted":
-    case "blocked":
-    case "error":
-      return "end_turn";
-    default:
-      return "end_turn";
-  }
-}
 function errorChain(value) {
   const seen = /* @__PURE__ */ new Set();
   const render = (current) => {
@@ -431,11 +576,18 @@ function apply(ctx, rawConfig) {
   const activeMcpServerNames = /* @__PURE__ */ new Set();
   let closed = false;
   let conn;
-  for (const mode of PERMISSION_MODE_IDS) {
-    if (!ctx.permissionPresets.names.includes(mode)) {
-      throw new Error(`acp-extension-dsh: permission preset ${JSON.stringify(mode)} is not composed`);
-    }
+  let imagePromptEnabled = false;
+  if (ctx.permissionPresets.names.length === 0) {
+    throw new Error("acp-extension-dsh: no permission presets are composed");
   }
+  const llm = ctx.get("llm");
+  if (!llm)
+    throw new Error("acp-extension-dsh: no Harness LLM catalog is mounted");
+  const attachments = ctx.get("attachments");
+  const baseUrl = process.env[DEEPSEEK_HARNESS_BASE_URL_ENV]?.trim();
+  const apiKey = process.env[DEEPSEEK_HARNESS_API_KEY_ENV]?.trim();
+  let modelCatalog;
+  const loadModelCatalog = () => modelCatalog ??= loadHarnessModels(llm, config.provider, config.model, baseUrl ? { baseUrl, ...apiKey ? { apiKey } : {} } : void 0);
   const assertOpen = () => {
     if (closed)
       throw internalError("the ACP bridge has been disposed");
@@ -450,19 +602,96 @@ function apply(ctx, rawConfig) {
     const record = sessions.get(agent.session.id);
     return record?.agent === agent ? record : void 0;
   };
-  const notify = (notification) => {
-    void conn.sessionUpdate(notification).catch((error) => {
+  const notify = async (notification) => {
+    await conn.sessionUpdate(notification).catch((error) => {
       ctx.logger.warn(`acp-extension-dsh: session/update failed: ${String(error)}`);
     });
   };
-  const settlePrompt = (record, reason) => {
-    const inflight = record.inflight;
-    if (!inflight)
+  const enqueueOutput = (record, work, inflight) => {
+    record.outputTail = record.outputTail.then(work).catch((error) => {
+      const failure = error instanceof Error ? error : new Error(String(error));
+      if (inflight)
+        inflight.outputError ??= failure;
+      ctx.logger.warn(`acp-extension-dsh: assistant output failed: ${errorChain(error)}`);
+    });
+  };
+  const enqueueNotification = (record, notification, inflight) => enqueueOutput(record, () => notify(notification), inflight);
+  const settleAfterQuiescence = (record, inflight) => {
+    if (inflight.settlementStarted)
       return;
-    record.inflight = void 0;
-    inflight.resolve(reason);
+    inflight.settlementStarted = true;
+    void (async () => {
+      await inflight.admissionDone;
+      if (inflight.messageQueued) {
+        await record.agent.whenIdle();
+        await record.outputTail;
+      }
+      if (record.inflight !== inflight)
+        return;
+      record.inflight = void 0;
+      if (inflight.cancelRequested) {
+        inflight.resolve("cancelled");
+      } else if (inflight.outputError) {
+        inflight.reject(internalError(`assistant output delivery failed: ${inflight.outputError.message}`));
+      } else if (inflight.agentError) {
+        inflight.reject(internalError(`turn failed: ${inflight.agentError.message}`));
+      } else if (inflight.endReason?.kind === "error") {
+        inflight.reject(internalError(`turn failed: ${inflight.endReason.error.message}`));
+      } else {
+        const end = inflight.endReason;
+        inflight.resolve(end ? end.kind === "interrupted" ? "cancelled" : "end_turn" : "cancelled");
+      }
+    })().catch((error) => {
+      if (record.inflight !== inflight)
+        return;
+      record.inflight = void 0;
+      inflight.reject(internalError(`prompt settlement failed: ${errorChain(error)}`));
+    });
+  };
+  const refreshPermissionState = (record) => {
+    const permissionMode = ctx.permissionPresets.current(record.agent.session.events);
+    if (permissionMode === record.permissionMode)
+      return false;
+    record.permissionMode = permissionMode;
+    record.permissionOptions = permissionState(ctx, permissionMode);
+    return true;
+  };
+  const schedulePermissionSync = (record) => {
+    if (record.permissionSyncQueued)
+      return;
+    record.permissionSyncQueued = true;
+    queueMicrotask(() => {
+      record.permissionSyncQueued = false;
+      if (sessions.get(record.agent.session.id) !== record)
+        return;
+      try {
+        if (!refreshPermissionState(record))
+          return;
+        enqueueNotification(record, {
+          sessionId: record.agent.session.id,
+          update: {
+            sessionUpdate: "current_mode_update",
+            currentModeId: record.permissionMode
+          }
+        });
+        enqueueNotification(record, {
+          sessionId: record.agent.session.id,
+          update: {
+            sessionUpdate: "config_option_update",
+            configOptions: configOptions(record)
+          }
+        });
+      } catch (error) {
+        ctx.logger.warn(`acp-extension-dsh: failed to synchronize permission state: ${errorChain(error)}`);
+      }
+    });
   };
   const disposeRecords = async (records) => {
+    await Promise.all(records.map(async (record) => {
+      await record.inflight?.admissionDone;
+      await record.agent.whenIdle();
+      await record.outputTail;
+    }));
     const subagents = ctx.get("subagents");
     if (subagents) {
       try {
@@ -481,9 +710,11 @@ function apply(ctx, rawConfig) {
     const record = sessions.get(session.header.id);
     if (!record || record.agent.session !== session)
       return;
+    if (PERMISSION_EVENT_TYPES.has(event.type))
+      schedulePermissionSync(record);
     try {
       if (event.type === "assistant/chunk" && event.data.chunk?.type === "reasoning-delta" && typeof event.data.chunk.text === "string" && event.data.chunk.text.length > 0) {
-        notify({
+        enqueueNotification(record, {
           sessionId: record.agent.session.id,
           update: {
             sessionUpdate: "agent_thought_chunk",
@@ -491,7 +722,7 @@ function apply(ctx, rawConfig) {
           }
         });
       } else if (event.type === "assistant/chunk" && event.data.chunk?.type === "block-end" && event.data.chunk.block?.type === "reasoning") {
-        notify({
+        enqueueNotification(record, {
           sessionId: record.agent.session.id,
           update: {
             sessionUpdate: "agent_thought_chunk",
@@ -499,35 +730,25 @@ function apply(ctx, rawConfig) {
           }
         });
       } else if (event.type === "assistant/message") {
-        for (const block of event.data.message?.content ?? []) {
-          if (block.type === "text" && "text" in block && block.text.length > 0) {
-            notify({
-              sessionId: record.agent.session.id,
-              update: {
-                sessionUpdate: "agent_message_chunk",
-                content: { type: "text", text: block.text }
-              }
-            });
-          } else if (block.type === "image" && "attachment" in block) {
-            notify({
+        const inflight = record.inflight?.turn === event.data.turn ? record.inflight : void 0;
+        enqueueOutput(record, async () => {
+          for (const block of event.data.message?.content ?? []) {
+            const content = await assistantBlockToAcp(block, attachments);
+            if (!content)
+              continue;
+            await notify({
               sessionId: record.agent.session.id,
-              update: {
-                sessionUpdate: "agent_message_chunk",
-                content: {
-                  type: "text",
-                  text: `[image attachment ${block.attachment.attachmentId}]`
-                }
-              }
+              update: { sessionUpdate: "agent_message_chunk", content }
             });
           }
-        }
+        }, inflight);
       } else if (event.type === "compaction/start" && event.data.compactionId) {
         const activity = {
           version: 1,
           kind: "context_compaction",
           automatic: event.data.turn !== null
         };
-        notify({
+        enqueueNotification(record, {
           sessionId: record.agent.session.id,
           update: {
             sessionUpdate: "tool_call",
@@ -545,7 +766,7 @@ function apply(ctx, rawConfig) {
           automatic: event.data.turn !== null,
           ...event.data.error ? { failureReason: event.data.error } : {}
         };
-        notify({
+        enqueueNotification(record, {
           sessionId: record.agent.session.id,
           update: {
             sessionUpdate: "tool_call_update",
@@ -559,12 +780,7 @@ function apply(ctx, rawConfig) {
     } finally {
       const inflight = record.inflight;
       if (inflight && event.type === "turn/end" && inflight.turn === event.data.turn && event.data.reason) {
-        if (event.data.reason.kind === "error") {
-          record.inflight = void 0;
-          inflight.reject(internalError(`turn failed: ${event.data.reason.error.message}`));
-        } else {
-          inflight.endReason = event.data.reason;
-        }
+        inflight.endReason = event.data.reason;
       }
     }
   });
@@ -576,10 +792,10 @@ function apply(ctx, rawConfig) {
   ctx.on("agent/error", ({ agent, turn, error }) => {
     const record = ownedRecord(agent);
     const inflight = record?.inflight;
-    if (!record || !inflight || inflight.turn !== void 0 && inflight.turn !== turn)
+    if (!record || !inflight || !inflight.messageQueued || inflight.turn !== turn)
       return;
-    record.inflight = void 0;
-    inflight.reject(internalError(`turn failed: ${errorChain(error)}`));
+    inflight.agentError = new Error(errorChain(error));
+    settleAfterQuiescence(record, inflight);
   });
   ctx.on("approval/request", (request, next) => {
     const record = ownedRecord(request.agent);
@@ -599,9 +815,16 @@ function apply(ctx, rawConfig) {
     });
   });
   const setPermissionMode = (record, modeId) => {
-    assertAllowed(modeId, PERMISSION_MODE_IDS, "permission mode");
+    if (modeId === record.permissionMode)
+      return;
+    assertAllowed(modeId, new Set(ctx.permissionPresets.names), "permission mode");
     ctx.permissionPresets.set(record.agent.session, modeId);
-    record.permissionMode = modeId;
+    const permissionMode = ctx.permissionPresets.current(record.agent.session.events);
+    if (permissionMode !== modeId) {
+      throw internalError(`permission preset ${JSON.stringify(modeId)} did not become the effective mode`);
+    }
+    record.permissionMode = permissionMode;
+    record.permissionOptions = permissionState(ctx, permissionMode);
   };
   const setConfigOption = (record, params) => {
     const value = requireSelectValue(params);
@@ -625,13 +848,35 @@ function apply(ctx, rawConfig) {
         throw invalidParams(`failed to select agent preset ${JSON.stringify(value)}: ${errorChain(error)}`);
       });
     } else if (params.configId === MODEL_CONFIG_ID) {
-      assertAllowed(value, new Set(record.models.map((model) => model.id)), "model");
-      record.selection.current = { ...record.selection.current, model: value };
+      return resolveHarnessModel(llm, record.selection.current.provider, value).then((model) => {
+        const index = record.models.findIndex((candidate) => candidate.id === value);
+        if (index === -1)
+          record.models.push(model);
+        else
+          record.models[index] = model;
+        const reasoningEffort = resolveReasoningEffort(model, record.selection.current.reasoningEffort && model.reasoning?.efforts.some((effort) => effort.id === record.selection.current.reasoningEffort) ? record.selection.current.reasoningEffort : void 0);
+        record.selection.current = {
+          provider: record.selection.current.provider,
+          model: value,
+          ...reasoningEffort ? { reasoningEffort } : {}
+        };
+        return { configOptions: configOptions(record) };
+      }).catch((error) => {
+        if (error instanceof RequestError)
+          throw error;
+        throw invalidParams(`failed to resolve model ${JSON.stringify(value)}: ${errorChain(error)}`);
+      });
     } else if (params.configId === REASONING_EFFORT_CONFIG_ID) {
-      assertAllowed(value, REASONING_EFFORT_IDS, "reasoning effort");
+      const model = record.models.find((candidate) => candidate.id === record.selection.current.model);
+      if (!model)
+        throw internalError("selected model metadata is unavailable");
+      const reasoningEffort = resolveReasoningEffort(model, value);
+      if (!reasoningEffort) {
+        throw invalidParams(`model ${JSON.stringify(model.id)} has no reasoning selector`);
+      }
       record.selection.current = {
         ...record.selection.current,
-        reasoningEffort: value
+        reasoningEffort
       };
     } else {
       throw invalidParams(`unknown config option: ${params.configId}`);
@@ -642,13 +887,14 @@ function apply(ctx, rawConfig) {
     conn = connection;
     return {
       async initialize(_params) {
-        const models = await loadHarnessModels(ctx, config.provider);
+        const { models } = await loadModelCatalog();
+        imagePromptEnabled = supportsAcpImagePrompts(attachments, models);
         return {
           protocolVersion: PROTOCOL_VERSION,
           agentInfo: { name: "acp-extension-dsh", version: ACP_EXTENSION_DSH_VERSION },
           agentCapabilities: {
             promptCapabilities: {
-              image: models.some((model) => modelSupportsImages(models, model.id)),
+              image: imagePromptEnabled,
               audio: false,
               embeddedContext: false
             },
@@ -665,18 +911,23 @@ function apply(ctx, rawConfig) {
       async newSession(params) {
         assertOpen();
         validateSessionParams(params);
-        let models;
+        let catalog;
         try {
-          models = await loadHarnessModels(ctx, config.provider);
+          catalog = await loadModelCatalog();
         } catch (error) {
-          throw internalError(`failed to list models: ${errorChain(error)}`);
+          throw internalError(`failed to discover models: ${errorChain(error)}`);
         }
+        const { models, initialModel: initialModelId } = catalog;
         const sessionId = randomUUID();
+        const initialModel = models.find((model) => model.id === initialModelId);
+        if (!initialModel)
+          throw internalError("initial model metadata is unavailable");
+        const reasoningEffort = resolveReasoningEffort(initialModel, config.reasoningEffort);
         const selection = {
           current: {
             provider: config.provider,
-            model: config.model,
-            reasoningEffort: config.reasoningEffort
+            model: initialModelId,
+            ...reasoningEffort ? { reasoningEffort } : {}
           }
         };
         const agentPresetOptions = (await ctx.agentPresets.list()).filter((preset) => preset.broken === void 0);
@@ -691,7 +942,7 @@ function apply(ctx, rawConfig) {
           handle = await ctx.agents.create({
             sessionId,
             meta: { cwd: params.cwd, agentPreset: requestedPreset },
-            agentOptions: { provider: config.provider, model: config.model },
+            agentOptions: { provider: config.provider, model: initialModelId },
             setup: async (agentContext) => {
               installModelSelection(agentContext, selection);
               mountedPreset = (await ctx.agentPresets.mount(agentContext, requestedPreset)).id;
@@ -716,9 +967,10 @@ function apply(ctx, rawConfig) {
           throw internalError("connection closed during session/new");
         }
         let permissionMode;
+        let permissionOptions;
         try {
           permissionMode = ctx.permissionPresets.current(handle.agent.session.events);
-          assertAllowed(permissionMode, PERMISSION_MODE_IDS, "permission mode");
+          permissionOptions = permissionState(ctx, permissionMode);
         } catch (error) {
           await dispose();
           throw error;
@@ -728,24 +980,19 @@ function apply(ctx, rawConfig) {
           dispose,
           selection,
           permissionMode,
+          permissionOptions,
           agentPreset: mountedPreset,
           agentPresetOptions,
           models,
-          started: false
+          started: false,
+          outputTail: Promise.resolve()
         };
         sessions.set(sessionId, record);
         return {
           sessionId,
           modes: modeState(record),
           configOptions: configOptions(record),
-          models: {
-            currentModelId: record.selection.current.model,
-            availableModels: record.models.map((model) => ({
-              modelId: model.id,
-              name: model.name ?? model.id,
-              description: model.description ?? null
-            }))
-          }
+          models: legacyModels(record)
         };
       },
       setSessionMode(params) {
@@ -763,60 +1010,92 @@ function apply(ctx, rawConfig) {
         if (ctx.agents.get(record.agent.id) !== record.agent) {
           throw internalError("prompt was not queued: the agent was disposed outside the bridge");
         }
-        const attachments = ctx.get("attachments");
         const messageId = randomUUID();
         let resolvePrompt;
         let rejectPrompt;
+        let finishAdmission;
         const completion = new Promise((resolve, reject) => {
           resolvePrompt = resolve;
           rejectPrompt = reject;
         });
+        const admissionDone = new Promise((resolve) => {
+          finishAdmission = resolve;
+        });
+        const admissionController = new AbortController();
         const inflight = {
           resolve: resolvePrompt,
           reject: rejectPrompt,
-          messageId
+          messageQueued: false,
+          admissionDone,
+          admissionController,
+          cancelRequested: false,
+          settlementStarted: false
         };
         record.inflight = inflight;
+        let admissionError;
         try {
-          const content = await admitAcpPrompt(params.prompt, record.models, record.selection.current.model, attachments);
-          if (record.inflight !== inflight)
-            return { stopReason: await completion };
-          const message = createUserMessage(messageId, content);
-          record.started = true;
-          try {
-            record.agent.followup(message);
-          } catch (error) {
-            record.inflight = void 0;
-            record.started = false;
-            throw internalError(`prompt was not queued: ${error instanceof Error ? error.message : String(error)}`);
+          const content = await admitAcpPrompt(params.prompt, llm, record.selection.current, attachments, imagePromptEnabled, admissionController.signal);
+          if (!inflight.cancelRequested) {
+            if (ctx.agents.get(record.agent.id) !== record.agent) {
+              throw internalError("prompt was not queued: the agent was disposed outside the bridge");
+            }
+            const message = createUserMessage(messageId, content);
+            inflight.messageId = messageId;
+            inflight.messageQueued = true;
+            const wasStarted = record.started;
+            try {
+              record.agent.followup(message);
+              record.started = true;
+            } catch (error) {
+              inflight.messageQueued = false;
+              record.started = wasStarted;
+              throw new Error(`prompt was not queued: ${error instanceof Error ? error.message : String(error)}`, { cause: error });
+            }
           }
-          void record.agent.whenIdle().then(() => {
-            if (record.inflight !== inflight)
-              return;
-            record.inflight = void 0;
-            const end = inflight.endReason;
-            inflight.resolve(end ? end.kind === "max-tokens" ? "end_turn" : turnEndToStopReason(end) : "cancelled");
-          });
         } catch (error) {
+          admissionError = error;
+        } finally {
+          finishAdmission();
+        }
+        if (inflight.cancelRequested) {
+          settleAfterQuiescence(record, inflight);
+          return { stopReason: await completion };
+        }
+        if (admissionError) {
           if (record.inflight === inflight)
             record.inflight = void 0;
-          throw error;
+          if (admissionError instanceof RequestError)
+            throw admissionError;
+          throw internalError(errorChain(admissionError));
         }
+        settleAfterQuiescence(record, inflight);
         return { stopReason: await completion };
       },
       cancel(params) {
         const record = sessions.get(params.sessionId);
         if (!record)
           return Promise.resolve();
-        record.agent.cancel({ kind: "user" });
-        settlePrompt(record, "cancelled");
+        const inflight = record.inflight;
+        if (inflight) {
+          inflight.cancelRequested = true;
+          inflight.admissionController.abort(new Error("ACP prompt cancelled"));
+          settleAfterQuiescence(record, inflight);
+        }
+        if (!inflight || inflight.messageQueued)
+          record.agent.cancel({ kind: "user" });
         return Promise.resolve();
       },
       async closeSession(params) {
         const record = requireSession(params.sessionId);
         sessions.delete(params.sessionId);
-        record.agent.cancel({ kind: "user" });
-        settlePrompt(record, "cancelled");
+        const inflight = record.inflight;
+        if (inflight) {
+          inflight.cancelRequested = true;
+          inflight.admissionController.abort(new Error("ACP session closed"));
+          settleAfterQuiescence(record, inflight);
+        }
+        if (!inflight || inflight.messageQueued)
+          record.agent.cancel({ kind: "user" });
         await disposeRecords([record]);
       }
     };
@@ -831,8 +1110,14 @@ function apply(ctx, rawConfig) {
     const records = [...sessions.values()];
     sessions.clear();
     for (const record of records) {
-      record.agent.cancel({ kind: "user" });
-      settlePrompt(record, "cancelled");
+      const inflight = record.inflight;
+      if (inflight) {
+        inflight.cancelRequested = true;
+        inflight.admissionController.abort(new Error("ACP bridge disposed"));
+        settleAfterQuiescence(record, inflight);
+      }
+      if (!inflight || inflight.messageQueued)
+        record.agent.cancel({ kind: "user" });
     }
     quiescing = (async () => {
       await disposeRecords(records);