verybot 0.1.3

package/dist/computer/desktop/macos.js

@@ -0,0 +1,223 @@
+import { execFileSync, execSync } from "child_process";
+import { readFileSync, unlinkSync } from "fs";
+import { tmpdir } from "os";
+import { join } from "path";
+import { randomUUID } from "crypto";
+import { logger } from "../../logger.js";
+/** Timeout for shell commands (ms). */
+const CMD_TIMEOUT = 30_000;
+/** xdotool key name → cliclick key name */
+const KEY_MAP = {
+    return: "return",
+    enter: "return",
+    tab: "tab",
+    space: "space",
+    escape: "escape",
+    delete: "delete",
+    backspace: "delete",
+    up: "arrow-up",
+    down: "arrow-down",
+    left: "arrow-left",
+    right: "arrow-right",
+    home: "home",
+    end: "end",
+    pageup: "page-up",
+    page_up: "page-up",
+    pagedown: "page-down",
+    page_down: "page-down",
+    f1: "f1",
+    f2: "f2",
+    f3: "f3",
+    f4: "f4",
+    f5: "f5",
+    f6: "f6",
+    f7: "f7",
+    f8: "f8",
+    f9: "f9",
+    f10: "f10",
+    f11: "f11",
+    f12: "f12",
+};
+/** xdotool modifier → cliclick modifier */
+const MODIFIER_MAP = {
+    ctrl: "ctrl",
+    control: "ctrl",
+    alt: "alt",
+    option: "alt",
+    shift: "shift",
+    super: "cmd",
+    meta: "cmd",
+    cmd: "cmd",
+    command: "cmd",
+};
+export class MacOSAdapter {
+    screenInfo = null;
+    constructor() {
+        this.checkDependencies();
+    }
+    getScreenInfo() {
+        if (!this.screenInfo) {
+            this.screenInfo = this.detectScreenInfo();
+        }
+        return this.screenInfo;
+    }
+    async screenshot() {
+        const tmpFile = join(tmpdir(), `mvp-screenshot-${randomUUID()}.png`);
+        try {
+            execFileSync("screencapture", ["-x", "-t", "png", tmpFile], {
+                timeout: CMD_TIMEOUT,
+            });
+            return readFileSync(tmpFile);
+        }
+        finally {
+            try {
+                unlinkSync(tmpFile);
+            }
+            catch {
+                // ignore cleanup errors
+            }
+        }
+    }
+    async click(x, y) {
+        const [lx, ly] = this.toLogical(x, y);
+        this.cliclick(`c:${lx},${ly}`);
+    }
+    async doubleClick(x, y) {
+        const [lx, ly] = this.toLogical(x, y);
+        this.cliclick(`dc:${lx},${ly}`);
+    }
+    async rightClick(x, y) {
+        const [lx, ly] = this.toLogical(x, y);
+        this.cliclick(`rc:${lx},${ly}`);
+    }
+    async middleClick(x, y) {
+        // cliclick doesn't have a native middle-click; simulate with option+click
+        const [lx, ly] = this.toLogical(x, y);
+        this.cliclick(`kd:alt`, `c:${lx},${ly}`, `ku:alt`);
+    }
+    async tripleClick(x, y) {
+        const [lx, ly] = this.toLogical(x, y);
+        this.cliclick(`tc:${lx},${ly}`);
+    }
+    async mouseMove(x, y) {
+        const [lx, ly] = this.toLogical(x, y);
+        this.cliclick(`m:${lx},${ly}`);
+    }
+    async type(text) {
+        // cliclick t: types the literal text
+        this.cliclick(`t:${text}`);
+    }
+    async key(combo) {
+        const parts = combo.split("+").map((s) => s.trim().toLowerCase());
+        const modifiers = [];
+        let mainKey = null;
+        for (const part of parts) {
+            if (MODIFIER_MAP[part]) {
+                modifiers.push(MODIFIER_MAP[part]);
+            }
+            else {
+                mainKey = KEY_MAP[part] ?? part;
+            }
+        }
+        if (!mainKey && modifiers.length > 0) {
+            // Single modifier key press (e.g., just "shift")
+            mainKey = modifiers.pop();
+        }
+        if (!mainKey) {
+            logger.warn(`Desktop: could not parse key combo "${combo}"`);
+            return;
+        }
+        const args = [];
+        for (const mod of modifiers)
+            args.push(`kd:${mod}`);
+        args.push(`kp:${mainKey}`);
+        for (const mod of modifiers.reverse())
+            args.push(`ku:${mod}`);
+        this.cliclick(...args);
+    }
+    async scroll(x, y, direction, amount) {
+        const [lx, ly] = this.toLogical(x, y);
+        // Move to position first, then use AppleScript for scrolling
+        this.cliclick(`m:${lx},${ly}`);
+        // AppleScript scroll: positive = up, negative = down
+        const scrollAmount = direction === "up" || direction === "left" ? amount : -amount;
+        const axis = direction === "left" || direction === "right" ? "axis 1" : "axis 2";
+        // Use CGEvent for scrolling via python3 (available on macOS)
+        const script = `tell application "System Events" to ` +
+            `scroll ${axis === "axis 2" ? "vertically" : "horizontally"} by ${scrollAmount}`;
+        try {
+            execFileSync("osascript", ["-e", script], { timeout: CMD_TIMEOUT });
+        }
+        catch {
+            // Fallback: use key-based scrolling
+            const key = direction === "up" ? "arrow-up" : "arrow-down";
+            for (let i = 0; i < Math.abs(amount); i++) {
+                this.cliclick(`kp:${key}`);
+            }
+        }
+    }
+    async getCursorPosition() {
+        const output = execFileSync("cliclick", ["p:"], {
+            encoding: "utf-8",
+            timeout: CMD_TIMEOUT,
+        }).trim();
+        // Output format: "x,y" (logical coordinates)
+        const [lx, ly] = output.split(",").map(Number);
+        const { scaleFactor } = this.getScreenInfo();
+        return [lx * scaleFactor, ly * scaleFactor];
+    }
+    async dragTo(startX, startY, endX, endY) {
+        const [sx, sy] = this.toLogical(startX, startY);
+        const [ex, ey] = this.toLogical(endX, endY);
+        this.cliclick(`dd:${sx},${sy}`, `du:${ex},${ey}`);
+    }
+    // ── Private helpers ──
+    checkDependencies() {
+        try {
+            execFileSync("which", ["cliclick"], { timeout: CMD_TIMEOUT });
+        }
+        catch {
+            throw new Error("cliclick is required for desktop control on macOS. " +
+                "Install it with: brew install cliclick");
+        }
+    }
+    detectScreenInfo() {
+        // Get screenshot pixel dimensions
+        const tmpFile = join(tmpdir(), `mvp-screeninfo-${randomUUID()}.png`);
+        try {
+            execFileSync("screencapture", ["-x", "-t", "png", tmpFile], {
+                timeout: CMD_TIMEOUT,
+            });
+            const sipsOutput = execFileSync("sips", ["-g", "pixelWidth", "-g", "pixelHeight", tmpFile], { encoding: "utf-8", timeout: CMD_TIMEOUT });
+            const widthMatch = sipsOutput.match(/pixelWidth:\s*(\d+)/);
+            const heightMatch = sipsOutput.match(/pixelHeight:\s*(\d+)/);
+            const widthPx = widthMatch ? Number(widthMatch[1]) : 1920;
+            const heightPx = heightMatch ? Number(heightMatch[1]) : 1080;
+            // Get logical screen size via osascript
+            const logicalOutput = execSync(`osascript -l JavaScript -e 'ObjC.import("AppKit"); ` +
+                `var f = $.NSScreen.mainScreen.frame; ` +
+                `f.size.width + " " + f.size.height'`, { encoding: "utf-8", timeout: CMD_TIMEOUT }).trim();
+            const [logicalW] = logicalOutput.split(" ").map(Number);
+            const scaleFactor = logicalW > 0 ? Math.round(widthPx / logicalW) : 2;
+            logger.info(`Desktop: screen ${widthPx}x${heightPx}px, logical ${logicalOutput}, scale ${scaleFactor}x`);
+            return { widthPx, heightPx, scaleFactor };
+        }
+        finally {
+            try {
+                unlinkSync(tmpFile);
+            }
+            catch {
+                // ignore
+            }
+        }
+    }
+    /** Convert pixel coordinates to logical (point) coordinates for cliclick. */
+    toLogical(x, y) {
+        const { scaleFactor } = this.getScreenInfo();
+        return [Math.round(x / scaleFactor), Math.round(y / scaleFactor)];
+    }
+    /** Run cliclick with the given action arguments. */
+    cliclick(...args) {
+        execFileSync("cliclick", args, { timeout: CMD_TIMEOUT });
+    }
+}

