qlogicagent 0.2.1 → 0.4.0

package/dist/llm/transports/anthropic-messages.js

@@ -1,293 +0,0 @@
-/**
- * Anthropic Messages Transport — SSE streaming for Claude API.
- *
- * POST {baseUrl}/v1/messages with stream: true
- * Auth: x-api-key: {apiKey} + anthropic-version header
- *
- * SSE event types:
- *   message_start, content_block_start, content_block_delta,
- *   content_block_stop, message_delta, message_stop
- *
- * Tool use is via content blocks with type "tool_use" + "input_json_delta".
- *
- * Aligned with Hermes anthropic_messages.py transport.
- */
-export class AnthropicMessagesTransport {
-    baseUrl;
-    apiVersion;
-    timeoutMs;
-    constructor(config) {
-        this.baseUrl = config.baseUrl.replace(/\/+$/, "");
-        this.apiVersion = config.apiVersion ?? "2023-06-01";
-        this.timeoutMs = config.timeoutMs ?? 180_000;
-    }
-    async *stream(request, apiKey, signal) {
-        const url = `${this.baseUrl}/v1/messages`;
-        // Convert OpenAI-style messages → Anthropic format
-        const { system, messages } = convertMessages(request.messages);
-        const body = {
-            model: request.model,
-            messages,
-            max_tokens: request.maxTokens ?? 8192,
-            stream: true,
-        };
-        if (system)
-            body.system = system;
-        if (request.tools && request.tools.length > 0) {
-            body.tools = request.tools.map(convertToolDef);
-            if (request.toolChoice) {
-                body.tool_choice =
-                    request.toolChoice === "auto"
-                        ? { type: "auto" }
-                        : request.toolChoice === "required"
-                            ? { type: "any" }
-                            : { type: "none" };
-            }
-        }
-        if (request.temperature !== undefined)
-            body.temperature = request.temperature;
-        if (request.reasoning) {
-            body.thinking = {
-                type: "enabled",
-                budget_tokens: mapReasoningEffortToBudget(request.reasoning.effort),
-            };
-        }
-        const timeoutSignal = AbortSignal.timeout(this.timeoutMs);
-        const combinedSignal = signal
-            ? AbortSignal.any([signal, timeoutSignal])
-            : timeoutSignal;
-        const response = await fetch(url, {
-            method: "POST",
-            headers: {
-                "Content-Type": "application/json",
-                "x-api-key": apiKey,
-                "anthropic-version": this.apiVersion,
-            },
-            body: JSON.stringify(body),
-            signal: combinedSignal,
-        });
-        if (!response.ok) {
-            const errorBody = await response.text().catch(() => "");
-            throw new Error(`Anthropic API error ${response.status}: ${errorBody.slice(0, 500)}`);
-        }
-        if (!response.body) {
-            throw new Error("Anthropic API returned no response body");
-        }
-        yield* this.parseSSEStream(response.body);
-    }
-    async *parseSSEStream(body) {
-        const decoder = new TextDecoder();
-        let buffer = "";
-        let currentEvent = "";
-        // Track active content blocks for tool_use accumulation
-        const blocks = new Map();
-        for await (const raw of body) {
-            buffer += decoder.decode(raw, { stream: true });
-            let newlineIdx;
-            while ((newlineIdx = buffer.indexOf("\n")) !== -1) {
-                const line = buffer.slice(0, newlineIdx).trim();
-                buffer = buffer.slice(newlineIdx + 1);
-                if (!line) {
-                    currentEvent = "";
-                    continue;
-                }
-                if (line.startsWith("event: ")) {
-                    currentEvent = line.slice(7).trim();
-                    continue;
-                }
-                if (!line.startsWith("data: "))
-                    continue;
-                const data = line.slice(6);
-                let parsed;
-                try {
-                    parsed = JSON.parse(data);
-                }
-                catch {
-                    continue;
-                }
-                yield* this.mapEvent(currentEvent, parsed, blocks);
-            }
-        }
-    }
-    *mapEvent(event, data, blocks) {
-        switch (event) {
-            case "message_start": {
-                // Extract usage from message_start
-                const msg = data.message;
-                const usage = msg?.usage;
-                if (usage?.input_tokens) {
-                    yield {
-                        type: "usage",
-                        promptTokens: usage.input_tokens ?? 0,
-                        completionTokens: usage.output_tokens ?? 0,
-                    };
-                }
-                break;
-            }
-            case "content_block_start": {
-                const index = data.index;
-                const block = data.content_block;
-                if (!block)
-                    break;
-                const blockType = block.type;
-                blocks.set(index, {
-                    type: blockType,
-                    id: block.id,
-                    name: block.name,
-                });
-                if (blockType === "tool_use") {
-                    yield {
-                        type: "tool_call_delta",
-                        index,
-                        id: block.id,
-                        name: block.name,
-                        arguments: "",
-                    };
-                }
-                else if (blockType === "thinking") {
-                    // Thinking block start — no chunk needed
-                }
-                break;
-            }
-            case "content_block_delta": {
-                const index = data.index;
-                const delta = data.delta;
-                if (!delta)
-                    break;
-                const deltaType = delta.type;
-                if (deltaType === "text_delta") {
-                    yield { type: "delta", text: delta.text };
-                }
-                else if (deltaType === "input_json_delta") {
-                    yield {
-                        type: "tool_call_delta",
-                        index,
-                        arguments: delta.partial_json,
-                    };
-                }
-                else if (deltaType === "thinking_delta") {
-                    yield {
-                        type: "reasoning_delta",
-                        text: delta.thinking,
-                    };
-                }
-                break;
-            }
-            case "content_block_stop": {
-                const index = data.index;
-                blocks.delete(index);
-                break;
-            }
-            case "message_delta": {
-                const delta = data.delta;
-                const usage = data.usage;
-                if (usage) {
-                    yield {
-                        type: "usage",
-                        promptTokens: 0,
-                        completionTokens: usage.output_tokens ?? 0,
-                    };
-                }
-                if (delta?.stop_reason) {
-                    yield { type: "done", finishReason: mapAnthropicStopReason(delta.stop_reason) };
-                }
-                break;
-            }
-            case "message_stop":
-                // Final event, no data needed
-                break;
-            case "error": {
-                const error = data.error;
-                throw new Error(`Anthropic stream error: ${error?.message ?? JSON.stringify(data)}`);
-            }
-        }
-    }
-}
-// ── Stop reason normalization (Anthropic → OpenAI standard) ──────────────────
-function mapAnthropicStopReason(reason) {
-    switch (reason) {
-        case "end_turn":
-        case "stop_sequence":
-            return "stop";
-        case "tool_use":
-            return "tool_calls";
-        case "max_tokens":
-            return "length";
-        default:
-            return reason;
-    }
-}
-// ── Reasoning effort → thinking budget (Hermes-aligned) ─────────────────────
-const THINKING_BUDGET = {
-    xhigh: 32000,
-    high: 16000,
-    medium: 8000,
-    low: 4000,
-};
-function mapReasoningEffortToBudget(effort) {
-    return THINKING_BUDGET[effort] ?? THINKING_BUDGET.high;
-}
-// ── Message format conversion (OpenAI → Anthropic) ───────────────────────────
-function convertMessages(messages) {
-    let system;
-    const out = [];
-    for (const msg of messages) {
-        if (msg.role === "system") {
-            // Anthropic requires system as a top-level param, not a message
-            system = system ? `${system}\n\n${msg.content ?? ""}` : (msg.content ?? "");
-            continue;
-        }
-        if (msg.role === "user") {
-            out.push({ role: "user", content: msg.content ?? "" });
-        }
-        else if (msg.role === "assistant") {
-            if (msg.tool_calls && msg.tool_calls.length > 0) {
-                // Assistant message with tool calls
-                const content = [];
-                if (msg.content) {
-                    content.push({ type: "text", text: msg.content });
-                }
-                for (const tc of msg.tool_calls) {
-                    let input;
-                    try {
-                        input = JSON.parse(tc.function.arguments);
-                    }
-                    catch {
-                        input = {};
-                    }
-                    content.push({
-                        type: "tool_use",
-                        id: tc.id,
-                        name: tc.function.name,
-                        input,
-                    });
-                }
-                out.push({ role: "assistant", content });
-            }
-            else {
-                out.push({ role: "assistant", content: msg.content ?? "" });
-            }
-        }
-        else if (msg.role === "tool") {
-            // Tool result → Anthropic user message with tool_result content blocks
-            out.push({
-                role: "user",
-                content: [
-                    {
-                        type: "tool_result",
-                        tool_use_id: msg.tool_call_id ?? "",
-                        content: msg.content ?? "",
-                    },
-                ],
-            });
-        }
-    }
-    return { system, messages: out };
-}
-function convertToolDef(tool) {
-    return {
-        name: tool.function.name,
-        description: tool.function.description,
-        input_schema: tool.function.parameters ?? { type: "object", properties: {} },
-    };
-}

