@ycodium-ai/agent-acp 0.2.1991 → 0.2.2014

package/dist/index.js

@@ -24996,6 +24996,11 @@ var defaultVendorHooks = {
 
 // ../../packages/ycodium-acp-executor/src/executor.ts
 var DEFAULT_CANCEL_GRACE_MS = 5e3;
+var userInputAnswerOptionId = (question, answers) => {
+  const answer = answers[question.id];
+  const selected = typeof answer === "string" ? answer : Array.isArray(answer) && answer.length === 1 && typeof answer[0] === "string" ? answer[0] : void 0;
+  return selected !== void 0 && question.options.some((option) => option.id === selected) ? selected : void 0;
+};
 function defaultNowIso() {
   return (/* @__PURE__ */ new Date()).toISOString();
 }
@@ -25046,6 +25051,14 @@ function createAcpExecutor(options) {
     singleResolver: false
   });
   const pendingUserInputs = /* @__PURE__ */ new Map();
+  let pendingSettlement;
+  const settledPromptKeys = [];
+  const SETTLED_PROMPT_KEY_LIMIT = 32;
+  const rememberSettledPromptKey = (key) => {
+    if (settledPromptKeys.includes(key)) return;
+    settledPromptKeys.push(key);
+    if (settledPromptKeys.length > SETTLED_PROMPT_KEY_LIMIT) settledPromptKeys.shift();
+  };
   const toolCalls = /* @__PURE__ */ new Map();
   let assistantSegment = { nextSegmentIndex: 0 };
   let modeState;
@@ -25221,10 +25234,118 @@ function createAcpExecutor(options) {
       emitResolved(entry, decision);
     }
   };
