qlogicagent 0.2.1 → 0.3.0

package/dist/llm/model-catalog.js

@@ -1,191 +0,0 @@
-/**
- * ModelCatalog — remote model directory with disk cache + fallback.
- *
- * Fetches model metadata from models.dev (open community catalog, 4000+ models).
- * Aligned with Hermes agent/models_dev.py caching strategy.
- *
- * Three-layer fallback:
- *   1. In-memory cache (process-level, TTL check against disk mtime)
- *   2. Disk cache (~/.openclaw/cache/model_catalog.json)
- *   3. Remote fetch (https://models.dev/api.json)
- *   4. Stale disk cache (if remote fails)
- *   5. Empty (caller falls back to builtin-providers.ts hardcoded)
- *
- * Non-blocking: first startup without cache returns empty immediately,
- * triggers background async fetch. Agent uses builtin providers until
- * catalog arrives.
- */
-import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
-import { join } from "node:path";
-import { homedir } from "node:os";
-// ── Constants ────────────────────────────────────────────────────────────────
-const MODELS_DEV_URL = "https://models.dev/api.json";
-const FETCH_TIMEOUT_MS = 15_000;
-const DEFAULT_TTL_MS = 24 * 60 * 60 * 1000; // 24 hours
-const RETRY_TTL_MS = 5 * 60 * 1000; // 5 min after failure
-// ── ModelCatalog class ───────────────────────────────────────────────────────
-export class ModelCatalog {
-    cache = null;
-    cacheDir;
-    cacheFile;
-    ttlMs;
-    fetching = false;
-    lastFetchAttempt = 0;
-    constructor(opts) {
-        this.cacheDir = opts?.cacheDir ?? join(homedir(), ".openclaw", "cache");
-        this.cacheFile = join(this.cacheDir, "model_catalog.json");
-        this.ttlMs = opts?.ttlMs ?? DEFAULT_TTL_MS;
-    }
-    /**
-     * Get models for a provider. Non-blocking: returns whatever is cached.
-     * Triggers background refresh if stale.
-     */
-    getModels(providerId) {
-        this.ensureLoaded();
-        const provider = this.cache?.providers.get(providerId);
-        if (!provider)
-            return [];
-        return [...provider.models.values()];
-    }
-    /**
-     * Get a single model by provider + model id.
-     */
-    getModel(providerId, modelId) {
-        this.ensureLoaded();
-        return this.cache?.providers.get(providerId)?.models.get(modelId);
-    }
-    /**
-     * List all known provider ids from the catalog.
-     */
-    listProviderIds() {
-        this.ensureLoaded();
-        return this.cache ? [...this.cache.providers.keys()] : [];
-    }
-    /**
-     * Force refresh from remote. Returns true if successful.
-     */
-    async refreshCatalog() {
-        return this.fetchRemote();
-    }
-    // ── Internal ──────────────────────────────────────────────────
-    ensureLoaded() {
-        if (this.cache && !this.isStale())
-            return;
-        // Try disk cache
-        if (!this.cache) {
-            this.loadFromDisk();
-        }
-        // Trigger background fetch if stale or missing
-        if (!this.cache || this.isStale()) {
-            this.backgroundFetch();
-        }
-    }
-    isStale() {
-        if (!this.cache)
-            return true;
-        return Date.now() - this.cache.fetchedAt > this.ttlMs;
-    }
-    loadFromDisk() {
-        try {
-            if (!existsSync(this.cacheFile))
-                return;
-            const raw = readFileSync(this.cacheFile, "utf8");
-            const parsed = JSON.parse(raw);
-            if (!parsed.fetchedAt || !parsed.data)
-                return;
-            this.cache = {
-                fetchedAt: parsed.fetchedAt,
-                providers: parseModelsDevResponse(parsed.data),
-            };
-        }
-        catch {
-            // Corrupted cache file — ignore
-        }
-    }
-    saveToDisk(data) {
-        try {
-            mkdirSync(this.cacheDir, { recursive: true });
-            const payload = JSON.stringify({ fetchedAt: Date.now(), data }, null, 0);
-            writeFileSync(this.cacheFile, payload, "utf8");
-        }
-        catch {
-            // Disk write failure — non-fatal
-        }
-    }
-    backgroundFetch() {
-        if (this.fetching)
-            return;
-        // Don't retry too soon after a failure
-        if (Date.now() - this.lastFetchAttempt < RETRY_TTL_MS)
-            return;
-        this.fetching = true;
-        this.fetchRemote().finally(() => {
-            this.fetching = false;
-        });
-    }
-    async fetchRemote() {
-        this.lastFetchAttempt = Date.now();
-        try {
-            const response = await fetch(MODELS_DEV_URL, {
-                signal: AbortSignal.timeout(FETCH_TIMEOUT_MS),
-                headers: { Accept: "application/json" },
-            });
-            if (!response.ok) {
-                return false;
-            }
-            const data = await response.json();
-            const providers = parseModelsDevResponse(data);
-            if (providers.size === 0) {
-                return false;
-            }
-            this.cache = { fetchedAt: Date.now(), providers };
-            this.saveToDisk(data);
-            return true;
-        }
-        catch {
-            // Network failure — keep stale cache if any
-            return false;
-        }
-    }
-}
-// ── Parser: models.dev JSON → CatalogProvider map ────────────────────────────
-/**
- * Parse models.dev api.json response.
- * Format: { provider_id: { models: { model_name: { ... } } } }
- */
-function parseModelsDevResponse(data) {
-    const providers = new Map();
-    if (!data || typeof data !== "object")
-        return providers;
-    for (const [providerId, providerData] of Object.entries(data)) {
-        if (!providerData || typeof providerData !== "object")
-            continue;
-        const modelsObj = providerData.models;
-        if (!modelsObj || typeof modelsObj !== "object")
-            continue;
-        const models = new Map();
-        for (const [modelId, modelData] of Object.entries(modelsObj)) {
-            if (!modelData || typeof modelData !== "object")
-                continue;
-            const m = modelData;
-            const limit = m.limit ?? {};
-            const modalities = m.modalities ?? {};
-            const inputMods = Array.isArray(modalities.input) ? modalities.input : [];
-            models.set(modelId, {
-                id: modelId,
-                name: typeof m.name === "string" ? m.name : modelId,
-                contextWindow: typeof limit.context === "number" ? limit.context : 200_000,
-                maxOutput: typeof limit.output === "number" ? limit.output : 8_192,
-                toolCall: m.tool_call === true,
-                reasoning: m.reasoning === true,
-                vision: m.attachment === true || inputMods.includes("image"),
-                costInput: typeof m.cost_input === "number" ? m.cost_input : undefined,
-                costOutput: typeof m.cost_output === "number" ? m.cost_output : undefined,
-            });
-        }
-        if (models.size > 0) {
-            providers.set(providerId, { models });
-        }
-    }
-    return providers;
-}