package/dist/llm/transports/openai-chat.d.ts

@@ -1,36 +0,0 @@
-/**
- * OpenAI Chat Completions Transport — SSE streaming implementation.
- *
- * Covers all OpenAI-compatible providers:
- *   DeepSeek, Qwen, 硅基, Minimax, Moonshot, Groq, Together, OpenRouter, etc.
- *
- * POST {baseUrl}/v1/chat/completions with stream: true
- * Auth: Authorization: Bearer {apiKey}
- *
- * SSE format: lines prefixed with "data: ", JSON parsing per event.
- *
- * Adapted from admin-infer-proxy-client.ts SSE logic + Hermes openai_chat.py transport.
- */
-import type { LLMChunk, LLMRequest, LLMTransport } from "../transport.js";
-export interface OpenAIChatTransportConfig {
-    baseUrl: string;
-    /** Additional headers (e.g. for specific providers) */
-    extraHeaders?: Record<string, string>;
-    /** Timeout in ms (default 180_000) */
-    timeoutMs?: number;
-    /** Whether to include stream_options (default true). Set false for providers that reject it. */
-    supportsStreamOptions?: boolean;
-    /** Whether to omit temperature when it equals 0 (e.g. Moonshot rejects 0) */
-    omitZeroTemperature?: boolean;
-}
-export declare class OpenAIChatTransport implements LLMTransport {
-    private baseUrl;
-    private extraHeaders;
-    private timeoutMs;
-    private supportsStreamOptions;
-    private omitZeroTemperature;
-    constructor(config: OpenAIChatTransportConfig);
-    stream(request: LLMRequest, apiKey: string, signal?: AbortSignal): AsyncGenerator<LLMChunk>;
-    private parseSSEStream;
-    private mapChunk;
-}

