@cryer/star-cli 0.3.10 → 0.3.11

package/dist/{chunk-MNVCCOI2.js → chunk-63CGUF3F.js}

@@ -12,7 +12,7 @@ import {
   toCoreMessages,
   toStarMessage,
   trackTree
-} from "./chunk-IJGUW4PM.js";
+} from "./chunk-N4MIQSNZ.js";
 import {
   createModel,
   streamActivity
@@ -24,7 +24,7 @@ import {
   ToolRegistry,
   createDefaultRegistry,
   debugStreamLog
-} from "./chunk-URC7JXKX.js";
+} from "./chunk-Q5FJN4LN.js";
 import {
   TodoStore,
   beginTurn,
@@ -43,7 +43,7 @@ import {
   stripOversizedImages,
   undoTurnSnapshots,
   userMemoryPath
-} from "./chunk-A5PXPWHB.js";
+} from "./chunk-LSYGHLRU.js";
 
 // src/agent/loop.ts
 import { tool as aiTool, generateText as generateText3 } from "ai";
@@ -76,6 +76,9 @@ function textWeight(text) {
   }
   return text.length + cjk * (CHARS_PER_TOKEN - 1);
 }
+function roughTextTokens(text) {
+  return Math.ceil(textWeight(text) / CHARS_PER_TOKEN);
+}
 function contentTokenLength(message) {
   if (message.role === "tool") {
     let tokens2 = 0;
@@ -241,6 +244,7 @@ ${transcript}`,
 }
 function compactMessages(messages, maxTokens, opts = {}) {
   const limit = opts.force ? 0 : maxTokens;
+  const minKept = opts.force ? 1 : MIN_KEPT_MESSAGES;
   const overhead = opts.overheadTokens ?? 0;
   const tokens = messages.map((star) => estimateMessageTokens(star.message));
   let total = overhead;
@@ -269,7 +273,7 @@ function compactMessages(messages, maxTokens, opts = {}) {
   let droppedCount = 0;
   let droppedTokens = 0;
   for (const turn of turns) {
-    if (restCount - droppedCount - turn.length < MIN_KEPT_MESSAGES) {
+    if (restCount - droppedCount - turn.length < minKept) {
       break;
     }
     droppedCount += turn.length;
@@ -299,6 +303,7 @@ var KEEP_RECENT_MESSAGES = 24;
 var MIN_ELISION_TOKENS = 250;
 var ELIDED_TOOL_RESULT_TEXT = "[stale tool output elided to free context \u2014 it was shown in full earlier; re-run the tool if you need it again]";
 var ELIDED_IMAGE_TEXT = "[image elided to free context \u2014 re-attach it if it is still needed]";
+var ELIDED_TOOL_CALL_ARGS_TEXT = "arguments elided to free context \u2014 the call already ran; this placeholder is not valid tool input, re-read the file if you need the old content";
 function elideStaleContent(messages, thresholdTokens, overheadTokens = 0) {
   let total = overheadTokens;
   for (const star of messages) total += estimateMessageTokens(star.message);
@@ -324,6 +329,19 @@ function elideStaleContent(messages, thresholdTokens, overheadTokens = 0) {
         meta: { ...star.meta, elided: true }
       };
       elidedCount++;
+    } else if (message.role === "assistant" && Array.isArray(message.content)) {
+      if (!message.content.some((part) => part.type === "tool-call")) continue;
+      if (estimateMessageTokens(message) < MIN_ELISION_TOKENS) continue;
+      out[i] = {
+        message: {
+          ...message,
+          content: message.content.map(
+            (part) => part.type === "tool-call" ? { ...part, args: { elided: ELIDED_TOOL_CALL_ARGS_TEXT } } : part
+          )
+        },
+        meta: { ...star.meta, elided: true }
+      };
+      elidedCount++;
     } else if (message.role === "user" && Array.isArray(message.content)) {
       if (!message.content.some((part) => part.type === "image" || part.type === "file")) continue;
       out[i] = {
@@ -709,7 +727,7 @@ function summarizeStreamError(error) {
 }
 
 // src/llm/stream.ts
-import { streamText } from "ai";
+import { InvalidToolArgumentsError, streamText } from "ai";
 var DEFAULT_IDLE_TIMEOUT_MS = 6e4;
 var DEFAULT_FIRST_PART_TIMEOUT_MS = 12e4;
 var CONTENT_PART_TYPES = /* @__PURE__ */ new Set(["text-delta", "tool-call", "tool-call-delta"]);
@@ -791,6 +809,7 @@ async function* streamChat(opts) {
   let deltas = 0;
   let hasContent = false;
   const argsProgress = /* @__PURE__ */ new Map();
+  let invalidArgsCounter = 0;
   let lastPartAt = Date.now();
   debugStreamLog("request", {
     messages: opts.messages.length,
@@ -863,6 +882,7 @@ async function* streamChat(opts) {
           break;
         case "tool-call":
           hasContent = true;
+          argsProgress.delete(part.toolCallId);
           yield {
             type: "tool-call",
             id: part.toolCallId,
@@ -902,6 +922,22 @@ async function* streamChat(opts) {
             usage: part.usage,
             deltas
           });
+          for (const [id, progress] of argsProgress) {
+            debugStreamLog("truncated-tool-call", {
+              toolCallId: id,
+              toolName: progress.name,
+              chars: progress.chars,
+              finishReason: part.finishReason
+            });
+            yield {
+              type: "tool-call",
+              id,
+              name: progress.name,
+              args: {},
+              invalidArgs: `the arguments were cut off mid-stream after ${progress.chars} characters (finish reason: ${part.finishReason}) \u2014 the reply hit the output or context limit before the JSON completed. Reissue ${progress.name} with complete arguments; for large content, split it into several smaller calls.`
+            };
+          }
+          argsProgress.clear();
           yield {
             type: "finish",
             finishReason: part.finishReason,
@@ -916,6 +952,29 @@ async function* streamChat(opts) {
         }
         case "error": {
           if (opts.abortSignal?.aborted) return;
+          if (InvalidToolArgumentsError.isInstance(part.error)) {
+            const invalid = part.error;
+            let args = invalid.toolArgs;
+            try {
+              args = JSON.parse(invalid.toolArgs);
+            } catch {
+            }
+            const started = [...argsProgress.entries()].reverse().find(([, progress]) => progress.name === invalid.toolName);
+            debugStreamLog("invalid-tool-args", {
+              toolName: invalid.toolName,
+              recoveredId: started?.[0] ?? null
+            });
+            yield {
+              type: "tool-call",
+              id: started?.[0] ?? `invalid-args-${++invalidArgsCounter}`,
+              name: invalid.toolName,
+              args,
+              // The zod detail tells the model exactly which field to fix;
+              // capped because the message embeds the full rejected value.
+              invalidArgs: invalid.message.length > 2e3 ? `${invalid.message.slice(0, 2e3)}\u2026` : invalid.message
+            };
+            return;
+          }
           const error = toStreamErrorInfo(part.error);
           debugStreamLog("error-part", { seenContent, deltas, error: summarizeStreamError(error) });
           yield { type: "error", error };
@@ -2087,7 +2146,7 @@ function findModelPricing(config, name, modelId) {
   return config.models.find((m) => m.model === modelId);
 }
 async function runSubagent(deps, args, cwd, signal, agentIdRef) {
-  const { AgentLoop: AgentLoop2 } = await import("./loop-TW2FHL7J.js");
+  const { AgentLoop: AgentLoop2 } = await import("./loop-AY4PXRVP.js");
   const child = new AgentLoop2({
     model: deps.model,
     registry: createDefaultRegistry(),
@@ -2284,6 +2343,7 @@ function finalNudgeWarning(autoContinues, maxAutoContinues) {
   return autoContinues >= maxAutoContinues ? " This is the final automatic continuation \u2014 if your next reply again has no tool calls, nudging stops and the turn is handed back to the user. Finish the work now or summarize what remains." : "";
 }
 var COMPLETION_CHECK_TIMEOUT_MS = 3e4;
+var TODO_STALE_NUDGE_STEPS = 20;
 function attachTurnContext(messages, context) {
   if (!context) return messages;
   for (let i = messages.length - 1; i >= 0; i--) {
@@ -2422,6 +2482,29 @@ var AgentLoop = class {
   // (the tool map's share of the request window) is computed alongside since
   // it depends on the same inputs.
   aiToolsCache = null;
+  // Server-calibration baseline for the context estimate: the latest finish
+  // event's provider-reported promptTokens paired with the local estimate of
+  // the exact request that produced it. Non-OpenAI tokenizers can count the
+  // same history far higher than the local cl100k estimate (a qwen endpoint
+  // counted ~30% more on a Chinese-heavy code session), which let the ctx%
+  // display and the auto-compaction trigger lag the real window fill until
+  // the provider itself started truncating replies. The delta refreshes on
+  // every step's finish, so drift is bounded to one step's new content.
+  serverTokenBaseline = null;
+  // Text streamed by the in-flight reply (visible text + reasoning +
+  // completed tool-call args). estimateContextTokens folds a rough token
+  // estimate of it into the status-bar ctx% so the display tracks the
+  // server's real-time occupancy — prompt PLUS generated-so-far, which is
+  // what llama.cpp-style monitors show — instead of lagging it by the whole
+  // in-flight generation (10k reasoning tokens ≈ 8% of a 128k window).
+  // Reset when each stream attempt ends: the persisted reply is then counted
+  // through the history estimate, and reasoning — never resent — drops out.
+  // User steering prompts submitted while a turn is running (the REPL's
+  // "insert now" choice). Drained into the history as synthetic user
+  // messages at the next step boundary — the in-flight model reply and its
+  // tool calls always finish first, so a steer never interrupts mid-step.
+  pendingSteers = [];
+  inflightStreamText = "";
   // Lazily resolved auxiliary model (config.smallModel) for cheap side calls
   // — compaction summaries, session titles, completion checks. Undefined =
   // use the main model; a resolution failure is surfaced once as a notice.
@@ -2487,12 +2570,56 @@ var AgentLoop = class {
   getStarMessages() {
     return this.messages;
   }
+  // Queue a user steering prompt for the running turn. Delivery happens at
+  // the next step boundary (see drainSteers); if the turn ends first the
+  // text stays queued and takeUndeliveredSteers hands it back to the caller.
+  injectUserMessage(text) {
+    const trimmed = text.trim();
+    if (trimmed.length > 0) this.pendingSteers.push(trimmed);
+  }
+  // Steers that never reached a step boundary (turn ended, aborted or
+  // errored first). The caller decides their fate — the REPL re-queues them
+  // as ordinary prompts so user input is never dropped.
+  takeUndeliveredSteers() {
+    return this.pendingSteers.splice(0);
+  }
+  // Append queued steers to the history as synthetic user messages: they
+  // belong to the turn in progress, so /undo, /rewind and compaction must
+  // not treat them as turn boundaries. Returns the number delivered.
+  async drainSteers() {
+    const steers = this.pendingSteers.splice(0);
+    for (const text of steers) {
+      const message = { role: "user", content: text };
+      const meta = { synthetic: "steer" };
+      this.messages.push({ message, meta });
+      await this.persist(message, meta);
+    }
+    return steers.length;
+  }
   // Wire-schema token overhead of the active tool set (memoized by
   // buildAiTools). The auto-compact budget includes it; surfaced here so the
   // status bar ctx% can show the same total the compaction decision uses.
   getToolSchemaTokens() {
     return this.buildAiTools().schemaTokens;
   }
+  // Additive correction from serverTokenBaseline, clamped ≥ 0: an
+  // under-reading provider estimate must pull compaction earlier (the bug
+  // this fixes), but an over-reading one must never push it later than the
+  // local estimate alone would — compacting early is safe, late is fatal.
+  calibrationDelta() {
+    const baseline = this.serverTokenBaseline;
+    if (!baseline) return 0;
+    return Math.max(0, baseline.serverTokens - baseline.localTokens);
+  }
+  // Effective context-window usage in tokens: local BPE estimate + tool
+  // schemas + the server-calibration delta + the in-flight reply's streamed
+  // output. This is the status bar's live ctx% view; the elision/compaction
+  // budgets deliberately use only the first three (history + schemas +
+  // calibration), since in-flight reasoning is never resent and must not
+  // trigger a compaction the next request won't need.
+  estimateContextTokens() {
+    return estimateTokens(this.getMessages()) + this.getToolSchemaTokens() + this.calibrationDelta() + (this.inflightStreamText.length > 0 ? roughTextTokens(this.inflightStreamText) : 0);
+  }
   // Auxiliary model for cheap side calls: config.smallModel, resolved once.
   // An unresolvable name/key degrades to the main model instead of breaking
   // turns; the failure rides out once as a notice at the next turn start.
@@ -2832,6 +2959,9 @@ var AgentLoop = class {
     let usedToolsThisTurn = false;
     let streamCutContinues = 0;
     let openTodos = [];
+    let todoRevision = this.opts.registry.todos.revision;
+    let stepsSinceTodoChange = 0;
+    const todoStaleNudgeSteps = this.opts.todoStaleNudgeSteps ?? TODO_STALE_NUDGE_STEPS;
     const maxSteps = config.maxSteps;
     let step = 0;
     let toolExecutedSinceCheckpoint = false;
@@ -2868,16 +2998,47 @@ ${finished.result}`
           await this.persist(note, meta);
         }
       }
