@alejandroroman/agent-kit 0.1.0

package/dist/heartbeat/runner.js

@@ -0,0 +1,215 @@
+import * as fs from "fs";
+import * as path from "path";
+import { runAgentLoop } from "../agent/loop.js";
+import { setupAgentSession } from "../agent/setup.js";
+import { resolveAgent, resolveModelAlias, resolveWebSearch } from "../config/resolve.js";
+import { createBuiltinRegistry } from "../tools/builtin/index.js";
+import { registerSpawnWrappers } from "../tools/builtin/spawn.js";
+import { createActivateSkillTool } from "../skills/index.js";
+import { createLogger } from "../logger.js";
+import { dateContext } from "../text.js";
+const log = createLogger("heartbeat");
+const HEARTBEAT_OK = "HEARTBEAT_OK";
+export function isHeartbeatSuppressed(text) {
+    return text.trim() === HEARTBEAT_OK;
+}
+export function isWithinActiveHours(activeHours) {
+    if (!activeHours)
+        return true;
+    const formatter = new Intl.DateTimeFormat("en-US", {
+        hour: "numeric",
+        hour12: false,
+        timeZone: activeHours.timezone,
+    });
+    const hour = parseInt(formatter.format(new Date()), 10);
+    const { start, end } = activeHours;
+    if (start < end)
+        return hour >= start && hour < end;
+    return hour >= start || hour < end; // midnight wraparound
+}
+export class HeartbeatRunner {
+    timers = new Map();
+    running = new Set();
+    config;
+    agentRegistry;
+    dataDir;
+    skillsDir;
+    usageStore;
+    constructor(config, agentRegistry, dataDir, skillsDir, usageStore) {
+        this.config = config;
+        this.agentRegistry = agentRegistry;
+        this.dataDir = dataDir;
+        this.skillsDir = skillsDir ?? path.join(process.cwd(), "skills");
+        this.usageStore = usageStore;
+    }
+    getHeartbeatAgents() {
+        return Object.entries(this.config.agents)
+            .filter(([_, def]) => def.heartbeat?.enabled)
+            .map(([name]) => name);
+    }
+    loadHeartbeatInstructions(agentName) {
+        const filePath = path.join(this.dataDir, "agents", agentName, "HEARTBEAT.md");
+        try {
+            return fs.readFileSync(filePath, "utf-8");
+        }
+        catch (err) {
+            if (err.code === "ENOENT")
+                return undefined;
+            log.error({ err, agent: agentName, filePath }, "failed to read HEARTBEAT.md");
+            return undefined;
+        }
+    }
+    async tick(agentName) {
+        const agentDef = this.config.agents[agentName];
+        if (!agentDef?.heartbeat)
+            return undefined;
+        const hb = agentDef.heartbeat;
+        if (!isWithinActiveHours(hb.activeHours)) {
+            log.debug({ agent: agentName }, "outside active hours, skipping");
+            return undefined;
+        }
+        const instructions = this.loadHeartbeatInstructions(agentName);
+        if (!instructions) {
+            log.warn({ agent: agentName }, "no HEARTBEAT.md found, skipping");
+            return undefined;
+        }
+        // Isolated tool registry per tick (same pattern as CronScheduler)
+        const sandbox = agentDef.sandbox ?? this.config.defaults.sandbox;
+        const memoryConfig = this.config.defaults.memory;
+        const tickRegistry = createBuiltinRegistry({
+            allowedCommands: sandbox?.allowedCommands,
+            allowedPaths: sandbox?.allowedPaths,
+            memoryConfig,
+            webSearch: resolveWebSearch(agentName, this.config),
+        });
+        const resolved = resolveAgent(agentName, this.config, tickRegistry, this.skillsDir);
+        // Skills setup — auto-activate all skills upfront so Haiku doesn't need to call activate_skill
+        const promptFragments = [];
+        let skillsIndex = "";
+        if (resolved.skills.length > 0) {
+            const ctx = {
+                manifests: resolved.skills,
+                skillsDir: this.skillsDir,
+                toolRegistry: tickRegistry,
+                promptFragments,
+                activatedSkills: new Set(),
+            };
+            const activateTool = createActivateSkillTool(ctx);
+            tickRegistry.register(activateTool);
+            // Auto-activate all skills upfront
+            for (const manifest of resolved.skills) {
+                try {
+                    const result = await activateTool.execute({ skill_name: manifest.name });
+                    if (typeof result === "string" && result.startsWith("Error")) {
+                        log.error({ agent: agentName, skill: manifest.name, result }, "failed to auto-activate skill");
+                    }
+                }
+                catch (err) {
+                    log.error({ err, agent: agentName, skill: manifest.name }, "skill auto-activation threw");
+                }
+            }
+            const activatedNames = [...ctx.activatedSkills];
+            if (activatedNames.length > 0) {
+                skillsIndex = "\n\nThe following skills are pre-activated: "
+                    + activatedNames.join(", ")
+                    + ".\nTheir tools are already available — you do not need to call activate_skill.";
+            }
+        }
+        // Spawn wrappers
+        if (resolved.canSpawn.length > 0) {
+            registerSpawnWrappers(resolved.canSpawn, this.config, this.agentRegistry, tickRegistry, this.usageStore);
+        }
+        // Ephemeral session: no history accumulation, append-only audit log
+        const sessionId = `heartbeat-${agentName}`;
+        const { soul, session } = setupAgentSession(this.dataDir, agentName, sessionId);
+        // Build tick prompt with fresh instructions + timestamp
+        const tickPrompt = `[Heartbeat tick — ${new Date().toISOString()}]\n\n${instructions}`;
+        const userMsg = { role: "user", content: tickPrompt };
+        session.append(userMsg); // audit only
+        const messages = [userMsg]; // ephemeral — no history
+        // Model: heartbeat.model overrides agent model
+        const model = hb.model
+            ? resolveModelAlias(hb.model, this.config.models)
+            : resolved.model;
+        const systemPrompt = [soul, dateContext(), skillsIndex, ...promptFragments]
+            .filter(Boolean)
+            .join("\n\n") || undefined;
+        const result = await runAgentLoop(messages, {
+            model,
+            fallbacks: resolved.fallbacks,
+            systemPrompt,
+            toolRegistry: tickRegistry,
+            maxIterations: hb.maxIterations ?? resolved.maxIterations,
+            compactionThreshold: resolved.compactionThreshold,
+            maxToolResultSize: resolved.maxToolResultSize,
+            agentName,
+            usageStore: this.usageStore,
+            source: "heartbeat",
+        });
+        // Audit: append all new messages from the agent loop
+        for (const msg of result.messages.slice(1)) {
+            session.append(msg);
+        }
+        return result;
+    }
+    start(callbacks) {
+        for (const [agentName, agentDef] of Object.entries(this.config.agents)) {
+            if (!agentDef.heartbeat?.enabled)
+                continue;
+            if (this.timers.has(agentName))
+                continue; // already started
+            const intervalMs = agentDef.heartbeat.intervalMinutes * 60_000;
+            const runTick = async () => {
+                if (this.running.has(agentName)) {
+                    log.info({ agent: agentName }, "previous tick still running, skipping");
+                    return;
+                }
+                this.running.add(agentName);
+                log.info({ agent: agentName }, "heartbeat tick");
+                let result;
+                try {
+                    result = await this.tick(agentName);
+                }
+                catch (err) {
+                    const error = err instanceof Error ? err : new Error(String(err));
+                    log.error({ err: error, agent: agentName }, "heartbeat tick failed");
+                    try {
+                        callbacks?.onError?.(agentName, error);
+                    }
+                    catch { /* callback error */ }
+                    return;
+                }
+                finally {
+                    this.running.delete(agentName);
+                }
+                if (!result)
+                    return;
+                try {
+                    if (isHeartbeatSuppressed(result.text)) {
+                        log.info({ agent: agentName }, "heartbeat suppressed (HEARTBEAT_OK)");
+                        callbacks?.onSuppressed?.(agentName);
+                    }
+                    else {
+                        callbacks?.onResult?.(agentName, result);
+                    }
+                }
+                catch (err) {
+                    log.error({ err, agent: agentName }, "heartbeat callback threw");
+                }
+            };
+            // Fire immediately, then on interval
+            runTick();
+            const timer = setInterval(runTick, intervalMs);
+            timer.unref();
+            this.timers.set(agentName, timer);
+        }
+    }
+    stop() {
+        for (const timer of this.timers.values())
+            clearInterval(timer);
+        this.timers.clear();
+    }
+    isRunning(agentName) {
+        return this.running.has(agentName);
+    }
+}