package/dist/computer/desktop/tools.d.ts

@@ -0,0 +1,25 @@
+import type { DesktopAdapter } from "./adapter.js";
+export declare function createDesktopTool(adapter: DesktopAdapter, modelId: string): import("ai").Tool<{
+    action: "key" | "hold_key" | "type" | "cursor_position" | "mouse_move" | "left_mouse_down" | "left_mouse_up" | "left_click" | "left_click_drag" | "right_click" | "middle_click" | "double_click" | "triple_click" | "scroll" | "wait" | "screenshot";
+    coordinate?: [number, number];
+    duration?: number;
+    scroll_amount?: number;
+    scroll_direction?: "up" | "down" | "left" | "right";
+    start_coordinate?: [number, number];
+    text?: string;
+}, string | {
+    data: Buffer;
+    mediaType: string;
+}> | import("ai").Tool<{
+    action: "key" | "hold_key" | "type" | "cursor_position" | "mouse_move" | "left_mouse_down" | "left_mouse_up" | "left_click" | "left_click_drag" | "right_click" | "middle_click" | "double_click" | "triple_click" | "scroll" | "wait" | "screenshot" | "zoom";
+    coordinate?: [number, number];
+    duration?: number;
+    region?: [number, number, number, number];
+    scroll_amount?: number;
+    scroll_direction?: "up" | "down" | "left" | "right";
+    start_coordinate?: [number, number];
+    text?: string;
+}, string | {
+    data: Buffer;
+    mediaType: string;
+}>;