+      const steered = await this.drainSteers();
+      if (steered > 0) {
+        yield {
+          type: "notice",
+          message: `${steered} steering message(s) delivered to the model; taking effect from this step.`
+        };
+      }
+      const currentTodoRevision = registry.todos.revision;
+      if (currentTodoRevision !== todoRevision) {
+        todoRevision = currentTodoRevision;
+        stepsSinceTodoChange = 0;
+      } else if (stepsSinceTodoChange >= todoStaleNudgeSteps) {
+        const open = registry.todos.list().filter((t) => t.status !== "done");
+        if (open.length > 0) {
+          stepsSinceTodoChange = 0;
+          yield {
+            type: "notice",
+            message: `todo list unchanged for ${todoStaleNudgeSteps} steps with ${open.length} open item(s); reminding the model to update it.`
+          };
+          const reminder = {
+            role: "user",
+            content: `[todo reminder] Your todo list still has ${open.length} open item(s), unchanged for ${todoStaleNudgeSteps} steps: ${open.slice(0, 5).map((t) => `"${t.title}"`).join(
+              ", "
+            )}${open.length > 5 ? ", \u2026" : ""}. Update the list with todo_write so it reflects what is done and what you are working on now, then continue working.`
+          };
+          const meta = { synthetic: "nudge" };
+          this.messages.push({ message: reminder, meta });
+          await this.persist(reminder, meta);
+        }
+      }
       const maxTokens = this.opts.contextMaxTokens ?? config.contextMaxTokens;
       const threshold = resolveCompactThreshold(config, maxTokens);
