@aiaiaichain/agent 0.1.1

package/dist/models/CostTracker.js

@@ -0,0 +1,75 @@
+/**
+ * CostTracker — tracks token usage and cost across sessions.
+ */
+import { existsSync, readFileSync, writeFileSync } from "node:fs";
+import { resolve } from "node:path";
+import { Type } from "@sinclair/typebox";
+import { AgentDir } from "../core/AgentDir.js";
+const LIFETIME_PATH = resolve(AgentDir.getHome(), "lifetime-cost.json");
+export class CostTracker {
+    registry;
+    sessionEntry = { entries: [], totalCost: 0, totalTokens: 0 };
+    lifetime = { sessions: 0, totalCost: 0, totalTokens: 0 };
+    loaded = false;
+    constructor(registry) {
+        this.registry = registry;
+    }
+    track(model, promptTokens, completionTokens) {
+        if (!this.loaded)
+            this.loadLifetime();
+        const cost = this.estimateCost(model, promptTokens, completionTokens);
+        const entry = { model, promptTokens, completionTokens, cost, timestamp: Date.now() };
+        this.sessionEntry.entries.push(entry);
+        this.sessionEntry.totalCost += cost;
+        this.sessionEntry.totalTokens += promptTokens + completionTokens;
+    }
+    estimateCost(model, prompt, completion) {
+        const all = this.registry.getAllModels();
+        const m = all.find(m => m.id === model);
+        if (!m)
+            return (prompt + completion) * 0.000001;
+        const p = parseFloat(m.pricing.prompt) || DEFAULT_RATES.prompt;
+        const c = parseFloat(m.pricing.completion) || DEFAULT_RATES.completion;
+        return (prompt * p) + (completion * c);
+    }
+    statusLine() {
+        return `$${this.sessionEntry.totalCost.toFixed(4)}`;
+    }
+    saveLifetime() {
+        this.lifetime.sessions++;
+        this.lifetime.totalCost += this.sessionEntry.totalCost;
+        this.lifetime.totalTokens += this.sessionEntry.totalTokens;
+        this.writeLifetime();
+    }
+    loadLifetime() {
+        try {
+            if (existsSync(LIFETIME_PATH)) {
+                this.lifetime = JSON.parse(readFileSync(LIFETIME_PATH, "utf-8"));
+            }
+        }
+        catch { /* fresh start */ }
+        this.loaded = true;
+    }
+    writeLifetime() {
+        try {
+            writeFileSync(LIFETIME_PATH, JSON.stringify(this.lifetime, null, 2), "utf-8");
+        }
+        catch { /* non-fatal */ }
+    }
+    costReportParams = Type.Object({});
+    async costReportTool() {
+        const s = this.sessionEntry;
+        const l = this.lifetime;
+        return {
+            content: [{
+                    type: "text",
+                    text: [
+                        `Session cost: $${s.totalCost.toFixed(4)} (${s.totalTokens} tokens, ${s.entries.length} calls)`,
+                        `Lifetime:     $${l.totalCost.toFixed(4)} (${l.totalTokens} tokens, ${l.sessions} sessions)`,
+                    ].join("\n"),
+                }],
+        };
+    }
+}
+const DEFAULT_RATES = { prompt: 0.000001, completion: 0.000002 };
+//# sourceMappingURL=CostTracker.js.map

package/dist/models/ModelRegistry.d.ts

