qlogicagent 2.13.5 → 2.13.6

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

@@ -1,44 +0,0 @@
-/**
- * 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

@@ -1,68 +0,0 @@
-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

@@ -1,15 +0,0 @@
-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

@@ -1,86 +0,0 @@
-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

@@ -1,18 +0,0 @@
-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

@@ -1,42 +0,0 @@
-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;
-}

package/dist/agent/tool-loop/single-round.d.ts

@@ -1,2 +0,0 @@
-import type { AgentLogger, ChatMessage, LLMTransport, TurnEvent } from "../types.js";
-export declare function executeSingleLLMRound(turnId: string, model: string, messages: ChatMessage[], apiKey: string, temperature: number | undefined, signal: AbortSignal | undefined, transport: LLMTransport, log: AgentLogger): AsyncGenerator<TurnEvent>;

package/dist/agent/tool-loop/single-round.js

@@ -1,43 +0,0 @@
-export async function* executeSingleLLMRound(turnId, model, messages, apiKey, temperature, signal, transport, log) {
-    const textChunks = [];
-    let usage;
-    let sawTerminalChunk = false;
-    log.debug(`single LLM round, messages: ${messages.length}`);
-    for await (const chunk of transport.stream({ model, messages, temperature }, apiKey, signal)) {
-        switch (chunk.type) {
-            case "delta":
-                textChunks.push(chunk.text);
-                yield { type: "delta", turnId, text: chunk.text };
-                break;
-            case "usage":
-                usage = {
-                    inputTokens: chunk.promptTokens,
-                    outputTokens: chunk.completionTokens,
-                    reasoningTokens: chunk.reasoningTokens,
-                    cacheRead: chunk.cacheReadTokens,
-                    cacheWrite: chunk.cacheCreationTokens,
-                };
-                break;
-            case "done":
-                sawTerminalChunk = true;
-                break;
-        }
-    }
-    if (!sawTerminalChunk) {
-        yield {
-            type: "error",
-            turnId,
-            error: "LLM stream closed before a terminal event; the response was likely truncated upstream.",
-            code: "RETRYABLE_TRANSIENT",
-            usage: usage ?? { inputTokens: 0, outputTokens: 0 },
-        };
-        return;
-    }
-    yield {
-        type: "end",
-        turnId,
-        content: textChunks.join(""),
-        usage: usage ?? { inputTokens: 0, outputTokens: 0 },
-        model,
-    };
-}

package/dist/agent/tool-loop/skill-instruction-policy.d.ts

@@ -1,7 +0,0 @@
-import { buildSkillInstruction } from "../../orchestration/index.js";
-export interface SkillInstructionPolicyInput {
-    totalToolCallCount: number;
-    distinctToolNames: ReadonlySet<string>;
-    projectRoot?: string;
-}
-export declare function resolveToolUsageSkillInstruction(input: SkillInstructionPolicyInput): ReturnType<typeof buildSkillInstruction>;

package/dist/agent/tool-loop/skill-instruction-policy.js

@@ -1,18 +0,0 @@
-import { buildSkillInstruction, } from "../../orchestration/index.js";
-export function resolveToolUsageSkillInstruction(input) {
-    if (input.totalToolCallCount <= 0)
-        return null;
-    const skillResult = {
-        ok: true,
-        toolCallCount: input.totalToolCallCount,
-        distinctToolCount: input.distinctToolNames.size,
-        multiStep: input.totalToolCallCount >= 2,
-        hasSubAgent: false,
-        feedback: null,
-        existingSkillName: null,
-    };
-    return buildSkillInstruction(skillResult, {
-        tools: [...input.distinctToolNames],
-        projectRoot: input.projectRoot,
-    });
-}

package/dist/agent/tool-loop/stream-error-recovery.d.ts

@@ -1,59 +0,0 @@
-/**
- * Stream-error recovery — extracted phase of the tool loop (CC withRetry.ts parity).
- *
- * Handles an error thrown while streaming the LLM round. This is the loop's densest,
- * most regression-prone branch, so it is pulled out behind a small control-flow
- * protocol: the generator yields any user-facing events (recovery / error / heartbeat)
- * and RETURNS a decision the loop acts on, instead of `continue`/`return`-ing the outer
- * loop itself (which a sub-generator cannot do):
- *
- *   - { kind: "continue", patch } → loop applies `state = { ...state, ...patch }` and retries
- *   - { kind: "return" }          → loop returns (a terminal error event was already yielded)
- *   - { kind: "streamError", … }  → loop sets streamError and falls through to error withholding
- *
- * Behavior is byte-for-byte the same as the former inline catch block, including the
- * in-place `consecutive529Errors` increment (so the count persists onto the loop's State
- * whether we continue or fall through). Covered by tool-loop.states.test.ts:
- * fallback / stale-connection / max-tokens-overflow / 429-retry.
- */
-import type { AgentLogger, TokenUsage, ToolLoopTransition, TurnEvent } from "../types.js";
-/** Subset of the loop's State this phase reads / mutates in place. */
-export interface StreamErrorState {
-    consecutive529Errors: number;
-    consecutiveApiRetries: number;
-    currentModel: string;
-    totalUsage: TokenUsage;
-}
-/** Fields the loop should merge into State before continuing. */
-export interface StreamErrorPatch {
-    currentModel?: string;
-    consecutive529Errors?: number;
-    consecutiveApiRetries?: number;
-    maxOutputTokensOverride?: number;
-    transition?: ToolLoopTransition | undefined;
-}
-export type StreamErrorDecision = {
-    kind: "continue";
-    patch: StreamErrorPatch;
-} | {
-    kind: "return";
-} | {
-    kind: "streamError";
-    streamError: {
-        status?: number;
-        message: string;
-    };
-};
-export interface StreamErrorCtx {
-    state: StreamErrorState;
-    guardState: {
-        currentMaxOutputTokens: number;
-    };
-    fallbackModel: string | undefined;
-    signal: AbortSignal | undefined;
-    querySource: string | undefined;
-    turnId: string;
-    log: AgentLogger;
-    emitRecovery: (action: string, detail?: string) => TurnEvent;
-}
-export declare function handleStreamError(err: unknown, ctx: StreamErrorCtx): AsyncGenerator<TurnEvent, StreamErrorDecision>;

