qlogicagent 0.2.1 → 0.3.0

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.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.js

@@ -1,87 +0,0 @@
-function formatToolList(toolNames) {
-    if (toolNames.length === 0) {
-        return "no tools";
-    }
-    if (toolNames.length === 1) {
-        return toolNames[0];
-    }
-    if (toolNames.length === 2) {
-        return `${toolNames[0]} and ${toolNames[1]}`;
-    }
-    return `${toolNames.slice(0, -1).join(", ")}, and ${toolNames.at(-1)}`;
-}
-function requiresInteractiveApproval(capability) {
-    if (!capability) {
-        return false;
-    }
-    return capability.requiresApproval === true || capability.approvalMode === "user-confirm";
-}
-function buildEligibilityMap(eligibility) {
-    return new Map((eligibility ?? []).map((entry) => [entry.toolName, entry]));
-}
-function requiresApprovalForTool(params) {
-    const eligibility = params.eligibilityMap.get(params.toolName);
-    if (eligibility?.approvalRequired !== undefined) {
-        return eligibility.approvalRequired;
-    }
-    return requiresInteractiveApproval(params.capabilityMap.get(params.toolName));
-}
-export function summarizeApprovalAwareToolPlan(params) {
-    const capabilityMap = new Map(params.toolCapabilities.map((capability) => [capability.name, capability]));
-    const eligibilityMap = buildEligibilityMap(params.eligibility);
-    const stepCount = params.batches.length;
-    return params.batches.map((batch, index) => {
-        const toolNames = batch.calls.map((call) => call.function.name);
-        const approvalToolNames = batch.calls
-            .map((call) => requiresApprovalForTool({
-            toolName: call.function.name,
-            capabilityMap,
-            eligibilityMap,
-        }) ? call.function.name : null)
-            .filter((toolName) => Boolean(toolName));
-        const approvalRequired = approvalToolNames.length > 0;
-        const headline = batch.mode === "parallel"
-            ? `Step ${index + 1}/${stepCount}: run ${toolNames.length} tools in parallel: ${formatToolList(toolNames)}.`
-            : approvalRequired
-                ? `Step ${index + 1}/${stepCount}: approval-gated execution for ${formatToolList(approvalToolNames)}.`
-                : `Step ${index + 1}/${stepCount}: run ${formatToolList(toolNames)} serially.`;
-        const detail = approvalRequired
-            ? stepCount > index + 1
-                ? "This step must be approved before later steps continue."
-                : "This is the final planned step and requires approval before execution."
-            : batch.mode === "parallel"
-                ? "Parallel-safe tools are grouped to avoid unnecessary waiting."
-                : "This step stays serial because the tool is not parallel-safe.";
-        return {
-            stepIndex: index + 1,
-            stepCount,
-            mode: batch.mode,
-            callIds: batch.calls.map((call) => call.id),
-            toolNames,
-            approvalRequired,
-            approvalToolNames,
-            summary: `${headline} ${detail}`,
-        };
-    });
-}
-export function buildApprovalAwareReason(params) {
-    if (!params.step) {
-        return `semantic turn requested local tool: ${params.toolName}`;
-    }
-    const suffix = params.step.approvalRequired
-        ? params.step.approvalToolNames.length > 1
-            ? ` Approval is currently blocking ${formatToolList(params.step.approvalToolNames)}.`
-            : " Approval is required before this step can continue."
-        : "";
-    return `${params.step.summary}${suffix}`;
-}
-export function buildApprovalStepContext(step) {
-    if (!step) {
-        return {};
-    }
-    return {
-        stepIndex: step.stepIndex,
-        stepTotal: step.stepCount,
-        stepSummary: step.summary,
-    };
-}