@@ -0,0 +1,70 @@
+/**
+ * ModelRegistry — discovers available models via OpenRouter API.
+ * Caches results and provides tiered model pools.
+ */
+import type { ToolResult } from "../api/ExtensionAPI.js";
+export type ModelTier = "orchestrator" | "analyst" | "worker" | "free";
+export interface OpenRouterModel {
+    id: string;
+    name: string;
+    created: number;
+    description: string;
+    context_length: number;
+    architecture: {
+        modality: string;
+        tokenizer: string;
+        instruct_type: string | null;
+    };
+    pricing: {
+        prompt: string;
+        completion: string;
+        image: string;
+        request: string;
+    };
+    top_provider: {
+        max_completion_tokens: number | null;
+        is_moderated: boolean;
+    };
+    per_request_limits: {
+        prompt_tokens: number | null;
+        completion_tokens: number | null;
+    };
+}
+export interface TieredModel {
+    model: OpenRouterModel;
+    tier: ModelTier;
+    available: boolean;
+    failures: number;
+}
+export interface TieredPool {
+    tier: ModelTier;
+    models: TieredModel[];
+}
+export declare function classifyModel(model: OpenRouterModel): ModelTier;
+export declare class ModelRegistry {
+    private models;
+    private tiered;
+    private initialized;
+    initialise(): Promise<void>;
+    get modelCount(): number;
+    getPool(tier: ModelTier): TieredModel[];
+    getAllModels(): OpenRouterModel[];
+    getTier(modelId: string): ModelTier | undefined;
+    resolvePrimary(): string;
+    listModelsParams: import("@sinclair/typebox").TObject<{
+        query: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+        limit: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TNumber>;
+        available_only: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TBoolean>;
+    }>;
+    pickModelParams: import("@sinclair/typebox").TObject<{
+        tier: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+        min_context: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TNumber>;
+    }>;
+    summaryParams: import("@sinclair/typebox").TObject<{}>;
+    listModelsTool(_id: string, params: Record<string, unknown>): Promise<ToolResult>;
+    pickModelTool(_id: string, params: Record<string, unknown>): Promise<ToolResult>;
+    summaryTool(): Promise<ToolResult>;
+    private getFallbackModels;
+}
+export declare const modelRegistry: ModelRegistry;
+//# sourceMappingURL=ModelRegistry.d.ts.map

package/dist/models/ModelRegistry.js