package/dist/agent/tool-loop/stream-error-recovery.js

@@ -1,93 +0,0 @@
-import { FallbackTriggeredError, isPersistentRetryEnabled, computeRetryBackoff, isForegroundSource, isTransientCapacityError, } from "../../orchestration/index.js";
-import { parseMaxTokensOverflow, parseRetryAfterMs } from "./recovery-helpers.js";
-import { MAX_API_RETRIES, MAX_529_RETRIES, HEARTBEAT_INTERVAL_MS } from "../tunable-defaults.js";
-export async function* handleStreamError(err, ctx) {
-    const { state, guardState, fallbackModel, signal, querySource, turnId, log, emitRecovery } = ctx;
-    // P0: FallbackTriggeredError catch (CC parity)
-    if (err instanceof FallbackTriggeredError && fallbackModel) {
-        log.info(`model fallback triggered: ${err.originalModel} -> ${err.fallbackModel}`);
-        yield emitRecovery("model_fallback", `${err.originalModel} -> ${err.fallbackModel}`);
-        return {
-            kind: "continue",
-            patch: { currentModel: err.fallbackModel, consecutive529Errors: 0, consecutiveApiRetries: 0, transition: undefined },
-        };
-    }
-    const message = err instanceof Error ? err.message : String(err);
-    const status = typeof err?.status === "number"
-        ? err.status
-        : undefined;
-    // CC isStaleConnectionError parity: ECONNRESET/EPIPE -> retry immediately
-    if (!status && message && (message.includes("ECONNRESET") || message.includes("EPIPE"))) {
-        const nextRetries = (state.consecutiveApiRetries ?? 0) + 1;
-        if (nextRetries > MAX_API_RETRIES) {
-            log.info(`stale connection retry limit reached (${MAX_API_RETRIES}), aborting`);
-            yield { type: "error", turnId, error: message, code: "RETRIES_EXHAUSTED", usage: state.totalUsage };
-            return { kind: "return" };
-        }
-        log.info(`stale connection (${message.includes("ECONNRESET") ? "ECONNRESET" : "EPIPE"}): retrying`);
-        yield emitRecovery("stale_connection_retry", message.slice(0, 80));
-        return { kind: "continue", patch: { consecutiveApiRetries: nextRetries, transition: undefined } };
-    }
-    // P2: max_tokens context overflow (CC parseMaxTokensContextOverflowError)
-    const overflowMaxTokens = parseMaxTokensOverflow({ status, message });
-    if (overflowMaxTokens !== null) {
-        log.info(`max_tokens overflow: adjusting to ${overflowMaxTokens}`);
-        guardState.currentMaxOutputTokens = overflowMaxTokens;
-        return { kind: "continue", patch: { maxOutputTokensOverride: overflowMaxTokens, transition: undefined } };
-    }
-    // P0: 529/429 consecutive tracking + fallback (CC withRetry.ts parity)
-    if (isTransientCapacityError(status)) {
-        // In-place increment so the count persists onto State on every exit path
-        // (continue OR streamError fall-through), matching the former inline behavior.
-        state.consecutive529Errors++;
-        // Hard limit: abort after too many consecutive transient errors without fallback
-        // or persistent retry. Transport retries 2x/call, so limit=2 caps at ~9 HTTP reqs.
-        const TRANSIENT_HARD_LIMIT = 2;
-        const canFallback = fallbackModel && state.currentModel !== fallbackModel;
-        if (state.consecutive529Errors > TRANSIENT_HARD_LIMIT && !canFallback && !isPersistentRetryEnabled()) {
-            log.info(`transient ${status} 脳 ${state.consecutive529Errors}: hard limit reached, aborting`);
-            yield {
-                type: "error",
-                turnId,
-                error: `API unavailable after ${state.consecutive529Errors} consecutive ${status} errors`,
-                code: "API_ERROR",
-                usage: state.totalUsage,
-            };
-            return { kind: "return" };
-        }
-        if (state.consecutive529Errors >= MAX_529_RETRIES && fallbackModel && state.currentModel !== fallbackModel) {
-            log.info(`529 脳 ${state.consecutive529Errors}: triggering fallback to ${fallbackModel}`);
-            yield emitRecovery("model_fallback", `529 脳 ${state.consecutive529Errors}`);
-            return { kind: "continue", patch: { currentModel: fallbackModel, consecutive529Errors: 0, transition: undefined } };
-        }
-        // P0: Persistent retry (CC UNATTENDED_RETRY parity)
-        if (isPersistentRetryEnabled()) {
-            const backoff = computeRetryBackoff(state.consecutive529Errors);
-            log.info(`persistent retry: waiting ${backoff}ms (attempt ${state.consecutive529Errors})`);
-            let remaining = backoff;
-            while (remaining > 0) {
-                if (signal?.aborted) {
-                    yield { type: "error", turnId, error: "Aborted during retry wait", code: "ABORTED", usage: state.totalUsage };
-                    return { kind: "return" };
-                }
-                yield { type: "heartbeat", turnId, message: `Retrying in ${Math.ceil(remaining / 1000)}s (${status})` };
-                const chunk = Math.min(remaining, HEARTBEAT_INTERVAL_MS);
-                await new Promise((r) => setTimeout(r, chunk));
-                remaining -= chunk;
-            }
-            return { kind: "continue", patch: { transition: undefined } };
-        }
-        // Foreground/background retry distinction (CC parity)
-        if (isForegroundSource(querySource)) {
-            const retryDelay = parseRetryAfterMs({ status, message });
-            const delay = retryDelay ?? computeRetryBackoff(state.consecutive529Errors);
-            log.info(`transient ${status}: retry in ${delay}ms`);
-            yield emitRecovery("retry", `${status} retry in ${delay}ms`);
-            await new Promise((r) => setTimeout(r, delay));
-            return { kind: "continue", patch: { transition: undefined } };
-        }
-        // Background: bail immediately
-        log.info(`background source ${querySource}: not retrying ${status}`);
-    }
-    return { kind: "streamError", streamError: { status, message } };
-}