package/dist/llm/transports/openai-chat.js

@@ -1,165 +0,0 @@
-/**
- * OpenAI Chat Completions Transport — SSE streaming implementation.
- *
- * Covers all OpenAI-compatible providers:
- *   DeepSeek, Qwen, 硅基, Minimax, Moonshot, Groq, Together, OpenRouter, etc.
- *
- * POST {baseUrl}/v1/chat/completions with stream: true
- * Auth: Authorization: Bearer {apiKey}
- *
- * SSE format: lines prefixed with "data: ", JSON parsing per event.
- *
- * Adapted from admin-infer-proxy-client.ts SSE logic + Hermes openai_chat.py transport.
- */
-export class OpenAIChatTransport {
-    baseUrl;
-    extraHeaders;
-    timeoutMs;
-    supportsStreamOptions;
-    omitZeroTemperature;
-    constructor(config) {
-        // Strip trailing slash
-        this.baseUrl = config.baseUrl.replace(/\/+$/, "");
-        this.extraHeaders = config.extraHeaders ?? {};
-        this.timeoutMs = config.timeoutMs ?? 180_000;
-        this.supportsStreamOptions = config.supportsStreamOptions ?? true;
-        this.omitZeroTemperature = config.omitZeroTemperature ?? false;
-    }
-    async *stream(request, apiKey, signal) {
-        const url = `${this.baseUrl}/v1/chat/completions`;
-        const body = {
-            model: request.model,
-            messages: request.messages,
-            stream: true,
-        };
-        // stream_options: supported by most providers, but some reject it
-        if (this.supportsStreamOptions) {
-            body.stream_options = { include_usage: true };
-        }
-        if (request.tools && request.tools.length > 0) {
-            body.tools = request.tools;
-            if (request.toolChoice)
-                body.tool_choice = request.toolChoice;
-        }
-        if (request.temperature !== undefined) {
-            // Some providers (e.g. Moonshot/Kimi) reject temperature=0
-            if (!(this.omitZeroTemperature && request.temperature === 0)) {
-                body.temperature = request.temperature;
-            }
-        }
-        if (request.maxTokens !== undefined)
-            body.max_tokens = request.maxTokens;
-        if (request.reasoning) {
-            // DeepSeek-R1 / o1 style reasoning
-            body.reasoning = request.reasoning;
-        }
-        const timeoutSignal = AbortSignal.timeout(this.timeoutMs);
-        const combinedSignal = signal
-            ? AbortSignal.any([signal, timeoutSignal])
-            : timeoutSignal;
-        const response = await fetch(url, {
-            method: "POST",
-            headers: {
-                "Content-Type": "application/json",
-                Authorization: `Bearer ${apiKey}`,
-                ...this.extraHeaders,
-            },
-            body: JSON.stringify(body),
-            signal: combinedSignal,
-        });
-        if (!response.ok) {
-            const errorBody = await response.text().catch(() => "");
-            throw new Error(`LLM API error ${response.status}: ${errorBody.slice(0, 500)}`);
-        }
-        if (!response.body) {
-            throw new Error("LLM API returned no response body");
-        }
-        yield* this.parseSSEStream(response.body);
-    }
-    async *parseSSEStream(body) {
-        const decoder = new TextDecoder();
-        let buffer = "";
-        for await (const raw of body) {
-            buffer += decoder.decode(raw, { stream: true });
-            // Process complete lines
-            let newlineIdx;
-            while ((newlineIdx = buffer.indexOf("\n")) !== -1) {
-                const line = buffer.slice(0, newlineIdx).trim();
-                buffer = buffer.slice(newlineIdx + 1);
-                if (!line)
-                    continue;
-                if (line.startsWith(":"))
-                    continue; // SSE comment
-                if (!line.startsWith("data: "))
-                    continue;
-                const data = line.slice(6);
-                if (data === "[DONE]") {
-                    return;
-                }
-                let parsed;
-                try {
-                    parsed = JSON.parse(data);
-                }
-                catch {
-                    continue; // Skip malformed JSON
-                }
-                yield* this.mapChunk(parsed);
-            }
-        }
-        // Flush remaining buffer
-        if (buffer.trim()) {
-            const line = buffer.trim();
-            if (line.startsWith("data: ") && line.slice(6) !== "[DONE]") {
-                try {
-                    const parsed = JSON.parse(line.slice(6));
-                    yield* this.mapChunk(parsed);
-                }
-                catch {
-                    // ignore
-                }
-            }
-        }
-    }
-    *mapChunk(chunk) {
-        // Usage chunk (often sent at the end with stream_options)
-        if (chunk.usage) {
-            yield {
-                type: "usage",
-                promptTokens: chunk.usage.prompt_tokens ?? 0,
-                completionTokens: chunk.usage.completion_tokens ?? 0,
-                reasoningTokens: chunk.usage.completion_tokens_details?.reasoning_tokens,
-            };
-        }
-        if (!chunk.choices || chunk.choices.length === 0)
-            return;
-        for (const choice of chunk.choices) {
-            const delta = choice.delta;
-            if (!delta)
-                continue;
-            // Reasoning content (DeepSeek-R1 style)
-            if (delta.reasoning_content) {
-                yield { type: "reasoning_delta", text: delta.reasoning_content };
-            }
-            // Text content
-            if (delta.content) {
-                yield { type: "delta", text: delta.content };
-            }
-            // Tool call deltas
-            if (delta.tool_calls) {
-                for (const tc of delta.tool_calls) {
-                    yield {
-                        type: "tool_call_delta",
-                        index: tc.index,
-                        id: tc.id,
-                        name: tc.function?.name,
-                        arguments: tc.function?.arguments ?? "",
-                    };
-                }
-            }
-            // Finish reason
-            if (choice.finish_reason) {
-                yield { type: "done", finishReason: choice.finish_reason };
-            }
-        }
-    }
-}

