qlogicagent 2.13.5 → 2.13.6

package/dist/cli/acp-extended-handlers.specchat.test.js

@@ -1,62 +0,0 @@
-import { describe, expect, it, vi } from "vitest";
-// Mock the multi-turn orchestrator so we exercise the handler wiring without a real LLM/fork.
-vi.mock("../orchestration/solo-spec-builder.js", () => ({ runSpecChatRound: vi.fn() }));
-import { handleAcpSoloSpecChat, handleAcpSoloSpecJudge } from "./acp-extended-handlers.js";
-import { runSpecChatRound } from "../orchestration/solo-spec-builder.js";
-import { ASK_USER_TOOL_NAME } from "../skills/tools/ask-user-tool.js";
-const runSpecChatRoundMock = vi.mocked(runSpecChatRound);
-const askUserManifestEntry = {
-    type: "function",
-    function: { name: ASK_USER_TOOL_NAME, description: "ask user", parameters: { type: "object" } },
-};
-function fakeHost(overrides = {}) {
-    return {
-        log: () => { },
-        resolveClientForPurpose: () => ({ transport: {}, apiKey: "k", model: "m" }),
-        toolCatalog: { getToolManifest: () => [askUserManifestEntry] },
-        pendingAskUser: new Map(),
-        sendNotification: () => { },
-        activeTurn: null,
-        ...overrides,
-    };
-}
-const SPEC = { goal: "g", constraints: [], acceptance: ["a1"], rawTask: "t" };
-describe("handleAcpSoloSpecChat — guard + 集成 seam(降级 { error },不抛)", () => {
-    it("no LLM → { error }", async () => {
-        const r = (await handleAcpSoloSpecChat(fakeHost({ resolveClientForPurpose: () => null }), { rawTask: "t", history: [{ role: "user", content: "t" }] }));
-        expect(r.error).toMatch(/no llm provider/i);
-    });
-    it("no ask_user manifest → { error }", async () => {
-        const r = (await handleAcpSoloSpecChat(fakeHost({ toolCatalog: { getToolManifest: () => [] } }), { rawTask: "t", history: [{ role: "user", content: "t" }] }));
-        expect(r.error).toMatch(/ask_user/i);
-    });
-    it("缺 rawTask+history → { error }", async () => {
-        const r = (await handleAcpSoloSpecChat(fakeHost(), {}));
-        expect(r.error).toMatch(/rawTask|history/i);
-    });
-    it("转发 history + ask_user toolDef → { reply, spec }", async () => {
-        runSpecChatRoundMock.mockResolvedValueOnce({ reply: "ok", spec: SPEC });
-        const r = (await handleAcpSoloSpecChat(fakeHost(), { rawTask: "t", history: [{ role: "user", content: "t" }] }));
-        expect(r.reply).toBe("ok");
-        expect(r.spec?.goal).toBe("g");
-        const deps = runSpecChatRoundMock.mock.calls[0][0];
-        expect(deps.history).toEqual([{ role: "user", content: "t" }]);
-        expect(deps.askUserToolDef.function.name).toBe(ASK_USER_TOOL_NAME);
-    });
-    it("runSpecChatRound 抛 → { error }(不抛)", async () => {
-        runSpecChatRoundMock.mockRejectedValueOnce(new Error("boom"));
-        const r = (await handleAcpSoloSpecChat(fakeHost(), { rawTask: "t", history: [{ role: "user", content: "t" }] }));
-        expect(r.error).toBe("boom");
-    });
-});
-describe("handleAcpSoloSpecJudge — 软门降级", () => {
-    it("无 LLM → { ok:true }(放行)", async () => {
-        const r = (await handleAcpSoloSpecJudge(fakeHost({ resolveClientForPurpose: () => null }), { spec: SPEC }));
-        expect(r.ok).toBe(true);
-        expect(r.issues).toEqual([]);
-    });
-    it("无 spec → { ok:false }", async () => {
-        const r = (await handleAcpSoloSpecJudge(fakeHost(), {}));
-        expect(r.ok).toBe(false);
-    });
-});

package/dist/cli/acp-extended-handlers.workflowchat.test.d.ts

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

package/dist/cli/acp-extended-handlers.workflowchat.test.js