package/dist/computer/desktop/tools.js

@@ -0,0 +1,114 @@
+import { anthropic } from "@ai-sdk/anthropic";
+import sharp from "sharp";
+import { logger } from "../../logger.js";
+/** Anthropic API rejects base64 images over 5 MB. We compress PNG → JPEG
+ *  to stay well under the limit while preserving original dimensions. */
+const MAX_IMAGE_BYTES = 3_500_000;
+const JPEG_QUALITY_START = 80;
+const JPEG_QUALITY_MIN = 40;
+const JPEG_QUALITY_STEP = 10;
+/** Compress a screenshot PNG to JPEG, reducing quality until under the size limit. */
+async function compressScreenshot(png) {
+    for (let quality = JPEG_QUALITY_START; quality >= JPEG_QUALITY_MIN; quality -= JPEG_QUALITY_STEP) {
+        const jpeg = await sharp(png).jpeg({ quality }).toBuffer();
+        if (jpeg.length <= MAX_IMAGE_BYTES) {
+            logger.info(`Desktop: screenshot compressed ${png.length} → ${jpeg.length} bytes (JPEG q${quality})`);
+            return { data: jpeg, mediaType: "image/jpeg" };
+        }
+    }
+    // Last resort: lowest quality
+    const jpeg = await sharp(png).jpeg({ quality: JPEG_QUALITY_MIN }).toBuffer();
+    logger.info(`Desktop: screenshot compressed ${png.length} → ${jpeg.length} bytes (JPEG q${JPEG_QUALITY_MIN}, may exceed limit)`);
+    return { data: jpeg, mediaType: "image/jpeg" };
+}
+/** Models that only support the older computer_20250124 tool version. */
+const OLDER_TOOL_MODELS = ["haiku", "claude-3"];
+export function createDesktopTool(adapter, modelId) {
+    const screen = adapter.getScreenInfo();
+    const useOlder = OLDER_TOOL_MODELS.some((m) => modelId.includes(m));
+    const factory = useOlder
+        ? anthropic.tools.computer_20250124
+        : anthropic.tools.computer_20251124;
+    logger.info(`Desktop: using computer tool ${useOlder ? "20250124" : "20251124"} for model ${modelId}`);
+    return factory({
+        displayWidthPx: screen.widthPx,
+        displayHeightPx: screen.heightPx,
+        execute: async (input) => {
+            logger.info(`Desktop: ${input.action} ${JSON.stringify(input)}`);
+            switch (input.action) {
+                case "screenshot": {
+                    const png = await adapter.screenshot();
+                    // Compress to stay under Anthropic's 5 MB base64 limit
+                    const compressed = await compressScreenshot(png);
+                    return compressed;
+                }
+                case "left_click":
+                    await adapter.click(input.coordinate[0], input.coordinate[1]);
+                    return `Clicked at (${input.coordinate[0]}, ${input.coordinate[1]})`;
+                case "double_click":
+                    await adapter.doubleClick(input.coordinate[0], input.coordinate[1]);
+                    return `Double-clicked at (${input.coordinate[0]}, ${input.coordinate[1]})`;
+                case "right_click":
+                    await adapter.rightClick(input.coordinate[0], input.coordinate[1]);
+                    return `Right-clicked at (${input.coordinate[0]}, ${input.coordinate[1]})`;
+                case "middle_click":
+                    await adapter.middleClick(input.coordinate[0], input.coordinate[1]);
+                    return `Middle-clicked at (${input.coordinate[0]}, ${input.coordinate[1]})`;
+                case "triple_click":
+                    await adapter.tripleClick(input.coordinate[0], input.coordinate[1]);
+                    return `Triple-clicked at (${input.coordinate[0]}, ${input.coordinate[1]})`;
+                case "mouse_move":
+                    await adapter.mouseMove(input.coordinate[0], input.coordinate[1]);
+                    return `Moved cursor to (${input.coordinate[0]}, ${input.coordinate[1]})`;
+                case "type":
+                    await adapter.type(input.text);
+                    return `Typed: ${input.text.slice(0, 100)}`;
+                case "key":
+                    await adapter.key(input.text);
+                    return `Pressed: ${input.text}`;
+                case "scroll":
+                    await adapter.scroll(input.coordinate[0], input.coordinate[1], input.scroll_direction, input.scroll_amount);
+                    return `Scrolled ${input.scroll_direction} by ${input.scroll_amount}`;
+                case "cursor_position": {
+                    const [cx, cy] = await adapter.getCursorPosition();
+                    return `Cursor position: (${cx}, ${cy})`;
+                }
+                case "left_click_drag":
+                    await adapter.dragTo(input.start_coordinate[0], input.start_coordinate[1], input.coordinate[0], input.coordinate[1]);
+                    return `Dragged from (${input.start_coordinate[0]}, ${input.start_coordinate[1]}) to (${input.coordinate[0]}, ${input.coordinate[1]})`;
+                case "hold_key":
+                    // hold_key with duration: press key, wait, release
+                    await adapter.key(input.text);
+                    return `Held key: ${input.text} for ${input.duration}s`;
+                case "wait":
+                    await new Promise((r) => setTimeout(r, (input.duration ?? 1) * 1000));
+                    return `Waited ${input.duration ?? 1}s`;
+                case "left_mouse_down":
+                    // Not directly supported by cliclick as a standalone; simulate with drag start
+                    await adapter.mouseMove(input.coordinate[0], input.coordinate[1]);
+                    return `Mouse down at (${input.coordinate[0]}, ${input.coordinate[1]})`;
+                case "left_mouse_up":
+                    await adapter.mouseMove(input.coordinate[0], input.coordinate[1]);
+                    return `Mouse up at (${input.coordinate[0]}, ${input.coordinate[1]})`;
+                default:
+                    return `Unsupported action: ${input.action}`;
+            }
+        },
+        toModelOutput({ input, output }) {
+            if (input.action === "screenshot" && typeof output === "object" && output !== null && "data" in output) {
+                const { data, mediaType } = output;
+                return {
+                    type: "content",
+                    value: [
+                        {
+                            type: "image-data",
+                            data: data.toString("base64"),
+                            mediaType,
+                        },
+                    ],
+                };
+            }
+            return { type: "text", value: String(output) };
+        },
+    });
+}