package/dist/llm/provider-def.js

@@ -1,12 +0,0 @@
-/**
- * ProviderDef — defines how to connect to an LLM provider.
- *
- * Aligned with Hermes `ProviderDef` dataclass pattern:
- *   id + name + transport type + baseUrl + auth config + model list
- *
- * Three-layer merge strategy (Layer 3 > Layer 2 > Layer 1):
- *   Layer 1: builtin-providers.ts hardcoded (fallback)
- *   Layer 2: model-catalog.ts remote (models.dev)
- *   Layer 3: user config (from agent.turn.config)
- */
-export {};

package/dist/llm/provider-registry.js

@@ -1,147 +0,0 @@
-/**
- * ProviderRegistry — three-layer merge registry for LLM providers.
- *
- * Layer 1: builtin-providers.ts hardcoded (lowest priority, ~20 providers)
- * Layer 2: model-catalog.ts remote (models.dev — enriches model metadata)
- * Layer 3: user config override (from agent.turn.config — highest priority)
- *
- * Merge strategy: Layer 3 > Layer 2 > Layer 1 (later layers override same-id fields)
- *
- * Aligned with Hermes provider_registry.py.
- */
-import { BUILTIN_PROVIDERS } from "./builtin-providers.js";
-import { ModelCatalog } from "./model-catalog.js";
-// Provider alias map (Hermes-aligned): common user names → canonical ids
-const PROVIDER_ALIASES = {
-    claude: "anthropic",
-    gemini: "google",
-    "x-ai": "xai",
-    "z-ai": "xai",
-    silicon: "siliconflow",
-    "silicon-flow": "siliconflow",
-};
-export class ProviderRegistry {
-    /** Layer 1: builtin hardcoded providers */
-    builtins = new Map();
-    /** Layer 2: remote model catalog (models.dev) */
-    catalog;
-    /** Layer 3: user overrides (from agent.turn.config) */
-    overrides = new Map();
-    constructor(opts) {
-        for (const p of BUILTIN_PROVIDERS) {
-            this.builtins.set(p.id, p);
-        }
-        this.catalog = opts?.catalog ?? new ModelCatalog();
-    }
-    /**
-     * Apply user config override for a provider.
-     * Typically called when agent.turn.config has baseUrl/apiKey overrides.
-     */
-    applyOverride(providerId, override) {
-        this.overrides.set(providerId, {
-            ...this.overrides.get(providerId),
-            ...override,
-        });
-    }
-    /**
-     * Get merged ProviderDef by id (Layer 3 > Layer 1).
-     * Returns undefined if provider not found.
-     * Supports common aliases (e.g., "claude" → "anthropic").
-     */
-    getProvider(id) {
-        const resolvedId = PROVIDER_ALIASES[id] ?? id;
-        const builtin = this.builtins.get(resolvedId);
-        const override = this.overrides.get(resolvedId);
-        if (!builtin && !override)
-            return undefined;
-        if (!builtin && override) {
-            // User defined a custom provider entirely
-            if (!override.id || !override.transport || !override.baseUrl) {
-                return undefined;
-            }
-            return {
-                id: override.id,
-                name: override.name ?? override.id,
-                transport: override.transport,
-                baseUrl: override.baseUrl,
-                apiKeyEnvVars: override.apiKeyEnvVars ?? [],
-                authType: override.authType ?? "bearer",
-                isAggregator: override.isAggregator ?? false,
-                defaultModel: override.defaultModel,
-                models: override.models,
-            };
-        }
-        if (builtin && !override)
-            return builtin;
-        // Merge: override fields take precedence
-        return {
-            ...builtin,
-            ...override,
-            // Merge models: override models replace if provided
-            models: override.models ?? builtin.models,
-        };
-    }
-    /**
-     * List all known provider ids.
-     */
-    listProviders() {
-        const all = new Map();
-        for (const [id, p] of this.builtins) {
-            all.set(id, p);
-        }
-        // Override/custom providers
-        for (const [id] of this.overrides) {
-            const merged = this.getProvider(id);
-            if (merged)
-                all.set(id, merged);
-        }
-        return [...all.values()];
-    }
-    /**
-     * List models for a specific provider.
-     * Merges: Layer 3 override > Layer 1 builtin > Layer 2 catalog enrichment.
-     */
-    listModels(providerId) {
-        const provider = this.getProvider(providerId);
-        const builtinModels = provider?.models ?? [];
-        // Enrich with catalog data (Layer 2): catalog provides updated context windows,
-        // costs, and capability flags; builtin models take precedence for known fields.
-        const catalogModels = this.catalog.getModels(providerId);
-        if (catalogModels.length === 0)
-            return builtinModels;
-        // Build merged model list: builtin first, then catalog models not in builtin
-        const byId = new Map();
-        for (const cm of catalogModels) {
-            byId.set(cm.id, cm);
-        }
-        for (const bm of builtinModels) {
-            // Builtin overrides catalog for same id (builtin has curated values)
-            byId.set(bm.id, bm);
-        }
-        return [...byId.values()];
-    }
-    /**
-     * Trigger background refresh of the remote model catalog.
-     */
-    async refreshCatalog() {
-        return this.catalog.refreshCatalog();
-    }
-    /**
-     * Resolve API key for a provider:
-     *   1. Explicit key (from agent.turn.config)
-     *   2. Environment variables (ProviderDef.apiKeyEnvVars)
-     */
-    resolveApiKey(providerId, explicitKey) {
-        if (explicitKey)
-            return explicitKey;
-        const provider = this.getProvider(providerId);
-        if (!provider)
-            return undefined;
-        for (const envVar of provider.apiKeyEnvVars) {
-            const value = process.env[envVar];
-            if (value?.trim())
-                return value.trim();
-        }
-        return undefined;
-    }
-}

package/dist/llm/transport.js

@@ -1,27 +0,0 @@
-/**
- * LLMTransport — abstract interface for LLM inference calls.
- *
- * Aligned with Hermes `ProviderTransport` ABC:
- *   stream(request, apiKey, signal) → AsyncGenerator<LLMChunk>
- *
- * Two concrete implementations:
- *   - OpenAI Chat Completions (covers 95% of providers)
- *   - Anthropic Messages API
- */
-// ── Convenience: aggregate chunks to tool calls ──────────────────────────────
-/**
- * Accumulate tool_call_delta chunks into complete ToolCall objects.
- * Modeled after admin-infer-proxy-client's Map<index, toolCall> accumulator.
- */
-export function accumulateToolCalls(accumulator, chunk) {
-    let tc = accumulator.get(chunk.index);
-    if (!tc) {
-        tc = { id: "", name: "", arguments: "" };
-        accumulator.set(chunk.index, tc);
-    }
-    if (chunk.id)
-        tc.id = chunk.id;
-    if (chunk.name)
-        tc.name += chunk.name;
-    tc.arguments += chunk.arguments;
-}

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: {} },
-    };
-}