qlogicagent 2.13.4 → 2.13.5

package/dist/agent/tool-loop/artifact-events.d.ts

@@ -0,0 +1,17 @@
+import type { TurnEvent } from "../types.js";
+import type { ToolExecutionResultPort } from "../../runtime/ports/index.js";
+type ToolSidecarEvent = Extract<TurnEvent, {
+    type: "plan_update" | "artifact";
+}>;
+type ToolCallLike = {
+    id: string;
+    function: {
+        arguments: string;
+    };
+};
+export declare function createToolSidecarEvents(params: {
+    turnId: string;
+    result: ToolExecutionResultPort;
+    toolCalls: ToolCallLike[];
+}): ToolSidecarEvent[];
+export {};

package/dist/agent/tool-loop/artifact-events.js

@@ -0,0 +1,75 @@
+const ARTIFACT_TOOL_SET = new Set(["write", "edit", "patch"]);
+export function createToolSidecarEvents(params) {
+    const { turnId, result, toolCalls } = params;
+    if (!result.ok)
+        return [];
+    const originalCall = toolCalls.find(tc => tc.id === result.callId);
+    if (!originalCall)
+        return [];
+    const events = [];
+    const callArgs = parseToolArguments(originalCall.function.arguments);
+    if (!callArgs)
+        return events;
+    if (result.toolName === "plan_mode" && callArgs.action === "exit" && typeof callArgs.plan === "string" && callArgs.plan.length > 0) {
+        events.push({
+            type: "plan_update",
+            turnId,
+            slug: "approved-plan",
+            content: callArgs.plan,
+        });
+    }
+    if (ARTIFACT_TOOL_SET.has(result.toolName)) {
+        const filePath = getArtifactPath(callArgs);
+        if (filePath) {
+            events.push({
+                type: "artifact",
+                turnId,
+                artifactId: `artifact-${result.callId}`,
+                artifactType: inferArtifactType(filePath),
+                title: filePath.split(/[\\/]/).pop() || filePath,
+                filePath,
+                language: inferLanguageFromPath(filePath),
+            });
+        }
+    }
+    return events;
+}
+function parseToolArguments(raw) {
+    try {
+        return JSON.parse(raw);
+    }
+    catch {
+        return null;
+    }
+}
+function getArtifactPath(args) {
+    return typeof args.file_path === "string" ? args.file_path
+        : typeof args.filePath === "string" ? args.filePath
+            : typeof args.path === "string" ? args.path
+                : undefined;
+}
+function inferArtifactType(filePath) {
+    const ext = filePath.split(".").pop()?.toLowerCase() ?? "";
+    if (["png", "jpg", "jpeg", "gif", "webp", "svg", "bmp", "ico"].includes(ext))
+        return "image";
+    if (["md", "txt", "pdf", "doc", "docx", "rtf", "html"].includes(ext))
+        return "document";
+    if (["mermaid", "mmd", "dot", "puml", "plantuml"].includes(ext))
+        return "diagram";
+    if (["csv", "tsv", "xlsx", "xls"].includes(ext))
+        return "table";
+    if (["ts", "tsx", "js", "jsx", "py", "rs", "go", "java", "c", "cpp", "h", "cs", "rb", "sh", "sql", "json", "yaml", "yml", "toml", "xml", "css", "scss", "vue", "svelte"].includes(ext))
+        return "code";
+    return "file";
+}
+function inferLanguageFromPath(filePath) {
+    const ext = filePath.split(".").pop()?.toLowerCase() ?? "";
+    const langMap = {
+        ts: "typescript", tsx: "typescriptreact", js: "javascript", jsx: "javascriptreact",
+        py: "python", rs: "rust", go: "go", java: "java", c: "c", cpp: "cpp", h: "c",
+        cs: "csharp", rb: "ruby", sh: "shellscript", sql: "sql", json: "json",
+        yaml: "yaml", yml: "yaml", toml: "toml", xml: "xml", html: "html",
+        css: "css", scss: "scss", vue: "vue", svelte: "svelte", md: "markdown",
+    };
+    return langMap[ext];
+}