package/dist/config/agent-config.d.ts

@@ -0,0 +1,41 @@
+export interface AgentConfig {
+    /** Unique agent identifier, e.g. "lead", "researcher", "coder". */
+    id: string;
+    /** Human-readable display name for this agent. */
+    name: string;
+    /** Full model string, e.g. "anthropic:claude-sonnet-4-5-20250929". */
+    model: string;
+    /** Override context window for custom models (0 = auto from catalog). */
+    contextWindow: number;
+    /** Max tool-call steps per run (0 = inherit global default). */
+    maxSteps: number;
+    /** System prompt / identity for this agent. */
+    identity: string;
+    /** Tool names to allow (empty = inherit all base tools). */
+    tools: string[];
+    /** Worker timeout in seconds (default 300 = 5 min). Only meaningful for workers. */
+    timeout: number;
+    /** If set, identity is resolved from the linked prompt template. */
+    templateId?: string | null;
+}
+export interface TeamConfig {
+    /** Unique team identifier, e.g. "research", "coding". */
+    id: string;
+    /** Human-readable label for UI. */
+    name?: string;
+    /** Team color for visual identification in the UI. */
+    color?: string;
+    /** Working directory for this team's agents. */
+    workspace?: string;
+    /** User-defined key-value pairs injected into agent prompts via {{varName}}. */
+    variables?: Record<string, string>;
+    /** The team's orchestrator agent. */
+    orchestrator: AgentConfig;
+    /** Workers scoped to this team. */
+    workers: AgentConfig[];
+}
+export declare const DEFAULT_TEAM_ID = "default";
+/** Default worker timeout: 30 minutes. */
+export declare const DEFAULT_WORKER_TIMEOUT_S = 1800;
+/** Fallback orchestrator for teams that have no orchestrator agent row yet. */
+export declare const FALLBACK_ORCHESTRATOR: AgentConfig;

