muonroi-cli 1.7.2 → 1.8.1

package/dist/src/orchestrator/sandbox.test.js

@@ -39,21 +39,23 @@ afterEach(() => {
     vi.doUnmock("../storage/index.js");
 });
 describe("Agent sandbox mode", { timeout: 30_000 }, () => {
-    it("can switch sandbox mode at runtime", async () => {
+    it("can switch sandbox mode at runtime — always 'off' (sandbox removed)", async () => {
         const { Agent } = await importAgentModule();
         const agent = new Agent(undefined, undefined, undefined, undefined, {
             persistSession: false,
             sandboxMode: "off",
         });
         expect(agent.getSandboxMode()).toBe("off");
+        // Sandbox has been removed: setSandboxMode is a no-op stub.
+        // The mode remains "off" regardless of what is passed.
         agent.setSandboxMode("shuru");
-        expect(agent.getSandboxMode()).toBe("shuru");
+        expect(agent.getSandboxMode()).toBe("off");
     });
-    it("passes sandbox mode into background delegations", async () => {
+    it("passes sandbox mode into background delegations — always 'off' (sandbox removed)", async () => {
         const { Agent } = await importAgentModule();
         const agent = new Agent(undefined, undefined, undefined, undefined, {
             persistSession: false,
-            sandboxMode: "shuru",
+            sandboxMode: "shuru", // accepted for back-compat but ignored
         });
         const startMock = vi.fn(async () => ({ success: true, output: "ok" }));
         agent.delegations.start = startMock;
@@ -62,7 +64,8 @@ describe("Agent sandbox mode", { timeout: 30_000 }, () => {
             description: "Inspect",
             prompt: "Look around",
         });
-        expect(startMock).toHaveBeenCalledWith(expect.objectContaining({ agent: "explore" }), expect.objectContaining({ sandboxMode: "shuru" }));
+        // Sandbox removed: delegations always receive sandboxMode: "off".
+        expect(startMock).toHaveBeenCalledWith(expect.objectContaining({ agent: "explore" }), expect.objectContaining({ sandboxMode: "off" }));
     });
     it("can get and set sandbox settings", async () => {
         const { Agent } = await importAgentModule();

package/dist/src/orchestrator/scope-ceiling.js

@@ -80,7 +80,7 @@ export function parseBudgetOverride(raw) {
         return { override: undefined, cleanedPrompt: raw };
     // Strip the entire matched segment including its leading/trailing whitespace
     // and re-collapse the surrounding spaces.
-    const cleaned = (raw.slice(0, match.index ?? 0) + " " + raw.slice((match.index ?? 0) + match[0].length))
+    const cleaned = `${raw.slice(0, match.index ?? 0)} ${raw.slice((match.index ?? 0) + match[0].length)}`
         .replace(/\s+/g, " ")
         .trim();
     return { override: n, cleanedPrompt: cleaned };

package/dist/src/orchestrator/stall-watchdog.d.ts

@@ -57,6 +57,53 @@ export interface StallRepromptState {
  * effects) so it is unit-testable in isolation from the orchestrator loop.
  */
 export declare function shouldRepromptStall(s: StallRepromptState): boolean;
+/** Inputs to the mid-loop stall continuation decision — see {@link shouldContinueAfterMidLoopStall}. */
+export interface MidLoopStallState {
+    /** The watchdog fired for this attempt. */
+    stallTriggered: boolean;
+    /**
+     * Real content parts received across the WHOLE streamText attempt (all steps).
+     * `> 0` proves earlier tool steps already ran — so this is NOT a time-to-first-
+     * byte stall (that case is handled by {@link shouldRepromptStall}).
+     */
+    chunksThisAttempt: number;
+    /**
+     * Real content parts received since the last step boundary (reset in
+     * `prepareStep`). `0` means the in-flight step's provider request produced no
+     * byte before the watchdog fired — a dead socket on a SINGLE step, with every
+     * prior step fully completed. Safe to continue: the completed steps'
+     * assistant+tool messages are appended to history before re-issuing, so no
+     * tool is re-run and no text is duplicated.
+     */
+    chunksThisStep: number;
+    /** How many mid-loop continuations have already happened this turn. */
+    retryCount: number;
+    /** Configured cap (getProviderStallRetries); 0 disables continuation. */
+    maxRetries: number;
+    /** True on genuine user cancel (never continue over a cancel). */
+    aborted: boolean;
+}
+/**
+ * Decide whether a fired stall watchdog should CONTINUE the turn (append the
+ * completed steps' messages, then re-issue streamText to resume from the
+ * stalled step) instead of falling through to the partial-answer rescue.
+ *
+ * This is the mid-loop counterpart to {@link shouldRepromptStall}. The TTFB
+ * re-prompt restarts the WHOLE request from the original prompt, so it is gated
+ * on `chunksThisAttempt === 0` to avoid re-running tools. Continuation instead
+ * preserves all completed steps in history (assistant tool-calls + their
+ * tool-results), so re-issuing cannot re-run a tool — making it safe even when
+ * earlier steps had side effects (writes, commits).
+ *
+ * Qualifies ONLY when: the watchdog fired, earlier steps ran
+ * (`chunksThisAttempt > 0`), the CURRENT step produced nothing
+ * (`chunksThisStep === 0` → a clean dead socket, no partial text to duplicate),
+ * under the retry cap, and not a user cancel. A step that emitted partial text
+ * then stalled (`chunksThisStep > 0`) falls through to rescue instead, since
+ * re-issuing would duplicate that partial output. Pure (no side effects) so it
+ * is unit-testable in isolation from the orchestrator loop.
+ */
+export declare function shouldContinueAfterMidLoopStall(s: MidLoopStallState): boolean;
 /**
  * Exponential backoff (ms, capped at 4s) before the Nth stall re-prompt
  * (1-based): 500 → 1000 → 2000 → 4000 → 4000.

package/dist/src/orchestrator/stall-watchdog.js

@@ -40,6 +40,29 @@ export function shouldRepromptStall(s) {
         s.assistantTextEmpty &&
         !s.aborted);
 }
+/**
+ * Decide whether a fired stall watchdog should CONTINUE the turn (append the
+ * completed steps' messages, then re-issue streamText to resume from the
+ * stalled step) instead of falling through to the partial-answer rescue.
+ *
+ * This is the mid-loop counterpart to {@link shouldRepromptStall}. The TTFB
+ * re-prompt restarts the WHOLE request from the original prompt, so it is gated
+ * on `chunksThisAttempt === 0` to avoid re-running tools. Continuation instead
+ * preserves all completed steps in history (assistant tool-calls + their
+ * tool-results), so re-issuing cannot re-run a tool — making it safe even when
+ * earlier steps had side effects (writes, commits).
+ *
+ * Qualifies ONLY when: the watchdog fired, earlier steps ran
+ * (`chunksThisAttempt > 0`), the CURRENT step produced nothing
+ * (`chunksThisStep === 0` → a clean dead socket, no partial text to duplicate),
+ * under the retry cap, and not a user cancel. A step that emitted partial text
+ * then stalled (`chunksThisStep > 0`) falls through to rescue instead, since
+ * re-issuing would duplicate that partial output. Pure (no side effects) so it
+ * is unit-testable in isolation from the orchestrator loop.
+ */
+export function shouldContinueAfterMidLoopStall(s) {
+    return (s.stallTriggered && s.chunksThisAttempt > 0 && s.chunksThisStep === 0 && s.retryCount < s.maxRetries && !s.aborted);
+}
 /**
  * Exponential backoff (ms, capped at 4s) before the Nth stall re-prompt
  * (1-based): 500 → 1000 → 2000 → 4000 → 4000.

package/dist/src/orchestrator/stall-watchdog.test.js

@@ -1,5 +1,5 @@
 import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
-import { createStallWatchdog, STALL_ABORT_REASON, shouldRepromptStall, stallRepromptBackoffMs, } from "./stall-watchdog.js";
+import { createStallWatchdog, STALL_ABORT_REASON, shouldContinueAfterMidLoopStall, shouldRepromptStall, stallRepromptBackoffMs, } from "./stall-watchdog.js";
 describe("createStallWatchdog", () => {
     beforeEach(() => vi.useFakeTimers());
     afterEach(() => vi.useRealTimers());
@@ -103,6 +103,41 @@ describe("shouldRepromptStall", () => {
         expect(shouldRepromptStall(ttfb({ aborted: true }))).toBe(false);
     });
 });
+describe("shouldContinueAfterMidLoopStall", () => {
+    // A clean mid-loop dead socket: watchdog fired AFTER earlier steps ran
+    // (chunksThisAttempt > 0), but the in-flight step produced nothing
+    // (chunksThisStep === 0). The ONLY shape that continues. Distinct from the
+    // TTFB re-prompt, which requires chunksThisAttempt === 0.
+    const midLoop = (over = {}) => ({
+        stallTriggered: true,
+        chunksThisAttempt: 132, // 66 prior steps' worth of chunks
+        chunksThisStep: 0,
+        retryCount: 0,
+        maxRetries: 1,
+        aborted: false,
+        ...over,
+    });
+    it("continues a mid-loop dead-socket stall under the cap", () => {
+        expect(shouldContinueAfterMidLoopStall(midLoop())).toBe(true);
+    });
+    it("does NOT continue when the watchdog never fired", () => {
+        expect(shouldContinueAfterMidLoopStall(midLoop({ stallTriggered: false }))).toBe(false);
+    });
+    it("does NOT continue a time-to-first-byte stall (chunksThisAttempt === 0 → TTFB re-prompt owns it)", () => {
+        expect(shouldContinueAfterMidLoopStall(midLoop({ chunksThisAttempt: 0 }))).toBe(false);
+    });
+    it("does NOT continue when the stalled step already emitted output (would duplicate)", () => {
+        expect(shouldContinueAfterMidLoopStall(midLoop({ chunksThisStep: 3 }))).toBe(false);
+    });
+    it("does NOT continue once the retry cap is reached", () => {
+        expect(shouldContinueAfterMidLoopStall(midLoop({ retryCount: 1, maxRetries: 1 }))).toBe(false);
+        // maxRetries=0 means the feature is disabled — never continue.
+        expect(shouldContinueAfterMidLoopStall(midLoop({ retryCount: 0, maxRetries: 0 }))).toBe(false);
+    });
+    it("does NOT continue over a genuine user cancel", () => {
+        expect(shouldContinueAfterMidLoopStall(midLoop({ aborted: true }))).toBe(false);
+    });
+});
 describe("stallRepromptBackoffMs", () => {
     it("grows exponentially and caps at 4s", () => {
         expect(stallRepromptBackoffMs(1)).toBe(500);

package/dist/src/orchestrator/stream-runner.js

@@ -34,8 +34,10 @@ import { normalizeModelId } from "../models/registry.js";
 import { cheapModelShellLine, injectCheapModelPlaybook, injectCheapModelShellDirective, shouldInjectCheapModelPlaybook, } from "../pil/cheap-model-playbook.js";
 import { injectCheapModelWorkbook, shouldInjectCheapModelWorkbook, subagentTaskType, } from "../pil/cheap-model-workbooks.js";
 import { getProviderCapabilities } from "../providers/capabilities.js";
+import { getVisionGuidanceForTextOnly } from "../providers/mcp-vision-bridge.js";
 import { captureToolSchemas } from "../providers/patch-zod-schema.js";
 import { buildTurnProviderOptions, requireRuntimeProvider, resolveModelRuntime, shouldDropParam, } from "../providers/runtime.js";
+import { needsVisionProxy } from "../providers/vision-proxy.js";
 import { wireDebug } from "../providers/wire-debug.js";
 import { BashTool } from "../tools/bash.js";
 import { createBuiltinTools } from "../tools/registry.js";
@@ -56,7 +58,7 @@ import { attachReminderToMessages, buildScopeReminder, cadenceForSize, shouldInj
 import { recordCompaction, recordElision } from "./session-experience.js";
 import { createStallWatchdog, STALL_ERROR_MESSAGE } from "./stall-watchdog.js";
 import { wrapToolSetWithCap } from "./sub-agent-cap.js";
-import { compactSubAgentMessages } from "./subagent-compactor.js";
+import { compactSubAgentMessages, applyAnthropicPromptCaching } from "./subagent-compactor.js";
 import { combineAbortSignals, firstLine, formatSubagentActivity } from "./tool-utils.js";
 /**
  * StreamRunner — extracted sub-agent stream lifecycle.
@@ -133,10 +135,19 @@ export class StreamRunner {
                 : topBash.getSandboxSettings(),
             shellSettings: getCurrentShellSettings(),
         });
+        // Resolve child model early so we can pass modelId to createBuiltinTools
+        // (needed for vision-proxy tools: analyze_image / ask_vision_proxy).
+        const childModelId = normalizeModelId(isVision
+            ? VISION_MODEL
+            : isComputer
+                ? COMPUTER_MODEL
+                : custom
+                    ? custom.model
+                    : this.deps.resolveModelForTask(isExplore ? "explore" : isVerify || isVerifyDetect || isVerifyManifest ? "verify" : "general"));
         // Mirror the file-local `createTools` wrapper from orchestrator.ts —
-        // it calls createBuiltinTools(bash, mode) without provider/opts; the
-        // provider arg in the original wrapper was unused.
-        const childBaseToolsRaw = createBuiltinTools(childBash, childMode);
+        // pass modelId so registry can inject analyze_image/ask_vision_proxy for
+        // text-only child models (needsVisionProxy).
+        const childBaseToolsRaw = createBuiltinTools(childBash, childMode, { modelId: childModelId });
         // Wrap with the cumulative cap so the sub-agent's tool loop cannot
         // accumulate unbounded tool_result tokens. See sub-agent-cap.ts for the
         // tiered compression schedule. The cap is per-invocation; each sub-agent
@@ -161,13 +172,6 @@ export class StreamRunner {
         let lastActivity = initialDetail;
         let childTools = childBaseTools;
         let closeMcp;
-        const childModelId = normalizeModelId(isVision
-            ? VISION_MODEL
-            : isComputer
-                ? COMPUTER_MODEL
-                : custom
-                    ? custom.model
-                    : this.deps.resolveModelForTask(isExplore ? "explore" : isVerify || isVerifyDetect || isVerifyManifest ? "verify" : "general"));
         const topModelId = this.deps.getModelId();
         if (childModelId !== topModelId) {
             statusBarStore.setState({ routed_from: topModelId, model: childModelId });
@@ -212,6 +216,11 @@ export class StreamRunner {
         const childSystem = shouldInjectCheapModelPlaybook(childRuntime.modelInfo)
             ? injectCheapModelShellDirective(childWithPlaybook, cheapModelShellLine(resolveShell({}).kind, process.platform))
             : childWithPlaybook;
+        // Inject vision proxy guidance for text-only child models (DeepSeek etc.)
+        // so sub-agents know to use analyze_image / ask_vision_proxy when they
+        // receive image context or file paths. Mirrors top-level in message-processor.
+        const visionGuidance = needsVisionProxy(childModelId) ? getVisionGuidanceForTextOnly(childModelId) : "";
+        const childSystemWithVision = visionGuidance ? `${childSystem}\n\n${visionGuidance}` : childSystem;
         onActivity?.(initialDetail);
         if (childMode === "agent" && taskCaps.supportsClientTools(childRuntime.modelInfo)) {
             const mcpBundle = await acquireMcpTools(loadMcpServers(), {
@@ -245,7 +254,8 @@ export class StreamRunner {
         // signal is intentionally unused on this branch — vision was the only consumer.
         void signal;
         const childMessages = [{ role: "user", content: childPrompt }];
-        const maxSteps = Math.min(this.deps.getMaxToolRounds(), isExplore ? 60 : 120);
+        // The main agent manages its sub-agents, so don't apply an arbitrary hard limit.
+        const maxSteps = request.maxToolRounds ?? (this.deps.getMaxToolRounds() * 2);
         // F1 parity — derive per-turn providerOptions so the sub-agent OpenAI calls
         // carry a stable session-derived promptCacheKey (every tool round routes to
         // the same cache node, keeping the unchanging prefix cached). The top-level
@@ -265,7 +275,7 @@ export class StreamRunner {
                 childMode,
                 childBash,
                 childRuntime,
-                childSystem,
+                childSystem: childSystemWithVision,
                 childMessages,
                 childTools,
                 childProviderOptions,
@@ -348,16 +358,16 @@ export class StreamRunner {
         // Explore sub-agents are READ-ONLY research — a codebase investigation
         // legitimately needs more grep/read steps than the tight general/medium=10
         // cell allows. Cutting it early (esp. for reasoning models that front-load
-        // tool calls) leaves no budget to reach the synthesis turn (root cause of
-        // empty "Task completed. Last action: grep" returns). Give explore the
-        // analyze/large cell (15); edit-capable agents keep general/medium (10).
+        // Sub-agent ceiling is no longer a hard halt. Per user request:
+        // "cũng áp dụng với sub agent nhé không nên hardcode maxtool mà nếu có
+        // vấn đề gì sẽ có main agent (khi spawn) kiểm soát đừng hard"
         const _subCeiling = isExplore ? resolveCeiling("analyze", "large") : resolveCeiling("general", "medium");
         const _subCounterKey = `subagent:${subCallId}`;
         const _subStopWhen = (async (state) => {
+            incSessionStep(_subCounterKey); // Keep telemetry counter ticking
             if (state.steps.length >= maxSteps)
                 return true;
-            const next = incSessionStep(_subCounterKey);
-            return next >= _subCeiling;
+            return false;
         });
         // Silent-hang guard — mirror the top-level loop (message-processor.ts).
         // A sub-agent provider connection can accept the request but never send a
@@ -436,12 +446,19 @@ export class StreamRunner {
                         /* fail-open */
                     }
                 };
+                // T1.1 + T1.2 — reasoning models (DeepSeek V4 Flash, R1) emit 2K-5K
+                // CoT tokens per turn that accumulate across the multi-step loop.
+                // Strip old reasoning and compact earlier (ratio 0.3 vs 0.5) to
+                // cut ~40-60% of cumulative input tokens.
+                const isReasoningModel = childRuntime.modelInfo?.reasoning === true;
                 const compacted = compactSubAgentMessages(stripped, {
                     thresholdChars: compactThreshold,
                     keepLastTurns: compactKeepLast,
                     contextWindowTokens: childCtxWindow,
+                    contextFillRatio: isReasoningModel ? 0.3 : undefined,
                     keepToolIds: subKeepToolIds.length ? subKeepToolIds : undefined,
                     persistArtifact: persistSubArtifact,
+                    stripOldReasoning: isReasoningModel,
                 });
                 if (compacted !== stripped)
                     recordCompaction(stepNumber);
@@ -456,21 +473,26 @@ export class StreamRunner {
                 const _subK = cadenceForSize(_subSize);
                 const _subShouldRemind = shouldInjectReminder(stepNumber, _subK);
                 const _subShouldWarn = shouldInjectSoftWarn(stepNumber, _subCeiling, _subCounterKey);
-                if (_subShouldRemind || _subShouldWarn) {
-                    const _baseReminder = buildScopeReminder({
-                        step: stepNumber,
-                        ceiling: _subCeiling,
-                        taskType: "general",
-                        size: _subSize,
-                        originalPrompt: prepared.request.prompt,
-                    });
-                    const _reminder = _subShouldWarn ? `[approaching ceiling] ${_baseReminder}` : _baseReminder;
-                    const withReminder = attachReminderToMessages(compacted, _reminder);
-                    return { messages: withReminder };
+                const finalMessages = (() => {
+                    if (_subShouldRemind || _subShouldWarn) {
+                        const _baseReminder = buildScopeReminder({
+                            step: stepNumber,
+                            ceiling: _subCeiling,
+                            taskType: "general",
+                            size: _subSize,
+                            originalPrompt: prepared.request.prompt,
+                        });
+                        const _reminder = _subShouldWarn ? `[approaching ceiling] ${_baseReminder}` : _baseReminder;
+                        return attachReminderToMessages(compacted, _reminder);
+                    }
+                    return compacted;
+                })();
+                if (childRuntime.modelId.startsWith("claude")) {
+                    return { messages: applyAnthropicPromptCaching(finalMessages, childRuntime.modelId) };
                 }
                 if (compacted === stripped && stripped === messages)
                     return undefined;
-                return { messages: compacted };
+                return { messages: finalMessages };
             },
             ...(childDropTemperature ? {} : { temperature: isExplore ? 0.2 : 0.5 }),
             ...(childDropMaxOutput ? {} : { maxOutputTokens: Math.min(this.deps.getMaxTokens(), 8_192) }),

package/dist/src/orchestrator/sub-agent-cap.d.ts

@@ -64,6 +64,8 @@ export interface SubAgentCapState {
     cumulative: number;
     /** Configured ceiling. */
     max: number;
+    /** Hard cap ceiling (e.g. max * 2). */
+    hardMax?: number;
     /** True once `cumulative >= max` (sub-agent should wrap up). */
     exhausted: boolean;
     /** Number of duplicate-output detections (telemetry / tests). */

package/dist/src/orchestrator/sub-agent-cap.js

@@ -46,7 +46,9 @@ function shortHash(text) {
     return createHash("sha1").update(text).digest("hex").slice(0, 12);
 }
 export function compressForCap(state, raw) {
-    if (state.exhausted) {
+    const hardCeiling = state.hardMax ?? state.max;
+    if (state.exhausted || state.cumulative >= hardCeiling) {
+        state.exhausted = true;
         return `[${state.label} tool budget exhausted (${state.cumulative}/${state.max} chars). Further tool calls will return this stub. Summarize findings now and return.]`;
     }
     state.callIndex += 1;
@@ -68,7 +70,11 @@ export function compressForCap(state, raw) {
     }
     const ratio = state.cumulative / state.max;
     let out;
-    if (ratio >= state.highTierRatio) {
+    if (state.cumulative >= state.max) {
+        const trimmed = trimHead(raw, state.highTierChars, state.label);
+        out = `${trimmed}\n\n[Warning: ${state.label} tool budget exceeded (${state.cumulative}/${state.max} chars). Please finalize your work and summarize findings now.]`;
+    }
+    else if (ratio >= state.highTierRatio) {
         out = trimHead(raw, state.highTierChars, state.label);
     }
     else if (ratio >= state.midTierRatio) {
@@ -78,7 +84,7 @@ export function compressForCap(state, raw) {
         out = raw;
     }
     state.cumulative += out.length;
-    if (state.cumulative >= state.max)
+    if (state.cumulative >= hardCeiling)
         state.exhausted = true;
     return out;
 }
@@ -141,9 +147,11 @@ function wrapInternal(tools, state) {
  * cumulative state.
  */
 export function wrapToolSetWithCap(tools, opts = {}) {
+    const max = Math.max(20_000, opts.maxCumulativeChars ?? DEFAULT_MAX_CUMULATIVE_CHARS);
     const state = {
         cumulative: 0,
-        max: Math.max(20_000, opts.maxCumulativeChars ?? DEFAULT_MAX_CUMULATIVE_CHARS),
+        max,
+        hardMax: max * 2,
         exhausted: false,
         dedupHits: 0,
         seenHashes: new Map(),

package/dist/src/orchestrator/sub-agent-model-tier.js

@@ -24,7 +24,7 @@ export const TASK_TIER_PREFS = {
     // general sub-agents downgrade to balanced (was premium-first) — the top
     // model already planned the delegation; the focused execution doesn't need
     // premium. Premium remains the fallback so premium-only providers are unaffected.
-    general: ["balanced", "premium"],
+    general: ["balanced", "fast", "premium"],
     // verify keeps premium-first: a downgrade here would weaken the very check it
     // exists to perform. Mirrors council `verify` role preference.
     verify: ["premium", "balanced"],

package/dist/src/orchestrator/subagent-compactor.d.ts

@@ -96,6 +96,14 @@ export interface SubAgentCompactorOptions {
      * source:"tool-artifact" so layer3/ee.query can later fetch "full tool result id=xxx".
      */
     persistArtifact?: (toolCallId: string, toolName: string, fullContent: string, reason: string) => void;
+    /**
+     * T1.1 — strip reasoning parts from old assistant turns (older than
+     * keepLastTurns). Reasoning tokens (CoT / <think>) from prior turns are
+     * never re-read by the model but accumulate O(N) chars per turn, costing
+     * full input billing on every subsequent step. Default true for reasoning
+     * models, false otherwise.
+     */
+    stripOldReasoning?: boolean;
 }
 /**
  * G1 — coarse char→token conversion. The real ratio is provider/tokenizer
@@ -140,3 +148,16 @@ export declare function cumulativeMessageChars(messages: ReadonlyArray<ModelMess
  * step.
  */
 export declare function compactSubAgentMessages(messages: ReadonlyArray<ModelMessage>, opts?: SubAgentCompactorOptions): ModelMessage[];
+/**
+ * Injects Anthropic prompt caching (cacheControl) into the last message's content
+ * block(s) if the model is Claude (starts with 'claude').
+ * Creates a copy of the messages array and the last message to avoid mutating in-place.
+ */
+export declare function applyAnthropicPromptCaching(messages: readonly ModelMessage[], modelId: string): ModelMessage[];
+/**
+ * Safely slice message history to keep at most `maxMessages` messages.
+ * Preserves the system message(s) at the front and ensures that the slice
+ * starts with a "user" message and does not split assistant tool calls and
+ * corresponding tool results.
+ */
+export declare function sliceMessageHistory(messages: ReadonlyArray<ModelMessage>, maxMessages?: number): ModelMessage[];