verybot 0.1.8

package/dist/brain/loop.d.ts

@@ -0,0 +1,24 @@
+import { type AssistantModelMessage, type LanguageModel, type ModelMessage, type ToolSet } from "ai";
+export interface RunLoopResult {
+    /** The final text reply. */
+    text: string;
+    /** All response messages (assistant + tool) generated during the run. */
+    responseMessages: ModelMessage[];
+    /** Structured assistant content from the model response (text/files/tool parts). */
+    assistantContent: AssistantModelMessage["content"] | null;
+}
+export declare function runLoop(opts: {
+    model: LanguageModel;
+    system: string;
+    messages: ModelMessage[];
+    tools: ToolSet;
+    sessionKey: string;
+    abortSignal?: AbortSignal;
+    maxSteps?: number;
+    /** Worker agent ID (e.g. "researcher"). Undefined for the orchestrator. */
+    agentId?: string;
+    /** Suppress all WebSocket broadcasts (used for background workers). */
+    silent?: boolean;
+    /** Human-readable label for logs (e.g. team name instead of UUID). Falls back to sessionKey. */
+    sessionLabel?: string;
+}): Promise<RunLoopResult>;

package/dist/brain/loop.js

@@ -0,0 +1,318 @@
+import { streamText, stepCountIs, } from "ai";
+import { emit } from "../events.js";
+import { logger } from "../logger.js";
+const NO_RESPONSE_TEXT = "(no response)";
+const IMAGE_ONLY_RESPONSE_TEXT = "Generated an image.";
+export async function runLoop(opts) {
+    const { model, system, messages, tools, sessionKey, abortSignal, maxSteps = 20, agentId, silent = false, sessionLabel, } = opts;
+    const tag = `[${sessionLabel ?? sessionKey}]`;
+    const runStart = Date.now();
+    let aborted = false;
+    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,
+        abortSignal,
+        stopWhen: stepCountIs(maxSteps),
+        onAbort({ steps }) {
+            aborted = true;
+            logger.info(`${tag}   ⛔ aborted after ${steps.length} steps`);
+        },
+        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 === "abort") {
+                aborted = true;
+            }
+            else if (event.type === "error") {
+                lastError = event.error;
+            }
+        }
+    }
+    catch (err) {
+        // fullStream flush may throw NoOutputGeneratedError — capture it
+        if (!lastError)
+            lastError = err;
+        if (isAbortLikeError(err))
+            aborted = true;
+    }
+    if (abortSignal?.aborted) {
+        aborted = true;
+    }
+    if (aborted) {
+        // Consume result promises to avoid unhandled rejections on early aborts.
+        const settled = await Promise.allSettled([Promise.resolve(result), result.response]);
+        for (const item of settled) {
+            if (item.status === "rejected" && !isAbortLikeError(item.reason)) {
+                logger.warn(`${tag} Unexpected abort settle error: ${String(item.reason)}`);
+            }
+        }
+        const totalMs = Date.now() - runStart;
+        logger.info(`${tag} ── ABORTED (${collected.length} chars, ${stepNum} steps, ${totalMs}ms) ──`);
+        logger.info(`${tag} ════════════════════════════════════════\n`);
+        if (!silent && collected.length > 0) {
+            emit("chat", {
+                sessionKey,
+                agentId,
+                state: "final",
+                message: { role: "assistant", content: collected },
+            });
+        }
+        return {
+            text: collected,
+            responseMessages: [],
+            assistantContent: null,
+        };
+    }
+    // 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 resp = await result.response;
+    const responseMessages = (resp.messages ?? []);
+    const assistantContent = findLastAssistantContent(responseMessages);
+    const assistantText = extractAssistantText(assistantContent);
+    const text = collected.length > 0
+        ? collected
+        : assistantText.length > 0
+            ? assistantText
+            : hasImageOutput(assistantContent)
+                ? IMAGE_ONLY_RESPONSE_TEXT
+                : NO_RESPONSE_TEXT;
+    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: assistantContent ?? text },
+            usage: final.usage,
+        });
+    }
+    return {
+        text,
+        responseMessages,
+        assistantContent,
+    };
+}
+function findLastAssistantContent(messages) {
+    for (let i = messages.length - 1; i >= 0; i--) {
+        const message = messages[i];
+        if (message.role === "assistant") {
+            return normalizeAssistantContent(message.content);
+        }
+    }
+    return null;
+}
+function normalizeAssistantContent(content) {
+    if (!Array.isArray(content))
+        return content;
+    return content.map((part) => {
+        if (!part || typeof part !== "object")
+            return part;
+        const candidate = part;
+        if (candidate.type !== "file")
+            return part;
+        const data = normalizeDataContent(candidate.data);
+        return { ...candidate, data };
+    });
+}
+function normalizeDataContent(data) {
+    if (Buffer.isBuffer(data)) {
+        return data.toString("base64");
+    }
+    if (data instanceof Uint8Array) {
+        return Buffer.from(data).toString("base64");
+    }
+    if (data instanceof ArrayBuffer) {
+        return Buffer.from(data).toString("base64");
+    }
+    if (data instanceof URL) {
+        return data.toString();
+    }
+    return data;
+}
+function extractAssistantText(content) {
+    if (typeof content === "string")
+        return content;
+    if (!Array.isArray(content))
+        return "";
+    const texts = [];
+    for (const part of content) {
+        if (!part || typeof part !== "object")
+            continue;
+        const candidate = part;
+        if (candidate.type === "text" && typeof candidate.text === "string") {
+            texts.push(candidate.text);
+            continue;
+        }
+        if (candidate.type === "tool-result" && candidate.output && typeof candidate.output === "object") {
+            const output = candidate.output;
+            if (output.type === "text" && typeof output.value === "string") {
+                texts.push(output.value);
+            }
+        }
+    }
+    return texts.join("\n");
+}
+function hasImageOutput(content) {
+    if (!Array.isArray(content))
+        return false;
+    for (const part of content) {
+        if (!part || typeof part !== "object")
+            continue;
+        const candidate = part;
+        if (candidate.type === "file" && isImageMediaType(candidate.mediaType)) {
+            return true;
+        }
+        if (candidate.type !== "tool-result" || !candidate.output || typeof candidate.output !== "object") {
+            continue;
+        }
+        const output = candidate.output;
+        if (output.type !== "content" || !Array.isArray(output.value))
+            continue;
+        for (const item of output.value) {
+            if (!item || typeof item !== "object")
+                continue;
+            const contentItem = item;
+            if (contentItem.type === "image-data" ||
+                contentItem.type === "image-url" ||
+                contentItem.type === "image-file-id") {
+                return true;
+            }
+            if (contentItem.type === "media" && isImageMediaType(contentItem.mediaType)) {
+                return true;
+            }
+            if (contentItem.type === "file-data" && isImageMediaType(contentItem.mediaType)) {
+                return true;
+            }
+        }
+    }
+    return false;
+}
+function isImageMediaType(mediaType) {
+    return typeof mediaType === "string" && mediaType.toLowerCase().startsWith("image/");
+}
+function isAbortLikeError(err) {
+    if (!(err instanceof Error))
+        return false;
+    if (err.name === "AbortError")
+        return true;
+    const msg = err.message.toLowerCase();
+    return msg.includes("aborted") || msg.includes("abort");
+}
+/** 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,43 @@
+import type { LanguageModel, ToolSet } from "ai";
+import type { McpSdkServerConfigWithInstance } from "@anthropic-ai/claude-agent-sdk";
+import { z } from "zod";
+import type { CodexReasoningEffort } from "../config/model-spec.js";
+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;
+    codexReasoningEffort?: CodexReasoningEffort;
+    /** Optional working directory for provider CLI execution. */
+    cwd?: string;
+}
+/** 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,244 @@
+import http from "node:http";
+import { randomUUID } from "node:crypto";
+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.cwd ? { cwd: options.cwd } : {}),
+            ...(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, { streamingInput: "always" }),
+        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);
+        });
+    }
+    // Codex performs multiple MCP requests per run (initialize, list tools, calls).
+    // Streamable HTTP transport must therefore be stateful across requests.
+    const transport = new StreamableHTTPServerTransport({
+        sessionIdGenerator: () => randomUUID(),
+    });
+    await mcpServer.connect(transport);
+    const createHandler = () => http.createServer(async (req, res) => {
+        const rawUrl = req.url ?? "";
+        let pathname = rawUrl;
+        try {
+            pathname = new URL(rawUrl, "http://127.0.0.1").pathname;
+        }
+        catch {
+            // Keep raw value when URL parsing fails.
+        }
+        const normalizedPath = pathname.endsWith("/") && pathname.length > 1 ? pathname.slice(0, -1) : pathname;
+        if (normalizedPath !== 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);
+    // Match "bypass all permissions": disable Codex CLI approvals and sandbox.
+    const codexCli = createCodexCli({
+        defaultSettings: {
+            dangerouslyBypassApprovalsAndSandbox: true,
+            env: CODEX_CLI_ENV,
+            ...(options.cwd ? { cwd: options.cwd } : {}),
+            ...(options.codexReasoningEffort ? { reasoningEffort: options.codexReasoningEffort } : {}),
+            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>;
+}