package/dist/agent/tool-loop/budget-continuation-policy.d.ts

@@ -0,0 +1,22 @@
+import type { AgentLogger, ThinkingBlock, TokenUsage, ToolLoopTransition } from "../types.js";
+export interface BudgetContinuationPolicyInput {
+    tokenBudget: number | undefined;
+    totalUsage: TokenUsage;
+    budgetContinuationCount: number;
+    lastBudgetDeltaTokens: number;
+    lastBudgetGlobalTokens: number;
+    messages: unknown[];
+    finalText: string;
+    thinkingBlocks: readonly ThinkingBlock[];
+    getBudgetContinuationMessage(usagePct: number, totalUsed: number, tokenBudget?: number): string;
+    log: Pick<AgentLogger, "info">;
+}
+export interface BudgetContinuationPolicyDecision {
+    messages: unknown[];
+    budgetContinuationCount: number;
+    lastBudgetDeltaTokens: number;
+    lastBudgetGlobalTokens: number;
+    recoveryDetail: string;
+    transition: ToolLoopTransition;
+}
+export declare function resolveBudgetContinuationPolicy(input: BudgetContinuationPolicyInput): BudgetContinuationPolicyDecision | null;

package/dist/agent/tool-loop/budget-continuation-policy.js

@@ -0,0 +1,44 @@
+import { DIMINISHING_RETURNS_MIN_CONTINUATIONS, DIMINISHING_RETURNS_THRESHOLD, } from "../tunable-defaults.js";
+const MAX_BUDGET_CONTINUATIONS = 5;
+function totalTokens(usage) {
+    return usage.inputTokens + usage.outputTokens + (usage.reasoningTokens ?? 0);
+}
+function assistantMessage(finalText, thinkingBlocks) {
+    return {
+        role: "assistant",
+        content: finalText,
+        ...(thinkingBlocks.length > 0 && { thinkingBlocks: [...thinkingBlocks] }),
+    };
+}
+export function resolveBudgetContinuationPolicy(input) {
+    if (!input.tokenBudget || input.tokenBudget <= 0)
+        return null;
+    if (input.budgetContinuationCount >= MAX_BUDGET_CONTINUATIONS)
+        return null;
+    const totalUsed = totalTokens(input.totalUsage);
+    const usagePct = (totalUsed / input.tokenBudget) * 100;
+    const deltaSinceLastCheck = totalUsed - input.lastBudgetGlobalTokens;
+    const isDiminishing = input.budgetContinuationCount >= DIMINISHING_RETURNS_MIN_CONTINUATIONS &&
+        deltaSinceLastCheck < DIMINISHING_RETURNS_THRESHOLD &&
+        input.lastBudgetDeltaTokens < DIMINISHING_RETURNS_THRESHOLD;
+    if (isDiminishing) {
+        input.log.info(`token budget early stop: diminishing returns at ${Math.round(usagePct)}% (delta=${deltaSinceLastCheck})`);
+        return null;
+    }
+    if (usagePct >= 90)
+        return null;
+    const nextCount = input.budgetContinuationCount + 1;
+    const budgetMsg = {
+        role: "user",
+        content: input.getBudgetContinuationMessage(usagePct, totalUsed, input.tokenBudget),
+    };
+    input.log.info(`token budget continuation #${nextCount}: ${Math.round(usagePct)}% used`);
+    return {
+        messages: [...input.messages, assistantMessage(input.finalText, input.thinkingBlocks), budgetMsg],
+        budgetContinuationCount: nextCount,
+        lastBudgetDeltaTokens: deltaSinceLastCheck,
+        lastBudgetGlobalTokens: totalUsed,
+        recoveryDetail: `${Math.round(usagePct)}% used (#${nextCount})`,
+        transition: { reason: "token_budget_continuation" },
+    };
+}