@@ -0,0 +1,163 @@
+/**
+ * ModelRegistry — discovers available models via OpenRouter API.
+ * Caches results and provides tiered model pools.
+ */
+import { env } from "../core/EnvLoader.js";
+import { Type } from "@sinclair/typebox";
+const DEFAULT_PRICING = {
+    prompt: 0.000001,
+    completion: 0.000002,
+};
+// ── Tier classification logic ─────────────────────────────────────────────────
+export function classifyModel(model) {
+    const id = model.id.toLowerCase();
+    const name = model.name.toLowerCase();
+    // High-end reasoning / largest models
+    if (id.includes("o1") || id.includes("o3") || id.includes("claude-3.5-sonnet") ||
+        id.includes("claude-4") || id.includes("gemini-2.5-pro") ||
+        id.includes("gpt-4o") || !id.includes("mini") && (id.includes("gpt-4") || id.includes("chatgpt-4o")))
+        return "orchestrator";
+    // Mid-range capable models
+    if (id.includes("sonnet") || id.includes("gpt-4o-mini") || id.includes("claude-3-haiku") ||
+        id.includes("gemini-2.0-flash") || id.includes("gemini-1.5-pro") ||
+        id.includes("mistral-large") || id.includes("llama-3.1-70b") || id.includes("llama-3.3-70b") ||
+        id.includes("command-r-plus") || id.includes("deepseek-v2") || id.includes("qwen-2.5-72b") ||
+        id.includes("mixtral-8x22b"))
+        return "analyst";
+    // Small, fast, cheap models
+    if (id.includes("haiku") || id.includes("flash") || id.includes("mistral-7b") ||
+        id.includes("llama-3.1-8b") || id.includes("llama-3.2") || id.includes("phi-3") ||
+        id.includes("qwen-2.5-7b") || id.includes("gemma-2") || id.includes("deepseek-v2-lite") ||
+        id.includes("ministral-3b") || id.includes("command-r-08-2024") ||
+        id.includes("mixtral-8x7b") || id.includes("nemotron-4") || id.includes("claude-3-opus"))
+        return "worker";
+    return "free";
+}
+// ── Model Registry ────────────────────────────────────────────────────────────
+export class ModelRegistry {
+    models = [];
+    tiered = new Map();
+    initialized = false;
+    async initialise() {
+        if (this.initialized)
+            return;
+        const apiKey = env.get("OPENROUTER_API_KEY");
+        try {
+            const response = await fetch("https://openrouter.ai/api/v1/models", {
+                headers: apiKey ? { Authorization: `Bearer ${apiKey}` } : {},
+            });
+            if (response.ok) {
+                const data = (await response.json());
+                this.models = (data.data ?? []).filter(m => m.id && m.name);
+            }
+        }
+        catch {
+            // Fallback: use a curated list of known models
+            this.models = this.getFallbackModels();
+        }
+        // Build tiered pools
+        this.tiered.clear();
+        const tiers = ["orchestrator", "analyst", "worker", "free"];
+        for (const tier of tiers)
+            this.tiered.set(tier, []);
+        for (const model of this.models) {
+            const tier = classifyModel(model);
+            this.tiered.get(tier)?.push({
+                model,
+                tier,
+                available: true,
+                failures: 0,
+            });
+        }
+        this.initialized = true;
+    }
+    get modelCount() { return this.models.length; }
+    getPool(tier) {
+        return this.tiered.get(tier) ?? [];
+    }
+    getAllModels() {
+        return [...this.models];
+    }
+    getTier(modelId) {
+        const model = this.models.find(m => m.id === modelId);
+        if (!model)
+            return undefined;
+        return classifyModel(model);
+    }
+    resolvePrimary() {
+        const tier = "orchestrator";
+        const pool = this.tiered.get(tier) ?? [];
+        const available = pool.filter(tm => tm.available && tm.failures < 3);
+        if (available.length > 0)
+            return available[0].model.id;
+        // Fall through tiers
+        for (const t of ["analyst", "worker", "free"]) {
+            const fallback = (this.tiered.get(t) ?? []).filter(tm => tm.available && tm.failures < 3);
+            if (fallback.length > 0)
+                return fallback[0].model.id;
+        }
+        return "openai/gpt-4o-mini";
+    }
+    // ── Tools exposed to the agent ──────────────────────────────────────────
+    listModelsParams = Type.Object({
+        query: Type.Optional(Type.String({ description: "Search query (name/provider)" })),
+        limit: Type.Optional(Type.Number({ description: "Max results", default: 20 })),
+        available_only: Type.Optional(Type.Boolean({ default: true })),
+    });
+    pickModelParams = Type.Object({
+        tier: Type.Optional(Type.String({ description: "Tier: orchestrator, analyst, worker, free" })),
+        min_context: Type.Optional(Type.Number({ description: "Minimum context length in tokens" })),
+    });
+    summaryParams = Type.Object({});
+    async listModelsTool(_id, params) {
+        let items = [...this.models];
+        const query = (params.query || "").toLowerCase();
+        if (query)
+            items = items.filter(m => m.id.toLowerCase().includes(query) || m.name.toLowerCase().includes(query));
+        const limit = params.limit || 20;
+        const top = items.slice(0, limit);
+        const lines = top.map(m => {
+            const tier = classifyModel(m);
+            const tierIcon = { orchestrator: "⭐", analyst: "🔬", worker: "⚡", free: "🆓" }[tier] ?? "❓";
+            return `${tierIcon} ${m.id} — ${m.name}`;
+        });
+        return {
+            content: [{ type: "text", text: `Models (${items.length} matching):\n${lines.join("\n")}` }],
+        };
+    }
+    async pickModelTool(_id, params) {
+        const tier = params.tier || "worker";
+        const minCtx = params.min_context || 0;
+        const pool = this.tiered.get(tier) ?? [];
+        const available = pool.filter(tm => tm.available && tm.failures < 3 && tm.model.context_length >= minCtx);
+        if (available.length === 0) {
+            return { content: [{ type: "text", text: `No available models in tier "${tier}"${minCtx > 0 ? ` with ${minCtx}+ context` : ""}` }] };
+        }
+        const pick = available[0];
+        return { content: [{ type: "text", text: `Selected: ${pick.model.id} (${pick.model.name}) — tier: ${tier}` }] };
+    }
+    async summaryTool() {
+        const pool = this.tiered;
+        const lines = [`Total models: ${this.models.length}`];
+        for (const tier of ["orchestrator", "analyst", "worker", "free"]) {
+            const p = pool.get(tier) ?? [];
+            const avail = p.filter(tm => tm.available).length;
+            lines.push(`  ${tier}: ${p.length} total, ${avail} available`);
+        }
+        return { content: [{ type: "text", text: lines.join("\n") }] };
+    }
+    // ── Fallback models ─────────────────────────────────────────────────────
+    getFallbackModels() {
+        return [
+            { id: "openai/gpt-4o", name: "GPT-4o", created: 2024, description: "OpenAI GPT-4o", context_length: 128000, architecture: { modality: "text+image", tokenizer: "cl100k_base", instruct_type: null }, pricing: { prompt: "2.5e-6", completion: "1e-5", image: "0", request: "0" }, top_provider: { max_completion_tokens: 4096, is_moderated: true }, per_request_limits: null },
+            { id: "openai/gpt-4o-mini", name: "GPT-4o Mini", created: 2024, description: "OpenAI GPT-4o Mini", context_length: 128000, architecture: { modality: "text+image", tokenizer: "cl100k_base", instruct_type: null }, pricing: { prompt: "1.5e-7", completion: "6e-7", image: "0", request: "0" }, top_provider: { max_completion_tokens: 4096, is_moderated: true }, per_request_limits: null },
+            { id: "anthropic/claude-3.5-sonnet", name: "Claude 3.5 Sonnet", created: 2024, description: "Anthropic Claude 3.5 Sonnet", context_length: 200000, architecture: { modality: "text", tokenizer: "claude", instruct_type: null }, pricing: { prompt: "3e-6", completion: "1.5e-5", image: "0", request: "0" }, top_provider: { max_completion_tokens: 8192, is_moderated: true }, per_request_limits: null },
+            { id: "anthropic/claude-3-haiku", name: "Claude 3 Haiku", created: 2024, description: "Anthropic Claude 3 Haiku", context_length: 200000, architecture: { modality: "text", tokenizer: "claude", instruct_type: null }, pricing: { prompt: "2.5e-7", completion: "1.25e-6", image: "0", request: "0" }, top_provider: { max_completion_tokens: 4096, is_moderated: true }, per_request_limits: null },
+            { id: "google/gemini-2.0-flash-001", name: "Gemini 2.0 Flash", created: 2024, description: "Google Gemini 2.0 Flash", context_length: 1048576, architecture: { modality: "text+image", tokenizer: "gemini", instruct_type: null }, pricing: { prompt: "1e-7", completion: "4e-7", image: "0", request: "0" }, top_provider: { max_completion_tokens: 8192, is_moderated: false }, per_request_limits: null },
+            { id: "meta-llama/llama-3.1-8b-instruct", name: "Llama 3.1 8B", created: 2024, description: "Meta Llama 3.1 8B", context_length: 131072, architecture: { modality: "text", tokenizer: "tiktoken", instruct_type: null }, pricing: { prompt: "2e-8", completion: "2e-8", image: "0", request: "0" }, top_provider: { max_completion_tokens: 4096, is_moderated: false }, per_request_limits: null },
+            { id: "mistralai/mistral-small", name: "Mistral Small", created: 2024, description: "Mistral Small", context_length: 32000, architecture: { modality: "text", tokenizer: "mistral", instruct_type: null }, pricing: { prompt: "1e-7", completion: "3e-7", image: "0", request: "0" }, top_provider: { max_completion_tokens: 8192, is_moderated: true }, per_request_limits: null },
+        ];
+    }
+}
+export const modelRegistry = new ModelRegistry();
+//# sourceMappingURL=ModelRegistry.js.map

