qlogicagent 2.13.5 → 2.13.7

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

@@ -1,30 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { createToolMediaResultEvents } from "./tool-result-events.js";
-describe("createToolMediaResultEvents", () => {
-    it("emits persisted image media as a first-class turn side event", () => {
-        const events = createToolMediaResultEvents("turn-1", {
-            callId: "call-1",
-            toolName: "image_generate",
-            ok: true,
-            message: {},
-            details: {
-                type: "image_generate",
-                model: "doubao-seedream-4-5",
-                provider: "volcengine",
-                mediaUrls: ["file:///workspace/.qlogicagent/sessions/session-1/media/image_1.jpeg"],
-            },
-        });
-        expect(events).toEqual([
-            {
-                type: "media_result",
-                turnId: "turn-1",
-                mediaType: "image",
-                url: "file:///workspace/.qlogicagent/sessions/session-1/media/image_1.jpeg",
-                model: "doubao-seedream-4-5",
-                provider: "volcengine",
-                durationSeconds: undefined,
-                taskId: undefined,
-            },
-        ]);
-    });
-});

package/dist/agent/tool-loop.contract.test.d.ts

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

package/dist/agent/tool-loop.contract.test.js

@@ -1,254 +0,0 @@
-import { describe, expect, it, vi } from "vitest";
-import { executeToolLoop } from "./tool-loop.js";
-import { StreamingToolExecutor } from "../runtime/execution/streaming-tool-executor.js";
-class ScriptedTransport {
-    rounds;
-    requests = [];
-    constructor(rounds) {
-        this.rounds = rounds;
-    }
-    async *stream(request) {
-        this.requests.push(request);
-        const round = this.rounds.shift();
-        if (!round)
-            throw new Error("unexpected LLM round");
-        for (const chunk of round)
-            yield chunk;
-    }
-}
-const log = {
-    info: vi.fn(),
-    warn: vi.fn(),
-    error: vi.fn(),
-    debug: vi.fn(),
-};
-function tool(name = "read") {
-    return {
-        type: "function",
-        function: {
-            name,
-            description: `${name} tool`,
-            parameters: {
-                type: "object",
-                properties: { path: { type: "string" } },
-            },
-        },
-    };
-}
-function runtimePorts(overrides = {}) {
-    return {
-        createContentReplacementState: () => ({}),
-        enforceToolResultBudget: async (messages) => ({ messages, newlyReplacedCount: 0 }),
-        getActiveContextCompressionEngine: () => null,
-        compressMessages: (messages) => ({ messages, droppedCount: 0, strategy: "none" }),
-        getBudgetContinuationMessage: (usagePct) => `Continue; ${Math.round(usagePct)}% budget used.`,
-        createStreamingToolExecutor: (config) => new StreamingToolExecutor(config),
-        resolveToolEligibility: (tools) => ({ eligibleTools: tools, blockedTools: [] }),
-        ...overrides,
-    };
-}
-async function collect(events) {
-    const out = [];
-    for await (const event of events)
-        out.push(event);
-    return out;
-}
-describe("executeToolLoop architecture contract", () => {
-    it("executes an LLM tool call through runtime ports and feeds the result into the next round", async () => {
-        const transport = new ScriptedTransport([
-            [
-                { type: "tool_call_delta", index: 0, id: "call-read", name: "read", arguments: "{\"path\":\"README.md\"}" },
-                { type: "done", finishReason: "tool_calls" },
-            ],
-            [
-                { type: "delta", text: "README says hello." },
-                { type: "usage", promptTokens: 10, completionTokens: 4 },
-                { type: "done", finishReason: "stop" },
-            ],
-        ]);
-        const invoker = {
-            invoke: vi.fn(async (_turnId, name, args) => ({
-                result: `${name}(${JSON.parse(args).path}) => hello`,
-            })),
-        };
-        const events = await collect(executeToolLoop({
-            turnId: "turn-1",
-            sessionId: "session-1",
-            messages: [{ role: "user", content: "Read README.md" }],
-            tools: [tool("read")],
-            model: "test-model",
-            apiKey: "test-key",
-            maxRounds: 3,
-            runtimePorts: runtimePorts(),
-        }, transport, invoker, log));
-        expect(invoker.invoke).toHaveBeenCalledWith("turn-1", "read", "{\"path\":\"README.md\"}", expect.any(AbortSignal));
-        expect(events.map((event) => event.type)).toEqual([
-            "tool_call",
-            "tool_result",
-            "delta",
-            "end",
-        ]);
-        expect(events.find((event) => event.type === "end")).toMatchObject({
-            content: "README says hello.",
-            usage: { inputTokens: 10, outputTokens: 4 },
-        });
-        expect(transport.requests).toHaveLength(2);
-        expect(transport.requests[1]?.messages.some((message) => message.role === "tool" && "tool_call_id" in message && message.tool_call_id === "call-read")).toBe(true);
-    });
-    it("does not stream or carry assistant preambles from tool-call rounds", async () => {
-        const transport = new ScriptedTransport([
-            [
-                { type: "delta", text: "I will search first. " },
-                { type: "tool_call_delta", index: 0, id: "call-search", name: "web_search", arguments: "{\"query\":\"Shanghai family trip\"}" },
-                { type: "done", finishReason: "tool_calls" },
-            ],
-            [
-                { type: "delta", text: "Here is the final answer." },
-                { type: "done", finishReason: "stop" },
-            ],
-        ]);
-        const invoker = {
-            invoke: vi.fn(async () => ({ result: "No results found for: \"Shanghai family trip\"" })),
-        };
-        const events = await collect(executeToolLoop({
-            turnId: "turn-preamble",
-            sessionId: "session-1",
-            messages: [{ role: "user", content: "Plan Shanghai with kids" }],
-            tools: [tool("web_search")],
-            model: "test-model",
-            apiKey: "test-key",
-            maxRounds: 3,
-            runtimePorts: runtimePorts(),
-        }, transport, invoker, log));
-        expect(events.filter((event) => event.type === "delta").map((event) => event.text).join("")).toBe("Here is the final answer.");
-        expect(transport.requests[1]?.messages).toContainEqual(expect.objectContaining({
-            role: "assistant",
-            content: null,
-            tool_calls: expect.any(Array),
-        }));
-        expect(events.find((event) => event.type === "end")).toMatchObject({
-            content: "Here is the final answer.",
-        });
-    });
-    it("treats empty web_search results as failures and blocks repeated search variants", async () => {
-        const transport = new ScriptedTransport([
-            [
-                { type: "tool_call_delta", index: 0, id: "call-search-1", name: "web_search", arguments: "{\"query\":\"Shanghai family trip 2026\"}" },
-                { type: "done", finishReason: "tool_calls" },
-            ],
-            [
-                { type: "tool_call_delta", index: 0, id: "call-search-2", name: "web_search", arguments: "{\"query\":\"Shanghai kids attractions 2026\"}" },
-                { type: "done", finishReason: "tool_calls" },
-            ],
-            [
-                { type: "tool_call_delta", index: 0, id: "call-search-3", name: "web_search", arguments: "{\"query\":\"Shanghai family itinerary 2026\"}" },
-                { type: "done", finishReason: "tool_calls" },
-            ],
-            [
-                { type: "delta", text: "Search did not return usable results; here is a general answer." },
-                { type: "done", finishReason: "stop" },
-            ],
-        ]);
-        const invoker = {
-            invoke: vi.fn(async (_turnId, _name, args) => ({
-                result: `No results found for: "${JSON.parse(args).query}"`,
-            })),
-        };
-        const events = await collect(executeToolLoop({
-            turnId: "turn-web-empty",
-            sessionId: "session-1",
-            messages: [{ role: "user", content: "Plan Shanghai with kids" }],
-            tools: [tool("web_search")],
-            model: "test-model",
-            apiKey: "test-key",
-            maxRounds: 5,
-            runtimePorts: runtimePorts(),
-        }, transport, invoker, log));
-        expect(invoker.invoke).toHaveBeenCalledTimes(2);
-        expect(events).toContainEqual(expect.objectContaining({
-            type: "tool_result",
-            callId: "call-search-3",
-            ok: false,
-        }));
-        expect(events.find((event) => event.type === "end")).toMatchObject({
-            content: "Search did not return usable results; here is a general answer.",
-        });
-    });
-    it("emits policy-blocked tools before falling back to a single no-tool LLM round", async () => {
-        const transport = new ScriptedTransport([
-            [
-                { type: "delta", text: "I cannot write files in this policy." },
-                { type: "done", finishReason: "stop" },
-            ],
-        ]);
-        const invoker = { invoke: vi.fn() };
-        const events = await collect(executeToolLoop({
-            turnId: "turn-2",
-            sessionId: "session-1",
-            messages: [{ role: "user", content: "Write a file" }],
-            tools: [tool("write")],
-            model: "test-model",
-            apiKey: "test-key",
-            runtimePorts: runtimePorts({
-                resolveToolEligibility: () => ({
-                    eligibleTools: [],
-                    blockedTools: [{ toolName: "write" }],
-                }),
-            }),
-        }, transport, invoker, log));
-        expect(invoker.invoke).not.toHaveBeenCalled();
-        expect(events[0]).toMatchObject({
-            type: "tool_blocked",
-            name: "write",
-            reason: "blocked-by-policy",
-        });
-        expect(transport.requests[0]).not.toHaveProperty("tools");
-        expect(transport.requests[0]).not.toHaveProperty("toolChoice");
-    });
-    it("does not pass assistantId into tool eligibility or change the offered tool set", async () => {
-        const transport = new ScriptedTransport([
-            [
-                { type: "delta", text: "Ready." },
-                { type: "done", finishReason: "stop" },
-            ],
-        ]);
-        const resolveToolEligibility = vi.fn((tools, context) => ({
-            eligibleTools: tools,
-            blockedTools: [],
-            approvalRequiredTools: [],
-            eligibilityByName: new Map(),
-            context,
-        }));
-        const events = await collect(executeToolLoop({
-            turnId: "turn-assistant",
-            sessionId: "session-1",
-            messages: [{ role: "user", content: "Read README.md" }],
-            tools: [tool("read")],
-            model: "test-model",
-            apiKey: "test-key",
-            assistantId: "builtin.code",
-            runtimePorts: runtimePorts({ resolveToolEligibility }),
-        }, transport, { invoke: vi.fn() }, log));
-        expect(resolveToolEligibility).toHaveBeenCalledWith([tool("read")], undefined);
-        expect(events.some((event) => event.type === "tool_blocked")).toBe(false);
-        expect(transport.requests[0]?.tools?.map((entry) => entry.function.name)).toEqual(["read"]);
-    });
-    it("surfaces a silently closed LLM stream instead of ending with an empty answer", async () => {
-        const transport = new ScriptedTransport([[]]);
-        const events = await collect(executeToolLoop({
-            turnId: "turn-empty-stream",
-            sessionId: "session-1",
-            messages: [{ role: "user", content: "Say hi" }],
-            tools: [],
-            model: "test-model",
-            apiKey: "test-key",
-            runtimePorts: runtimePorts(),
-        }, transport, { invoke: vi.fn() }, log));
-        expect(events).toHaveLength(1);
-        expect(events[0]).toMatchObject({
-            type: "error",
-            code: "RETRYABLE_TRANSIENT",
-        });
-        expect(events[0].error).toMatch(/stream closed before a terminal event/i);
-    });
-});

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