@@ -1,49 +0,0 @@
-import { describe, expect, it, vi } from "vitest";
-vi.mock("../orchestration/workflow-chat-builder.js", () => ({ runWorkflowChatRound: vi.fn() }));
-import { handleAcpWorkflowChat } from "./acp-extended-handlers.js";
-import { runWorkflowChatRound } from "../orchestration/workflow-chat-builder.js";
-import { ASK_USER_TOOL_NAME } from "../skills/tools/ask-user-tool.js";
-const runWorkflowChatRoundMock = vi.mocked(runWorkflowChatRound);
-const askUserManifestEntry = {
-    type: "function",
-    function: { name: ASK_USER_TOOL_NAME, description: "ask user", parameters: { type: "object" } },
-};
-function fakeHost(overrides = {}) {
-    return {
-        log: () => { },
-        resolveClientForPurpose: () => ({ transport: {}, apiKey: "k", model: "m" }),
-        toolCatalog: { getToolManifest: () => [askUserManifestEntry] },
-        // IT-3 能力目录构建所需(真实 handler 在调 runWorkflowChatRound 前枚举 agent/skill 根)。
-        getActiveProjectRoot: () => process.cwd(),
-        acpDetector: { list: () => [] },
-        pendingAskUser: new Map(),
-        sendNotification: () => { },
-        activeTurn: null,
-        ...overrides,
-    };
-}
-const HIST = [{ role: "user", content: "每天9点抓新闻发飞书" }];
-describe("handleAcpWorkflowChat — guard + 集成 seam(降级 { error },不抛)", () => {
-    it("no LLM → { error }", async () => {
-        const r = (await handleAcpWorkflowChat(fakeHost({ resolveClientForPurpose: () => null }), { history: HIST }));
-        expect(r.error).toMatch(/no llm provider/i);
-    });
-    it("缺 history → { error }", async () => {
-        const r = (await handleAcpWorkflowChat(fakeHost(), {}));
-        expect(r.error).toMatch(/history/i);
-    });
-    it("转发 history + currentWorkflow → { reply, def }", async () => {
-        runWorkflowChatRoundMock.mockResolvedValueOnce({ reply: "ok", def: { nodes: [], edges: [] } });
-        const r = (await handleAcpWorkflowChat(fakeHost(), { history: HIST, currentWorkflow: "W" }));
-        expect(r.reply).toBe("ok");
-        expect(r.def).toEqual({ nodes: [], edges: [] });
-        const deps = runWorkflowChatRoundMock.mock.calls[0][0];
-        expect(deps.history).toEqual(HIST);
-        expect(deps.currentWorkflow).toBe("W");
-    });
-    it("runWorkflowChatRound 抛 → { error }(不抛)", async () => {
-        runWorkflowChatRoundMock.mockRejectedValueOnce(new Error("boom"));
-        const r = (await handleAcpWorkflowChat(fakeHost(), { history: HIST }));
-        expect(r.error).toBe("boom");
-    });
-});

package/dist/cli/acp-extended-host-adapter.d.ts

@@ -1,29 +0,0 @@
-import type { AgentRpcError } from "../protocol/wire/index.js";
-import type { AcpExtendedHost } from "./acp-extended-handlers.js";
-import type { DreamHandlerHost } from "./handlers/dream-handler.js";
-import type { MultiAgentHandlerHost } from "./multi-agent-handler-host.js";
-type AgentStatusExtra = {
-    missedBeats?: number;
-    lastActivityAt?: number;
-    usage?: {
-        inputTokens: number;
-        outputTokens: number;
-        totalTokens: number;
-    };
-};
-export interface AcpExtendedHostAdapterDeps {
-    dreamHost: DreamHandlerHost;
-    multiAgentHost: MultiAgentHandlerHost;
-    getCurrentSessionId(): string;
-    getActiveProjectRoot(): string;
-    log(message: string): void;
-    resolveAgent: DreamHandlerHost["resolveAgent"];
-    sendNotification(method: string, params: Record<string, unknown>): void;
-    sendResponse(id: string | number, result?: unknown, error?: AgentRpcError): void;
-    emitAgentStatus(agentId: string, state: string, extra?: AgentStatusExtra): void;
-    handleMcpToolCall(memberId: string, toolName: string, args: Record<string, unknown>): Promise<unknown>;
-    resolveClientForPurpose: AcpExtendedHost["resolveClientForPurpose"];
-    pendingAskUser: AcpExtendedHost["pendingAskUser"];
-}
-export declare function createAcpExtendedHostAdapter(deps: AcpExtendedHostAdapterDeps): AcpExtendedHost;
-export {};