package/dist/index.d.ts

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

package/dist/index.js

@@ -0,0 +1,207 @@
+import * as readline from "readline";
+import * as path from "path";
+import { runAgentLoop } from "./agent/loop.js";
+import { compactMessages } from "./session/compaction.js";
+import { loadConfig } from "./config/index.js";
+import { CronScheduler } from "./cron/scheduler.js";
+import { HeartbeatRunner } from "./heartbeat/index.js";
+import { createSlackGateway } from "./gateways/slack/index.js";
+import { createLogger } from "./logger.js";
+import { createApiServer } from "./api/router.js";
+import { buildAgentRuntime, buildSystemPrompt, initUsageStore, createAgentExecutor, } from "./bootstrap.js";
+const log = createLogger("startup");
+const CONFIG_PATH = path.join(process.cwd(), "agent-kit.json");
+const DATA_DIR = path.join(process.cwd(), "data");
+const DEFAULT_AGENT = "default";
+const SKILLS_DIR = path.join(process.cwd(), "skills");
+async function main() {
+    const config = loadConfig(CONFIG_PATH);
+    const { usageStore, apiPort } = initUsageStore(config);
+    const apiServer = createApiServer({
+        config,
+        configPath: CONFIG_PATH,
+        usageStore,
+        dataDir: DATA_DIR,
+    }, apiPort);
+    const agentName = process.argv[2] ?? DEFAULT_AGENT;
+    // Validate all agent tool references at startup
+    const runtime = buildAgentRuntime(agentName, config, {
+        dataDir: DATA_DIR,
+        skillsDir: SKILLS_DIR,
+        usageStore,
+    });
+    runtime.toolRegistry.validateAgents(config.agents);
+    const { resolved, toolRegistry, agentRegistry, promptFragments, skillsIndex, soul, session } = runtime;
+    const sandbox = config.agents[agentName]?.sandbox ?? config.defaults.sandbox;
+    console.log("Agent Kit");
+    console.log(`  Model: ${resolved.model}`);
+    if (resolved.fallbacks.length > 0) {
+        console.log(`  Fallbacks: ${resolved.fallbacks.join(" → ")}`);
+    }
+    console.log(`  Agent: ${agentName}`);
+    console.log(`  SOUL: ${soul ? "loaded" : "none (create data/agents/default/SOUL.md)"}`);
+    console.log(`  Tools: ${resolved.tools.map((t) => t.name).join(", ")}`);
+    if (resolved.skills.length > 0) {
+        console.log(`  Skills: ${resolved.skills.map((s) => s.name).join(", ")}`);
+    }
+    const sandboxSummary = (() => {
+        if (!sandbox)
+            return "off (unrestricted)";
+        const parts = [];
+        if (sandbox.allowedCommands?.length) {
+            parts.push(`${sandbox.allowedCommands.length} commands allowed`);
+        }
+        if (sandbox.allowedPaths?.length) {
+            parts.push(`${sandbox.allowedPaths.length} paths allowed`);
+        }
+        return parts.length > 0 ? parts.join(", ") : "configured (no restrictions)";
+    })();
+    console.log(`  Sandbox: ${sandboxSummary}`);
+    if (config.defaults.usage) {
+        console.log(`  Usage: tracking enabled (${config.defaults.usage.dbPath})`);
+    }
+    const scheduler = new CronScheduler(config, toolRegistry, agentRegistry, DATA_DIR, SKILLS_DIR, usageStore);
+    const enabledJobs = scheduler.getJobs().filter((j) => j.enabled);
+    // Agent executor for inbound Slack messages
+    const executeAgent = createAgentExecutor(config, {
+        dataDir: DATA_DIR,
+        skillsDir: SKILLS_DIR,
+        agentRegistry,
+        usageStore,
+        source: "slack",
+    });
+    // Slack gateway (optional — requires both tokens + agent slack bindings)
+    let gateway;
+    const hasSlackBindings = Object.values(config.agents).some((a) => a.slack);
+    if (hasSlackBindings && process.env.SLACK_BOT_TOKEN && process.env.SLACK_APP_TOKEN) {
+        try {
+            gateway = createSlackGateway(config, { onAgentRequest: executeAgent });
+            await gateway.start();
+            const bindingCount = Object.values(config.agents).filter((a) => a.slack).length;
+            log.info({ bindings: bindingCount }, "Slack connected");
+        }
+        catch (err) {
+            log.warn({ err }, "Slack failed to connect");
+        }
+    }
+    try {
+        const actualPort = await apiServer.start();
+        console.log(`  API: http://localhost:${actualPort}/api`);
+    }
+    catch (err) {
+        log.warn({ err }, "failed to start API server — continuing without it");
+    }
+    if (enabledJobs.length > 0) {
+        const jobList = enabledJobs.map((j) => `${j.id} @ ${j.schedule}`).join(", ");
+        log.info({ jobs: enabledJobs.length, jobList }, "cron scheduled");
+        scheduler.start({
+            onResult: (jobId, agentName, result) => {
+                log.info({ jobId, tokens: result.usage.inputTokens + result.usage.outputTokens }, "cron job completed");
+                process.stdout.write("You: ");
+                const channelOverride = config.cron.find((j) => j.id === jobId)?.slack?.channelId;
+                gateway?.onJobResult(agentName, jobId, result, channelOverride).catch((err) => log.warn({ err, jobId }, "failed to post cron result to Slack"));
+            },
+            onError: (jobId, agentName, error) => {
+                log.error({ err: error, jobId }, "cron job failed");
+                process.stdout.write("You: ");
+                const channelOverride = config.cron.find((j) => j.id === jobId)?.slack?.channelId;
+                gateway?.onJobError(agentName, jobId, error, channelOverride).catch((err) => log.warn({ err, jobId }, "failed to post cron error to Slack"));
+            },
+        });
+    }
+    const heartbeat = new HeartbeatRunner(config, agentRegistry, DATA_DIR, SKILLS_DIR, usageStore);
+    const heartbeatAgents = heartbeat.getHeartbeatAgents();
+    if (heartbeatAgents.length > 0) {
+        log.info({ agents: heartbeatAgents }, "heartbeat started");
+        heartbeat.start({
+            onResult: (agentName, result) => {
+                log.info({ agent: agentName, tokens: result.usage.inputTokens + result.usage.outputTokens }, "heartbeat alert");
+                process.stdout.write("You: ");
+                const channelOverride = config.agents[agentName]?.heartbeat?.slack?.channelId;
+                gateway?.onJobResult(agentName, "heartbeat", result, channelOverride).catch((err) => log.warn({ err, agent: agentName }, "failed to post heartbeat result to Slack"));
+            },
+            onError: (agentName, error) => {
+                log.error({ err: error, agent: agentName }, "heartbeat failed");
+                process.stdout.write("You: ");
+                const channelOverride = config.agents[agentName]?.heartbeat?.slack?.channelId;
+                gateway?.onJobError(agentName, "heartbeat", error, channelOverride).catch((err) => log.warn({ err, agent: agentName }, "failed to post heartbeat error to Slack"));
+            },
+            onSuppressed: (agentName) => {
+                log.debug({ agent: agentName }, "heartbeat OK, suppressed");
+            },
+        });
+    }
+    if (heartbeatAgents.length > 0) {
+        console.log(`  Heartbeat: ${heartbeatAgents.join(", ")}`);
+    }
+    console.log(`  Commands: /new (reset), /quit`);
+    console.log();
+    let messages = session.getMessages();
+    const rl = readline.createInterface({
+        input: process.stdin,
+        output: process.stdout,
+    });
+    const ask = () => {
+        rl.question("You: ", async (input) => {
+            const trimmed = input.trim();
+            if (trimmed === "/quit") {
+                scheduler.stop();
+                heartbeat.stop();
+                await gateway?.stop();
+                await apiServer.stop();
+                try {
+                    usageStore?.close();
+                }
+                catch (err) {
+                    log.warn({ err }, "failed to close usage store");
+                }
+                finally {
+                    rl.close();
+                }
+                return;
+            }
+            if (trimmed === "/new") {
+                messages = [];
+                console.log("  Session reset.\n");
+                ask();
+                return;
+            }
+            if (!trimmed) {
+                ask();
+                return;
+            }
+            const userMsg = { role: "user", content: trimmed };
+            messages.push(userMsg);
+            session.append(userMsg);
+            messages = await compactMessages(messages, resolved.model, resolved.compactionThreshold);
+            try {
+                const systemPrompt = buildSystemPrompt(soul, skillsIndex, promptFragments);
+                const result = await runAgentLoop(messages, {
+                    model: resolved.model,
+                    fallbacks: resolved.fallbacks,
+                    systemPrompt,
+                    toolRegistry,
+                    maxIterations: resolved.maxIterations,
+                    compactionThreshold: resolved.compactionThreshold,
+                    maxToolResultSize: resolved.maxToolResultSize,
+                    agentName,
+                    usageStore,
+                    source: "cli",
+                });
+                const newMessages = result.messages.slice(messages.length - 1);
+                for (const msg of newMessages) {
+                    session.append(msg);
+                }
+                messages = result.messages;
+                console.log(`\nAgent: ${result.text}`);
+                console.log(`  (${result.usage.inputTokens + result.usage.outputTokens} tokens)\n`);
+            }
+            catch (err) {
+                console.error(`\n  Error: ${err instanceof Error ? err.message : err}\n`);
+            }
+            ask();
+        });
+    };
+    ask();
+}
+main();