package/dist/agent/tool-loop/completion-action-policy.d.ts

@@ -0,0 +1,19 @@
+import type { AgentLogger, ChatMessage, ThinkingBlock, ToolLoopTransition } from "../types.js";
+export type CompletionActionPolicyReason = "file_action_verification" | "multi_file_skeleton_verification";
+export interface CompletionActionPolicyInput {
+    inputMessages: readonly ChatMessage[];
+    messages: unknown[];
+    finalText: string;
+    thinkingBlocks: readonly ThinkingBlock[];
+    stopHookActive: boolean | undefined;
+    totalToolCallCount: number;
+    distinctToolNames: ReadonlySet<string>;
+    log: Pick<AgentLogger, "info">;
+}
+export interface CompletionActionPolicyDecision {
+    reason: CompletionActionPolicyReason;
+    messages: unknown[];
+    stopHookActive: true;
+    transition: ToolLoopTransition;
+}
+export declare function resolveCompletionActionPolicy(input: CompletionActionPolicyInput): CompletionActionPolicyDecision | null;

package/dist/agent/tool-loop/completion-action-policy.js

@@ -0,0 +1,68 @@
+const FILE_ACTION_PATTERN = /create\s+(?:a\s+)?file|write\s+(?:a\s+)?file|make\s+(?:a\s+)?file|fix|implement|modify|update|repair|generate\s+(?:a\s+)?file|new\s+file/i;
+function buildAssistantMessage(finalText, thinkingBlocks) {
+    return {
+        role: "assistant",
+        content: finalText,
+        ...(thinkingBlocks.length > 0 && { thinkingBlocks: [...thinkingBlocks] }),
+    };
+}
+function hasSuccessfulToolResult(msg) {
+    const m = msg;
+    const isError = m.is_error === true || (typeof m.content === "string" && m.content.startsWith("Error:"));
+    return m.role === "tool" && typeof m.content === "string" && !isError;
+}
+function appendLastToolResultInstruction(messages) {
+    const lastToolMsg = [...messages].reverse().find((m) => m.role === "tool");
+    if (lastToolMsg && typeof lastToolMsg.content === "string") {
+        lastToolMsg.content += "\n\n鈿狅笍 NOTE: You used shell commands but did not call the write or edit tool to create/modify the file. " +
+            "Shell commands may fail silently or produce incorrect results on this platform. " +
+            "Please use the 'write' tool directly to create the requested file with the correct content.";
+    }
+}
+function createDecision(reason, messages, assistantMsg, nudgeMsg) {
+    return {
+        reason,
+        messages: [...messages, assistantMsg, nudgeMsg],
+        stopHookActive: true,
+        transition: { reason: "stop_hook_blocking" },
+    };
+}
+export function resolveCompletionActionPolicy(input) {
+    if (input.stopHookActive)
+        return null;
+    const userMsg = input.inputMessages.find((m) => m.role === "user");
+    const userText = typeof userMsg?.content === "string" ? userMsg.content : "";
+    const requestsFileAction = FILE_ACTION_PATTERN.test(userText);
+    const usedWriteOrEdit = input.distinctToolNames.has("write") || input.distinctToolNames.has("edit");
+    if (requestsFileAction && !usedWriteOrEdit) {
+        input.log.info("AP1 action-verification: user requested file action but no write/edit tool was called, injecting nudge");
+        if (input.totalToolCallCount > 0) {
+            appendLastToolResultInstruction(input.messages);
+        }
+        const nudgeMsg = {
+            role: "user",
+            content: input.totalToolCallCount === 0
+                ? "You described what to do but did not actually call any tool to write or edit a file. " +
+                    "Please use the write or edit tool now to perform the requested action. Do not just describe the changes - actually make them."
+                : "You used shell commands but did not call the write or edit tool to create/modify the file. " +
+                    "Shell commands may fail on this platform. Please use the write tool directly to create the requested file with the correct content.",
+        };
+        return createDecision("file_action_verification", input.messages, buildAssistantMessage(input.finalText, input.thinkingBlocks), nudgeMsg);
+    }
+    if (input.totalToolCallCount >= 3 && input.distinctToolNames.has("write")) {
+        const fileWriteSuccessCount = input.messages.filter(hasSuccessfulToolResult).length;
+        if (fileWriteSuccessCount >= 3) {
+            input.log.info("AP3 verification nudge: 3+ files created, injecting completeness check");
+            const nudgeMsg = {
+                role: "user",
+                content: "You created multiple files. Before completing, verify: " +
+                    "(1) All imports between your files resolve to real exports. " +
+                    "(2) No TODO, placeholder, or 'not implemented' stubs remain. " +
+                    "(3) Functions that are imported are actually called, not just declared. " +
+                    "If everything is correct, confirm completion. If not, fix the issues now.",
+            };
+            return createDecision("multi_file_skeleton_verification", input.messages, buildAssistantMessage(input.finalText, input.thinkingBlocks), nudgeMsg);
+        }
+    }
+    return null;
+}