package/dist/agent/tool-loop/tool-failure-policy.d.ts

@@ -1,22 +0,0 @@
-import type { ChatMessage } from "../types.js";
-import type { OpenAiToolCall } from "../../orchestration/index.js";
-export interface VariantBlockedToolCall {
-    call: OpenAiToolCall;
-    failCount: number;
-    error: string;
-}
-export declare function splitVariantToolCalls(calls: readonly OpenAiToolCall[], toolFailureCounts: ReadonlyMap<string, number>): {
-    allowed: OpenAiToolCall[];
-    blocked: VariantBlockedToolCall[];
-};
-export declare function variantBlockNudge(): ChatMessage;
-export declare function recordToolFailureResult(input: {
-    toolFailureCounts: Map<string, number>;
-    toolName: string;
-    ok: boolean;
-    softEmpty: boolean;
-}): void;
-export declare function newVariantFailureNudges(input: {
-    toolFailureCounts: ReadonlyMap<string, number>;
-    snapshot: ReadonlyMap<string, number>;
-}): ChatMessage[];

package/dist/agent/tool-loop/tool-failure-policy.js

@@ -1,46 +0,0 @@
-import { MAX_TOOL_VARIANT_FAILURES } from "../tunable-defaults.js";
-export function splitVariantToolCalls(calls, toolFailureCounts) {
-    const allowed = [];
-    const blocked = [];
-    for (const call of calls) {
-        const failCount = toolFailureCounts.get(call.function.name) ?? 0;
-        if (failCount >= MAX_TOOL_VARIANT_FAILURES) {
-            blocked.push({
-                call,
-                failCount,
-                error: `Tool "${call.function.name}" has failed ${failCount} times this turn with different arguments. The target likely does not exist. Stop trying variations and report the issue to the user.`,
-            });
-        }
-        else {
-            allowed.push(call);
-        }
-    }
-    return { allowed, blocked };
-}
-export function variantBlockNudge() {
-    return {
-        role: "user",
-        content: "Tool calls were blocked because the tool has failed too many times with different arguments. " +
-            "The resource you are looking for does not exist. Stop trying variations and tell the user what happened.",
-    };
-}
-export function recordToolFailureResult(input) {
-    if (input.ok && !input.softEmpty)
-        return;
-    const prev = input.toolFailureCounts.get(input.toolName) ?? 0;
-    input.toolFailureCounts.set(input.toolName, prev + 1);
-}
-export function newVariantFailureNudges(input) {
-    const nudges = [];
-    for (const [toolName, count] of input.toolFailureCounts) {
-        if (count >= MAX_TOOL_VARIANT_FAILURES && (input.snapshot.get(toolName) ?? 0) < MAX_TOOL_VARIANT_FAILURES) {
-            nudges.push({
-                role: "user",
-                content: `Tool "${toolName}" has now failed/returned empty results ${count} times with different arguments. ` +
-                    `The target clearly does not exist. Do NOT call "${toolName}" again. ` +
-                    "Report the result to the user immediately.",
-            });
-        }
-    }
-    return nudges;
-}

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

