@ycodium-ai/agent-kimi 0.2.3252 → 0.2.3265

package/dist/index.js

@@ -93,7 +93,11 @@ var KIMI_CARD = {
 // src/kimiInstance.ts
 import * as NodeOS5 from "node:os";
 import * as NodePath7 from "node:path";
-import { mergeLaunchEnv, modelSelectionStringOption } from "@ycodium-ai/plugin-api/executor";
+import {
+  mergeLaunchEnv,
+  modelSelectionStringOption,
+  raceAbort
+} from "@ycodium-ai/plugin-api/executor";
 import { nodeStreamsFromHandle } from "@ycodium-ai/plugin-api/process-stdin";
 
 // ../../packages/ycodium-acp-executor/src/executor.ts
@@ -25126,11 +25130,15 @@ function createAcpConnection(options) {
     });
   };
   const close = (error62) => shutdown(error62 ?? new AcpConnectionClosedError());
+  const abandonPending = (error62) => {
+    rejectPending(error62);
+  };
   return {
     request,
     begin,
     notify,
     awaitInboundIdle,
+    abandonPending,
     close,
     closed
   };
@@ -25596,10 +25604,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
     });
@@ -25683,12 +25692,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()) {
@@ -25699,7 +25728,7 @@ function createExecutorPrompt({
       let written = false;
       try {
         response = await sendPromptRpc(
-          started.sessionId,
+          sessionId,
           promptParts,
           () => {
             written = true;
@@ -25749,7 +25778,7 @@ function createExecutorPrompt({
     if (hooks.readContextWindow !== void 0) {
       try {
         contextWindow = await hooks.readContextWindow({
-          sessionId: started.sessionId,
+          sessionId,
           promptResponse: response
         }) ?? void 0;
       } catch {
@@ -26392,6 +26421,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);
@@ -26440,43 +26519,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");
+    }
+    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 (value === input2.state.currentModelId) {
-      return input2.state;
+    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);
@@ -26545,12 +26712,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,
@@ -27085,7 +27257,6 @@ function createAcpExecutor(options) {
       currentModelId: void 0,
       advertisedModelValues: []
     },
-    lastUnmatchedModelId: void 0,
     initializeResult: void 0,
     startResult: void 0,
     startInFlight: void 0,
@@ -28220,6 +28391,7 @@ var createKimiTokenReader = (input2) => {
 // src/kimiModels.ts
 import {
   describeExecutorSpawnFailure,
+  ExecutorSpawnAbortedError,
   ExecutorSpawnRefusedError,
   REASONING_OPTION_LABEL,
   reasoningEffortShortLabel
@@ -28300,10 +28472,13 @@ async function probeKimiModels(input2) {
       args: KIMI_MODEL_LIST_ARGS,
       cwd: process.cwd(),
       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) };
   }
   try {
@@ -28329,14 +28504,15 @@ async function probeKimiModels(input2) {
   }
 }
 async function probeKimiVersion(input2) {
-  const { recipe, host, env } = input2;
+  const { recipe, host, env, signal } = input2;
   return probeCliVersion({
     spawn: () => host.process.spawn({
       program: recipe.binaryPath,
       args: ["--version"],
       cwd: process.cwd(),
       owner: { bindingId: host.bindingId },
-      ...Object.keys(env).length > 0 ? { env } : {}
+      ...Object.keys(env).length > 0 ? { env } : {},
+      ...signal === void 0 ? {} : { signal }
     }),
     timeoutMs: PROBE_TIMEOUT_MS
   });
@@ -28522,7 +28698,7 @@ var createKimiInstance = (config2, host) => {
     events.close();
   });
   const instance = {
-    probe: async () => {
+    probe: async (signal) => {
       if (recipe.binaryPath.length === 0) {
         return {
           installed: false,
@@ -28532,8 +28708,12 @@ var createKimiInstance = (config2, host) => {
           detail: "Kimi Code program path is not configured"
         };
       }
+      if (signal?.aborted) throw new Error("aborted");
       const env = buildSpawnEnv(recipe, recipe.homePath);
-      const outcome = await probeKimi({ recipe, host, env });
+      const outcome = await raceAbort(
+        probeKimi({ recipe, host, env, ...signal === void 0 ? {} : { signal } }),
+        signal
+      );
       const auth = () => {
         switch (readKimiAuthState(resolveHomePath(recipe))) {
           case "signed-in":
@@ -28583,6 +28763,7 @@ var createKimiInstance = (config2, host) => {
           };
       }
     },
+    readCliVersion: () => recipe.binaryPath.length === 0 ? Promise.resolve(null) : probeKimiVersion({ recipe, host, env: buildSpawnEnv(recipe, recipe.homePath) }),
     // 暂不处理 input.readOnlyDirectories（有意为之）：kimi 经共享的 ycodium-acp-executor 起会话，
     // 还没用真机确认这家 CLI 对 cwd 之外的读怎么处理、要不要放行。确认之后再接这一栏。
     startSession: async (input2, signal) => {
@@ -28824,7 +29005,7 @@ var executors = [
 ];
 var index_default = definePlugin({
   id: "agent-kimi",
-  apiVersion: 29,
+  apiVersion: 31,
   executors,
   activate(ctx) {
     ctx.log.info("Kimi Code executor ready");

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ycodium-ai/agent-kimi",
-  "version": "0.2.3252",
+  "version": "0.2.3265",
   "description": "Kimi Code executor: runs `kimi acp` 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-ai/plugin-api": "0.2.3252",
-    "ycodium-executor-testing": "0.0.0",
-    "ycodium-acp-executor": "0.2.3252"
+    "@ycodium-ai/plugin-api": "0.2.3265",
+    "ycodium-acp-executor": "0.2.3265",
+    "ycodium-executor-testing": "0.0.0"
   },
   "ycodium": {
     "plugin": "./dist/index.js",