package/dist/agent/tool-loop/completion-action-policy.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/agent/tool-loop/completion-action-policy.test.js

@@ -0,0 +1,77 @@
+import { describe, expect, it, vi } from "vitest";
+import { resolveCompletionActionPolicy } from "./completion-action-policy.js";
+const log = { info: vi.fn() };
+function user(content) {
+    return { role: "user", content };
+}
+function baseInput(overrides = {}) {
+    return {
+        inputMessages: [user("Create a file at src/example.ts")],
+        messages: [],
+        finalText: "I will create it.",
+        thinkingBlocks: [],
+        stopHookActive: undefined,
+        totalToolCallCount: 0,
+        distinctToolNames: new Set(),
+        log,
+        ...overrides,
+    };
+}
+describe("resolveCompletionActionPolicy", () => {
+    it("requests a write/edit action when a file action completes without tools", () => {
+        const decision = resolveCompletionActionPolicy(baseInput());
+        expect(decision).toMatchObject({
+            reason: "file_action_verification",
+            stopHookActive: true,
+            transition: { reason: "stop_hook_blocking" },
+        });
+        expect(decision?.messages).toHaveLength(2);
+        expect(decision?.messages[0]).toMatchObject({ role: "assistant", content: "I will create it." });
+        expect(decision?.messages[1]).toMatchObject({ role: "user" });
+        expect(String(decision?.messages[1]?.content)).toContain("write or edit tool");
+    });
+    it("annotates the last tool result when shell commands were used without write/edit", () => {
+        const messages = [
+            { role: "assistant", content: "running shell" },
+            { role: "tool", name: "shell", tool_call_id: "call-1", content: "ok" },
+        ];
+        const decision = resolveCompletionActionPolicy(baseInput({
+            messages,
+            totalToolCallCount: 1,
+            distinctToolNames: new Set(["shell"]),
+        }));
+        expect(decision?.reason).toBe("file_action_verification");
+        expect(messages[1].content).toContain("NOTE:");
+        expect(String(decision?.messages.at(-1)?.content)).toContain("Please use the write tool directly");
+    });
+    it("does not intervene when write/edit already handled the file action", () => {
+        const decision = resolveCompletionActionPolicy(baseInput({
+            totalToolCallCount: 1,
+            distinctToolNames: new Set(["write"]),
+        }));
+        expect(decision).toBeNull();
+    });
+    it("requests multi-file skeleton verification after a broad write burst", () => {
+        const messages = [
+            { role: "tool", content: "created a", tool_call_id: "a" },
+            { role: "tool", content: "created b", tool_call_id: "b" },
+            { role: "tool", content: "created c", tool_call_id: "c" },
+        ];
+        const decision = resolveCompletionActionPolicy(baseInput({
+            messages,
+            finalText: "All files created.",
+            totalToolCallCount: 3,
+            distinctToolNames: new Set(["write"]),
+        }));
+        expect(decision).toMatchObject({
+            reason: "multi_file_skeleton_verification",
+            stopHookActive: true,
+            transition: { reason: "stop_hook_blocking" },
+        });
+        expect(String(decision?.messages.at(-1)?.content)).toContain("All imports between your files resolve");
+    });
+    it("stays quiet while a stop hook is already active", () => {
+        const decision = resolveCompletionActionPolicy(baseInput({ stopHookActive: true }));
+        expect(decision).toBeNull();
+    });
+});