+  const emitUserInputResolved = (pending, answers) => {
+    emit({
+      type: "user-input.resolved",
+      ...stamp(),
+      provider: options.provider,
+      threadId: options.threadId,
+      ...pending.turnId !== void 0 ? { turnId: pending.turnId } : {},
+      requestId: pending.requestId,
+      payload: { answers }
+    });
+  };
+  const abortPendingSettlement = (reason) => {
+    const waiting = pendingSettlement;
+    if (waiting === void 0) return;
+    pendingSettlement = void 0;
+    waiting.settle({ error: new AcpExecutorRequestError("session/prompt", reason) });
+  };
+  const settleAllUserInputs = () => {
+    for (const pending of pendingUserInputs.values()) {
+      if (pending.settled) continue;
+      pending.settled = true;
+      pending.resolve({ kind: "cancelled" });
+    }
+    pendingUserInputs.clear();
+  };
+  const settleFromNotification = (method, params) => {
+    const hook = hooks.promptSettlement;
+    if (hook === void 0 || pendingSettlement === void 0) return false;
+    const signal = hook.fromNotification(method, params);
+    if (signal === void 0) return false;
+    const waiting = pendingSettlement;
+    if (signal.sessionId !== waiting.sessionId) return false;
+    if (signal.promptKey !== void 0 && signal.promptKey !== waiting.promptKey) {
+      return settledPromptKeys.includes(signal.promptKey);
+    }
+    pendingSettlement = void 0;
+    rememberSettledPromptKey(waiting.promptKey);
+    if (signal.outcome === "error") {
+      waiting.settle({
+        error: new AcpExecutorRequestError(
+          "session/prompt",
+          signal.detail ?? "prompt failed without an error detail"
+        )
+      });
+    } else {
+      waiting.settle({
+        response: { stopReason: signal.stopReason ?? "end_turn" }
+      });
+    }
+    return true;
+  };
+  const askUserInput = async (input2) => {
+    failIfDisposed();
+    const requestId = randomId();
+    const { promise: settlement, resolve: settle2 } = Promise.withResolvers();
+    const pending = {
+      requestId,
+      questions: input2.questions,
+      turnId: activeTurnId,
+      settled: false,
+      resolve: settle2
+    };
+    pendingUserInputs.set(requestId, pending);
+    emit({
+      type: "user-input.requested",
+      ...stamp(),
+      provider: options.provider,
+      threadId: options.threadId,
+      ...activeTurnId !== void 0 ? { turnId: activeTurnId } : {},
+      requestId,
+      payload: { questions: input2.questions },
+      raw: {
+        source: "acp.jsonrpc",
+        method: input2.method,
+        payload: input2.payload
+      }
+    });
+    const resolution = await settlement;
+    pendingUserInputs.delete(requestId);
+    emitUserInputResolved(pending, resolution.kind === "answered" ? resolution.answers : {});
+    return resolution;
+  };
+  const makeExtensionContext = (method, params) => ({
+    askUserInput: (questions) => askUserInput({ questions, method, payload: params })
+  });
+  const handlePermissionAsUserInput = async (params) => {
+    if (hooks.permissionUserInput === void 0) return void 0;
+    let question;
+    try {
+      question = hooks.permissionUserInput(params);
+    } catch (error62) {
+      throw RequestError.invalidParams({
+        detail: error62 instanceof Error ? error62.message : String(error62)
+      });
+    }
+    if (question === void 0) return void 0;
+    const resolution = await askUserInput({
+      questions: [question],
+      method: CLIENT_METHODS.session_request_permission,
+      payload: params
+    });
+    const optionId = resolution.kind === "answered" ? userInputAnswerOptionId(question, resolution.answers) : void 0;
+    return {
+      outcome: optionId !== void 0 ? { outcome: "selected", optionId } : { outcome: "cancelled" }
+    };
+  };
   const handlePermissionRequest = async (params) => {
     if (!isAcpRequestPermissionParams(params)) {
       throw RequestError.invalidParams({ detail: "Malformed session/request_permission" });
     }
+    const userInputOutcome = await handlePermissionAsUserInput(params);
+    if (userInputOutcome !== void 0) return userInputOutcome;
     const permissionRequest = parsePermissionRequest(params);
     const requestId = randomId();
     const outcome = await new Promise((resolve) => {
@@ -25265,6 +25386,7 @@ function createAcpExecutor(options) {
         handleSessionUpdate(notification.params);
         return;
       }
+      if (settleFromNotification(notification.method, notification.params)) return;
       void hooks.onExtensionNotification?.(notification.method, notification.params);
     },
     onRequest: async (method, params) => {
@@ -25272,7 +25394,12 @@ function createAcpExecutor(options) {
         return handlePermissionRequest(params);
       }
       if (hooks.onExtensionRequest) {
-        return hooks.onExtensionRequest(method, params);
+        const handled = await hooks.onExtensionRequest(
+          method,
+          params,
+          makeExtensionContext(method, params)
+        );
+        if (handled !== void 0) return handled;
       }
       throw RequestError.methodNotFound(method);
     }
@@ -25284,12 +25411,24 @@ function createAcpExecutor(options) {
         return;
       }
       settleAllApprovals("cancel");
+      settleAllUserInputs();
+      abortPendingSettlement("connection closed");
       promptWaiters.splice(0).forEach((wake) => wake());
     },
     () => {
       connectionClosed = true;
     }
   );