package/dist/llm/anthropic.d.ts

@@ -0,0 +1,12 @@
+import type { LLMProvider, CompleteOptions } from "./provider.js";
+import type { Message, LLMResponse, StreamEvent } from "./types.js";
+export declare class AnthropicProvider implements LLMProvider {
+    name: "anthropic";
+    private client;
+    constructor(apiKey?: string);
+    complete(model: string, messages: Message[], options?: CompleteOptions): Promise<LLMResponse>;
+    stream(model: string, messages: Message[], options?: CompleteOptions): AsyncIterable<StreamEvent>;
+    private toAnthropicMessages;
+    private fromAnthropicResponse;
+    private mapStopReason;
+}

package/dist/llm/anthropic.js

@@ -0,0 +1,89 @@
+import Anthropic from "@anthropic-ai/sdk";
+import { defaultStream } from "./provider.js";
+export class AnthropicProvider {
+    name = "anthropic";
+    client;
+    constructor(apiKey) {
+        this.client = new Anthropic({ apiKey: apiKey ?? process.env.ANTHROPIC_API_KEY });
+    }
+    async complete(model, messages, options) {
+        const params = {
+            model,
+            max_tokens: options?.maxTokens ?? 4096,
+            messages: this.toAnthropicMessages(messages),
+        };
+        if (options?.systemPrompt) {
+            params.system = [
+                { type: "text", text: options.systemPrompt, cache_control: { type: "ephemeral" } },
+            ];
+        }
+        if (options?.tools?.length) {
+            params.tools = options.tools.map((t, i) => {
+                const def = {
+                    name: t.name,
+                    description: t.description,
+                    input_schema: t.parameters,
+                };
+                if (i === options.tools.length - 1) {
+                    def.cache_control = { type: "ephemeral" };
+                }
+                return def;
+            });
+        }
+        const response = await this.client.messages.create(params);
+        return this.fromAnthropicResponse(response);
+    }
+    async *stream(model, messages, options) {
+        yield* defaultStream(this, model, messages, options);
+    }
+    toAnthropicMessages(messages) {
+        return messages.map((msg) => {
+            if (msg.role === "user")
+                return { role: "user", content: msg.content };
+            if (msg.role === "assistant") {
+                return {
+                    role: "assistant",
+                    content: msg.content.map((block) => {
+                        if (block.type === "text")
+                            return { type: "text", text: block.text };
+                        return { type: "tool_use", id: block.id, name: block.name, input: block.arguments };
+                    }),
+                };
+            }
+            if (msg.role === "tool_result") {
+                return { role: "user", content: [{ type: "tool_result", tool_use_id: msg.tool_call_id, content: msg.content }] };
+            }
+            return msg;
+        });
+    }
+    fromAnthropicResponse(response) {
+        const content = response.content.map((block) => {
+            if (block.type === "text")
+                return { type: "text", text: block.text };
+            if (block.type === "tool_use")
+                return { type: "tool_call", id: block.id, name: block.name, arguments: block.input };
+            return { type: "text", text: "" };
+        });
+        return {
+            content,
+            stopReason: this.mapStopReason(response.stop_reason),
+            usage: {
+                inputTokens: response.usage.input_tokens,
+                outputTokens: response.usage.output_tokens,
+                cacheCreationTokens: response.usage.cache_creation_input_tokens ?? 0,
+                cacheReadTokens: response.usage.cache_read_input_tokens ?? 0,
+                reasoningTokens: 0,
+            },
+            model: "",
+            latencyMs: 0,
+        };
+    }
+    mapStopReason(reason) {
+        switch (reason) {
+            case "end_turn": return "end_turn";
+            case "tool_use": return "tool_use";
+            case "max_tokens": return "max_tokens";
+            default: return "end_turn";
+        }
+    }
+}