package/dist/runner/AgentRunner.d.ts

@@ -0,0 +1,54 @@
+/**
+ * AgentRunner — main agent loop. Handles tool calling, streaming, and message processing.
+ * The AI responds with text or tool calls; we parse, dispatch, and feed results back.
+ */
+import type { Registry } from "../api/Registry.js";
+import type { SessionManager } from "../session/SessionManager.js";
+import type { SessionContext } from "../api/ExtensionAPI.js";
+import type { ModelRegistry } from "../models/ModelRegistry.js";
+import type { CostTracker } from "../models/CostTracker.js";
+import type { GoalManager } from "../session/GoalManager.js";
+import type { ContextStore } from "../session/ContextStore.js";
+export type RunnerEvent = {
+    type: "text_delta";
+    text: string;
+} | {
+    type: "tool_start";
+    name: string;
+} | {
+    type: "tool_done";
+    name: string;
+    result: string;
+    isError: boolean;
+} | {
+    type: "turn_done";
+} | {
+    type: "error";
+    message: string;
+} | {
+    type: "approval_request";
+    toolName: string;
+    args: string;
+    approve: (ok: boolean) => void;
+};
+export declare class AgentRunner {
+    private registry;
+    private session;
+    private dispatcher;
+    private onEvent;
+    private sessionCtx;
+    private effectLevel;
+    private modelReg;
+    private costTracker?;
+    private goalManager?;
+    private contextStore?;
+    private abortController;
+    private _pendingApproval?;
+    constructor(registry: Registry, session: SessionManager, onEvent: (event: RunnerEvent) => void, sessionCtx: SessionContext, effectLevel: string, modelReg: ModelRegistry, costTracker?: CostTracker, goalManager?: GoalManager, contextStore?: ContextStore);
+    setEffectLevel(level: string): void;
+    run(input: string): Promise<void>;
+    private executeTool;
+    private requiresApproval;
+    abort(): void;
+}
+//# sourceMappingURL=AgentRunner.d.ts.map