+  const onInputDead = () => {
+    if (disposed) {
+      return;
+    }
+    settleAllApprovals("cancel");
+    settleAllUserInputs();
+    promptWaiters.splice(0).forEach((wake) => wake());
+  };
+  options.readable.once("end", onInputDead);
+  options.readable.once("error", onInputDead);
   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) {
@@ -25546,12 +25685,35 @@ 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
+        prompt: promptParts,
+        ...settlementHooks !== void 0 && promptKey !== void 0 ? settlementHooks.requestFields(promptKey) : {}
       });
       try {
-        response = await promptRpc;
+        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);
+          }
+        }
       } catch (error62) {
         if (disposed) {
           throw new AcpExecutorDisposedError();
@@ -25573,6 +25735,17 @@ function createAcpExecutor(options) {
       throw new AcpExecutorError("internal", "ACP prompt settled without a turn id");
     }
     const settledTurnId = turnId;
+    let contextWindow;
+    if (hooks.readContextWindow !== void 0) {
+      try {
+        contextWindow = await hooks.readContextWindow({
+          sessionId: started.sessionId,
+          promptResponse: response
+        }) ?? void 0;
+      } catch {
+        contextWindow = void 0;
+      }
+    }
     const finishPrompt = () => {
       if (interruptedTurnIds.has(settledTurnId)) {
         settleTurn({
@@ -25589,6 +25762,21 @@ function createAcpExecutor(options) {
         };
       }
       const stopReason = hooks.completedStopReason?.(response) ?? response.stopReason;
+      if (contextWindow !== void 0) {
+        emit({
+          type: "thread.token-usage.updated",
+          ...stamp(),
+          provider: options.provider,
+          threadId: options.threadId,
+          turnId: settledTurnId,
+          payload: {
+            usage: {
+              usedTokens: contextWindow.usedTokens,
+              ...contextWindow.maxTokens === void 0 ? {} : { maxTokens: contextWindow.maxTokens }
+            }
+          }
+        });
+      }
       settleTurn({
         expectedGeneration: started.generation,
         expectedSessionId: started.sessionId,
@@ -25625,6 +25813,8 @@ function createAcpExecutor(options) {
       interruptedTurnIds.add(targetTurnId);
     }
     settleAllApprovals("cancel");
+    settleAllUserInputs();
+    abortPendingSettlement("turn cancelled");
     const runCancel = async () => {
       if (sessionId) {
         await connection.notify("session/cancel", { sessionId });
@@ -25687,11 +25877,32 @@ function createAcpExecutor(options) {
     };
     apply();
   };
+  const respondToUserInput = async (requestId, answers) => {
+    failIfDisposed();
+    const pending = pendingUserInputs.get(requestId);
+    if (pending === void 0) {
+      throw new AcpExecutorRequestError(
+        "session/request_permission",
+        `Unknown pending user-input request: ${requestId}`
+      );
+    }
+    if (pending.settled) {
+      return;
+    }
+    pending.settled = true;
+    pendingUserInputs.delete(requestId);
+    pending.resolve({
+      kind: "answered",
+      answers: isRecord3(answers) ? answers : {}
+    });
+  };
   const dispose = async () => {
     if (disposed) {
       return;
     }
     settleAllApprovals("cancel");
+    settleAllUserInputs();
+    abortPendingSettlement("executor disposed");
     notifyPromptSettled();
     abortLocalPrompt?.();
     emit({
@@ -25705,6 +25916,8 @@ function createAcpExecutor(options) {
     generation += 1;
     status = "disposed";
     eventStream.close();
+    options.readable.off("end", onInputDead);
+    options.readable.off("error", onInputDead);
     options.readable.pause();
     if (!connectionClosed) {
       await connection.awaitInboundIdle().catch(() => void 0);
@@ -25729,6 +25942,7 @@ function createAcpExecutor(options) {
     prompt,
     cancel,
     respondToRequest,
+    respondToUserInput,
     dispose
   };
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ycodium-ai/agent-acp",
-  "version": "0.2.1991",
+  "version": "0.2.2014",
   "description": "Generic ACP executor: user-supplied CLI over Agent Client Protocol stdio.",
   "keywords": [
     "ycodium",
@@ -20,7 +20,7 @@
     "@types/node": "24.12.4",
     "esbuild": "0.28.1",
     "vite-plus": "0.2.2",
-    "@ycodium-ai/plugin-api": "0.2.1991",
+    "@ycodium-ai/plugin-api": "0.2.2014",
     "ycodium-acp-executor": "0.0.0",
     "ycodium-acp-protocol": "0.0.0"
   },