package/dist/config/agent-config.js

@@ -0,0 +1,14 @@
+export const DEFAULT_TEAM_ID = "default";
+/** Default worker timeout: 30 minutes. */
+export const DEFAULT_WORKER_TIMEOUT_S = 1_800;
+/** Fallback orchestrator for teams that have no orchestrator agent row yet. */
+export const FALLBACK_ORCHESTRATOR = {
+    id: "main",
+    name: "main",
+    model: "",
+    contextWindow: 0,
+    maxSteps: 0,
+    identity: "",
+    tools: [],
+    timeout: DEFAULT_WORKER_TIMEOUT_S,
+};

package/dist/config/model-catalog.d.ts

@@ -0,0 +1,22 @@
+export interface ModelDef {
+    /** Provider key matching `providers.ts`, e.g. "anthropic". */
+    provider: string;
+    /** Full model ID passed to the provider SDK, e.g. "claude-sonnet-4-5-20250929". */
+    modelId: string;
+    /** Human-readable group label for the UI picker. */
+    group: string;
+    /** Context window size in tokens. */
+    contextWindow: number;
+}
+/**
+ * Single source of truth for all built-in model definitions.
+ * Both the UI picker list and the context-window metadata derive from this.
+ */
+export declare const MODEL_CATALOG: ModelDef[];
+/**
+ * Resolve a ModelDef for a given model ID.
+ * Lookup order: exact match > longest-prefix match > fallback.
+ * `contextWindowOverride` only applies when the model is NOT in the catalog —
+ * catalog values are always authoritative.
+ */
+export declare function resolveModelDef(modelId: string, contextWindowOverride?: number): ModelDef;

package/dist/config/model-catalog.js