-      const elided = elideStaleContent(this.messages, threshold, toolSchemaTokens);
+      const calibration = this.calibrationDelta();
+      const elided = elideStaleContent(this.messages, threshold, toolSchemaTokens + calibration);
       if (elided) {
         this.messages = elided.messages;
         await this.opts.sessionStore?.replaceMessages([...this.messages]);
         this.opts.registry?.resetVolatileState();
       }
       const compacted = compactMessages(this.messages, threshold, {
-        overheadTokens: toolSchemaTokens
+        overheadTokens: toolSchemaTokens + calibration
       });
       if (compacted.compacted) {
         this.messages = await this.applyCompactionSummary(compacted, signal);
@@ -2885,6 +3046,7 @@ ${finished.result}`
         this.turnMarkers = [];
         this.opts.registry?.resetVolatileState();
       }
+      const requestLocalTokens = estimateTokens(this.getMessages()) + toolSchemaTokens;
       const maxRetries = Math.max(0, config.streamMaxRetries);
       const baseDelay = this.opts.retryDelayMs ?? STREAM_RETRY_BASE_DELAY_MS;
       let text = "";
@@ -2905,22 +3067,37 @@ ${finished.result}`
         lastUsage = void 0;
         sawReasoning = false;
         wasTruncated = false;
+        this.inflightStreamText = "";
         const timeoutScale = Math.min(attempt + 1, 3);
         try {
           for await (const event of this.streamOnce(aiTools, signal, timeoutScale)) {
             if (event.type === "text-delta") {
               text += event.text;
+              this.inflightStreamText += event.text;
               yield event;
             } else if (event.type === "reasoning") {
               sawReasoning = true;
+              this.inflightStreamText += event.text;
               yield event;
             } else if (event.type === "tool-call") {
-              toolCalls.push({ id: event.id, name: event.name, args: event.args });
+              this.inflightStreamText += JSON.stringify(event.args ?? null);
+              toolCalls.push({
+                id: event.id,
+                name: event.name,
+                args: event.args,
+                ...event.invalidArgs !== void 0 ? { invalidArgs: event.invalidArgs } : {}
+              });
               yield event;
             } else if (event.type === "finish") {
               lastFinishReason = event.finishReason;
               if (event.truncated) wasTruncated = true;
               lastUsage = event.usage;
+              if (event.usage && event.usage.promptTokens > 0) {
+                this.serverTokenBaseline = {
+                  localTokens: requestLocalTokens,
+                  serverTokens: event.usage.promptTokens
+                };
+              }
               yield this.foldSubagentUsage(event);
             } else if (event.type === "error") {
               failure = event.error;
@@ -2933,6 +3110,7 @@ ${finished.result}`
             failure = toStreamErrorInfo(error);
           }
         }
+        this.inflightStreamText = "";
         if (signal.aborted) {
           yield* this.persistInterrupted(text, toolCalls);
           await this.runStopHooks("aborted");
@@ -2985,6 +3163,14 @@ ${finished.result}`
         return;
       }
       if (!hasOutput()) {
+        const steered2 = await this.drainSteers();
+        if (steered2 > 0) {
+          yield {
+            type: "notice",
+            message: `${steered2} steering message(s) delivered to the model after an empty reply.`
+          };
+          continue;
+        }
         if (isSteerableEmptyFinish(lastFinishReason) && config.permissionMode !== "plan" && autoContinues < config.maxAutoContinues) {
           autoContinues++;
           lastWasNudge = true;
@@ -3026,6 +3212,16 @@ ${finished.result}`
       this.messages.push({ message: assistantMessage });
       await this.persist(assistantMessage);
       if (toolCalls.length === 0) {
+        const steered2 = await this.drainSteers();
+        if (steered2 > 0) {
+          autoContinues = 0;
+          lastWasNudge = false;
+          yield {
+            type: "notice",
+            message: `${steered2} steering message(s) delivered to the model; the turn continues.`
+          };
+          continue;
+        }
         if (wasTruncated) {
           if (config.permissionMode !== "plan" && streamCutContinues < config.streamMaxRetries) {
             streamCutContinues++;
@@ -3114,7 +3310,8 @@ ${finished.result}`
       try {
         for (const call of toolCalls) {
           if (signal.aborted) break;
-          const refusal = this.doomLoopRefusal(call);
+          const refusal = call.invalidArgs !== void 0 ? `Tool call not executed \u2014 ${call.invalidArgs}
+Reissue ${call.name} with valid arguments.` : this.doomLoopRefusal(call);
           if (refusal !== null) {
             yield { type: "notice", message: refusal };
           } else {
@@ -3194,6 +3391,7 @@ ${finished.result}`
         return;
       }
       step++;
+      stepsSinceTodoChange++;
     }
   }
   // The permission mode can change at runtime, so the system message is
@@ -3507,4 +3705,4 @@ export {
   attachTurnContext,
   AgentLoop
 };
-//# sourceMappingURL=chunk-MNVCCOI2.js.map
+//# sourceMappingURL=chunk-63CGUF3F.js.map