laohuang 0.9.5 → 0.9.7

package/README.md

@@ -33,7 +33,7 @@ npm install -g laohuang
 ```bash
 laohuang --help
 laohuang --version
-laohuang config set --provider deepseek --model deepseek-v4-flash
+laohuang config set --provider deepseek --model deepseek-flash
 laohuang doctor
 laohuang update
 ```
@@ -42,9 +42,10 @@ Run `laohuang` in a project directory to start an interactive session. The CLI
 loads local project instructions, uses saved provider profiles, and keeps file
 and shell tool execution rooted in the current project.
 
-Model providers come from the installed pi-ai API-key catalog. In pi-ai 0.83.0
-the product exposes 35 available API-key providers, excluding Amazon Bedrock,
-Google Vertex, OAuth-only providers, and OpenAI Codex. Use `/providers` to see
+Model providers come from the installed pi-ai API-key catalog. In pi-ai 1.0.0
+the product exposes 38 available chat API-key providers, excluding Amazon Bedrock,
+Google Vertex, OAuth-only providers, OpenAI Codex, and operation-only catalogs.
+`deepseek-flash` is the built-in DeepSeek V4.1 Flash model. Use `/providers` to see
 available, configured, and verified status independently.
 
 `/login <provider>` stores API-key credentials, `/logout <provider>` removes

package/dist/bin.js

@@ -9105,7 +9105,7 @@ function validateToolPairs(selected) {
 }
 
 // ../../packages/session/session-context/dist/summary-prompt.js
-var COMPACTION_SYSTEM_PROMPT = "Summarize the conversation for continuation. Preserve user goals, explicit constraints, completed work, modified files, architectural decisions, tool outcomes, failures, current TODOs, and concrete state needed to continue. Do not include credentials. Do not invent results.";
+var COMPACTION_SYSTEM_PROMPT = "Summarize the conversation for continuation. If the input contains <previous_summary>, merge and update it with the newer conversation instead of discarding it. Preserve user goals, explicit constraints, completed work, modified files, architectural decisions, tool outcomes, failures, current TODOs, and concrete state needed to continue. Do not include credentials. Do not invent results.";
 
 // ../../packages/session/session-context/dist/compaction.js
 function selectCompactionPlan(input) {
@@ -9225,6 +9225,8 @@ var ContextBudgetError = class extends Error {
     this.name = "ContextBudgetError";
   }
 };