package/dist/agent/tool-loop/completion-stop-policy.d.ts

@@ -0,0 +1,19 @@
+import type { AgentLogger, HookRegistry, ThinkingBlock, ToolLoopTransition } from "../types.js";
+export type CompletionStopPolicyDecision = {
+    action: "end";
+    content: string;
+} | {
+    action: "continue";
+    messages: unknown[];
+    stopHookActive: true;
+    transition: ToolLoopTransition;
+};
+export interface CompletionStopPolicyInput {
+    hooks: HookRegistry | undefined;
+    sessionId: string;
+    messages: unknown[];
+    finalText: string;
+    thinkingBlocks: readonly ThinkingBlock[];
+    log: Pick<AgentLogger, "info">;
+}
+export declare function resolveCompletionStopPolicy(input: CompletionStopPolicyInput): Promise<CompletionStopPolicyDecision | null>;

package/dist/agent/tool-loop/completion-stop-policy.js

@@ -0,0 +1,31 @@
+function assistantMessage(finalText, thinkingBlocks) {
+    return {
+        role: "assistant",
+        content: finalText,
+        ...(thinkingBlocks.length > 0 && { thinkingBlocks: [...thinkingBlocks] }),
+    };
+}
+export async function resolveCompletionStopPolicy(input) {
+    if (!input.hooks)
+        return null;
+    const stopResult = await input.hooks.invoke("stop", { sessionId: input.sessionId, reason: "completed" });
+    if (stopResult.action === "prevent") {
+        input.log.info(`stop hook prevented continuation: ${stopResult.reason ?? "no reason"}`);
+        return { action: "end", content: input.finalText };
+    }
+    if (stopResult.action === "abort") {
+        const reason = stopResult.reason ?? "Stop hook requested continuation";
+        input.log.info(`stop hook blocking: ${reason}`);
+        const continuationMsg = {
+            role: "user",
+            content: reason,
+        };
+        return {
+            action: "continue",
+            messages: [...input.messages, assistantMessage(input.finalText, input.thinkingBlocks), continuationMsg],
+            stopHookActive: true,
+            transition: { reason: "stop_hook_blocking" },
+        };
+    }
+    return null;
+}

package/dist/agent/tool-loop/compression-pipeline.d.ts