package/dist/llm/fallback.d.ts

@@ -0,0 +1,6 @@
+import type { Message, LLMResponse } from "./types.js";
+import type { CompleteOptions } from "./provider.js";
+export declare function isRetryableError(err: unknown): boolean;
+type CompleteFn = (model: string, messages: Message[], options?: CompleteOptions) => Promise<LLMResponse>;
+export declare function completeWithFallback(primary: string, fallbacks: string[], messages: Message[], options: CompleteOptions | undefined, completeFn: CompleteFn): Promise<LLMResponse>;
+export {};

package/dist/llm/fallback.js

@@ -0,0 +1,30 @@
+import { createLogger } from "../logger.js";
+const log = createLogger("llm");
+const RETRYABLE_STATUS_CODES = new Set([429, 500, 502, 503]);
+export function isRetryableError(err) {
+    if (err instanceof Error) {
+        if (err.name === "TimeoutError")
+            return true;
+        if ("status" in err && typeof err.status === "number") {
+            return RETRYABLE_STATUS_CODES.has(err.status);
+        }
+    }
+    return false;
+}
+export async function completeWithFallback(primary, fallbacks, messages, options, completeFn) {
+    const models = [primary, ...fallbacks];
+    let lastError;
+    for (const model of models) {
+        try {
+            return await completeFn(model, messages, options);
+        }
+        catch (err) {
+            lastError = err;
+            if (!isRetryableError(err) || model === models[models.length - 1]) {
+                throw err;
+            }
+            log.warn({ err, model }, "model failed, trying next");
+        }
+    }
+    throw lastError ?? new Error("completeWithFallback: no models were attempted");
+}