+var NoCompactionAvailableError = class extends Error {
+};
 var ContextGovernor = class {
   #builder;
   #estimator;
@@ -9245,7 +9247,17 @@ var ContextGovernor = class {
         throw new ContextBudgetError("context exceeds hard input limit");
       return { built, messages: built.messages, compacted: false, tokens };
     }
-    const result = await this.compact({ ...input, trigger: "automatic" });
+    let result;
+    try {
+      result = await this.compact({ ...input, trigger: "automatic" });
+    } catch (error) {
+      if (!(error instanceof NoCompactionAvailableError))
+        throw error;
+      if (tokens > calculated.hardInputLimit) {
+        throw new ContextBudgetError("context exceeds hard input limit with no earlier messages to compact");
+      }
+      return { built, messages: built.messages, compacted: false, tokens };
+    }
     const entries = [...input.entries, result.entry];
     built = this.#builder.build({ ...input, entries });
     tokens = this.measure({ ...input, entries }, built);
@@ -9256,29 +9268,32 @@ var ContextGovernor = class {
   }
   async compact(input) {
     const calculated = calculateModelBudget({ budget: input.budget, policy: input.policy });
+    const built = this.#builder.build(input);
+    const activeCompaction = input.entries.find((entry) => entry.id === built.activeCompactionId && entry.entryType === "compaction");
+    const activeSourceEntryIds = new Set(built.sourceEntryIds);
+    const projectedEntries = activeCompaction === void 0 ? input.entries : input.entries.filter((entry) => entry.id !== activeCompaction.id && activeSourceEntryIds.has(entry.id));
     const plan = selectCompactionPlan({
       protectedFromSeq: input.protectedFromSeq,
-      entries: input.entries,
+      entries: projectedEntries,
       // A search preflight reserves the pending call/result/definition unit.
       // Keep the latest completed unit and summarize older units to make room.
       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.");
+      }
+      throw new NoCompactionAvailableError();
     }
-    const summarizedFromSeq = plan.summarizedEntries[0]?.seq ?? 1;
-    const summarizedThroughSeq = plan.summarizedEntries.at(-1)?.seq ?? Math.max(0, summarizedFromSeq - 1);
-    const built = this.#builder.build(input);
-    const activeCompaction = input.entries.find((entry) => entry.id === built.activeCompactionId);
+    const summarizedFromSeq = activeCompaction?.payload.summarizedFromSeq ?? plan.summarizedEntries[0]?.seq ?? 1;
+    const summarizedThroughSeq = plan.summarizedEntries.at(-1)?.seq ?? activeCompaction?.payload.summarizedThroughSeq ?? Math.max(0, summarizedFromSeq - 1);
     const messagesBefore = built.messages;
     const tokensBefore = this.#estimator.estimateMessages(messagesBefore) + this.#estimator.estimateTools(input.projectTools?.(messagesBefore) ?? input.tools);
-    const summary = plan.summarizedEntries.length === 0 ? {
-      summary: "No prior conversation needed compaction.",
-      inputTokens: 0,
-      outputTokens: 0
-    } : await this.#summarize({
-      serialized: serializeConversation(plan.summarizedEntries),
+    const summary = await this.#summarize({
+      serialized: serializeCompactionInput(activeCompaction?.payload.summary, plan.summarizedEntries),
       maxSummaryTokens: input.policy.maxSummaryTokens
     });
     const payload = {
@@ -9306,10 +9321,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({
@@ -9325,6 +9343,15 @@ var ContextGovernor = class {
     }).totalTokens + (input.reserveTokens ?? 0);
   }
 };
+function serializeCompactionInput(previousSummary, entries) {
+  const conversation = serializeConversation(entries);
+  if (previousSummary === void 0)
+    return conversation;
+  return `<previous_summary>
+${previousSummary}
+</previous_summary>
+${conversation}`;
+}
 function calculateModelBudget(input) {
   const hardInputLimit = input.budget.contextWindow - input.budget.maxOutputTokens;
   const safetyTokens = Math.ceil(input.budget.contextWindow * input.policy.safetyRatio);
@@ -9513,8 +9540,22 @@ function parseToolArguments(raw) {
       kind: "protocol"
     });
   }
+  if (!Object.values(parsed).every(isJsonValue)) {
+    throw new ModelError("tool-call arguments contain invalid JSON values", {
+      kind: "protocol"
+    });
+  }
   return parsed;
 }