package/dist/orchestration/agent-registry.d.ts

@@ -1,41 +0,0 @@
-/**
- * Built-in Agent Registry — CC-aligned agent definitions for fork/subagent.
- *
- * Each built-in agent defines a role with constrained tools, system prompt,
- * and execution budget. The LLM can invoke these via the AgentTool.
- */
-export interface AgentDefinition {
-    /** Unique identifier for the agent (kebab-case). */
-    name: string;
-    /** Human-readable label. */
-    label: string;
-    /** Short description (appears in tool_search / LLM prompt). */
-    description: string;
-    /** Maximum turns this agent can execute before forced stop. */
-    maxTurns: number;
-    /** Tool access mode. */
-    toolAccessMode: "full" | "read-only" | "none";
-    /** Explicit allowed tool names (if empty, uses toolAccessMode filter). */
-    allowedTools?: string[];
-    /** Whether this agent can fork sub-agents itself. */
-    canFork: boolean;
-    /** System prompt override for this agent. */
-    systemPromptSuffix?: string;
-}
-/**
- * Get the full list of built-in agent definitions.
- */
-export declare function getBuiltInAgents(): AgentDefinition[];
-/**
- * Look up a built-in agent by name.
- */
-export declare function getBuiltInAgent(name: string): AgentDefinition | undefined;
-/**
- * Check if a given agent name is a built-in agent.
- */
-export declare function isBuiltInAgent(name: string): boolean;
-/**
- * Resolve tool access for an agent definition.
- * Returns the set of tool names the agent is allowed to use.
- */
-export declare function resolveAgentToolSet(agent: AgentDefinition, availableTools: string[]): string[];