package/dist/llm/index.d.ts

@@ -0,0 +1,9 @@
+import type { Message, LLMResponse, StreamEvent } from "./types.js";
+import type { LLMProvider, CompleteOptions } from "./provider.js";
+export type { Message, LLMResponse, StreamEvent, LLMProvider, CompleteOptions };
+export type { ContentBlock, TextBlock, ToolCallBlock, ToolDefinition, StopReason, TokenUsage } from "./types.js";
+export type ProviderName = "anthropic" | "openai";
+export declare function createProvider(name: ProviderName, apiKey?: string): LLMProvider;
+export declare function complete(modelString: string, messages: Message[], options?: CompleteOptions): Promise<LLMResponse>;
+export declare function stream(modelString: string, messages: Message[], options?: CompleteOptions): AsyncIterable<StreamEvent>;
+export { completeWithFallback, isRetryableError } from "./fallback.js";

package/dist/llm/index.js

@@ -0,0 +1,40 @@
+import { AnthropicProvider } from "./anthropic.js";
+import { OpenAIProvider } from "./openai.js";
+const providers = new Map();
+export function createProvider(name, apiKey) {
+    switch (name) {
+        case "anthropic": return new AnthropicProvider(apiKey);
+        case "openai": return new OpenAIProvider(apiKey);
+        default: throw new Error(`Unknown provider: ${name}`);
+    }
+}
+function getOrCreateProvider(name) {
+    if (!providers.has(name))
+        providers.set(name, createProvider(name));
+    return providers.get(name);
+}
+function parseModelString(modelString) {
+    const [provider, ...rest] = modelString.split(":");
+    if (!rest.length)
+        throw new Error(`Model string must be "provider:model", got "${modelString}"`);
+    return { provider: provider, model: rest.join(":") };
+}
+export async function complete(modelString, messages, options) {
+    const { provider, model } = parseModelString(modelString);
+    const start = performance.now();
+    const response = await getOrCreateProvider(provider).complete(model, messages, options);
+    const latencyMs = Math.round(performance.now() - start);
+    return { ...response, model: modelString, latencyMs };
+}
+export async function* stream(modelString, messages, options) {
+    const { provider, model } = parseModelString(modelString);
+    for await (const event of getOrCreateProvider(provider).stream(model, messages, options)) {
+        if (event.type === "done") {
+            yield { ...event, response: { ...event.response, model: modelString, latencyMs: 0 } };
+        }
+        else {
+            yield event;
+        }
+    }
+}
+export { completeWithFallback, isRetryableError } from "./fallback.js";

package/dist/llm/openai.d.ts

@@ -0,0 +1,12 @@
+import type { LLMProvider, CompleteOptions } from "./provider.js";
+import type { Message, LLMResponse, StreamEvent } from "./types.js";
+export declare class OpenAIProvider implements LLMProvider {
+    name: "openai";
+    private client;
+    constructor(apiKey?: string);
+    complete(model: string, messages: Message[], options?: CompleteOptions): Promise<LLMResponse>;
+    stream(model: string, messages: Message[], options?: CompleteOptions): AsyncIterable<StreamEvent>;
+    private toOpenAIMessages;
+    private fromOpenAIResponse;
+    private mapStopReason;
+}