package/dist/cli/acp-extended-host-adapter.js

@@ -1,40 +0,0 @@
-export function createAcpExtendedHostAdapter(deps) {
-    const { dreamHost, multiAgentHost } = deps;
-    return {
-        get activeTurn() { return dreamHost.activeTurn; },
-        set activeTurn(value) { dreamHost.activeTurn = value ?? null; },
-        get currentTransport() { return dreamHost.currentTransport; },
-        get currentApiKey() { return dreamHost.currentApiKey; },
-        get currentModel() { return dreamHost.currentModel; },
-        get currentHooks() { return dreamHost.currentHooks; },
-        get memoryProvider() { return dreamHost.memoryProvider; },
-        get memoryUserId() { return dreamHost.memoryUserId; },
-        get toolCatalog() { return dreamHost.toolCatalog; },
-        get taskStore() { return dreamHost.taskStore; },
-        get verbose() { return dreamHost.verbose; },
-        log: deps.log,
-        resolveMemoryRoot: () => dreamHost.resolveMemoryRoot?.() ?? deps.getActiveProjectRoot(),
-        resolveTranscriptDir: () => dreamHost.resolveTranscriptDir?.() ?? deps.getActiveProjectRoot(),
-        resolveAgent: deps.resolveAgent,
-        sendNotification: deps.sendNotification,
-        sendResponse: deps.sendResponse,
-        get acpDetector() { return multiAgentHost.acpDetector; },
-        get agentConfigStore() { return multiAgentHost.agentConfigStore; },
-        get soloEvaluator() { return multiAgentHost.soloEvaluator; },
-        set soloEvaluator(value) { multiAgentHost.soloEvaluator = value; },
-        get soloProcessManager() { return multiAgentHost.soloProcessManager; },
-        set soloProcessManager(value) { multiAgentHost.soloProcessManager = value; },
-        get productOrchestrator() { return multiAgentHost.productOrchestrator; },
-        set productOrchestrator(value) { multiAgentHost.productOrchestrator = value; },
-        get productPlanner() { return multiAgentHost.productPlanner; },
-        set productPlanner(value) { multiAgentHost.productPlanner = value; },
-        get productProcessManager() { return multiAgentHost.productProcessManager; },
-        set productProcessManager(value) { multiAgentHost.productProcessManager = value; },
-        get currentSessionId() { return deps.getCurrentSessionId(); },
-        getActiveProjectRoot: deps.getActiveProjectRoot,
-        emitAgentStatus: deps.emitAgentStatus,
-        handleMcpToolCall: deps.handleMcpToolCall,
-        resolveClientForPurpose: deps.resolveClientForPurpose,
-        pendingAskUser: deps.pendingAskUser,
-    };
-}

package/dist/cli/acp-extended-host-adapter.test.d.ts

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

package/dist/cli/acp-extended-host-adapter.test.js

@@ -1,63 +0,0 @@
-import { describe, expect, it, vi } from "vitest";
-import { createAcpExtendedHostAdapter } from "./acp-extended-host-adapter.js";
-describe("createAcpExtendedHostAdapter", () => {
-    it("composes dream runtime and multi-agent handler host without owning their state", async () => {
-        let activeTurn = null;
-        const dreamHost = {
-            get activeTurn() { return activeTurn; },
-            set activeTurn(value) { activeTurn = value ?? null; },
-            currentTransport: null,
-            currentApiKey: "key",
-            currentModel: "model",
-            currentHooks: null,
-            memoryProvider: null,
-            memoryUserId: "user",
-            verbose: true,
-        };
-        const multiAgentHost = {
-            acpDetector: { id: "detector" },
-            agentConfigStore: { id: "store" },
-            soloEvaluator: null,
-            productOrchestrator: null,
-            productPlanner: null,
-            soloProcessManager: null,
-            productProcessManager: null,
-        };
-        const calls = [];
-        const host = createAcpExtendedHostAdapter({
-            dreamHost,
-            multiAgentHost,
-            getCurrentSessionId: () => "session-1",
-            getActiveProjectRoot: () => "F:\\workspace",
-            log: (message) => calls.push(`log:${message}`),
-            resolveAgent: () => ({ ok: true }),
-            sendNotification: (method) => calls.push(`notification:${method}`),
-            sendResponse: (id) => calls.push(`response:${id}`),
-            emitAgentStatus: (agentId, state) => calls.push(`status:${agentId}:${state}`),
-            handleMcpToolCall: vi.fn(async () => "tool-result"),
-            resolveClientForPurpose: () => null,
-            pendingAskUser: new Map(),
-        });
-        const controller = new AbortController();
-        host.activeTurn = controller;
-        expect(activeTurn).toBe(controller);
-        expect(host.currentSessionId).toBe("session-1");
-        expect(host.getActiveProjectRoot()).toBe("F:\\workspace");
-        expect(host.agentConfigStore).toBe(multiAgentHost.agentConfigStore);
-        const soloEvaluator = { id: "solo" };
-        host.soloEvaluator = soloEvaluator;
-        expect(multiAgentHost.soloEvaluator).toBe(soloEvaluator);
-        expect(host.soloEvaluator).toBe(soloEvaluator);
-        host.log("hello");
-        host.sendNotification("turn.start", {});
-        host.sendResponse("rpc-1");
-        host.emitAgentStatus("agent-1", "running");
-        await expect(host.handleMcpToolCall("member-1", "read", {})).resolves.toBe("tool-result");
-        expect(calls).toEqual([
-            "log:hello",
-            "notification:turn.start",
-            "response:rpc-1",
-            "status:agent-1:running",
-        ]);
-    });
-});