package/dist/orchestration/agent-registry.js

@@ -1,116 +0,0 @@
-/**
- * Built-in Agent Registry — CC-aligned agent definitions for fork/subagent.
- *
- * Each built-in agent defines a role with constrained tools, system prompt,
- * and execution budget. The LLM can invoke these via the AgentTool.
- */
-/** General-purpose sub-agent for delegated tasks. */
-const GENERAL_PURPOSE_AGENT = {
-    name: "general",
-    label: "General Purpose",
-    description: "A general-purpose sub-agent that can perform any task with full tool access.",
-    maxTurns: 200,
-    toolAccessMode: "full",
-    canFork: false,
-};
-/** Explore agent — read-only exploration (code search, file reading, analysis). */
-const EXPLORE_AGENT = {
-    name: "explore",
-    label: "Explore",
-    description: "Fast read-only codebase exploration. Search files, read code, analyze structure. Cannot write or execute.",
-    maxTurns: 50,
-    toolAccessMode: "read-only",
-    allowedTools: ["read_file", "search", "web_search", "web_fetch", "think", "memory_query", "tool_search"],
-    canFork: false,
-};
-/** Plan agent — read-only planning mode (explore + propose, no execution). */
-const PLAN_AGENT = {
-    name: "plan",
-    label: "Plan",
-    description: "Planning mode. Explore, analyze, and produce a structured plan. Cannot write files or execute commands.",
-    maxTurns: 80,
-    toolAccessMode: "read-only",
-    allowedTools: ["read_file", "search", "web_search", "web_fetch", "think", "memory_query", "todo", "tool_search"],
-    canFork: false,
-};
-/** Code agent — full execution capability for code tasks. */
-const CODE_AGENT = {
-    name: "code",
-    label: "Code",
-    description: "A coding sub-agent with full tool access for implementation tasks.",
-    maxTurns: 200,
-    toolAccessMode: "full",
-    canFork: true,
-};
-/** Research agent — web research and information gathering. */
-const RESEARCH_AGENT = {
-    name: "research",
-    label: "Research",
-    description: "Web research and information gathering. Searches the web, fetches pages, and synthesizes findings.",
-    maxTurns: 30,
-    toolAccessMode: "read-only",
-    allowedTools: ["web_search", "web_fetch", "read_file", "search", "think", "memory_query"],
-    canFork: false,
-};
-/** Verification agent — runs tests and validates changes. */
-const VERIFY_AGENT = {
-    name: "verify",
-    label: "Verify",
-    description: "Verification agent. Runs tests, checks build output, validates changes are correct.",
-    maxTurns: 40,
-    toolAccessMode: "full",
-    allowedTools: ["exec", "read_file", "search", "think"],
-    canFork: false,
-};
-const BUILT_IN_AGENTS = [
-    GENERAL_PURPOSE_AGENT,
-    EXPLORE_AGENT,
-    PLAN_AGENT,
-    CODE_AGENT,
-    RESEARCH_AGENT,
-    VERIFY_AGENT,
-];
-/**
- * Get the full list of built-in agent definitions.
- */
-export function getBuiltInAgents() {
-    return [...BUILT_IN_AGENTS];
-}
-/**
- * Look up a built-in agent by name.
- */
-export function getBuiltInAgent(name) {
-    return BUILT_IN_AGENTS.find((a) => a.name === name);
-}
-/**
- * Check if a given agent name is a built-in agent.
- */
-export function isBuiltInAgent(name) {
-    return BUILT_IN_AGENTS.some((a) => a.name === name);
-}
-/**
- * Resolve tool access for an agent definition.
- * Returns the set of tool names the agent is allowed to use.
- */
-export function resolveAgentToolSet(agent, availableTools) {
-    if (agent.allowedTools && agent.allowedTools.length > 0) {
-        const allowed = new Set(agent.allowedTools);
-        return availableTools.filter((t) => allowed.has(t));
-    }
-    if (agent.toolAccessMode === "none")
-        return [];
-    if (agent.toolAccessMode === "read-only") {
-        const writeTools = new Set([
-            "file_edit", "create_file", "write_file", "replace_string_in_file",
-            "multi_replace_string_in_file", "create_directory", "delete_file",
-            "rename_file", "move_file", "exec", "run_in_terminal", "run_command",
-            "git_commit", "git_push", "patch",
-        ]);
-        return availableTools.filter((t) => !writeTools.has(t));
-    }
-    // "full" — all tools except agent_tool itself (no recursive fork for non-canFork)
-    if (!agent.canFork) {
-        return availableTools.filter((t) => t !== "agent_tool" && t !== "team_create");
-    }
-    return [...availableTools];
-}

