@ycodium-ai/agent-acp 0.2.3254 → 0.2.3272

package/dist/index.js

@@ -10,7 +10,11 @@ import { definePlugin } from "@ycodium-ai/plugin-api";
 // src/acpInstance.ts
 import * as NodeOS3 from "node:os";
 import * as NodePath4 from "node:path";
-import { mergeLaunchEnv, modelSelectionStringOption } from "@ycodium-ai/plugin-api/executor";
+import {
+  mergeLaunchEnv,
+  modelSelectionStringOption,
+  raceAbort as raceAbort2
+} from "@ycodium-ai/plugin-api/executor";
 import { nodeStreamsFromHandle as nodeStreamsFromHandle2 } from "@ycodium-ai/plugin-api/process-stdin";
 
 // ../../packages/ycodium-acp-executor/src/executor.ts
@@ -25043,11 +25047,15 @@ function createAcpConnection(options) {
     });
   };
   const close = (error62) => shutdown(error62 ?? new AcpConnectionClosedError());
+  const abandonPending = (error62) => {
+    rejectPending(error62);
+  };
   return {
     request,
     begin,
     notify,
     awaitInboundIdle,
+    abandonPending,
     close,
     closed
   };
@@ -25513,10 +25521,11 @@ function createExecutorPrompt({
   const prompt = async (input2) => {
     failIfPromptUnavailable();
     const started = requireStarted();
+    let sessionId = started.sessionId;
     let record2;
     const settle2 = (rest) => settleTurn({
       expectedGeneration: started.generation,
-      expectedSessionId: started.sessionId,
+      expectedSessionId: sessionId,
       record: record2,
       ...rest
     });
@@ -25600,12 +25609,32 @@ function createExecutorPrompt({
       const queuedTurnId = turnId;
       const isStale = () => interruptedTurnIds.has(queuedTurnId) || input2.expectedActiveTurnId !== void 0 && shared.activeTurnId !== queuedTurnId;
       if (!isStale()) {
-        shared.modelSelectionState = await applyRequestedModel({
-          state: shared.modelSelectionState,
-          acpSessionId: started.sessionId,
-          requestedModelId: input2.requestedModelId,
-          expectedGeneration: started.generation
-        });
+        try {
+          const applied = await applyRequestedModel({
+            state: shared.modelSelectionState,
+            acpSessionId: sessionId,
+            setup: shared.startResult?.sessionSetupResult ?? {},
+            requestedModelId: input2.requestedModelId,
+            expectedGeneration: started.generation
+          });
+          shared.modelSelectionState = applied.state;
+          sessionId = applied.sessionId;
+          record2.sessionId = applied.sessionId;
+        } catch (error62) {
+          const failureCategory = readAcpFailureCategory(error62);
+          if (failureCategory === "model-unavailable") {
+            const errorMessage = error62 instanceof Error && error62.message.trim().length > 0 ? error62.message : "Requested model is not in this agent's catalog. This turn was not sent.";
+            settle2({
+              turnId,
+              stopReason: "error",
+              state: "failed",
+              errorMessage,
+              failureCategory
+            });
+            throw error62 instanceof Error ? withFailureCategory(error62, failureCategory) : error62;
+          }
+          throw error62;
+        }
       }
       failIfDisposed();
       if (isStale()) {
@@ -25616,7 +25645,7 @@ function createExecutorPrompt({
       let written = false;
       try {
         response = await sendPromptRpc(
-          started.sessionId,
+          sessionId,
           promptParts,
           () => {
             written = true;
@@ -25666,7 +25695,7 @@ function createExecutorPrompt({
     if (hooks.readContextWindow !== void 0) {
       try {
         contextWindow = await hooks.readContextWindow({
-          sessionId: started.sessionId,
+          sessionId,
           promptResponse: response
         }) ?? void 0;
       } catch {
@@ -26341,6 +26370,56 @@ function acpInitializePayload(clientInfo, overrides) {
   };
 }
 
+// ../../packages/ycodium-acp-executor/src/refreshDeadline.ts
+var MODEL_CATALOG_REFRESH_TIMEOUT_MS = 9e4;
+
+// ../../packages/ycodium-acp-executor/src/model-send.ts
+function judgeRequestedModel(input2) {
+  const requested = normalizeModelId(input2.requestedModelId);
+  const current = input2.state.currentModelId;
+  if (requested === void 0 || requested === current) return { kind: "keep" };
+  const hasCatalog = input2.state.advertisedModelValues.length > 0;
+  const hasCurrent = current !== void 0;
+  if (!hasCatalog && !hasCurrent) return { kind: "keep" };
+  const canSwitch = input2.state.strategy === "session/set_model" && input2.state.sessionModelsAdvertised || input2.state.strategy === "config-option" && input2.state.modelConfigId !== void 0;
+  const value = hasCatalog ? matchAdvertisedModelValue(requested, input2.state.advertisedModelValues) : void 0;
+  if (value !== void 0 && value === current) return { kind: "keep" };
+  if (value !== void 0 && canSwitch) return { kind: "switch", value };
+  return input2.refreshed ? { kind: "unavailable" } : { kind: "refresh" };
+}
+function modelUnavailableError(requestedModelId, currentModelId) {
+  const current = currentModelId ?? "its own model";
+  return withFailureCategory(
+    new Error(
+      `Requested model "${requestedModelId}" is not in this agent's catalog; it is on "${current}". This turn was not sent. Refresh the model list in this agent's settings and try again.`
+    ),
+    "model-unavailable"
+  );
+}
+var ModelCatalogRefreshTimeoutError = class extends Error {
+  constructor() {
+    super("model catalog refresh timed out");
+    this.name = "ModelCatalogRefreshTimeoutError";
+  }
+};
+function modelRefreshTimedOutError(requestedModelId) {
+  return withFailureCategory(
+    new Error(
+      `Refreshing this agent's model list timed out, so this turn was not sent. Requested model "${requestedModelId}".`
+    ),
+    "model-unavailable"
+  );
+}
+function modelRefreshFailedError(requestedModelId, error62) {
+  const detail = error62 instanceof Error && error62.message.trim().length > 0 ? error62.message : "the model list could not be read";
+  return withFailureCategory(
+    new Error(
+      `Refreshing this agent's model list failed (${detail}), so this turn was not sent. Requested model "${requestedModelId}".`
+    ),
+    "model-unavailable"
+  );
+}
+
 // ../../packages/ycodium-acp-executor/src/runtime-mode.ts
 function isRecord5(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
@@ -26424,43 +26503,131 @@ function createExecutorSession({
   failIfDisposed,
   shared
 }) {
-  const applyRequestedModel = async (input2) => {
-    const requestedModelId = normalizeModelId(input2.requestedModelId);
-    if (requestedModelId === void 0 || requestedModelId === input2.state.currentModelId || input2.state.strategy === "session/set_model" && !input2.state.sessionModelsAdvertised || input2.state.strategy === "config-option" && input2.state.modelConfigId === void 0) {
-      return input2.state;
-    }
-    const value = matchAdvertisedModelValue(requestedModelId, input2.state.advertisedModelValues);
-    if (value === void 0) {
-      if (requestedModelId !== shared.lastUnmatchedModelId) {
-        shared.lastUnmatchedModelId = requestedModelId;
-        options.log?.info("requested model is not in the agent catalog; keeping its own model", {
-          requestedModelId,
-          currentModelId: input2.state.currentModelId,
-          advertisedModelValues: input2.state.advertisedModelValues
-        });
-      }
-      return input2.state;
+  const openFreshSession = async (expectedGeneration) => {
+    const initialized = shared.initializeResult;
+    if (initialized === void 0) {
+      throw new Error("no handshake");
     }
-    if (value === input2.state.currentModelId) {
-      return input2.state;
+    const mcpServers = filterMcpServersByAgentCapabilities(
+      options.mcpServers ?? [],
+      initialized.agentCapabilities
+    );
+    const additionalDirectories = options.additionalDirectories !== void 0 && options.additionalDirectories.length > 0 ? { additionalDirectories: options.additionalDirectories } : {};
+    const created = await connection.request("session/new", {
+      cwd: options.cwd,
+      mcpServers,
+      ...additionalDirectories
+    });
+    if (!isLive(expectedGeneration)) {
+      throw new AcpExecutorDisposedError();
+    }
+    if (created.sessionId === void 0 || created.sessionId.length === 0) {
+      throw new Error("session/new did not return a session id");
     }
+    return { sessionId: created.sessionId, setup: created };
+  };
+  const switchModel = async (input2) => {
     let configOptions = input2.state.configOptions;
     if (input2.state.strategy === "config-option") {
       const switched = await connection.request(
         "session/set_config_option",
-        { sessionId: input2.acpSessionId, configId: input2.state.modelConfigId, value }
+        { sessionId: input2.sessionId, configId: input2.state.modelConfigId, value: input2.value }
       );
       configOptions = switched?.configOptions ?? configOptions;
     } else {
       await connection.request("session/set_model", {
-        sessionId: input2.acpSessionId,
-        modelId: value
+        sessionId: input2.sessionId,
+        modelId: input2.value
       });
     }
     if (!isLive(input2.expectedGeneration)) {
       throw new AcpExecutorDisposedError();
     }
-    return { ...input2.state, currentModelId: value, configOptions };
+    return { ...input2.state, currentModelId: input2.value, configOptions };
+  };
+  const adoptReopenedSession = (applied) => {
+    if (shared.sessionId === void 0 && shared.startResult === void 0) return;
+    const setup = applied.setup;
+    shared.sessionId = applied.sessionId;
+    shared.modelSelectionState = applied.state;
+    shared.modeState = parseSessionModeState(setup);
+    if (shared.startResult !== void 0) {
+      shared.startResult = {
+        ...shared.startResult,
+        sessionId: applied.sessionId,
+        sessionSetupResult: setup,
+        modelConfigId: extractModelConfigId(setup),
+        modelId: applied.state.currentModelId
+      };
+    }
+  };
+  const applyRequestedModel = async (input2) => {
+    async function applyOnce(state, sessionId, setup, refreshed) {
+      const requestedModelId = normalizeModelId(input2.requestedModelId) ?? "";
+      const judgment = judgeRequestedModel({
+        state,
+        requestedModelId: input2.requestedModelId,
+        refreshed
+      });
+      if (judgment.kind === "keep") return { state, sessionId, setup };
+      if (judgment.kind === "unavailable") {
+        throw modelUnavailableError(requestedModelId, state.currentModelId);
+      }
+      if (judgment.kind === "switch") {
+        return {
+          state: await switchModel({
+            state,
+            sessionId,
+            value: judgment.value,
+            expectedGeneration: input2.expectedGeneration
+          }),
+          sessionId,
+          setup
+        };
+      }
+      return refreshAndRejudge(requestedModelId);
+    }
+    async function refreshAndRejudge(requestedModelId) {
+      const timeoutMs = options.modelCatalogRefreshTimeoutMs ?? MODEL_CATALOG_REFRESH_TIMEOUT_MS;
+      let timedOut = false;
+      const timeoutError = new ModelCatalogRefreshTimeoutError();
+      let timer;
+      const work = (async () => {
+        await options.refreshCatalogForSend?.();
+        if (timedOut) throw timeoutError;
+        const reopened = await openFreshSession(input2.expectedGeneration);
+        if (timedOut) throw timeoutError;
+        const next = modelSelectionStateFromSetup(reopened.setup);
+        const applied = await applyOnce(next, reopened.sessionId, reopened.setup, true);
+        if (timedOut) throw timeoutError;
+        adoptReopenedSession(applied);
+        return applied;
+      })();
+      void work.then(
+        () => void 0,
+        () => void 0
+      );
+      const deadline = new Promise((_resolve, reject) => {
+        timer = setTimeout(() => {
+          timedOut = true;
+          connection.abandonPending(timeoutError);
+          reject(timeoutError);
+        }, timeoutMs);
+      });
+      try {
+        return await Promise.race([work, deadline]);
+      } catch (error62) {
+        if (error62 instanceof AcpExecutorDisposedError) throw error62;
+        if (timedOut || error62 instanceof ModelCatalogRefreshTimeoutError) {
+          throw modelRefreshTimedOutError(requestedModelId);
+        }
+        if (readAcpFailureCategory(error62) === "model-unavailable") throw error62;
+        throw modelRefreshFailedError(requestedModelId, error62);
+      } finally {
+        if (timer !== void 0) clearTimeout(timer);
+      }
+    }
+    return applyOnce(input2.state, input2.acpSessionId, input2.setup, false);
   };
   const startOnce = async (expectedGeneration) => {
     const initializePayload = acpInitializePayload(options.clientInfo, options.clientCapabilities);
@@ -26529,12 +26696,17 @@ function createExecutorSession({
         categories: unhandledCategories
       });
     }
-    const nextModelSelectionState = await applyRequestedModel({
-      state: modelSelectionStateFromSetup(setup),
+    const openedSetup = setup;
+    const appliedModel = await applyRequestedModel({
+      state: modelSelectionStateFromSetup(openedSetup),
       acpSessionId: nextSessionId,
+      setup: openedSetup,
       requestedModelId: options.requestedModelId,
       expectedGeneration
     });
+    nextSessionId = appliedModel.sessionId;
+    setup = appliedModel.setup;
+    const nextModelSelectionState = appliedModel.state;
     await applyRequestedEffort({
       connection,
       log: options.log,
@@ -27069,7 +27241,6 @@ function createAcpExecutor(options) {
       currentModelId: void 0,
       advertisedModelValues: []
     },
-    lastUnmatchedModelId: void 0,
     initializeResult: void 0,
     startResult: void 0,
     startInFlight: void 0,
@@ -27724,7 +27895,9 @@ import * as NodeOS2 from "node:os";
 import * as NodePath3 from "node:path";
 import {
   describeExecutorSpawnFailure,
+  ExecutorSpawnAbortedError,
   ExecutorSpawnRefusedError,
+  raceAbort,
   REASONING_OPTION_LABEL
 } from "@ycodium-ai/plugin-api/executor";
 import { nodeStreamsFromHandle } from "@ycodium-ai/plugin-api/process-stdin";
@@ -27807,22 +27980,28 @@ async function probeAcpModelsViaSession(input2) {
       args: tokenizeLaunchArgs(recipe.launchArgs),
       cwd: probeCwd,
       owner: { bindingId: host.bindingId },
-      ...Object.keys(env).length > 0 ? { env } : {}
+      ...Object.keys(env).length > 0 ? { env } : {},
+      ...input2.signal === void 0 ? {} : { signal: input2.signal }
     });
   } catch (error62) {
-    if (error62 instanceof ExecutorSpawnRefusedError) throw error62;
+    if (error62 instanceof ExecutorSpawnRefusedError || error62 instanceof ExecutorSpawnAbortedError) {
+      throw error62;
+    }
     return { kind: "not-started", ...describeExecutorSpawnFailure(error62) };
   }
   let handshake;
   try {
     const { readable, writable } = nodeStreamsFromHandle(handle);
-    handshake = await openAcpProbeHandshake({
-      readable,
-      writable,
-      clientInfo: CLIENT_INFO,
-      requestTimeoutMs: PROBE_REQUEST_TIMEOUT_MS
-    });
-    const setup = await probeSessionSetup(handshake, probeCwd);
+    handshake = await raceAbort(
+      openAcpProbeHandshake({
+        readable,
+        writable,
+        clientInfo: CLIENT_INFO,
+        requestTimeoutMs: PROBE_REQUEST_TIMEOUT_MS
+      }),
+      input2.signal
+    );
+    const setup = await raceAbort(probeSessionSetup(handshake, probeCwd), input2.signal);
     return {
       kind: "answered",
       version: acpAgentVersion(handshake.initializeResult),
@@ -27847,6 +28026,43 @@ async function probeAcpModelsViaSession(input2) {
     await handle.kill("SIGTERM").catch(() => void 0);
   }
 }
+async function probeAcpAgentVersion(input2) {
+  if (input2.recipe.binaryPath.length === 0) return null;
+  const probeCwd = acpProbeSessionCwd(input2.host.instanceId);
+  try {
+    NodeFS2.mkdirSync(probeCwd, { recursive: true });
+  } catch {
+    return null;
+  }
+  let handle;
+  try {
+    handle = await input2.host.process.spawn({
+      program: input2.recipe.binaryPath,
+      args: tokenizeLaunchArgs(input2.recipe.launchArgs),
+      cwd: probeCwd,
+      owner: { bindingId: input2.host.bindingId },
+      ...Object.keys(input2.env).length > 0 ? { env: input2.env } : {}
+    });
+  } catch {
+    return null;
+  }
+  let handshake;
+  try {
+    const { readable, writable } = nodeStreamsFromHandle(handle);
+    handshake = await openAcpProbeHandshake({
+      readable,
+      writable,
+      clientInfo: CLIENT_INFO,
+      requestTimeoutMs: PROBE_REQUEST_TIMEOUT_MS
+    });
+    return acpAgentVersion(handshake.initializeResult);
+  } catch {
+    return acpAgentVersion(handshake?.initializeResult);
+  } finally {
+    await handshake?.close().catch(() => void 0);
+    await handle.kill("SIGTERM").catch(() => void 0);
+  }
+}
 
 // src/runtimeModeApproval.ts
 function acpRuntimeModeAutoApproves(runtimeMode, toolKind) {
@@ -27956,7 +28172,7 @@ var createAcpInstance = (config2, host) => {
     events.close();
   });
   const instance = {
-    probe: async () => {
+    probe: async (signal) => {
       if (recipe.binaryPath.length === 0) {
         return {
           installed: false,
@@ -27966,8 +28182,17 @@ var createAcpInstance = (config2, host) => {
           detail: "ACP program path is not configured"
         };
       }
+      if (signal?.aborted) throw new Error("aborted");
       const env = buildSpawnEnv(recipe, recipe.homePath);
-      const outcome = await probeAcpModelsViaSession({ recipe, host, env });
+      const outcome = await raceAbort2(
+        probeAcpModelsViaSession({
+          recipe,
+          host,
+          env,
+          ...signal === void 0 ? {} : { signal }
+        }),
+        signal
+      );
       switch (outcome.kind) {
         case "not-started":
           return {
@@ -28007,6 +28232,11 @@ var createAcpInstance = (config2, host) => {
           };
       }
     },
+    readCliVersion: () => recipe.binaryPath.length === 0 ? Promise.resolve(null) : probeAcpAgentVersion({
+      recipe,
+      host,
+      env: buildSpawnEnv(recipe, recipe.homePath)
+    }),
     // 暂不处理 input.readOnlyDirectories（有意为之）：acp 经共享的 ycodium-acp-executor 起会话，
     // 还没用真机确认这家 CLI 对 cwd 之外的读怎么处理、要不要放行。确认之后再接这一栏。
     startSession: async (input2, signal) => {
@@ -28220,7 +28450,7 @@ var executors = [
 ];
 var index_default = definePlugin({
   id: "agent-acp",
-  apiVersion: 30,
+  apiVersion: 32,
   executors,
   activate(ctx) {
     ctx.log.info("generic ACP executor ready");

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ycodium-ai/agent-acp",
-  "version": "0.2.3254",
+  "version": "0.2.3272",
   "description": "Generic ACP executor: user-supplied CLI over Agent Client Protocol stdio.",
   "keywords": [
     "ycodium",
@@ -21,9 +21,9 @@
     "@types/node": "24.12.4",
     "esbuild": "0.28.1",
     "vite-plus": "0.2.2",
-    "ycodium-acp-executor": "0.2.3254",
-    "ycodium-executor-testing": "0.0.0",
-    "@ycodium-ai/plugin-api": "0.2.3254"
+    "@ycodium-ai/plugin-api": "0.2.3272",
+    "ycodium-acp-executor": "0.2.0",
+    "ycodium-executor-testing": "0.0.0"
   },
   "ycodium": {
     "plugin": "./dist/index.js",