@@ -0,0 +1,44 @@
+/**
+ * Context compression pipeline — extracted phase of the tool loop (CC query.ts parity).
+ *
+ * Pure-ish transform with a side-channel of `recovery` events: takes the round's
+ * messages and runs the staged compaction
+ *   tool-result-budget → snip → microcompact → context-collapse → autocompact
+ * → whitespace filter, returning the messages to send to the LLM. Each stage runs
+ * before the next; an earlier stage that brings us under threshold makes later
+ * stages no-ops.
+ *
+ * Extracted from the main loop to cut its reading cost: this phase has no control-flow
+ * escape (never continues/returns the outer loop), so it is a clean `yield*` boundary.
+ * The only outward state mutation (resetting the reactive-compact guard after autocompact)
+ * is handed back through `onAutocompact` so the loop keeps ownership of its State.
+ */
+import type { AgentLogger, HookRegistry, TurnEvent } from "../types.js";
+import type { ToolLoopRuntimePorts } from "../../runtime/ports/index.js";
+import { type CollapseStore, type TurnLoopGuardConfig, type TurnLoopGuardState } from "../../orchestration/index.js";
+export interface CompressionPipelineDeps {
+    messages: unknown[];
+    contentReplacementState: unknown;
+    snipRemovedIds: Set<string>;
+    collapseStore: CollapseStore;
+    guardState: TurnLoopGuardState;
+    guardConfig: TurnLoopGuardConfig;
+    runtimePorts: ToolLoopRuntimePorts;
+    hooks: HookRegistry | undefined;
+    hookCtx: {
+        sessionId: string;
+        turnId: string;
+    };
+    sessionId: string;
+    currentModel: string;
+    log: AgentLogger;
+    /** Build + record a recovery event (centralized in the loop's recovery trace). */
+    recovery: (action: string, detail?: string) => TurnEvent;
+    /** Invoked when autocompact drops messages — caller resets its reactive-compact guard. */
+    onAutocompact: () => void;
+}
+/**
+ * Run the compression pipeline for one round. Yields `recovery` events for stages
+ * that actually fired; returns the (possibly compacted) messages to query with.
+ */
+export declare function runCompressionPipeline(deps: CompressionPipelineDeps): AsyncGenerator<TurnEvent, unknown[]>;

package/dist/agent/tool-loop/compression-pipeline.js

@@ -0,0 +1,68 @@
+import { fireHook } from "../../contracts/fire-hook.js";
+import { applyContextCollapsesIfNeeded, snipCompactIfNeeded, MicroCompactStrategy, } from "../../orchestration/index.js";
+import { filterWhitespaceOnlyAssistant } from "./loop-helpers.js";
+/**
+ * Run the compression pipeline for one round. Yields `recovery` events for stages
+ * that actually fired; returns the (possibly compacted) messages to query with.
+ */
+export async function* runCompressionPipeline(deps) {
+    const { messages, contentReplacementState, snipRemovedIds, collapseStore, guardState, guardConfig, runtimePorts, hooks, hookCtx, sessionId, currentModel, log, recovery, onAutocompact, } = deps;
+    let messagesForQuery;
+    // Stage 0: Tool result budget — enforce per-message aggregate budget (CC applyToolResultBudget)
+    {
+        const budgetResult = await runtimePorts.enforceToolResultBudget(messages, contentReplacementState, sessionId);
+        messagesForQuery = budgetResult.messages;
+        if (budgetResult.newlyReplacedCount > 0) {
+            log.info(`tool-result-budget: persisted ${budgetResult.newlyReplacedCount} oversized tool results`);
+            yield recovery("tool_result_budget", `${budgetResult.newlyReplacedCount} persisted`);
+        }
+    }
+    // Stage 1: Snip — remove messages by tool_call_id (CC HISTORY_SNIP)
+    {
+        const snipResult = snipCompactIfNeeded(messagesForQuery, snipRemovedIds);
+        messagesForQuery = snipResult.messages;
+        if (snipResult.removedCount > 0) {
+            log.info(`snip: removed ${snipResult.removedCount} messages, freed ~${snipResult.tokensFreed} tokens`);
+            yield recovery("snip", `${snipResult.removedCount} messages`);
+        }
+    }
+    // Stage 2: Microcompact — clear old tool results (CC microcompact)
+    {
+        const micro = new MicroCompactStrategy();
+        const microResult = micro.compress(messagesForQuery, 0);
+        if (microResult.droppedCount > 0) {
+            messagesForQuery = microResult.messages;
+            log.info(`microcompact: cleared ${microResult.droppedCount} old tool results`);
+        }
+    }
+    // Stage 3: Context collapse — project + maybe commit new collapses
+    {
+        const collapseResult = applyContextCollapsesIfNeeded(messagesForQuery, collapseStore);
+        messagesForQuery = collapseResult.messages;
+    }
+    // Stage 4: Autocompact — async pipeline with LLM summarization (CC parity).
+    // Uses the registered context engine (HeadTail protected summarization) when
+    // available; falls back to the sync pipeline otherwise.
+    if (guardState.promptTokens > 0) {
+        const compactBudget = guardConfig.contextWindowTokens * 0.75;
+        const contextEngine = runtimePorts.getActiveContextCompressionEngine();
+        let compactResult;
+        if (contextEngine) {
+            compactResult = await contextEngine.compressAsync(messagesForQuery, compactBudget, { model: currentModel, sessionId });
+        }
+        else {
+            compactResult = runtimePorts.compressMessages(messagesForQuery, { budget: compactBudget, model: currentModel });
+        }
+        if (compactResult.droppedCount > 0) {
+            messagesForQuery = compactResult.messages;
+            log.info(`autocompact: ${compactResult.strategy}, dropped ${compactResult.droppedCount}`);
+            yield recovery("autocompact", `${compactResult.strategy}: ${compactResult.droppedCount} dropped`);
+            // Post-compact: reset reactive compact guard + fire hook
+            onAutocompact();
+            fireHook(hooks, "context.after_compact", { ...hookCtx, removedCount: compactResult.droppedCount }, log);
+        }
+    }
+    // P2: Filter whitespace-only assistant messages
+    messagesForQuery = filterWhitespaceOnlyAssistant(messagesForQuery);
+    return messagesForQuery;
+}