@@ -0,0 +1,99 @@
+/**
+ * Single source of truth for all built-in model definitions.
+ * Both the UI picker list and the context-window metadata derive from this.
+ */
+export const MODEL_CATALOG = [
+    // Claude Code (subscription — no API key needed, requires `claude login`)
+    { provider: "claude-code", modelId: "haiku", group: "Claude Code", contextWindow: 200_000 },
+    { provider: "claude-code", modelId: "sonnet", group: "Claude Code", contextWindow: 200_000 },
+    { provider: "claude-code", modelId: "opus", group: "Claude Code", contextWindow: 200_000 },
+    // Codex CLI (OpenAI subscription — no API key needed, requires `codex login`)
+    // Context windows are approximate; override via config `contextWindow` if needed.
+    { provider: "codex-cli", modelId: "gpt-5.1-codex-mini", group: "Codex CLI", contextWindow: 200_000 },
+    { provider: "codex-cli", modelId: "gpt-5.1-codex-max", group: "Codex CLI", contextWindow: 200_000 },
+    { provider: "codex-cli", modelId: "gpt-5.2-codex", group: "Codex CLI", contextWindow: 200_000 },
+    // Anthropic (API key)
+    { provider: "anthropic", modelId: "claude-haiku-4-5-20251001", group: "Anthropic", contextWindow: 200_000 },
+    { provider: "anthropic", modelId: "claude-opus-4-6", group: "Anthropic", contextWindow: 200_000 },
+    { provider: "anthropic", modelId: "claude-sonnet-4-5-20250929", group: "Anthropic", contextWindow: 200_000 },
+    // OpenAI
+    { provider: "openai", modelId: "gpt-4.1", group: "OpenAI", contextWindow: 1_000_000 },
+    { provider: "openai", modelId: "gpt-4o", group: "OpenAI", contextWindow: 128_000 },
+    { provider: "openai", modelId: "gpt-4o-mini", group: "OpenAI", contextWindow: 128_000 },
+    // Google
+    { provider: "google", modelId: "gemini-2.0-flash", group: "Google", contextWindow: 1_000_000 },
+    { provider: "google", modelId: "gemini-2.5-pro", group: "Google", contextWindow: 1_000_000 },
+    // Groq
+    { provider: "groq", modelId: "llama-3.1-8b-instant", group: "Groq", contextWindow: 131_072 },
+    { provider: "groq", modelId: "llama-3.3-70b-versatile", group: "Groq", contextWindow: 128_000 },
+    { provider: "groq", modelId: "mixtral-8x7b-32768", group: "Groq", contextWindow: 32_768 },
+    // OpenRouter — own models + top 15 most popular (openrouter.ai/rankings)
+    { provider: "openrouter", modelId: "anthropic/claude-4.5-opus-20251124", group: "OpenRouter", contextWindow: 200_000 },
+    { provider: "openrouter", modelId: "anthropic/claude-4.5-sonnet-20250929", group: "OpenRouter", contextWindow: 1_000_000 },
+    { provider: "openrouter", modelId: "anthropic/claude-4.6-opus-20260205", group: "OpenRouter", contextWindow: 1_000_000 },
+    { provider: "openrouter", modelId: "deepseek/deepseek-v3.2-20251201", group: "OpenRouter", contextWindow: 163_840 },
+    { provider: "openrouter", modelId: "google/gemini-2.0-flash-001", group: "OpenRouter", contextWindow: 1_048_576 },
+    { provider: "openrouter", modelId: "google/gemini-2.5-flash", group: "OpenRouter", contextWindow: 1_048_576 },
+    { provider: "openrouter", modelId: "google/gemini-2.5-pro", group: "OpenRouter", contextWindow: 1_048_576 },
+    { provider: "openrouter", modelId: "google/gemini-3-flash-preview-20251217", group: "OpenRouter", contextWindow: 1_048_576 },
+    { provider: "openrouter", modelId: "minimax/minimax-m2.1", group: "OpenRouter", contextWindow: 196_608 },
+    { provider: "openrouter", modelId: "minimax/minimax-m2.5", group: "OpenRouter", contextWindow: 204_800 },
+    { provider: "openrouter", modelId: "mistralai/devstral-2512", group: "OpenRouter", contextWindow: 262_144 },
+    { provider: "openrouter", modelId: "moonshotai/kimi-k2.5-0127", group: "OpenRouter", contextWindow: 262_144 },
+    { provider: "openrouter", modelId: "openai/gpt-5.2-20251211", group: "OpenRouter", contextWindow: 400_000 },
+    { provider: "openrouter", modelId: "openai/gpt-oss-120b", group: "OpenRouter", contextWindow: 131_072 },
+    { provider: "openrouter", modelId: "openrouter/aurora-alpha", group: "OpenRouter", contextWindow: 128_000 },
+    { provider: "openrouter", modelId: "openrouter/pony-alpha", group: "OpenRouter", contextWindow: 200_000 },
+    { provider: "openrouter", modelId: "x-ai/grok-4.1-fast", group: "OpenRouter", contextWindow: 2_000_000 },
+    { provider: "openrouter", modelId: "x-ai/grok-code-fast-1", group: "OpenRouter", contextWindow: 256_000 },
+    // DeepSeek
+    { provider: "deepseek", modelId: "deepseek-chat", group: "DeepSeek", contextWindow: 128_000 },
+    { provider: "deepseek", modelId: "deepseek-reasoner", group: "DeepSeek", contextWindow: 128_000 },
+    // Mistral
+    { provider: "mistral", modelId: "codestral-latest", group: "Mistral", contextWindow: 256_000 },
+    { provider: "mistral", modelId: "mistral-large-latest", group: "Mistral", contextWindow: 128_000 },
+    { provider: "mistral", modelId: "mistral-small-latest", group: "Mistral", contextWindow: 128_000 },
+    // xAI
+    { provider: "xai", modelId: "grok-3", group: "xAI", contextWindow: 131_072 },
+    { provider: "xai", modelId: "grok-3-mini", group: "xAI", contextWindow: 131_072 },
+    // Together AI
+    { provider: "togetherai", modelId: "meta-llama/Meta-Llama-3.1-405B-Instruct-Turbo", group: "Together AI", contextWindow: 128_000 },
+    { provider: "togetherai", modelId: "meta-llama/Meta-Llama-3.1-70B-Instruct-Turbo", group: "Together AI", contextWindow: 128_000 },
+    // Ollama (local)
+    { provider: "ollama", modelId: "deepseek-r1", group: "Ollama", contextWindow: 128_000 },
+    { provider: "ollama", modelId: "llama3.3", group: "Ollama", contextWindow: 128_000 },
+    { provider: "ollama", modelId: "qwen2.5", group: "Ollama", contextWindow: 128_000 },
+];
+const FALLBACK_CONTEXT_WINDOW = 128_000;
+/** Lookup map keyed by modelId for exact matching. */
+const catalogByModelId = new Map(MODEL_CATALOG.map((m) => [m.modelId, m]));
+/**
+ * Resolve a ModelDef for a given model ID.
+ * Lookup order: exact match > longest-prefix match > fallback.
+ * `contextWindowOverride` only applies when the model is NOT in the catalog —
+ * catalog values are always authoritative.
+ */
+export function resolveModelDef(modelId, contextWindowOverride = 0) {
+    // Exact match — catalog is authoritative, ignore override
+    const exact = catalogByModelId.get(modelId);
+    if (exact)
+        return exact;
+    // Longest-prefix match — also authoritative
+    const prefix = findPrefixMatch(modelId);
+    if (prefix)
+        return prefix;
+    // Unknown model — apply user override if provided, else fallback
+    const ctxWindow = contextWindowOverride > 0 ? contextWindowOverride : FALLBACK_CONTEXT_WINDOW;
+    return { provider: "unknown", modelId, group: "Other", contextWindow: ctxWindow };
+}
+function findPrefixMatch(modelId) {
+    let best;
+    let bestLen = 0;
+    for (const entry of MODEL_CATALOG) {
+        if (modelId.startsWith(entry.modelId) && entry.modelId.length > bestLen) {
+            best = entry;
+            bestLen = entry.modelId.length;
+        }
+    }
+    return best;
+}

package/dist/config/store.d.ts

@@ -0,0 +1,25 @@
+export type ConfigData = Record<string, unknown>;
+/**
+ * Manages a single `config.json` file on disk.
+ * Handles reading, writing, patching, and redaction of secret values.
+ */
+export declare class ConfigStore {
+    private filePath;
+    constructor(baseDir: string);
+    /** Read config from disk. Returns empty object if file doesn't exist. */
+    load(): ConfigData;
+    /** Write full config to disk atomically (temp file → rename). */
+    save(data: ConfigData): void;
+    /** Deep-merge a partial update into the existing config and save. */
+    patch(partial: ConfigData): ConfigData;
+    /** Return config with secret values redacted. */
+    getRedacted(): ConfigData;
+    /**
+     * Given an incoming config (possibly with redacted values from the UI),
+     * restore redacted secrets from the existing disk values before saving.
+     */
+    patchFromUI(incoming: ConfigData): ConfigData;
+    /** Return file mtime in ms, or null if file doesn't exist. */
+    mtime(): number | null;
+    getFilePath(): string;
+}