@@ -1,121 +0,0 @@
-/**
- * Tool loop state machine - CC query.ts aligned.
- *
- * Architecture:
- *   - Infinite while(true) loop with centralized State object (CC parity)
- *   - 7 labeled continue sites matching CC's query loop transitions
- *   - Error Withholding: 413 / max_output_tokens / media errors are
- *     withheld from callers during recovery attempts
- *   - Context Collapse drain: staged collapses committed on 413
- *     BEFORE falling through to reactive compact
- *   - Media error recovery: image/media errors -> reactive compact retry
- *   - Hermes delta suppression preserved
- *   - StreamingToolExecutor preserved
- *   - Sub-agent fork depth preserved
- *   - Skill learning evaluation preserved
- *
- * CC reference: src/query.ts queryLoop()
- *
- * Zero imports from express/pg/ioredis/ws.
- */
-import type { AgentLogger, ChatMessage, ToolDefinition, ToolInvoker, TurnEvent, HookRegistry, LLMTransport } from "./types.js";
-import type { ToolLoopRuntimePorts } from "../runtime/ports/index.js";
-export interface ToolLoopParams {
-    turnId: string;
-    sessionId: string;
-    messages: ChatMessage[];
-    tools: ToolDefinition[];
-    model: string;
-    apiKey: string;
-    temperature?: number;
-    maxRounds?: number;
-    /** Context window size in tokens (for turn-loop-guard budget checks) */
-    contextWindowTokens?: number;
-    /** Max output tokens for current model */
-    maxOutputTokens?: number;
-    /** Model's absolute max output tokens (escalation ceiling) */
-    modelMaxOutputTokens?: number;
-    /** Tool choice strategy (default "auto") */
-    toolChoice?: "auto" | "none" | "required";
-    /** Parent fork depth (0 = top-level) */
-    parentDepth?: number;
-    /** Tool eligibility context for policy-based filtering */
-    toolEligibilityContext?: unknown;
-    /** Hook registry for lifecycle events (optional, fire-and-forget) */
-    hooks?: HookRegistry;
-    /** Max turns (loop iterations). 0 = use maxRounds. */
-    maxTurns?: number;
-    /** Fallback model to switch to after repeated 529 errors (CC parity). */
-    fallbackModel?: string;
-    /** Query source for foreground/background retry distinction (CC parity). */
-    querySource?: string;
-    /** Token budget for this turn (>0 enables budget continuation). */
-    tokenBudget?: number;
-    /**
-     * Refresh tools callback -called between turns (CC refreshTools parity).
-     * Returns updated tool definitions if tools have changed (e.g. MCP reconnect),
-     * or the same array reference if unchanged.
-     */
-    refreshTools?: () => ToolDefinition[];
-    /**
-     * Generate a human-readable summary label for a tool batch (CC generateToolUseSummary parity).
-     * Fire-and-forget: called after tool execution, result yielded as tool_use_summary event
-     * when the next LLM round starts streaming. ~30 chars, git-commit-subject style.
-     */
-    generateToolUseSummary?: (toolCalls: Array<{
-        name: string;
-        arguments: string;
-        result?: string;
-    }>) => Promise<string | null>;
-    /**
-     * Post-sampling hooks -fire-and-forget after LLM response completes (CC executePostSamplingHooks parity).
-     * Cannot modify messages. Used for background tasks (memory extraction, skill learning, etc.).
-     */
-    postSamplingHooks?: Array<(context: {
-        messages: unknown[];
-        model: string;
-        sessionId: string;
-    }) => Promise<void> | void>;
-    /** Max concurrent tool executions (0 = unlimited, CC parity: semantic concurrency control). */
-    maxConcurrentTools?: number;
-    /** Model requires streaming -disable non-streaming fallback. */
-    streamRequired?: boolean;
-    /** Reasoning effort for models that support it. */
-    reasoning?: {
-        effort: "minimal" | "low" | "medium" | "high" | "xhigh";
-        includeEncryptedReasoning?: boolean;
-    };
-    /** Prompt cache bucketing key. */
-    promptCacheKey?: string;
-    /** Prompt cache retention policy. */
-    promptCacheRetention?: "in_memory" | "24h";
-    /** Service tier scheduling. */
-    serviceTier?: "auto" | "default" | "flex" | "priority";
-    /** OpenAI Responses API built-in tools. */
-    openaiBuiltinTools?: Array<{
-        type: "web_search_preview" | "file_search" | "code_interpreter" | "computer_use_preview";
-        [key: string]: unknown;
-    }>;
-    /** Max builtin tool calls per turn. */
-    maxToolCalls?: number;
-    /** Disable parallel tool calling. */
-    parallelToolCalls?: boolean;
-    /** Text output verbosity hint. */
-    textVerbosity?: "low" | "medium" | "high";
-    /** Project root directory -used for skill pattern tracking at project level. */
-    projectRoot?: string;
-    runtimePorts: ToolLoopRuntimePorts;
-    signal?: AbortSignal;
-}
-/**
- * Execute the tool loop -CC query.ts queryLoop() aligned.
- *
- * Yields TurnEvent stream. The caller (Agent class) wraps this with
- * start/end lifecycle and error handling.
- *
- * Architecture: infinite while(true) with centralized State + 7 continue
- * labels. Error withholding gates recoverable errors through collapse
- * drain ->reactive compact ->escalation ->recovery message pipeline
- * before surfacing to callers.
- */
-export declare function executeToolLoop(params: ToolLoopParams, transport: LLMTransport, toolInvoker: ToolInvoker, log: AgentLogger): AsyncGenerator<TurnEvent>;