+function isJsonValue(value) {
+  if (value === null || typeof value === "string" || typeof value === "boolean")
+    return true;
+  if (typeof value === "number")
+    return Number.isFinite(value);
+  if (Array.isArray(value))
+    return value.every(isJsonValue);
+  return isRecord(value) && Object.values(value).every(isJsonValue);
+}
 function zeroUsage() {
   return {
     input: 0,
@@ -9952,7 +9993,10 @@ var PiModelsStore = class {
       return void 0;
     }
     return {
-      models: entry.models.map((model2) => restoreModel(providerId, model2)),
+      models: entry.models.flatMap((model2) => {
+        const restored = restoreModel(providerId, model2);
+        return restored === void 0 ? [] : [restored];
+      }),
       ...entry.lastModified === void 0 ? {} : { lastModified: entry.lastModified },
       ...entry.checkedAt === void 0 ? {} : { checkedAt: entry.checkedAt },
       ...entry.etag === void 0 ? {} : { etag: entry.etag }
@@ -9971,12 +10015,15 @@ var PiModelsStore = class {
   }
 };
 function restoreModel(providerId, model2) {
+  const type = model2["type"] ?? "chat";
+  if (type !== "chat" && type !== "image" && type !== "classifier")
+    return void 0;
   const id = readString(model2, "id", providerId);
   const name = readString(model2, "name", providerId);
   const api2 = readString(model2, "api", providerId);
   const provider2 = readString(model2, "provider", providerId);
   const input = model2["input"];
-  if (!Array.isArray(input) || !input.every((item) => typeof item === "string")) {
+  if (!Array.isArray(input) || !input.every((item) => item === "text" || item === "image")) {
     throw new ModelError(`stored model for '${providerId}' has invalid input`, {
       kind: "protocol"
     });
@@ -9987,6 +10034,27 @@ function restoreModel(providerId, model2) {
       kind: "protocol"
     });
   }
+  const common = {
+    ...model2,
+    id,
+    name,
+    api: api2,
+    provider: provider2,
+    input,
+    cost: cost2,
+    baseUrl: readString(model2, "baseUrl", providerId)
+  };
+  if (type === "image") {
+    const output = model2["output"];
+    if (!Array.isArray(output) || !output.includes("image") || !output.every((item) => item === "text" || item === "image")) {
+      throw new ModelError(`stored model for '${providerId}' has invalid output`, { kind: "protocol" });
+    }
+    return { ...common, type, api: api2, output };
+  }
+  const contextWindow = readPositiveNumber(model2, "contextWindow", providerId);
+  if (type === "classifier") {
+    return { ...common, type, api: api2, contextWindow };
+  }
   const reasoning = model2["reasoning"];
   if (typeof reasoning !== "boolean") {
     throw new ModelError(`stored model for '${providerId}' has invalid reasoning`, {
@@ -9994,15 +10062,13 @@ function restoreModel(providerId, model2) {
     });
   }
   return {
-    ...model2,
-    id,
-    name,
+    ...common,
+    type,
     api: api2,
-    provider: provider2,
     reasoning,
     input,
     cost: cost2,
-    contextWindow: readPositiveNumber(model2, "contextWindow", providerId),
+    contextWindow,
     maxTokens: readPositiveNumber(model2, "maxTokens", providerId)
   };
 }
@@ -10036,11 +10102,11 @@ function isCost(value) {
 }
 
 // ../../packages/llm/llm-pi-ai/dist/platform.js
-import { defaultProviderAuthContext, getSupportedThinkingLevels } from "@earendil-works/pi-ai";
+import { defaultProviderAuthContext, getSupportedThinkingLevels, isModelType as isModelType2 } from "@earendil-works/pi-ai";
 import { builtinModels as builtinModels2 } from "@earendil-works/pi-ai/providers/all";
 
 // ../../packages/llm/llm-pi-ai/dist/custom-models.js
-import { createProvider, envApiKeyAuth } from "@earendil-works/pi-ai";
+import { createProvider, envApiKeyAuth, isModelType } from "@earendil-works/pi-ai";
 import { openAICompletionsApi } from "@earendil-works/pi-ai/api/openai-completions.lazy";
 import { openAIResponsesApi } from "@earendil-works/pi-ai/api/openai-responses.lazy";
 import { anthropicMessagesApi } from "@earendil-works/pi-ai/api/anthropic-messages.lazy";
@@ -17866,6 +17932,8 @@ var completionsCompat = partial(typebox_exports.Object({
   supportsOpenAIGrammarTools: typebox_exports.Boolean(),
   supportsStrictMode: typebox_exports.Boolean(),
   cacheControlFormat: typebox_exports.Literal("anthropic"),
+  supportsMidConvoSystemMessages: typebox_exports.Boolean(),
+  supportsMidConvoToolAdditions: typebox_exports.Boolean(),
   sendSessionAffinityHeaders: typebox_exports.Boolean(),
   deferredToolsMode: typebox_exports.Literal("kimi"),
   sessionAffinityFormat: affinity,
@@ -17875,6 +17943,7 @@ var completionsCompat = partial(typebox_exports.Object({
 var responsesCompat = partial(typebox_exports.Object({
   supportsDeveloperRole: typebox_exports.Boolean(),
   sessionAffinityFormat: affinity,
+  supportsMidConvoSystemMessages: typebox_exports.Boolean(),
   supportsLongCacheRetention: typebox_exports.Boolean(),
   supportsStrictMode: typebox_exports.Boolean(),
   supportsOpenAIGrammarTools: typebox_exports.Boolean(),
@@ -17894,6 +17963,9 @@ var anthropicCompat = partial(typebox_exports.Object({
   supportsStrictTools: typebox_exports.Boolean(),
   supportsMidConvoEffort: typebox_exports.Boolean(),
   supportsToolReferences: typebox_exports.Boolean(),
+  supportsMidConvoSystemMessages: typebox_exports.Boolean(),
+  supportsMidConvoToolChanges: typebox_exports.Boolean(),
+  sessionAffinityFormat: typebox_exports.Literal("openrouter"),
   allowedFallbackModels: typebox_exports.Array(typebox_exports.Object({ provider: text, model: text, cost }, { additionalProperties: false }))
 }, { additionalProperties: false }));
 var api = typebox_exports.Union([
@@ -18066,6 +18138,10 @@ function customProvider(id, config, base) {
     baseUrl: config.baseUrl ?? base?.baseUrl,
     headers: { ...base?.headers, ...config.headers },
     getModels,
+    getAllModels: () => [
+      ...getModels(),
+      ...(base?.getAllModels?.() ?? []).filter((model2) => !isModelType(model2, "chat"))
+    ],
     // Keep provider-owned refresh/cache logic; getModels reapplies user overrides afterwards.
     ...base?.filterModels === void 0 ? {} : {
       filterModels: (models, credential) => {
@@ -18073,6 +18149,12 @@ function customProvider(id, config, base) {
         return models.filter((model2) => available.has(model2.id) || additions.has(model2.id));
       }
     },
+    ...base?.filterAllModels === void 0 ? {} : {
+      filterAllModels: (models, credential) => {
+        const available = new Set(base.filterAllModels(models, credential).map((model2) => `${model2.type ?? "chat"}:${model2.id}`));
+        return models.filter((model2) => available.has(`${model2.type ?? "chat"}:${model2.id}`) || isModelType(model2, "chat") && additions.has(model2.id));
+      }
+    },
     stream: (model2, context, options) => dispatch(model2).stream(model2, context, options),
     streamSimple: (model2, context, options) => dispatch(model2).streamSimple(model2, context, options)
   };
@@ -18183,7 +18265,9 @@ var PiAiPlatform = class {
   }
 };
 function isEligibleProvider(provider2, excludedProviderIds) {
-  return provider2.auth.apiKey?.login !== void 0 && !excludedProviderIds.has(provider2.id);
+  const allModels = provider2.getAllModels?.() ?? provider2.getModels();
+  return provider2.auth.apiKey?.login !== void 0 && !excludedProviderIds.has(provider2.id) && // Empty dynamic catalogs remain eligible; operation-only catalogs do not.
+  (allModels.length === 0 || allModels.some((model2) => isModelType2(model2, "chat")));
 }
 var PiAiCatalog = class {
   models;
@@ -32495,7 +32579,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 +32617,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 +33645,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 +38847,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 +39854,7 @@ async function main(argv, options = {}) {
   let attachmentRuntime;
   try {
     modelPlatform = await createPiAiPlatform({
+      // 附件运行时稍后才创建，通过回调取得届时可用的存储实例。
       attachments: { store: () => attachmentRuntime?.store },
       credentials,
       modelCatalogStore,