package/dist/runner/AgentRunner.js

@@ -0,0 +1,171 @@
+/**
+ * AgentRunner — main agent loop. Handles tool calling, streaming, and message processing.
+ * The AI responds with text or tool calls; we parse, dispatch, and feed results back.
+ */
+import { ToolDispatcher } from "./ToolDispatcher.js";
+import { ModelClient, resolveModelConfig } from "./ModelClient.js";
+export class AgentRunner {
+    registry;
+    session;
+    dispatcher;
+    onEvent;
+    sessionCtx;
+    effectLevel;
+    modelReg;
+    costTracker;
+    goalManager;
+    contextStore;
+    abortController = null;
+    _pendingApproval;
+    constructor(registry, session, onEvent, sessionCtx, effectLevel, modelReg, costTracker, goalManager, contextStore) {
+        this.registry = registry;
+        this.session = session;
+        this.dispatcher = new ToolDispatcher(registry);
+        this.onEvent = onEvent;
+        this.sessionCtx = sessionCtx;
+        this.effectLevel = effectLevel;
+        this.modelReg = modelReg;
+        this.costTracker = costTracker;
+        this.goalManager = goalManager;
+        this.contextStore = contextStore;
+    }
+    setEffectLevel(level) {
+        this.effectLevel = level;
+    }
+    async run(input) {
+        this.session.addMessage("user", input);
+        const config = resolveModelConfig(this.modelReg);
+        const messages = this.session.getMessages();
+        const systemPrompt = this.session.getSystemPrompt();
+        let fullResponse = "";
+        let toolCallBuffer = "";
+        this.abortController = new AbortController();
+        const handleEvent = (event) => {
+            if (event.type === "text_delta") {
+                fullResponse += event.text;
+                // Check for tool call patterns
+                toolCallBuffer += event.text;
+                // Simple JSON tool call detection
+                const toolCallMatch = toolCallBuffer.match(/\{("tool"|"name"):\s*"([^"]+)"\s*,\s*"args"|"params"|"parameters":\s*(\{[^}]+\})\s*\}/);
+                if (toolCallMatch) {
+                    const toolName = toolCallMatch[2];
+                    let args = {};
+                    try {
+                        args = JSON.parse(toolCallMatch[3]);
+                    }
+                    catch { /* use empty args */ }
+                    fullResponse = fullResponse.replace(toolCallMatch[0], "").trim();
+                    toolCallBuffer = "";
+                    if (toolName !== "noop") {
+                        this.onEvent({ type: "tool_start", name: toolName });
+                        // Check if tool requires approval
+                        const tool = this.dispatcher.getTool(toolName);
+                        if (tool && this.requiresApproval(toolName)) {
+                            this.onEvent({
+                                type: "approval_request",
+                                toolName,
+                                args: JSON.stringify(args),
+                                approve: (ok) => {
+                                    if (ok) {
+                                        this.executeTool(toolName, args, fullResponse, systemPrompt, messages, config);
+                                    }
+                                    else {
+                                        this.onEvent({
+                                            type: "tool_done",
+                                            name: toolName,
+                                            result: JSON.stringify({ error: "User denied approval" }),
+                                            isError: true,
+                                        });
+                                        this.session.addMessage("assistant", fullResponse || `(tool ${toolName} was denied)`);
+                                        this.onEvent({ type: "turn_done" });
+                                    }
+                                },
+                            });
+                            return;
+                        }
+                        this.executeTool(toolName, args, fullResponse, systemPrompt, messages, config);
+                    }
+                }
+                this.onEvent({ type: "text_delta", text: event.text });
+            }
+            else if (event.type === "turn_done") {
+                if (fullResponse.trim()) {
+                    this.session.addMessage("assistant", fullResponse.trim());
+                    if (this.costTracker) {
+                        this.costTracker.track(config.model, messages.reduce((s, m) => s + m.content.length, 0), fullResponse.length);
+                    }
+                }
+                this.onEvent({ type: "turn_done" });
+            }
+            else if (event.type === "error") {
+                // Check if it's a streaming error that might be tool-call related
+                if (toolCallBuffer.includes("tool") || toolCallBuffer.includes("function")) {
+                    // Try to extract tool name from error
+                    const nameMatch = toolCallBuffer.match(/"name"\s*:\s*"([^"]+)"/);
+                    const name = nameMatch ? nameMatch[1] : "unknown";
+                    this.onEvent({
+                        type: "tool_done",
+                        name,
+                        result: JSON.stringify({ error: event.message }),
+                        isError: true,
+                    });
+                }
+                this.onEvent({ type: "error", message: event.message ?? "unknown error" });
+            }
+        };
+        await ModelClient.runStreaming({
+            config,
+            systemPrompt,
+            messages,
+            onEvent: handleEvent,
+            signal: this.abortController.signal,
+        });
+    }
+    async executeTool(toolName, args, responseSoFar, systemPrompt, messages, config) {
+        const result = await this.dispatcher.dispatch(toolName, args);
+        const resultText = result.content.map(c => c.text).join("\n");
+        this.onEvent({
+            type: "tool_done",
+            name: toolName,
+            result: resultText,
+            isError: result.isError ?? false,
+        });
+        // Feed the result back to the model for a follow-up
+        const toolMessages = [
+            ...messages.slice(-5),
+            { role: "assistant", content: responseSoFar || `(using ${toolName})` },
+            { role: "user", content: `Tool "${toolName}" returned:\n${resultText}\n\nSummarize the result or continue.` },
+        ];
+        let secondResponse = "";
+        await ModelClient.runStreaming({
+            config,
+            systemPrompt,
+            messages: toolMessages,
+            onEvent: (event) => {
+                if (event.type === "text_delta") {
+                    secondResponse += event.text;
+                    this.onEvent({ type: "text_delta", text: event.text });
+                }
+                else if (event.type === "turn_done") {
+                    if (secondResponse.trim()) {
+                        this.session.addMessage("assistant", secondResponse.trim());
+                    }
+                    this.onEvent({ type: "turn_done" });
+                }
+                else if (event.type === "error") {
+                    this.onEvent({ type: "error", message: event.message ?? "unknown error" });
+                }
+            },
+            signal: this.abortController?.signal,
+        });
+    }
+    requiresApproval(toolName) {
+        const approvalTools = ["execute_trade", "send_transaction", "sign_message", "deploy_contract"];
+        return approvalTools.includes(toolName);
+    }
+    abort() {
+        this.abortController?.abort();
+        this.abortController = null;
+    }
+}
+//# sourceMappingURL=AgentRunner.js.map