@@ -1,11 +0,0 @@
-import type { TurnEvent } from "../types.js";
-import type { ToolExecutionResultPort } from "../../runtime/ports/index.js";
-type ToolResultEvent = Extract<TurnEvent, {
-    type: "tool_result";
-}>;
-type ToolMediaResultEvent = Extract<TurnEvent, {
-    type: "media_result";
-}>;
-export declare function createToolResultEvent(turnId: string, result: ToolExecutionResultPort): ToolResultEvent;
-export declare function createToolMediaResultEvents(turnId: string, result: ToolExecutionResultPort): ToolMediaResultEvent[];
-export {};

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

@@ -1,59 +0,0 @@
-export function createToolResultEvent(turnId, result) {
-    const rawOutput = typeof result.message?.content === "string"
-        ? result.message.content
-        : "";
-    const outputPreview = rawOutput ? rawOutput.slice(0, 2000) : undefined;
-    const details = result.details;
-    const stdout = typeof details?.stdout === "string" ? details.stdout.slice(0, 8000) : undefined;
-    const stderr = typeof details?.stderr === "string" ? details.stderr.slice(0, 4000) : undefined;
-    const exitCode = typeof details?.exitCode === "number" ? details.exitCode : undefined;
-    return {
-        type: "tool_result",
-        turnId,
-        callId: result.callId,
-        name: result.toolName,
-        ok: result.ok,
-        error: result.error,
-        outputPreview,
-        durationMs: result.durationMs,
-        exitCode,
-        stdout,
-        stderr,
-        details,
-    };
-}
-export function createToolMediaResultEvents(turnId, result) {
-    if (!result.ok)
-        return [];
-    const details = result.details;
-    if (!details)
-        return [];
-    const mediaType = mediaTypeFromDetails(details);
-    if (!mediaType)
-        return [];
-    const mediaUrls = Array.isArray(details.mediaUrls)
-        ? details.mediaUrls.filter((url) => typeof url === "string" && url.trim().length > 0)
-        : [];
-    return mediaUrls.map((url) => ({
-        type: "media_result",
-        turnId,
-        mediaType,
-        url,
-        model: typeof details.model === "string" ? details.model : undefined,
-        provider: typeof details.provider === "string" ? details.provider : undefined,
-        durationSeconds: typeof details.durationMs === "number" ? details.durationMs / 1000 : undefined,
-        taskId: typeof details.taskId === "string" ? details.taskId : undefined,
-    }));
-}
-function mediaTypeFromDetails(details) {
-    const detailType = typeof details.type === "string" ? details.type : "";
-    if (!detailType)
-        return null;
-    if (detailType === "three_d_generate")
-        return "3d";
-    const baseType = detailType.split("_")[0];
-    if (baseType === "image" || baseType === "tts" || baseType === "video" || baseType === "music") {
-        return baseType;
-    }
-    return null;
-}

package/dist/agent/tool-loop/tool-result-events.test.d.ts

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