package/dist/agent/tool-loop/loop-helpers.d.ts

@@ -0,0 +1,15 @@
+import type { ChatMessage } from "../types.js";
+export declare function isEmptyToolResult(r: {
+    toolName: string;
+    message: unknown;
+}): boolean;
+export declare function findLastToolError(messages: unknown[], _toolName: string): string | undefined;
+export declare function resolveToolLoopBudget(requested?: number): number;
+export declare function filterWhitespaceOnlyAssistant<T extends {
+    role: string;
+    content?: unknown;
+}>(messages: T[]): T[];
+export declare function synthesizeFallbackContent(messages: ChatMessage[], log: {
+    info: (m: string) => void;
+}): string;
+export declare function summarizeToolInput(rawArgs: string): string | undefined;

package/dist/agent/tool-loop/loop-helpers.js

@@ -0,0 +1,86 @@
+import { DEFAULT_TOOL_BUDGET, MAX_TOOL_BUDGET_CAP } from "../tunable-defaults.js";
+const EMPTY_RESULT_PATTERNS = /^no (matches|files|results) found(?:\s+for:.*)?\.?$|^file not found|^not found|^0 results|^\(exit code \d+, no output\)$/i;
+const SOFT_FAILURE_TOOLS = new Set(["search", "web_search", "grep", "glob", "find", "list", "read", "exec"]);
+export function isEmptyToolResult(r) {
+    if (!SOFT_FAILURE_TOOLS.has(r.toolName))
+        return false;
+    const content = typeof r.message?.content === "string"
+        ? r.message.content.trim()
+        : "";
+    return content.length > 0 && content.length < 200 && EMPTY_RESULT_PATTERNS.test(content);
+}
+export function findLastToolError(messages, _toolName) {
+    for (let i = messages.length - 1; i >= 0; i--) {
+        const m = messages[i];
+        if (!m || m.role !== "tool")
+            continue;
+        const content = typeof m.content === "string" ? m.content : "";
+        if (!content.startsWith("Error: "))
+            continue;
+        return content.slice(7).trim();
+    }
+    return undefined;
+}
+export function resolveToolLoopBudget(requested) {
+    if (typeof requested === "number" && Number.isFinite(requested) && requested >= 1) {
+        return Math.min(Math.round(requested), MAX_TOOL_BUDGET_CAP);
+    }
+    return DEFAULT_TOOL_BUDGET;
+}
+export function filterWhitespaceOnlyAssistant(messages) {
+    return messages.filter((m) => {
+        if (m.role !== "assistant")
+            return true;
+        if (typeof m.content === "string" && m.content.trim() === "")
+            return false;
+        return true;
+    });
+}
+export function synthesizeFallbackContent(messages, log) {
+    const toolResults = [];
+    for (let i = messages.length - 1; i >= 0; i--) {
+        const msg = messages[i];
+        if (msg.role === "tool" && typeof msg.content === "string") {
+            toolResults.unshift(msg.content.slice(0, 500));
+        }
+        else if (msg.role === "assistant") {
+            if (typeof msg.content === "string" && msg.content.trim()) {
+                log.info("synthesizeFallbackContent: found assistant text, using it");
+                return msg.content;
+            }
+            break;
+        }
+        else {
+            break;
+        }
+    }
+    if (toolResults.length > 0) {
+        log.info(`synthesizeFallbackContent: synthesized from ${toolResults.length} tool result(s)`);
+        return toolResults.join("\n\n");
+    }
+    return "";
+}
+export function summarizeToolInput(rawArgs) {
+    try {
+        const args = JSON.parse(rawArgs);
+        const candidates = [
+            args.description,
+            args.command,
+            args.query,
+            args.url,
+            args.path,
+            args.file_path,
+            args.filePath,
+            args.pattern,
+            args.model,
+        ];
+        const hit = candidates.find((value) => typeof value === "string" && value.trim().length > 0);
+        if (typeof hit === "string")
+            return hit.trim().slice(0, 240);
+        const keys = Object.keys(args);
+        return keys.length > 0 ? keys.slice(0, 5).join(" / ") : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}

package/dist/agent/tool-loop/recovery-helpers.d.ts

@@ -0,0 +1,18 @@
+export declare function isPromptTooLongError(error: {
+    status?: number;
+    message: string;
+}): boolean;
+export declare function isMaxOutputTokensTruncation(finishReason: string): boolean;
+export declare function isMediaSizeError(error: {
+    status?: number;
+    message: string;
+}): boolean;
+export declare function parseRetryAfterMs(error: {
+    status?: number;
+    message: string;
+    headers?: Record<string, string>;
+}): number | null;
+export declare function parseMaxTokensOverflow(error: {
+    status?: number;
+    message: string;
+}): number | null;

package/dist/agent/tool-loop/recovery-helpers.js

@@ -0,0 +1,42 @@
+export function isPromptTooLongError(error) {
+    const msg = error.message.toLowerCase();
+    return (error.status === 413 ||
+        msg.includes("prompt_too_long") ||
+        msg.includes("context_length_exceeded") ||
+        msg.includes("maximum context length"));
+}
+export function isMaxOutputTokensTruncation(finishReason) {
+    return finishReason === "length" || finishReason === "max_tokens";
+}
+export function isMediaSizeError(error) {
+    const msg = error.message.toLowerCase();
+    return (msg.includes("image") ||
+        msg.includes("media") ||
+        msg.includes("file too large") ||
+        msg.includes("payload too large")) && (error.status === 413 || msg.includes("too large") || msg.includes("size"));
+}
+export function parseRetryAfterMs(error) {
+    const headers = error.headers;
+    if (!headers)
+        return null;
+    const retryAfter = headers["retry-after"] ?? headers["Retry-After"];
+    if (!retryAfter)
+        return null;
+    const seconds = parseInt(retryAfter, 10);
+    if (!isNaN(seconds) && seconds > 0)
+        return seconds * 1000;
+    return null;
+}
+export function parseMaxTokensOverflow(error) {
+    if (error.status !== 400)
+        return null;
+    const match = error.message.match(/input length and `max_tokens` exceed context limit: (\d+) \+ (\d+) > (\d+)/);
+    if (!match?.[1] || !match?.[3])
+        return null;
+    const inputTokens = parseInt(match[1], 10);
+    const contextLimit = parseInt(match[3], 10);
+    if (isNaN(inputTokens) || isNaN(contextLimit))
+        return null;
+    const available = contextLimit - inputTokens - 1000;
+    return available >= 3000 ? available : null;
+}