package/dist/runner/ModelClient.d.ts

@@ -0,0 +1,30 @@
+/**
+ * ModelClient — LLM API client for OpenRouter.
+ * Handles streaming and non-streaming calls.
+ */
+import type { ModelRegistry } from "../models/ModelRegistry.js";
+export interface ModelConfig {
+    model: string;
+    apiKey: string;
+    baseUrl: string;
+}
+export declare function resolveModelConfig(registry: ModelRegistry): ModelConfig;
+export interface StreamEvent {
+    type: "text_delta" | "turn_done" | "error";
+    text?: string;
+    message?: string;
+}
+export interface ModelClientOptions {
+    config: ModelConfig;
+    systemPrompt: string;
+    messages: Array<{
+        role: string;
+        content: string;
+    }>;
+    onEvent: (event: StreamEvent) => void;
+    signal?: AbortSignal;
+}
+export declare class ModelClient {
+    static runStreaming(options: ModelClientOptions): Promise<void>;
+}
+//# sourceMappingURL=ModelClient.d.ts.map

package/dist/runner/ModelClient.js

@@ -0,0 +1,84 @@
+/**
+ * ModelClient — LLM API client for OpenRouter.
+ * Handles streaming and non-streaming calls.
+ */
+import { env } from "../core/EnvLoader.js";
+export function resolveModelConfig(registry) {
+    const apiKey = env.get("OPENROUTER_API_KEY");
+    const defaultModel = env.get("DEFAULT_MODEL");
+    return {
+        model: defaultModel || registry.resolvePrimary(),
+        apiKey: apiKey || "",
+        baseUrl: "https://openrouter.ai/api/v1",
+    };
+}
+export class ModelClient {
+    static async runStreaming(options) {
+        const { config, systemPrompt, messages, onEvent, signal } = options;
+        const body = {
+            model: config.model,
+            messages: [
+                { role: "system", content: systemPrompt },
+                ...messages,
+            ],
+            stream: true,
+            max_tokens: 4096,
+        };
+        try {
+            const response = await fetch(`${config.baseUrl}/chat/completions`, {
+                method: "POST",
+                headers: {
+                    "Content-Type": "application/json",
+                    Authorization: `Bearer ${config.apiKey}`,
+                    "HTTP-Referer": "https://aiaiaichain.dev",
+                    "X-Title": "AIAIAI Chain Agent",
+                },
+                body: JSON.stringify(body),
+                signal,
+            });
+            if (!response.ok) {
+                const err = await response.text().catch(() => "unknown error");
+                onEvent({ type: "error", message: `API error ${response.status}: ${err}` });
+                return;
+            }
+            const reader = response.body?.getReader();
+            if (!reader) {
+                onEvent({ type: "error", message: "No response body" });
+                return;
+            }
+            const decoder = new TextDecoder();
+            let buffer = "";
+            while (true) {
+                const { done, value } = await reader.read();
+                if (done)
+                    break;
+                buffer += decoder.decode(value, { stream: true });
+                const lines = buffer.split("\n");
+                buffer = lines.pop() || "";
+                for (const line of lines) {
+                    const trimmed = line.trim();
+                    if (!trimmed || trimmed === "data: [DONE]")
+                        continue;
+                    if (!trimmed.startsWith("data: "))
+                        continue;
+                    try {
+                        const json = JSON.parse(trimmed.slice(6));
+                        const delta = json.choices?.[0]?.delta?.content;
+                        if (delta)
+                            onEvent({ type: "text_delta", text: delta });
+                    }
+                    catch { /* skip malformed lines */ }
+                }
+            }
+            onEvent({ type: "turn_done" });
+        }
+        catch (e) {
+            if (e instanceof Error && e.name === "AbortError") {
+                onEvent({ type: "turn_done" });
+                return;
+            }
+            onEvent({ type: "error", message: e instanceof Error ? e.message : String(e) });
+        }
+    }
+}
+//# sourceMappingURL=ModelClient.js.map

package/dist/runner/SwarmRouter.d.ts

@@ -0,0 +1,23 @@
+/**
+ * SwarmRouter — parallel sub-agent orchestration.
+ * Routes tasks to appropriate model tiers for parallel execution.
+ */
+import type { Registry } from "../api/Registry.js";
+import type { SessionContext } from "../api/ExtensionAPI.js";
+export interface SubAgentTask {
+    id: string;
+    prompt: string;
+    tier: "orchestrator" | "analyst" | "worker" | "free";
+}
+export interface SubAgentResult {
+    taskId: string;
+    output: string;
+    error?: string;
+}
+export declare class SwarmRouter {
+    private registry;
+    constructor(registry: Registry);
+    runConcurrent(tasks: SubAgentTask[], _sessionCtx: SessionContext): Promise<SubAgentResult[]>;
+    private runSingle;
+}
+//# sourceMappingURL=SwarmRouter.d.ts.map