laohuang 0.9.5 → 0.9.6

package/dist/bin.js

@@ -9264,8 +9264,12 @@ var ContextGovernor = class {
       retainTokens: input.reserveTokens === void 0 ? calculated.retainTokens : 1,
       estimator: this.#estimator
     });
-    if (input.trigger === "manual" && plan.summarizedEntries.length === 0) {
-      throw new Error("No messages to compact in current history.");
+    if (plan.summarizedEntries.length === 0) {
+      if (input.trigger === "manual")
+        throw new Error("No messages to compact in current history.");
+      if (input.trigger === "provider_overflow") {
+        throw new ContextBudgetError("No earlier messages to compact after provider overflow.");
+      }
     }
     const summarizedFromSeq = plan.summarizedEntries[0]?.seq ?? 1;
     const summarizedThroughSeq = plan.summarizedEntries.at(-1)?.seq ?? Math.max(0, summarizedFromSeq - 1);
@@ -9306,10 +9310,13 @@ var ContextGovernor = class {
         throw error;
       }
     }
-    const compaction = await this.compact({ ...input, trigger: "provider_overflow" });
-    prepared = await this.prepare({ ...input, entries: [...input.entries, compaction.entry] });
+    prepared = await this.recoverAfterOverflow(input);
     return await send(prepared);
   }
+  async recoverAfterOverflow(input) {
+    const compaction = await this.compact({ ...input, trigger: "provider_overflow" });
+    return this.prepare({ ...input, entries: [...input.entries, compaction.entry] });
+  }
   measure(input, built) {
     const tools = input.projectTools?.(built.messages) ?? input.tools;
     return this.#estimator.measure({
@@ -32495,7 +32502,7 @@ var AgentStepRunner = class {
       }
       modelRound += 1;
       modelRequests += 1;
-      const requestId = modelRound === 1 && this.options.requestId !== null ? this.options.requestId : randomUUID10();
+      let requestId = modelRound === 1 && this.options.requestId !== null ? this.options.requestId : randomUUID10();
       this.options.onRequestId(requestId);
       const registry = this.options.getTools();
       const selection = this.options.selection ?? new ToolSelection();
@@ -32533,96 +32540,137 @@ var AgentStepRunner = class {
           throw error;
         }
       }, () => history.snapshot().map((message) => message.role === "system" || message.role === "user" ? message : {}));