package/dist/cli/acp-message-router.d.ts

@@ -1,8 +0,0 @@
-export type IncomingRoute = "acp" | "legacy" | "ignore";
-/**
- * Classify a parsed inbound frame.
- *  - "acp"    → hand to the ACP server (only when ACP is active)
- *  - "legacy" → hand to the native gateway handler (a valid AgentRpcRequest)
- *  - "ignore" → neither; drop with a warning
- */
-export declare function classifyIncomingMessage(parsed: unknown, acpActive: boolean): IncomingRoute;

package/dist/cli/acp-message-router.js

@@ -1,40 +0,0 @@
-/**
- * Incoming-message routing policy — pure classifier for the stdio transport.
- *
- * StdioServer speaks two protocols over one transport: ACP (when an ACP client is
- * connected) and the native gateway JSON-RPC. This decides where a parsed frame
- * goes, with no side effects, so the policy is testable in isolation and start()
- * stays a thin dispatch switch.
- *
- * Policy: when ACP is active, ACP responses/notifications and ACP-namespaced
- * requests (initialize, session/*, x/*, fs/*) go to the ACP server; every other
- * gateway request (thread.turn, agent.ping, …) falls through to the native handler.
- */
-import { isAcpJsonRpcNotification, isAcpJsonRpcRequest, isAcpJsonRpcResponse, isAgentRpcRequest, } from "../protocol/wire/index.js";
-/** ACP-namespaced request methods that the ACP server owns. */
-function isAcpRequestMethod(method) {
-    return (method === "initialize" ||
-        method.startsWith("session/") ||
-        method.startsWith("x/") ||
-        method.startsWith("fs/"));
-}
-/**
- * Classify a parsed inbound frame.
- *  - "acp"    → hand to the ACP server (only when ACP is active)
- *  - "legacy" → hand to the native gateway handler (a valid AgentRpcRequest)
- *  - "ignore" → neither; drop with a warning
- */
-export function classifyIncomingMessage(parsed, acpActive) {
-    if (acpActive) {
-        // Responses and notifications always belong to ACP.
-        if (isAcpJsonRpcResponse(parsed) || isAcpJsonRpcNotification(parsed))
-            return "acp";
-        // Requests: only ACP-namespaced methods; the rest fall through to native.
-        if (isAcpJsonRpcRequest(parsed) && isAcpRequestMethod(parsed.method)) {
-            return "acp";
-        }
-    }
-    if (!isAgentRpcRequest(parsed))
-        return "ignore";
-    return "legacy";
-}

package/dist/cli/acp-message-router.test.d.ts

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

package/dist/cli/acp-message-router.test.js

