verybot 0.1.3

package/dist/brain/loop.js

@@ -0,0 +1,161 @@
+import { streamText, stepCountIs } from "ai";
+import { emit } from "../events.js";
+import { logger } from "../logger.js";
+export async function runLoop(opts) {
+    const { model, system, messages, tools, sessionKey, maxSteps = 20, agentId, silent = false, sessionLabel } = opts;
+    const tag = `[${sessionLabel ?? sessionKey}]`;
+    const runStart = Date.now();
+    logger.info(`\n${tag} ════════════════════════════════════════`);
+    logger.info(`\x1b[36m${tag}   model: ${typeof model === "string" ? model : model.modelId}  tools: [${Object.keys(tools).join(", ")}]\x1b[0m`);
+    logger.info(`${tag}   maxSteps: ${maxSteps}`);
+    logger.info(`${tag} ── SYSTEM PROMPT ──\n${system}`);
+    logger.info(`${tag} ── MESSAGES (${messages.length}) ──`);
+    for (const msg of messages) {
+        const body = typeof msg.content === "string" ? msg.content : JSON.stringify(msg.content);
+        logger.info(`${tag}   [${msg.role}] ${body.slice(0, 2000)}`);
+    }
+    let stepNum = 0;
+    let stepStart = Date.now();
+    const result = streamText({
+        model,
+        system,
+        messages,
+        tools,
+        stopWhen: stepCountIs(maxSteps),
+        onStepFinish({ text, reasoningText, toolCalls, toolResults, usage }) {
+            stepNum++;
+            const elapsed = Date.now() - stepStart;
+            logger.info(`${tag} ── step ${stepNum}/${maxSteps} (${elapsed}ms) ──`);
+            if (reasoningText) {
+                logger.info(`${tag}   🧠 reasoning: ${reasoningText.slice(0, 1500)}`);
+            }
+            if (toolCalls.length > 0) {
+                for (const tc of toolCalls) {
+                    logger.info(`${tag}   🔧 call: ${tc.toolName}(${JSON.stringify(tc.input)})`);
+                }
+                if (!silent) {
+                    emit("agent", {
+                        sessionKey,
+                        agentId,
+                        tools: toolCalls.map((tc) => ({ name: tc.toolName, args: tc.input })),
+                    });
+                }
+            }
+            if (toolResults.length > 0) {
+                for (const tr of toolResults) {
+                    const out = tr.output;
+                    // Skip binary/image data from logs
+                    const isImage = Buffer.isBuffer(out) ||
+                        (typeof out === "object" && out !== null && "data" in out && Buffer.isBuffer(out.data));
+                    if (isImage) {
+                        const size = Buffer.isBuffer(out) ? out.length : out.data.length;
+                        logger.info(`${tag}   ← ${tr.toolName}: [image ${size} bytes]`);
+                    }
+                    else {
+                        const full = String(out);
+                        if (looksLikeHtml(full)) {
+                            logger.info(`${tag}   ← ${tr.toolName} (${full.length} chars): [HTML] ${extractHtmlSummary(full)}`);
+                        }
+                        else {
+                            logger.info(`${tag}   ← ${tr.toolName} (${full.length} chars): ${full.slice(0, 1500)}`);
+                        }
+                    }
+                }
+            }
+            if (text) {
+                logger.info(`${tag}   💬 text: ${text.slice(0, 500)}`);
+            }
+            if (usage) {
+                logger.info(`${tag}   📊 tokens: ${usage.inputTokens} in / ${usage.outputTokens} out`);
+            }
+            stepStart = Date.now();
+        },
+    });
+    // Consume fullStream (not textStream) so errors surface here instead of
+    // becoming unhandled rejections from an unconsumed internal pipeline.
+    let collected = "";
+    let lastError = null;
+    try {
+        for await (const event of result.fullStream) {
+            if (event.type === "text-delta") {
+                collected += event.text;
+                if (!silent) {
+                    emit("chat", {
+                        sessionKey,
+                        agentId,
+                        state: "delta",
+                        delta: event.text,
+                    });
+                }
+            }
+            else if (event.type === "error") {
+                lastError = event.error;
+            }
+        }
+    }
+    catch (err) {
+        // fullStream flush may throw NoOutputGeneratedError — capture it
+        if (!lastError)
+            lastError = err;
+    }
+    // If no text was produced and we captured an error, re-throw it
+    // so Agent.handleMessage can send a friendly error to the user.
+    if (!collected && lastError) {
+        throw lastError instanceof Error ? lastError : new Error(String(lastError));
+    }
+    const final = await result;
+    const text = collected.length > 0 ? collected : "(no response)";
+    const totalMs = Date.now() - runStart;
+    logger.info(`${tag} ── FINAL REPLY (${text.length} chars, ${stepNum} steps, ${totalMs}ms) ──`);
+    logger.info(`${tag} ${text}`);
+    logger.info(`${tag} ════════════════════════════════════════\n`);
+    if (!silent) {
+        emit("chat", {
+            sessionKey,
+            agentId,
+            state: "final",
+            message: { role: "assistant", content: text },
+            usage: final.usage,
+        });
+    }
+    const resp = await result.response;
+    return {
+        text,
+        responseMessages: (resp.messages ?? []),
+    };
+}
+/** When the model ends on a tool call, try to pull text from the last tool result. */
+function extractFallbackText(final) {
+    for (let i = final.steps.length - 1; i >= 0; i--) {
+        const results = final.steps[i].toolResults;
+        if (results && results.length > 0) {
+            const last = results[results.length - 1].output;
+            return typeof last === "string" ? last : JSON.stringify(last);
+        }
+    }
+    return undefined;
+}
+function lastUserMessage(messages) {
+    for (let i = messages.length - 1; i >= 0; i--) {
+        if (messages[i].role === "user") {
+            const content = messages[i].content;
+            const text = typeof content === "string" ? content : JSON.stringify(content);
+            return text.slice(0, 200);
+        }
+    }
+    return "(empty)";
+}
+/** Quick check for HTML-heavy content that would be noisy in logs. */
+function looksLikeHtml(s) {
+    const start = s.slice(0, 500);
+    return start.includes("<!DOCTYPE") || start.includes("<html") || (start.match(/<\w/g)?.length ?? 0) > 5;
+}
+/** Pull title + meta description from raw HTML for a compact summary. */
+function extractHtmlSummary(html) {
+    const title = html.match(/<title[^>]*>(.*?)<\/title>/is)?.[1]?.trim() ?? "";
+    const desc = html.match(/<meta[^>]+name=["']description["'][^>]+content=["']([^"']+)/i)?.[1]?.trim() ??
+        html.match(/<meta[^>]+content=["']([^"']+)["'][^>]+name=["']description["']/i)?.[1]?.trim() ??
+        "";
+    const parts = [title && `title="${title}"`, desc && `desc="${desc.slice(0, 150)}"`].filter(Boolean);
+    return parts.length > 0 ? parts.join(" | ") : "(no meta)";
+}

package/dist/brain/mcp-adapter.d.ts

@@ -0,0 +1,39 @@
+import type { LanguageModel, ToolSet } from "ai";
+import type { McpSdkServerConfigWithInstance } from "@anthropic-ai/claude-agent-sdk";
+import { z } from "zod";
+export interface AdaptedTools {
+    model: LanguageModel;
+    tools: ToolSet;
+    /** Cleanup function to shut down any HTTP MCP servers (Codex CLI strategy). */
+    cleanup?: () => Promise<void>;
+}
+/** Options forwarded to adapt strategies. */
+export interface AdaptOptions {
+    sandboxEnabled?: boolean;
+}
+/** Extracted tool entry from an AI SDK ToolSet. */
+interface UsableTool {
+    name: string;
+    description: string;
+    inputSchema: z.ZodObject<z.ZodRawShape>;
+    execute: (args: Record<string, unknown>) => Promise<unknown>;
+}
+/** Extract the usable tools from an AI SDK ToolSet (skips proprietary / incomplete tools). */
+export declare function extractUsableTools(tools: ToolSet): UsableTool[];
+/**
+ * Convert an AI SDK ToolSet into a Claude Code MCP server config.
+ * Each tool's `inputSchema` (Zod) is passed through directly,
+ * and `execute` is wrapped in the MCP `handler` envelope.
+ */
+export declare function toolSetToMcpServer(tools: ToolSet, serverName?: string): McpSdkServerConfigWithInstance;
+/** Start an HTTP MCP server on loopback with the given tools registered. */
+export declare function startHttpMcpServer(usable: UsableTool[]): Promise<{
+    url: string;
+    cleanup: () => Promise<void>;
+}>;
+/**
+ * Adapt tools for MCP-based providers (Claude Code, Codex CLI).
+ * Non-MCP providers pass through unchanged.
+ */
+export declare function adaptTools(provider: string, modelId: string, model: LanguageModel, tools: ToolSet, options?: AdaptOptions): Promise<AdaptedTools>;
+export {};

package/dist/brain/mcp-adapter.js

@@ -0,0 +1,227 @@
+import http from "node:http";
+import { createCustomMcpServer, createClaudeCode } from "ai-sdk-provider-claude-code";
+import { createCodexCli } from "ai-sdk-provider-codex-cli";
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/streamableHttp.js";
+import { logger } from "../logger.js";
+import { CLAUDE_CODE_PROVIDER, CODEX_CLI_PROVIDER, CODEX_CLI_ENV } from "./providers.js";
+/** Tool names that use Anthropic's proprietary format and should be skipped. */
+const SKIP_TOOLS = new Set(["computer"]);
+const MCP_SERVER_NAME = "verybot-tools";
+const MCP_HTTP_PATH = "/mcp";
+/** Force OAuth login by clearing API key from the SDK environment. */
+const CLAUDE_CODE_ENV = { ANTHROPIC_API_KEY: undefined };
+// ---------------------------------------------------------------------------
+// Port pool — allocate from a fixed range and reclaim on cleanup
+// ---------------------------------------------------------------------------
+const MCP_PORT_RANGE_START = 19400;
+const MCP_PORT_RANGE_END = 19999;
+const availablePorts = new Set(Array.from({ length: MCP_PORT_RANGE_END - MCP_PORT_RANGE_START + 1 }, (_, i) => MCP_PORT_RANGE_START + i));
+function allocatePort() {
+    const port = availablePorts.values().next().value;
+    if (port === undefined)
+        throw new Error(`No available MCP ports in range ${MCP_PORT_RANGE_START}-${MCP_PORT_RANGE_END}`);
+    availablePorts.delete(port);
+    return port;
+}
+function releasePort(port) {
+    availablePorts.add(port);
+}
+/** Extract the usable tools from an AI SDK ToolSet (skips proprietary / incomplete tools). */
+export function extractUsableTools(tools) {
+    const result = [];
+    for (const [name, tool] of Object.entries(tools)) {
+        if (SKIP_TOOLS.has(name)) {
+            logger.info(`[mcp-adapter]   skip "${name}" (proprietary format)`);
+            continue;
+        }
+        const { description, inputSchema, execute } = tool;
+        if (!execute || !inputSchema) {
+            logger.info(`[mcp-adapter]   skip "${name}" — execute=${!!execute} inputSchema=${!!inputSchema}`);
+            continue;
+        }
+        logger.info(`[mcp-adapter]   + "${name}"`);
+        result.push({ name, description: description ?? name, inputSchema, execute });
+    }
+    return result;
+}
+/** Serialize a tool result into a string for MCP text content. */
+function formatResult(result) {
+    if (result === undefined || result === null)
+        return "";
+    if (typeof result === "string")
+        return result;
+    if (Buffer.isBuffer(result))
+        return `[binary ${result.length} bytes]`;
+    if (typeof result === "object" && "data" in result && Buffer.isBuffer(result.data)) {
+        return `[image ${(result.data).length} bytes]`;
+    }
+    return JSON.stringify(result);
+}
+/** Wrap an execute function in the MCP CallToolResult envelope. */
+function wrapToolHandler(name, execute) {
+    return async (args) => {
+        try {
+            const result = await execute(args);
+            return { content: [{ type: "text", text: formatResult(result) }] };
+        }
+        catch (err) {
+            const message = err instanceof Error ? err.message : String(err);
+            logger.warn(`[mcp-adapter] Tool "${name}" error: ${message}`);
+            return {
+                content: [{ type: "text", text: `Error: ${message}` }],
+                isError: true,
+            };
+        }
+    };
+}
+// ---------------------------------------------------------------------------
+// Claude Code in-process MCP server (unchanged behavior)
+// ---------------------------------------------------------------------------
+/**
+ * Convert an AI SDK ToolSet into a Claude Code MCP server config.
+ * Each tool's `inputSchema` (Zod) is passed through directly,
+ * and `execute` is wrapped in the MCP `handler` envelope.
+ */
+export function toolSetToMcpServer(tools, serverName = MCP_SERVER_NAME) {
+    const usable = extractUsableTools(tools);
+    logger.info(`[mcp-adapter] Converting ${Object.keys(tools).length} AI SDK tools for server "${serverName}"`);
+    const mcpTools = {};
+    for (const { name, description, inputSchema, execute } of usable) {
+        mcpTools[name] = { description, inputSchema, handler: wrapToolHandler(name, execute) };
+    }
+    const toolCount = Object.keys(mcpTools).length;
+    logger.info(`[mcp-adapter] Registered ${toolCount} tools as MCP server "${serverName}"`);
+    return createCustomMcpServer({ name: serverName, tools: mcpTools });
+}
+// ---------------------------------------------------------------------------
+// Strategy: Claude Code (in-process MCP)
+// ---------------------------------------------------------------------------
+function claudeCodeStrategy(modelId, _model, tools, options) {
+    const mcpServer = toolSetToMcpServer(tools);
+    const claudeCode = createClaudeCode({
+        defaultSettings: {
+            permissionMode: "bypassPermissions",
+            env: CLAUDE_CODE_ENV,
+            mcpServers: { [MCP_SERVER_NAME]: mcpServer },
+            ...(options.sandboxEnabled && { sandbox: { enabled: true } }),
+            verbose: logger.level === "debug",
+            logger: {
+                debug: (msg) => logger.debug(`[claude-code-sdk] ${msg}`),
+                info: (msg) => logger.info(`[claude-code-sdk] ${msg}`),
+                warn: (msg) => logger.warn(`[claude-code-sdk] ${msg}`),
+                error: (msg) => logger.error(`[claude-code-sdk] ${msg}`),
+            },
+        },
+    });
+    logger.info(`[mcp-adapter] Created claude-code provider with MCP server "${MCP_SERVER_NAME}" for model "${modelId}"`);
+    return {
+        model: claudeCode(modelId),
+        tools: {}, // tools are in the MCP server; pass empty set to AI SDK
+    };
+}
+// ---------------------------------------------------------------------------
+// Strategy: Codex CLI (external HTTP MCP server)
+// ---------------------------------------------------------------------------
+/** Start an HTTP MCP server on loopback with the given tools registered. */
+export async function startHttpMcpServer(usable) {
+    const mcpServer = new McpServer({ name: MCP_SERVER_NAME, version: "1.0.0" }, { capabilities: { tools: {} } });
+    for (const { name, description, inputSchema, execute } of usable) {
+        mcpServer.tool(name, description, inputSchema.shape, async (args) => {
+            return wrapToolHandler(name, execute)(args);
+        });
+    }
+    const transport = new StreamableHTTPServerTransport({ sessionIdGenerator: undefined });
+    await mcpServer.connect(transport);
+    const createHandler = () => http.createServer(async (req, res) => {
+        if (req.url !== MCP_HTTP_PATH) {
+            res.writeHead(404).end("Not Found");
+            return;
+        }
+        try {
+            await transport.handleRequest(req, res);
+        }
+        catch (err) {
+            logger.error(`[mcp-adapter] HTTP MCP request error: ${err instanceof Error ? err.message : err}`);
+            if (!res.headersSent) {
+                res.writeHead(500).end("Internal Server Error");
+            }
+        }
+    });
+    // Try up to MAX_PORT_RETRIES ports in case one is already in use externally
+    const MAX_PORT_RETRIES = 3;
+    let port = 0;
+    let httpServer;
+    for (let attempt = 0; attempt < MAX_PORT_RETRIES; attempt++) {
+        port = allocatePort();
+        httpServer = createHandler();
+        httpServer.unref(); // allow process to exit even if cleanup is missed
+        try {
+            await new Promise((resolve, reject) => {
+                httpServer.listen(port, "127.0.0.1", () => resolve());
+                httpServer.on("error", reject);
+            });
+            break;
+        }
+        catch (err) {
+            releasePort(port);
+            if (attempt === MAX_PORT_RETRIES - 1)
+                throw err;
+            logger.warn(`[mcp-adapter] Port ${port} in use, retrying with another port`);
+        }
+    }
+    const url = `http://127.0.0.1:${port}${MCP_HTTP_PATH}`;
+    logger.info(`[mcp-adapter] HTTP MCP server listening on ${url} (${usable.length} tools)`);
+    const cleanup = async () => {
+        logger.info(`[mcp-adapter] Shutting down HTTP MCP server on port ${port}`);
+        await mcpServer.close();
+        await new Promise((resolve) => httpServer.close(() => resolve()));
+        releasePort(port);
+    };
+    return { url, cleanup };
+}
+async function codexCliStrategy(modelId, _model, tools, _options) {
+    const usable = extractUsableTools(tools);
+    logger.info(`[mcp-adapter] Setting up Codex CLI HTTP MCP server for model "${modelId}"`);
+    const { url, cleanup } = await startHttpMcpServer(usable);
+    // Agent handles its own sandboxing; fullAuto bypasses Codex CLI's interactive approval
+    const codexCli = createCodexCli({
+        defaultSettings: {
+            fullAuto: true,
+            env: CODEX_CLI_ENV,
+            rmcpClient: true,
+            mcpServers: {
+                [MCP_SERVER_NAME]: { transport: "http", url },
+            },
+            verbose: logger.level === "debug",
+            logger: {
+                debug: (msg) => logger.debug(`[codex-cli-sdk] ${msg}`),
+                info: (msg) => logger.info(`[codex-cli-sdk] ${msg}`),
+                warn: (msg) => logger.warn(`[codex-cli-sdk] ${msg}`),
+                error: (msg) => logger.error(`[codex-cli-sdk] ${msg}`),
+            },
+        },
+    });
+    return {
+        model: codexCli(modelId),
+        tools: {}, // tools are in the MCP server; pass empty set to AI SDK
+        cleanup,
+    };
+}
+// ---------------------------------------------------------------------------
+// Strategy dispatcher
+// ---------------------------------------------------------------------------
+const STRATEGIES = {
+    [CLAUDE_CODE_PROVIDER]: claudeCodeStrategy,
+    [CODEX_CLI_PROVIDER]: codexCliStrategy,
+};
+/**
+ * Adapt tools for MCP-based providers (Claude Code, Codex CLI).
+ * Non-MCP providers pass through unchanged.
+ */
+export async function adaptTools(provider, modelId, model, tools, options = {}) {
+    const strategy = STRATEGIES[provider];
+    if (!strategy)
+        return { model, tools };
+    return strategy(modelId, model, tools, options);
+}

package/dist/brain/memory-extractor.d.ts

@@ -0,0 +1,26 @@
+import type { LanguageModel, ModelMessage } from "ai";
+import type { MemoryStore } from "../memory/store.js";
+import type { EmbeddingProvider } from "../memory/embedding.js";
+import { extractFacts } from "../memory/extractor.js";
+import type { SessionStateMap } from "./session-state.js";
+/**
+ * Handles memory extraction from conversation sessions.
+ * Tracks per-session message counts and batches extraction.
+ */
+export declare class MemoryExtractor {
+    private model;
+    private memoryStore;
+    private embeddingProvider;
+    constructor(model: LanguageModel, memoryStore: MemoryStore, embeddingProvider: EmbeddingProvider | null);
+    /** Update the model used for extraction (e.g. after config reload). */
+    setModel(model: LanguageModel): void;
+    /**
+     * Increment extraction counter and trigger extraction if threshold reached.
+     * Non-blocking: extraction runs in background.
+     */
+    trackAndMaybeExtract(sessionKey: string, sessions: SessionStateMap, messages: ModelMessage[], teamId?: string): void;
+    /** Extract and save facts from messages to memory store. */
+    extractAndSaveFacts(sessionKey: string, messages: Parameters<typeof extractFacts>[1], teamId?: string): Promise<void>;
+    /** Extract remaining facts from all active sessions (call before shutdown). */
+    flushAll(sessions: SessionStateMap): Promise<void>;
+}

package/dist/brain/memory-extractor.js

@@ -0,0 +1,82 @@
+import { randomUUID } from "crypto";
+import { extractFacts } from "../memory/extractor.js";
+import { deriveMemoryTeamId } from "./session-key.js";
+import { logger } from "../logger.js";
+/** Run fact extraction every N user messages (not every message). */
+const EXTRACT_EVERY_N = 5;
+/**
+ * Handles memory extraction from conversation sessions.
+ * Tracks per-session message counts and batches extraction.
+ */
+export class MemoryExtractor {
+    model;
+    memoryStore;
+    embeddingProvider;
+    constructor(model, memoryStore, embeddingProvider) {
+        this.model = model;
+        this.memoryStore = memoryStore;
+        this.embeddingProvider = embeddingProvider;
+    }
+    /** Update the model used for extraction (e.g. after config reload). */
+    setModel(model) {
+        this.model = model;
+    }
+    /**
+     * Increment extraction counter and trigger extraction if threshold reached.
+     * Non-blocking: extraction runs in background.
+     */
+    trackAndMaybeExtract(sessionKey, sessions, messages, teamId) {
+        const state = sessions.get(sessionKey);
+        if (!state)
+            return;
+        const count = state.messagesSinceExtraction + 1;
+        state.messagesSinceExtraction = count;
+        if (count >= EXTRACT_EVERY_N) {
+            state.messagesSinceExtraction = 0;
+            const recent = messages.slice(-EXTRACT_EVERY_N * 2);
+            this.extractAndSaveFacts(sessionKey, recent, teamId).catch((err) => {
+                logger.warn(`Fact extraction failed: ${err instanceof Error ? err.message : err}`);
+            });
+        }
+    }
+    /** Extract and save facts from messages to memory store. */
+    async extractAndSaveFacts(sessionKey, messages, teamId) {
+        const facts = await extractFacts(this.model, messages);
+        if (facts.length === 0)
+            return;
+        // Embed all facts in parallel when a provider is available
+        const embeddings = this.embeddingProvider
+            ? await Promise.all(facts.map((f) => this.embeddingProvider.embed(f)))
+            : facts.map(() => undefined);
+        let saved = 0;
+        for (let i = 0; i < facts.length; i++) {
+            const wasSaved = this.memoryStore.save({
+                id: randomUUID(),
+                fact: facts[i],
+                source: sessionKey,
+                timestamp: Date.now(),
+                embedding: embeddings[i],
+                teamId,
+            });
+            if (wasSaved)
+                saved++;
+        }
+        if (saved > 0) {
+            logger.info(`[${sessionKey}] Saved ${saved} new memories (${facts.length - saved} duplicates skipped)`);
+        }
+    }
+    /** Extract remaining facts from all active sessions (call before shutdown). */
+    async flushAll(sessions) {
+        for (const [sessionKey, state] of sessions.entries()) {
+            if (state.messagesSinceExtraction > 0) {
+                try {
+                    const flushTeamId = deriveMemoryTeamId(sessionKey);
+                    await this.extractAndSaveFacts(sessionKey, state.session.getMessages(), flushTeamId);
+                }
+                catch (err) {
+                    logger.warn(`Shutdown extraction failed for ${sessionKey}: ${err instanceof Error ? err.message : err}`);
+                }
+            }
+        }
+    }
+}

package/dist/brain/providers.d.ts

@@ -0,0 +1,10 @@
+import type { LanguageModel } from "ai";
+/** Provider identifier for Claude Code (used for MCP adapter detection). */
+export declare const CLAUDE_CODE_PROVIDER = "claude-code";
+/** Provider identifier for Codex CLI (used for MCP adapter detection). */
+export declare const CODEX_CLI_PROVIDER = "codex-cli";
+/** Force subscription auth by clearing API key from the SDK environment. */
+export declare const CODEX_CLI_ENV: {
+    readonly OPENAI_API_KEY: "";
+};
+export declare function getModel(provider: string, modelId: string): LanguageModel;

package/dist/brain/providers.js

@@ -0,0 +1,69 @@
+import { anthropic } from "@ai-sdk/anthropic";
+import { createClaudeCode } from "ai-sdk-provider-claude-code";
+import { createCodexCli } from "ai-sdk-provider-codex-cli";
+import { openai } from "@ai-sdk/openai";
+import { google } from "@ai-sdk/google";
+import { xai } from "@ai-sdk/xai";
+import { mistral } from "@ai-sdk/mistral";
+import { groq } from "@ai-sdk/groq";
+import { togetherai } from "@ai-sdk/togetherai";
+import { deepseek } from "@ai-sdk/deepseek";
+import { createOpenAICompatible } from "@ai-sdk/openai-compatible";
+/** Provider identifier for Claude Code (used for MCP adapter detection). */
+export const CLAUDE_CODE_PROVIDER = "claude-code";
+/** Provider identifier for Codex CLI (used for MCP adapter detection). */
+export const CODEX_CLI_PROVIDER = "codex-cli";
+/** Force subscription auth by clearing API key from the SDK environment. */
+export const CODEX_CLI_ENV = { OPENAI_API_KEY: "" };
+/** Base Claude Code provider (OAuth auth, no tools). Tools are added per-session in mcp-adapter.ts. */
+const claudeCode = createClaudeCode({
+    defaultSettings: {
+        permissionMode: "bypassPermissions",
+        env: { ANTHROPIC_API_KEY: undefined },
+    },
+});
+/**
+ * Base Codex CLI provider (full-auto, no tools). Tools are added per-session in mcp-adapter.ts.
+ * fullAuto bypasses Codex CLI's interactive approval — the agent handles its own sandboxing.
+ */
+const codexCliBase = createCodexCli({
+    defaultSettings: {
+        fullAuto: true,
+        env: CODEX_CLI_ENV,
+    },
+});
+const providers = {
+    anthropic: (id) => anthropic(id),
+    [CLAUDE_CODE_PROVIDER]: (id) => claudeCode(id),
+    [CODEX_CLI_PROVIDER]: (id) => codexCliBase(id),
+    openai: (id) => openai(id),
+    google: (id) => google(id),
+    xai: (id) => xai(id),
+    mistral: (id) => mistral(id),
+    groq: (id) => groq(id),
+    togetherai: (id) => togetherai(id),
+    deepseek: (id) => deepseek(id),
+    openrouter: (id) => {
+        const provider = createOpenAICompatible({
+            name: "openrouter",
+            baseURL: "https://openrouter.ai/api/v1",
+            apiKey: process.env.OPENROUTER_API_KEY,
+        });
+        return provider(id);
+    },
+    ollama: (id) => {
+        const provider = createOpenAICompatible({
+            name: "ollama",
+            baseURL: process.env.OLLAMA_BASE_URL ?? "http://localhost:11434/v1",
+            apiKey: "ollama",
+        });
+        return provider(id);
+    },
+};
+export function getModel(provider, modelId) {
+    const factory = providers[provider];
+    if (!factory) {
+        throw new Error(`Unknown provider: ${provider}. Available: ${Object.keys(providers).join(", ")}`);
+    }
+    return factory(modelId);
+}

package/dist/brain/queue.d.ts

@@ -0,0 +1,18 @@
+export type QueueMode = "sequential" | "collect";
+export declare class MessageQueue {
+    private lanes;
+    private mode;
+    private processMessage;
+    constructor(opts: {
+        mode?: QueueMode;
+        processMessage: (sessionKey: string, text: string, signal: AbortSignal) => Promise<string>;
+    });
+    /** Enqueue a message. Returns a promise that resolves with the agent reply. */
+    enqueue(sessionKey: string, text: string): Promise<string>;
+    /** Abort the current run for a session. */
+    abort(sessionKey: string): boolean;
+    /** Remove the lane for a cleared session. Aborts any in-flight run first. */
+    deleteLane(sessionKey: string): void;
+    private drain;
+    private getOrCreateLane;
+}