-      let selected = select(history.snapshot());
-      if (selected.announcement)
-        history.commitToolContext({ role: "user", ...selected.announcement });
-      let prepared = { messages: history.snapshot() };
-      for (let attempt = 0; attempt < 3; attempt++) {
-        prepared = await this.options.contextGovernor?.prepare({
-          messages: history.snapshot(),
-          tools: selected.view.definitions,
-          provider: this.options.provider,
-          model: this.options.model,
-          projectTools: (messages) => select(messages).view.definitions
-        }) ?? { messages: history.snapshot() };
-        history.retain(prepared.messages);
-        selected = select(prepared.messages);
-        const resources = await this.options.resources?.prepareContext(prepared.messages, cancelToken?.signal) ?? [];
-        if (!selected.announcement && resources.length === 0)
-          break;
-        if (attempt === 2)
-          throw this.options.createError("Resource catalog cannot fit the retained context.");
-        if (selected.announcement)
-          history.commitToolContext({ role: "user", ...selected.announcement });
-        for (const message of resources) {
-          history.commitSkillContext(message);
-          this.options.resources?.committed([message]);
-        }
-      }
-      remainingTokens = prepared.hardInputLimit === void 0 ? Number.POSITIVE_INFINITY : Math.max(0, prepared.hardInputLimit - (prepared.contextTokens ?? 0) - 1024);
-      const tools = selected.view;
-      const definitions = tools.definitions;
-      const requestMessages = [...prepared.messages];
-      this.emit("model_request", {
-        round: modelRound,
-        request_id: requestId,
-        message_count: requestMessages.length,
-        tool_rounds: toolRounds,
-        model_requests: modelRequests,
-        total_tokens: totalTokens,
-        ...prepared.contextTokens === void 0 ? {} : { context_tokens: prepared.contextTokens },
-        ...prepared.contextWindow === void 0 ? {} : { context_window: prepared.contextWindow }
-      });
-      let result;
-      try {
-        const modelRequestOpened = context?.modelRequestOpened;
-        result = await this.options.modelRuntime.complete({
-          provider: this.options.provider,
-          model: this.options.model,
-          ...this.options.baseUrl === null ? {} : { baseUrl: this.options.baseUrl },
-          messages: requestMessages,
-          tools: definitions,
-          reasoningEffort: this.options.getReasoningEffort(),
-          requestId,
-          cancelToken,
-          isRequestActive: this.options.isRequestActive,
-          onDelta: (kind, payload) => {
-            this.emit(kind, { round: modelRound, request_id: requestId, ...payload });
-          },
-          onRequestOpened: () => {
-            if (modelRequestOpened?.call(context) === false)
-              return false;
-            this.options.resources?.committed(pendingResourceInputs);
-            pendingResourceInputs = [];
-            return true;
+      const prepareRequest = async () => {
+        let selected2 = select(history.snapshot());
+        if (selected2.announcement)
+          history.commitToolContext({ role: "user", ...selected2.announcement });
+        let prepared2 = { messages: history.snapshot() };
+        for (let attempt = 0; attempt < 3; attempt++) {
+          prepared2 = await this.options.contextGovernor?.prepare({
+            messages: history.snapshot(),
+            tools: selected2.view.definitions,
+            provider: this.options.provider,
+            model: this.options.model,
+            projectTools: (messages) => select(messages).view.definitions
+          }) ?? { messages: history.snapshot() };
+          history.retain(prepared2.messages);
+          selected2 = select(prepared2.messages);
+          const resources = await this.options.resources?.prepareContext(prepared2.messages, cancelToken?.signal) ?? [];
+          if (!selected2.announcement && resources.length === 0)
+            break;
+          if (attempt === 2)
+            throw this.options.createError("Resource catalog cannot fit the retained context.");
+          if (selected2.announcement)
+            history.commitToolContext({ role: "user", ...selected2.announcement });
+          for (const message of resources) {
+            history.commitSkillContext(message);
+            this.options.resources?.committed([message]);
           }
+        }
+        remainingTokens = prepared2.hardInputLimit === void 0 ? Number.POSITIVE_INFINITY : Math.max(0, prepared2.hardInputLimit - (prepared2.contextTokens ?? 0) - 1024);
+        return { selected: selected2, prepared: prepared2 };
+      };
+      let { selected, prepared } = await prepareRequest();
+      let tools = selected.view;
+      let definitions = tools.definitions;
+      let requestMessages = [...prepared.messages];
+      let result;
+      for (let overflowAttempt = 0; ; overflowAttempt++) {
+        const attemptRequestId = requestId;
+        const attemptRound = modelRound;
+        this.emit("model_request", {
+          round: attemptRound,
+          request_id: attemptRequestId,
+          message_count: requestMessages.length,
+          tool_rounds: toolRounds,
+          model_requests: modelRequests,
+          total_tokens: totalTokens,
+          ...prepared.contextTokens === void 0 ? {} : { context_tokens: prepared.contextTokens },
+          ...prepared.contextWindow === void 0 ? {} : { context_window: prepared.contextWindow }
         });
-      } catch (error) {
-        if (error instanceof ModelStreamCancelled) {
-          this.emit("model_response_aborted", {
-            round: modelRound,
-            request_id: requestId,
-            reason: errorMessage10(error)
+        try {
+          const modelRequestOpened = context?.modelRequestOpened;
+          result = await this.options.modelRuntime.complete({
+            provider: this.options.provider,
+            model: this.options.model,
+            ...this.options.baseUrl === null ? {} : { baseUrl: this.options.baseUrl },
+            messages: requestMessages,
+            tools: definitions,
+            reasoningEffort: this.options.getReasoningEffort(),
+            requestId: attemptRequestId,
+            cancelToken,
+            isRequestActive: this.options.isRequestActive,
+            onDelta: (kind, payload) => {
+              this.emit(kind, { round: attemptRound, request_id: attemptRequestId, ...payload });
+            },
+            onRequestOpened: () => {
+              if (modelRequestOpened?.call(context) === false)
+                return false;
+              this.options.resources?.committed(pendingResourceInputs);
+              pendingResourceInputs = [];
+              return true;
+            }
           });
-          throw this.options.createCancelled(errorMessage10(error), error);
-        }
-        const errorPayload = {
-          round: modelRound,
-          request_id: requestId,
-          error: errorMessage10(error)
-        };
-        if (error instanceof ModelStreamError && error.hadDelta) {
-          this.emit("model_response_aborted", errorPayload);
-          this.options.emitLegacy("model_error", errorPayload);
-        } else {
-          this.emit("model_error", errorPayload);
-        }
-        let message = `Model request failed: ${errorMessage10(error)}`;
-        if (this.options.provider && modelErrorKind(error) === "authentication") {
-          message += `
+          break;
+        } catch (error) {
+          if (error instanceof ModelStreamCancelled) {
+            this.emit("model_response_aborted", {
+              round: attemptRound,
+              request_id: attemptRequestId,
+              reason: errorMessage10(error)
+            });
+            throw this.options.createCancelled(errorMessage10(error), error);
+          }
+          const errorPayload = {
+            round: attemptRound,
+            request_id: attemptRequestId,
+            error: errorMessage10(error)
+          };
+          if (error instanceof ModelStreamError && error.hadDelta) {
+            this.emit("model_response_aborted", errorPayload);
+            this.options.emitLegacy("model_error", errorPayload);
+          } else {
+            this.emit("model_error", errorPayload);
+          }
+          if (overflowAttempt === 0 && error instanceof ModelError && error.kind === "context_overflow" && !error.hadDelta && this.options.contextGovernor?.recoverAfterOverflow !== void 0) {
+            this.raiseIfCancelled();
+            const recovered = await this.options.contextGovernor.recoverAfterOverflow({
+              messages: history.snapshot(),
+              tools: definitions,
+              provider: this.options.provider,
+              model: this.options.model,
+              projectTools: (messages) => select(messages).view.definitions
+            });
+            this.raiseIfCancelled();
+            history.retain(recovered.messages);
+            remainingTokens = Number.POSITIVE_INFINITY;
+            preflightCompacted = false;
+            ({ selected, prepared } = await prepareRequest());
+            this.raiseIfCancelled();
+            tools = selected.view;
+            definitions = tools.definitions;
+            requestMessages = [...prepared.messages];
+            this.emit("model_retry_scheduled", {
+              round: attemptRound,
+              request_id: attemptRequestId,
+              attempt: 2,
+              max_attempts: 2,
+              delay_ms: 0,
+              error_kind: "context_overflow"
+            });
+            modelRound += 1;
+            modelRequests += 1;
+            requestId = randomUUID10();
+            this.options.onRequestId(requestId);
+            continue;
+          }
+          let message = `Model request failed: ${errorMessage10(error)}`;
+          if (this.options.provider && modelErrorKind(error) === "authentication") {
+            message += `
 Authentication failed for ${this.options.provider}. Run /login ${this.options.provider} to update your API key.`;
+          }
+          throw this.options.createError(message, error);
         }
-        throw this.options.createError(message, error);
       }
       const toolCalls = toolCallsOf(result.message);
       let requestTokens = usageTotalTokens(result.usage);
@@ -33520,6 +33568,25 @@ function createSessionRuntime(options) {
           contextWindow: selectedModel.contextWindow,
           hardInputLimit: selectedModel.contextWindow - selectedModel.maxTokens
         };
+      },
+      recoverAfterOverflow: async ({ tools, projectTools: projectTools2 }) => {
+        const history = activeHistory(options.sessionController);
+        const prepared = await createGovernor(history).recoverAfterOverflow({
+          protectedFromSeq: attachmentTurnStart,
+          entries: history.entries(),
+          currentProvider: route.provider,
+          currentModel: route.model,
+          tools,
+          projectTools: projectTools2,
+          budget: modelBudget(selectedModel),
+          policy: defaultContextPolicy()
+        });
+        return {
+          messages: prepared.messages,
+          contextTokens: prepared.tokens,
+          contextWindow: selectedModel.contextWindow,
+          hardInputLimit: selectedModel.contextWindow - selectedModel.maxTokens
+        };
       }
     }
   });
@@ -38703,64 +38770,7 @@ async function handleCommandResult(presenter, suggestCommand, result) {
   return true;
 }
 async function runSessionRepl(session, options) {
-  if (options.runUi !== void 0 || typeof options.ui.run === "function") {
-    return runPersistentSessionRepl(session, options);
-  }
-  return runClassicSessionRepl(session, options);
-}
-async function runClassicSessionRepl(session, options) {
-  const { commandHandler, presenter, suggestCommand, ui } = options;
-  ui.startEventRenderer?.();
-  ui.showWelcome?.();
-  let cleanShutdown = false;
-  try {
-    for (; ; ) {
-      let userInput;
-      try {
-        const prompt = ui.prompt;
-        if (typeof prompt !== "function") {
-          throw new Error("Classic session UI requires a prompt function.");
-        }
-        userInput = await prompt.call(ui);
-        if (!/^\s*\/skill:/.test(userInput)) userInput = userInput.trim();
-      } catch (error) {
-        if (isEofError(error)) {
-          break;
-        }
-        if (isInterruptedError(error)) {
-          presentNotice(presenter, "Interrupted.", "warning");
-          continue;
-        }
-        throw error;
-      }
-      const keepGoing = await handleSessionInput(
-        session,
-        commandHandler,
-        presenter,
-        suggestCommand,
-        userInput
-      );
-      if (!keepGoing) {
-        break;
-      }
-    }
-  } finally {
-    cleanShutdown = await session.close({ wait: true, timeoutMs: 1e4 });
-    if (cleanShutdown) {
-      await session.eventBus.flush();
-      ui.flushEventRenderer?.();
-    }
-    ui.stopEventRenderer?.();
-  }
-  if (cleanShutdown) {
-    ui.showGoodbye?.();
-  } else {
-    presenter.notice({
-      text: "Task worker did not stop before the shutdown timeout.",
-      tone: "error"
-    });
-  }
-  return cleanShutdown;
+  return runPersistentSessionRepl(session, options);
 }
 function startCoordinator(session, commandHandler, presenter, suggestCommand) {
   const queue = [];
@@ -39767,6 +39777,7 @@ async function main(argv, options = {}) {
   let attachmentRuntime;
   try {
     modelPlatform = await createPiAiPlatform({
+      // 附件运行时稍后才创建，通过回调取得届时可用的存储实例。
       attachments: { store: () => attachmentRuntime?.store },
       credentials,
       modelCatalogStore,