@@ -1,30 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { classifyIncomingMessage } from "./acp-message-router.js";
-const req = (method, id = 1) => ({ jsonrpc: "2.0", id, method, params: {} });
-const notif = (method) => ({ jsonrpc: "2.0", method, params: {} });
-const resp = (id = 1) => ({ jsonrpc: "2.0", id, result: {} });
-describe("classifyIncomingMessage", () => {
-    it("routes ACP responses and notifications to acp when active", () => {
-        expect(classifyIncomingMessage(resp(), true)).toBe("acp");
-        expect(classifyIncomingMessage(notif("session/update"), true)).toBe("acp");
-    });
-    it("routes ACP-namespaced requests to acp when active", () => {
-        for (const m of ["initialize", "session/new", "x/workflow.run", "fs/read"]) {
-            expect(classifyIncomingMessage(req(m), true)).toBe("acp");
-        }
-    });
-    it("falls non-ACP gateway requests through to legacy even when ACP is active", () => {
-        expect(classifyIncomingMessage(req("thread.turn"), true)).toBe("legacy");
-        expect(classifyIncomingMessage(req("agent.ping"), true)).toBe("legacy");
-    });
-    it("bypasses ACP entirely when inactive", () => {
-        // ACP-shaped request with no ACP server → native handler (would METHOD_NOT_FOUND it)
-        expect(classifyIncomingMessage(req("session/new"), false)).toBe("legacy");
-        // A response is not a gateway request → dropped
-        expect(classifyIncomingMessage(resp(), false)).toBe("ignore");
-    });
-    it("ignores frames that are neither ACP nor a gateway request", () => {
-        expect(classifyIncomingMessage({}, false)).toBe("ignore");
-        expect(classifyIncomingMessage(null, true)).toBe("ignore");
-    });
-});

package/dist/cli/acp-session-handlers.d.ts

@@ -1,41 +0,0 @@
-import type { AcpSessionHost } from "./acp-session-host.js";
-import { type AcpInitializeParams, type AcpInitializeResult, type AcpSessionCloseParams, type AcpSessionLoadParams, type AcpSessionNewParams, type AcpSessionNewResult, type AcpSessionPromptParams, type AcpSessionPromptResult, type AcpSessionSetConfigParams } from "../protocol/wire/index.js";
-export type { AcpSessionHost };
-export declare function handleAcpInitialize(host: AcpSessionHost, params: AcpInitializeParams, packageVersion: string): Promise<AcpInitializeResult>;
-export declare function handleAcpSessionNew(host: AcpSessionHost, params: AcpSessionNewParams): Promise<AcpSessionNewResult>;
-/**
- * Standard ACP session/load: point the host at an existing session and return its persisted
- * history as display-only chunks for the server to replay. The backend turn context is NOT
- * rebuilt here — every session/prompt hydrates history from disk via the turn pipeline's
- * withResumedHistory, so load only needs to (a) make this the active session and (b) hand back
- * the transcript for the host to render. Returns data only; the server owns the send path.
- */
-export declare function handleAcpSessionLoad(host: AcpSessionHost, params: AcpSessionLoadParams): Promise<{
-    replay: Array<{
-        type: "user_message_chunk" | "agent_message_chunk";
-        content: string;
-    }>;
-}>;
-/**
- * Pre-prompt slash-command interception (data only). Extracts the leading text from the prompt; if
- * it starts with "/", routes it through the single-source command registry (dispatchSlashCommand)
- * and returns its {handled, reply}. Otherwise returns {handled:false} so the caller runs a normal
- * turn. This NEVER emits session/update or runs a turn — the acp-server orchestrates the single
- * send path (agent_message_chunk + result) when handled, keeping handleAcpSessionPrompt untouched.
- */
-export declare function tryDispatchCommand(host: AcpSessionHost, params: AcpSessionPromptParams): Promise<{
-    handled: boolean;
-    reply?: string;
-}>;
-export declare function handleAcpSessionPrompt(host: AcpSessionHost, params: AcpSessionPromptParams): Promise<AcpSessionPromptResult>;
-export declare function handleAcpSessionClose(host: AcpSessionHost, params: AcpSessionCloseParams): Promise<void>;
-export declare function handleAcpSessionSetConfig(host: AcpSessionHost, params: AcpSessionSetConfigParams): Promise<void>;
-export declare function handleAcpSessionSetModel(host: AcpSessionHost, _sessionId: string, model: string): Promise<void>;
-/**
- * Standard ACP session/set_mode: validate the requested permission mode and record it on the
- * session-level acpSessionMeta.permissions bag. The rule engine is NOT touched here — the next
- * session/prompt's syncTurnPermissionConfig reads permissions.mode and applies it (single track).
- * Returns the applied modeId; the server emits current_mode_update. An unknown mode throws a coded
- * error which the acp-server dispatch translates into a JSON-RPC error.
- */
-export declare function handleAcpSessionSetMode(host: AcpSessionHost, _sessionId: string, modeId: string): Promise<string>;