package/dist/orchestration/approval-aware-tool-plan.d.ts

@@ -1,32 +0,0 @@
-import type { ToolCallBatch, ToolCallLike } from "./parallel-tool-calls.js";
-import type { ToolEligibilityLike } from "./tool-choice-policy.js";
-export type ToolExecutionStepContext = {
-    stepIndex?: number;
-    stepTotal?: number;
-    stepSummary?: string;
-};
-export type ApprovalAwareToolCapability = {
-    name: string;
-    requiresApproval?: boolean;
-    approvalMode?: string;
-};
-export type ApprovalAwareToolPlanStep = {
-    stepIndex: number;
-    stepCount: number;
-    mode: "parallel" | "serial";
-    callIds: string[];
-    toolNames: string[];
-    approvalRequired: boolean;
-    approvalToolNames: string[];
-    summary: string;
-};
-export declare function summarizeApprovalAwareToolPlan<TCall extends ToolCallLike>(params: {
-    batches: Array<ToolCallBatch<TCall>>;
-    toolCapabilities: readonly ApprovalAwareToolCapability[];
-    eligibility?: readonly ToolEligibilityLike[];
-}): ApprovalAwareToolPlanStep[];
-export declare function buildApprovalAwareReason(params: {
-    toolName: string;
-    step: ApprovalAwareToolPlanStep | undefined;
-}): string;
-export declare function buildApprovalStepContext(step: ApprovalAwareToolPlanStep | undefined): ToolExecutionStepContext;