@ycodium-ai/agent-kimi 0.2.2634 → 0.2.2664

package/dist/index.js

@@ -23521,11 +23521,21 @@ var AcpExecutorRequestError = class extends AcpExecutorError {
   }
 };
 var AcpConnectionClosedError = class extends Error {
-  constructor(message = "ACP connection closed") {
-    super(message);
+  constructor(message = "ACP connection closed", options) {
+    super(message, options);
     this.name = "AcpConnectionClosedError";
   }
 };
+async function withStartupStderr(error62, stderrTail) {
+  if (!(error62 instanceof AcpConnectionClosedError) || stderrTail === void 0) return error62;
+  const tail = await stderrTail();
+  if (tail.length === 0) return error62;
+  return new AcpConnectionClosedError(`${error62.message}
+Agent stderr (last lines):
+${tail}`, {
+    cause: error62
+  });
+}
 
 // ../../packages/ycodium-acp-executor/src/jsonrpc.ts
 function isRecord2(value) {
@@ -24800,7 +24810,7 @@ function extractModelConfigId(sessionResponse) {
       return opt.id.trim();
     }
   }
-  return void 0;
+  return configOptions.find((opt) => opt.id.trim() === "model" && opt.type === "select") ? "model" : void 0;
 }
 function findSessionConfigOption(configOptions, configId) {
   if (!configOptions) {
@@ -25197,6 +25207,13 @@ function readAcpText(source, key) {
   const trimmed = value.trim();
   return trimmed.length > 0 ? trimmed : void 0;
 }
+function textFromContentBlocks(blocks) {
+  const parts = blocks.flatMap(
+    (block) => isRecord5(block) && block["type"] === "text" && typeof block["text"] === "string" ? [block["text"]] : []
+  );
+  const joined = parts.join("");
+  return joined.trim().length > 0 ? joined : void 0;
+}
 function parseSessionUpdateEvent(params) {
   const upd = params.update;
   const events = [];
@@ -25280,6 +25297,28 @@ function parseSessionUpdateEvent(params) {
       }
       break;
     }
+    case "compaction_update": {
+      const compactionId = readAcpText(upd, "compactionId");
+      const status = readAcpText(upd, "status");
+      if (compactionId === void 0 || status === void 0) break;
+      const rawSummary = upd["summary"];
+      events.push({
+        _tag: "CompactionUpdated",
+        compactionId,
+        status,
+        summary: rawSummary === void 0 ? void 0 : Array.isArray(rawSummary) ? textFromContentBlocks(rawSummary) ?? null : null,
+        error: readAcpText(upd, "error")
+      });
+      break;
+    }
+    case "compaction_summary_chunk": {
+      const compactionId = readAcpText(upd, "compactionId");
+      const content = isRecord5(upd["content"]) ? upd["content"] : void 0;
+      const text = content?.["type"] === "text" ? content["text"] : void 0;
+      if (compactionId === void 0 || typeof text !== "string" || text.length === 0) break;
+      events.push({ _tag: "CompactionSummaryChunk", compactionId, text });
+      break;
+    }
     default:
       break;
   }
@@ -25376,6 +25415,97 @@ function createAcpExecutor(options) {
     if (settledPromptKeys.length > SETTLED_PROMPT_KEY_LIMIT) settledPromptKeys.shift();
   };
   const toolCalls = /* @__PURE__ */ new Map();
+  const compactions = /* @__PURE__ */ new Map();
+  let manualCompaction;
+  const COMPACTION_SUMMARY_MAX_CHARS = 8e3;
+  const nowMs = () => options.nowMs?.() ?? Date.now();
+  const emitCompactionState = (record2, state) => {
+    const summary = record2.summary?.trim() ?? "";
+    const truncated = summary.length > COMPACTION_SUMMARY_MAX_CHARS;
+    emit({
+      type: "thread.state.changed",
+      ...stamp(),
+      provider: options.provider,
+      threadId: options.threadId,
+      ...activeTurnId !== void 0 ? { turnId: activeTurnId } : {},
+      payload: {
+        state,
+        compaction: {
+          compactionId: record2.snapshotId,
+          trigger: record2.trigger,
+          ...state === "compacted" ? { durationMs: Math.max(0, nowMs() - record2.startedAtMs) } : {},
+          ...summary.length > 0 ? {
+            summary: truncated ? summary.slice(0, COMPACTION_SUMMARY_MAX_CHARS) : summary,
+            ...truncated ? { summaryTruncated: true } : {}
+          } : {}
+        }
+      }
+    });
+  };
+  const applyCompactionUpdate = (event) => {
+    let record2 = compactions.get(event.compactionId);
+    if (record2 === void 0) {
+      if (manualCompaction !== void 0 && !manualCompaction.adopted) {
+        manualCompaction.adopted = true;
+        record2 = manualCompaction;
+      } else {
+        record2 = {
+          snapshotId: randomId(),
+          trigger: "automatic",
+          startedAtMs: nowMs(),
+          summary: void 0,
+          announced: false,
+          finished: false,
+          adopted: false
+        };
+      }
+      compactions.set(event.compactionId, record2);
+    }
+    if (event.summary !== void 0) record2.summary = event.summary ?? void 0;
+    switch (event.status) {
+      case "in_progress":
+        if (!record2.announced) {
+          record2.announced = true;
+          emitCompactionState(record2, "compacting");
+        }
+        return;
+      case "completed":
+        record2.announced = true;
+        record2.finished = true;
+        compactions.delete(event.compactionId);
+        emitCompactionState(record2, "compacted");
+        return;
+      case "failed":
+      case "cancelled":
+        record2.finished = true;
+        compactions.delete(event.compactionId);
+        emit({
+          type: "runtime.warning",
+          ...stamp(),
+          provider: options.provider,
+          threadId: options.threadId,
+          ...activeTurnId !== void 0 ? { turnId: activeTurnId } : {},
+          payload: {
+            message: event.error ?? `Context compaction ${event.status}`,
+            detail: { code: `context-compaction-${event.status}` }
+          }
+        });
+        return;
+      default:
+        return;
+    }
+  };
+  const shownToolCallIds = /* @__PURE__ */ new Set();
+  const SHOWN_TOOL_CALL_LIMIT = 256;
+  const rememberShownToolCall = (toolCallId) => {
+    shownToolCallIds.add(toolCallId);
+    if (shownToolCallIds.size <= SHOWN_TOOL_CALL_LIMIT) return;
+    for (const id of shownToolCallIds) {
+      if (toolCalls.has(id)) continue;
+      shownToolCallIds.delete(id);
+      return;
+    }
+  };
   let assistantSegment = { nextSegmentIndex: 0 };
   let modeState;
   let availableCommands = [];
@@ -25462,7 +25592,6 @@ function createAcpExecutor(options) {
     }
     for (const event of parsed.events) {
       if (event._tag === "ToolCallUpdated") {
-        closeActiveAssistantSegment(activeTurnId);
         const tracked = toolCalls.get(event.toolCall.toolCallId);
         const previous = tracked?.state;
         const nextToolCall = mergeToolCallState(previous, event.toolCall);
@@ -25481,9 +25610,35 @@ function createAcpExecutor(options) {
             skippedSinceEmit: decision.skippedSinceEmit
           });
         }
-        if (!decision.emit) {
+        const hookResult = hooks.onToolCallUpdated?.({
+          toolCallId: nextToolCall.toolCallId,
+          status: nextToolCall.status,
+          title: nextToolCall.title,
+          kind: nextToolCall.kind,
+          rawInput: nextToolCall.data["rawInput"],
+          rawOutput: nextToolCall.data["rawOutput"],
+          meta: params.update._meta,
+          turnId: activeTurnId
+        });
+        const taskEvents = hookResult === void 0 ? [] : "events" in hookResult ? hookResult.events : hookResult;
+        const handledByHook = hookResult !== void 0 && "events" in hookResult && hookResult.handled === true;
+        for (const taskEvent of taskEvents) {
+          emit({
+            type: taskEvent.type,
+            ...stamp(),
+            provider: options.provider,
+            threadId: options.threadId,
+            ...taskEvent.turnId !== void 0 ? { turnId: taskEvent.turnId } : {},
+            payload: taskEvent.payload
+          });
+        }
+        if (handledByHook || !decision.emit) {
           continue;
         }
+        if (!shownToolCallIds.has(nextToolCall.toolCallId)) {
+          rememberShownToolCall(nextToolCall.toolCallId);
+          closeActiveAssistantSegment(activeTurnId);
+        }
         emit(
           makeAcpToolCallEvent({
             stamp: stamp(),
@@ -25496,7 +25651,21 @@ function createAcpExecutor(options) {
         );
         continue;
       }
+      if (event._tag === "CompactionUpdated") {
+        applyCompactionUpdate(event);
+        continue;
+      }
+      if (event._tag === "CompactionSummaryChunk") {
+        const record2 = compactions.get(event.compactionId);
+        if (record2 !== void 0 && !record2.finished) {
+          record2.summary = (record2.summary ?? "") + event.text;
+        }
+        continue;
+      }
       if (event._tag === "ContentDelta") {
+        if (manualCompaction !== void 0) {
+          continue;
+        }
         if (event.streamKind === "reasoning_text") {
           if (event.text.trim().length === 0) {
             continue;
@@ -25739,7 +25908,9 @@ function createAcpExecutor(options) {
     },
     onNotification: (notification) => {
       if (notification.method === "session/update") {
-        handleSessionUpdate(notification.params);
+        const params = notification.params;
+        const transformed = hooks.transformSessionUpdate ? hooks.transformSessionUpdate(params) : params;
+        if (transformed !== void 0) handleSessionUpdate(transformed);
         return;
       }
       if (settleFromNotification(notification.method, notification.params)) return;
@@ -25873,13 +26044,15 @@ function createAcpExecutor(options) {
       options.mcpServers ?? [],
       initialized.agentCapabilities
     );
+    const additionalDirectories = options.additionalDirectories !== void 0 && options.additionalDirectories.length > 0 ? { additionalDirectories: options.additionalDirectories } : {};
     let setup;
     let nextSessionId;
     if (options.resumeSessionId && options.resumeMethod === "session/resume") {
       setup = await connection.request("session/resume", {
         sessionId: options.resumeSessionId,
         cwd: options.cwd,
-        mcpServers
+        mcpServers,
+        ...additionalDirectories
       });
       nextSessionId = options.resumeSessionId;
     } else if (options.resumeSessionId) {
@@ -25888,7 +26061,8 @@ function createAcpExecutor(options) {
         setup = await connection.request("session/load", {
           sessionId: options.resumeSessionId,
           cwd: options.cwd,
-          mcpServers
+          mcpServers,
+          ...additionalDirectories
         });
       } finally {
         sessionLoadInFlight = false;
@@ -25901,7 +26075,8 @@ function createAcpExecutor(options) {
     } else {
       const created = await connection.request("session/new", {
         cwd: options.cwd,
-        mcpServers
+        mcpServers,
+        ...additionalDirectories
       });
       nextSessionId = created.sessionId;
       setup = created;
@@ -25975,13 +26150,13 @@ function createAcpExecutor(options) {
         startInFlight = void 0;
         return result;
       },
-      (error62) => {
+      async (error62) => {
         startInFlight = void 0;
         if (isLive(expectedGeneration) && !startResult) {
           status = "idle";
           generation = expectedGeneration;
         }
-        throw error62;
+        throw await withStartupStderr(error62, options.stderrTail);
       }
     );
     return startInFlight;
@@ -26049,6 +26224,36 @@ function createAcpExecutor(options) {
       interruptedTurnIds.delete(input2.turnId);
     }
   };
+  const sendPromptRpc = async (sessionId2, promptParts) => {
+    const settlementHooks = hooks.promptSettlement;
+    const promptKey = settlementHooks === void 0 ? void 0 : randomId();
+    const promptRpc = connection.request("session/prompt", {
+      sessionId: sessionId2,
+      prompt: promptParts,
+      ...settlementHooks !== void 0 && promptKey !== void 0 ? settlementHooks.requestFields(promptKey) : {}
+    });
+    if (settlementHooks === void 0 || promptKey === void 0) {
+      return await promptRpc;
+    } else {
+      const { promise: early, resolve: settleEarly } = Promise.withResolvers();
+      pendingSettlement = { promptKey, sessionId: sessionId2, settle: settleEarly };
+      try {
+        const outcome = await Promise.race([
+          promptRpc.then((value) => {
+            const key = settlementHooks.responseKey?.(value);
+            if (key !== void 0) rememberSettledPromptKey(key);
+            return { response: value };
+          }),
+          early
+        ]);
+        if (outcome.error !== void 0) throw outcome.error;
+        return outcome.response;
+      } finally {
+        pendingSettlement = void 0;
+        void promptRpc.catch(() => void 0);
+      }
+    }
+  };
   const prompt = async (input2) => {
     failIfDisposed();
     const started = requireStarted();
@@ -26099,35 +26304,8 @@ function createAcpExecutor(options) {
         expectedGeneration: started.generation
       });
       closeActiveAssistantSegment(turnId);
-      const settlementHooks = hooks.promptSettlement;
-      const promptKey = settlementHooks === void 0 ? void 0 : randomId();
-      const promptRpc = connection.request("session/prompt", {
-        sessionId: started.sessionId,
-        prompt: promptParts,
-        ...settlementHooks !== void 0 && promptKey !== void 0 ? settlementHooks.requestFields(promptKey) : {}
-      });
       try {
-        if (settlementHooks === void 0 || promptKey === void 0) {
-          response = await promptRpc;
-        } else {
-          const { promise: early, resolve: settleEarly } = Promise.withResolvers();
-          pendingSettlement = { promptKey, sessionId: started.sessionId, settle: settleEarly };
-          try {
-            const outcome = await Promise.race([
-              promptRpc.then((value) => {
-                const key = settlementHooks.responseKey?.(value);
-                if (key !== void 0) rememberSettledPromptKey(key);
-                return { response: value };
-              }),
-              early
-            ]);
-            if (outcome.error !== void 0) throw outcome.error;
-            response = outcome.response;
-          } finally {
-            pendingSettlement = void 0;
-            void promptRpc.catch(() => void 0);
-          }
-        }
+        response = await sendPromptRpc(started.sessionId, promptParts);
       } catch (error62) {
         if (disposed) {
           throw new AcpExecutorDisposedError();
@@ -26291,6 +26469,74 @@ function createAcpExecutor(options) {
     };
     apply();
   };
+  const compact = async (input2) => {
+    failIfDisposed();
+    const started = requireStarted();
+    const trimmedName = input2.commandName.trim();
+    const commandName = trimmedName.startsWith("/") ? trimmedName.slice(1) : trimmedName;
+    if (!availableCommands.some((command) => command.name === commandName)) {
+      throw new AcpExecutorError(
+        "command-unavailable",
+        `The agent has not advertised the /${commandName} command`
+      );
+    }
+    if (promptsInFlight > 0 || promptMutex.isLocked || manualCompaction !== void 0) {
+      throw new AcpExecutorError(
+        "busy",
+        "Cannot compact while a turn or another compaction is running"
+      );
+    }
+    const record2 = {
+      snapshotId: randomId(),
+      trigger: "manual",
+      startedAtMs: nowMs(),
+      summary: void 0,
+      announced: true,
+      finished: false,
+      adopted: false
+    };
+    await promptMutex.acquire();
+    manualCompaction = record2;
+    const emitSessionState = (state) => {
+      emit({
+        type: "session.state.changed",
+        ...stamp(),
+        provider: options.provider,
+        threadId: options.threadId,
+        payload: { state, reason: "compaction" }
+      });
+    };
+    try {
+      failIfDisposed();
+      emitSessionState("compacting");
+      emitCompactionState(record2, "compacting");
+      let response;
+      try {
+        response = await sendPromptRpc(started.sessionId, [
+          { type: "text", text: `/${commandName}` }
+        ]);
+      } catch (error62) {
+        if (disposed) throw new AcpExecutorDisposedError();
+        throw error62;
+      }
+      await connection.awaitInboundIdle();
+      if (response.stopReason === "cancelled") {
+        return;
+      }
+      if (!record2.finished) {
+        record2.finished = true;
+        emitCompactionState(record2, "compacted");
+      }
+    } finally {
+      for (const [agentId, tracked] of compactions) {
+        if (tracked === record2) compactions.delete(agentId);
+      }
+      manualCompaction = void 0;
+      promptMutex.release();
+      notifyPromptSettled();
+      if (!disposed) emitSessionState("ready");
+    }
+  };
   const setNativeMode = async (modeId) => {
     failIfDisposed();
     const started = startResult;
@@ -26378,6 +26624,7 @@ function createAcpExecutor(options) {
     respondToRequest,
     respondToUserInput,
     setNativeMode,
+    compact,
     dispose
   };
 }
@@ -26572,6 +26819,11 @@ function tokenizeLaunchArgs(value) {
 import * as NodeFS from "node:fs";
 import * as NodePath from "node:path";
 var KIMI_USER_INPUT_TITLES = /* @__PURE__ */ new Set(["AskUserQuestion", "ExitPlanMode"]);
+var KIMI_PLAN_ACTIONS = {
+  plan_approve: "approve",
+  plan_revise: "revise",
+  plan_reject_and_exit: "stop"
+};
 var isRecord7 = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
 function questionTextFromContent(content) {
   if (!Array.isArray(content)) return "";
@@ -26588,6 +26840,7 @@ function questionTextFromContent(content) {
 function kimiPermissionUserInput(request) {
   const title = request.toolCall.title;
   if (typeof title !== "string" || !KIMI_USER_INPUT_TITLES.has(title)) return void 0;
+  const isPlan = title === "ExitPlanMode";
   const ids = new Set(request.options.map((option) => option.optionId));
   if (request.options.length === 0 || ids.size !== request.options.length) {
     throw new Error("Kimi interaction must provide distinct response options.");
@@ -26600,14 +26853,18 @@ function kimiPermissionUserInput(request) {
     id: request.toolCall.toolCallId,
     header: title,
     question,
-    kind: title === "ExitPlanMode" ? "plan" : "question",
+    kind: isPlan ? "plan" : "question",
     allowFreeform: false,
     multiSelect: false,
-    options: request.options.map((option) => ({
-      id: option.optionId,
-      label: option.name,
-      description: ""
-    }))
+    options: request.options.map((option) => {
+      const planAction = isPlan ? KIMI_PLAN_ACTIONS[option.optionId] : void 0;
+      return {
+        id: option.optionId,
+        label: option.name,
+        description: "",
+        ...planAction !== void 0 ? { planAction } : {}
+      };
+    })
   };
 }
 var WIRE_LOG_SEGMENTS = ["agents", "main", "wire.jsonl"];
@@ -26716,6 +26973,7 @@ function readKimiAuthState(resolvedHomePath) {
 
 // src/kimiModels.ts
 import {
+  describeExecutorSpawnFailure,
   ExecutorSpawnRefusedError
 } from "@ycodium-ai/plugin-api/executor";
 
@@ -26775,7 +27033,7 @@ async function probeKimiModels(input2) {
     });
   } catch (error62) {
     if (error62 instanceof ExecutorSpawnRefusedError) throw error62;
-    return { kind: "not-started", detail: probeFailureDetail(error62) };
+    return { kind: "not-started", ...describeExecutorSpawnFailure(error62) };
   }
   try {
     const run = await collectProbeProcess(handle, {
@@ -26816,7 +27074,7 @@ async function probeKimi(input2) {
   const [listed, version2] = await Promise.all([probeKimiModels(input2), probeKimiVersion(input2)]);
   switch (listed.kind) {
     case "not-started":
-      return { kind: "not-started", detail: listed.detail };
+      return { kind: "not-started", readiness: listed.readiness, detail: listed.detail };
     case "failed":
       return { kind: "failed", detail: listed.detail, version: version2 };
     case "answered":
@@ -26952,7 +27210,7 @@ var createKimiInstance = (config2, host) => {
         return {
           installed: false,
           version: null,
-          readiness: "error",
+          readiness: "not-installed",
           auth: { status: "unknown" },
           detail: "Kimi Code program path is not configured"
         };
@@ -26974,7 +27232,7 @@ var createKimiInstance = (config2, host) => {
           return {
             installed: false,
             version: null,
-            readiness: "error",
+            readiness: outcome.readiness,
             auth: { status: "unknown" },
             ...outcome.detail === void 0 ? {} : { detail: outcome.detail }
           };
@@ -27031,7 +27289,7 @@ var createKimiInstance = (config2, host) => {
         owner: { bindingId: host.bindingId },
         ...Object.keys(env).length > 0 ? { env } : {}
       });
-      const { readable, writable } = nodeStreamsFromHandle(handle);
+      const { readable, writable, stderrTail } = nodeStreamsFromHandle(handle);
       const resume = input2.discardResumeCursor === true ? void 0 : parseAcpResumeCursor(input2.resumeCursor, RESUME_SCHEMA_VERSION);
       const requestedModelId = modelIdFromSelection(input2.modelSelection);
       const requestedEffort = modelSelectionStringOption(
@@ -27046,6 +27304,7 @@ var createKimiInstance = (config2, host) => {
       const executor = createAcpExecutor({
         readable,
         writable,
+        stderrTail,
         ...requestedEffort === void 0 ? {} : { requestedEffort },
         cwd,
         threadId: input2.threadId,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ycodium-ai/agent-kimi",
-  "version": "0.2.2634",
+  "version": "0.2.2664",
   "description": "Kimi Code executor: runs `kimi acp` over Agent Client Protocol stdio.",
   "keywords": [
     "ycodium",
@@ -21,8 +21,8 @@
     "@types/node": "24.12.4",
     "esbuild": "0.28.1",
     "vite-plus": "0.2.2",
-    "@ycodium-ai/plugin-api": "0.2.2634",
-    "ycodium-acp-executor": "0.2.2634",
+    "@ycodium-ai/plugin-api": "0.2.2664",
+    "ycodium-acp-executor": "0.2.2664",
     "ycodium-executor-testing": "0.0.0"
   },
   "ycodium": {