@voybio/ace-swarm 0.1.0

package/dist/kanban.d.ts

@@ -0,0 +1,27 @@
+export type KanbanColumn = "backlog" | "blocked" | "in_progress" | "gated" | "done";
+export interface AceKanbanCard {
+    id: string;
+    title: string;
+    source: string;
+}
+export interface AceKanbanBoard {
+    backlog: AceKanbanCard[];
+    blocked: AceKanbanCard[];
+    in_progress: AceKanbanCard[];
+    gated: AceKanbanCard[];
+    done: AceKanbanCard[];
+}
+export interface AceKanbanSnapshot {
+    version: number;
+    generated_at: string;
+    trigger: string;
+    board: AceKanbanBoard;
+    counts: Record<KanbanColumn, number>;
+    html_path: string;
+    json_path: string;
+}
+export declare function renderKanbanHtml(snapshot: AceKanbanSnapshot): string;
+export declare function refreshKanbanArtifacts(trigger: string): AceKanbanSnapshot;
+export declare function getOrRefreshKanbanSnapshot(trigger: string): AceKanbanSnapshot;
+export declare function shouldAutoRefreshKanbanForPath(path: string): boolean;
+//# sourceMappingURL=kanban.d.ts.map

package/dist/kanban.js

@@ -0,0 +1,339 @@
+import { ACE_ROOT_REL, ACE_TASKS_ROOT_REL, safeRead, safeWrite, wsPath } from "./helpers.js";
+import { isReadError, slugify } from "./shared.js";
+import { readHandoffRegistry } from "./handoff-registry.js";
+import { readTodoState } from "./todo-state.js";
+/** Debounce threshold in milliseconds. Skip re-render if within this window. */
+const KANBAN_DEBOUNCE_MS = 2000;
+let lastKanbanRenderTimestamp = 0;
+const KANBAN_JSON_REL = "agent-state/kanban.json";
+const KANBAN_HTML_REL = "agent-state/kanban.html";
+const COLUMNS = ["backlog", "blocked", "in_progress", "gated", "done"];
+function nowIso() {
+    return new Date().toISOString();
+}
+function emptyBoard() {
+    return {
+        backlog: [],
+        blocked: [],
+        in_progress: [],
+        gated: [],
+        done: [],
+    };
+}
+function escapeHtml(input) {
+    return input
+        .replace(/&/g, "&")
+        .replace(/</g, "&lt;")
+        .replace(/>/g, "&gt;")
+        .replace(/"/g, "&quot;")
+        .replace(/'/g, "&#39;");
+}
+function tryParseJson(raw) {
+    try {
+        const parsed = JSON.parse(raw);
+        if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
+            return parsed;
+        }
+        return undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+function parseChecklistItems(todoRaw) {
+    const items = [];
+    let section = "General";
+    for (const line of todoRaw.split(/\r?\n/)) {
+        const header = line.match(/^##\s+(.+)$/);
+        if (header) {
+            section = header[1]?.trim() || "General";
+            continue;
+        }
+        const item = line.match(/^- \[( |x|X)\]\s+(.+)$/);
+        if (!item) {
+            continue;
+        }
+        items.push({
+            checked: item[1]?.toLowerCase() === "x",
+            section,
+            title: item[2]?.trim() || "Untitled task",
+        });
+    }
+    return items;
+}
+function classifyTodoItem(item) {
+    if (item.checked) {
+        return "done";
+    }
+    const section = item.section.toLowerCase();
+    const title = item.title.toLowerCase();
+    if (/\bblocked?\b|\bblocker\b|\bstuck\b|\bwaiting\b/.test(title)) {
+        return "blocked";
+    }
+    if (/\bin progress\b|\bwip\b|\bdoing\b|\bactive\b/.test(title)) {
+        return "in_progress";
+    }
+    if (section.includes("verification")) {
+        return "gated";
+    }
+    if (section.includes("active")) {
+        return "in_progress";
+    }
+    return "backlog";
+}
+function addTodoCards(board) {
+    const todoState = readTodoState();
+    if (todoState.order.length > 0) {
+        for (const nodeId of todoState.order) {
+            const node = todoState.nodes[nodeId];
+            if (!node)
+                continue;
+            board[node.status].push({
+                id: node.id,
+                title: `${node.title} (${node.section})`,
+                source: "agent-state/todo-state.json",
+            });
+        }
+        return;
+    }
+    const todoRaw = safeRead(`${ACE_TASKS_ROOT_REL}/todo.md`);
+    if (isReadError(todoRaw)) {
+        return;
+    }
+    const checklist = parseChecklistItems(todoRaw);
+    checklist.forEach((item, idx) => {
+        const lane = classifyTodoItem(item);
+        board[lane].push({
+            id: `todo-${idx + 1}-${slugify(item.title)}`,
+            title: `${item.title} (${item.section})`,
+            source: `${ACE_TASKS_ROOT_REL}/todo.md`,
+        });
+    });
+}
+function extractInlineValue(raw, key) {
+    const escaped = key.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+    const re = new RegExp(`^-\\s*${escaped}:\\s*(.+)$`, "im");
+    const match = raw.match(re);
+    if (!match || !match[1]) {
+        return undefined;
+    }
+    return match[1].replace(/`/g, "").trim();
+}
+function addStatusCard(board) {
+    const statusRaw = safeRead("agent-state/STATUS.md");
+    if (isReadError(statusRaw)) {
+        return;
+    }
+    const currentRole = extractInlineValue(statusRaw, "Current role");
+    if (!currentRole) {
+        return;
+    }
+    const phase = extractInlineValue(statusRaw, "Current phase") || "unknown phase";
+    const blockers = extractInlineValue(statusRaw, "Blockers") || "unknown";
+    const objective = extractInlineValue(statusRaw, "Current objective");
+    const title = objective
+        ? `${currentRole} (${phase}) - ${objective}`
+        : `${currentRole} (${phase})`;
+    const lane = blockers.toLowerCase() === "none" ? "in_progress" : "blocked";
+    board[lane].push({
+        id: "status-current-role",
+        title,
+        source: "agent-state/STATUS.md",
+    });
+}
+function addHandoffCard(board) {
+    const handoffRaw = safeRead("agent-state/HANDOFF.json");
+    if (isReadError(handoffRaw)) {
+        return;
+    }
+    const parsed = tryParseJson(handoffRaw);
+    if (!parsed) {
+        return;
+    }
+    const transition = (parsed.transition && typeof parsed.transition === "object" ? parsed.transition : undefined);
+    if (!transition) {
+        return;
+    }
+    const from = String(transition.from ?? "unknown-from");
+    const to = String(transition.to ?? "unknown-to");
+    const status = String(transition.status ?? "READY").toUpperCase();
+    const reason = String(transition.reason ?? "handoff reason unspecified");
+    let lane = "gated";
+    if (status === "BLOCKED") {
+        lane = "blocked";
+    }
+    else if (status === "DONE") {
+        lane = "done";
+    }
+    else if (status === "READY_FOR_REVIEW" || status === "READY") {
+        lane = "gated";
+    }
+    else {
+        lane = "in_progress";
+    }
+    board[lane].push({
+        id: `handoff-${slugify(from)}-to-${slugify(to)}`,
+        title: `${from} -> ${to} (${status}): ${reason}`,
+        source: "agent-state/HANDOFF.json",
+    });
+}
+function addHandoffRegistryCards(board) {
+    const registry = readHandoffRegistry();
+    const records = Object.values(registry.handoffs).sort((a, b) => b.updated_at.localeCompare(a.updated_at));
+    for (const record of records.slice(0, 24)) {
+        const lane = record.status === "blocked"
+            ? "blocked"
+            : record.status === "completed"
+                ? "done"
+                : record.status === "accepted"
+                    ? "in_progress"
+                    : "backlog";
+        board[lane].push({
+            id: `registry-${slugify(record.handoff_id)}`,
+            title: `${record.from} -> ${record.to} (${record.status.toUpperCase()}): ${record.title}`,
+            source: "agent-state/handoff-registry.json",
+        });
+    }
+}
+function normalizeBoardOrder(board) {
+    for (const name of COLUMNS) {
+        board[name].sort((a, b) => a.title.localeCompare(b.title));
+    }
+}
+function renderCard(card) {
+    return [
+        `<article class="card">`,
+        `<h3>${escapeHtml(card.title)}</h3>`,
+        `<p class="meta">${escapeHtml(card.id)} | ${escapeHtml(card.source)}</p>`,
+        `</article>`,
+    ].join("");
+}
+export function renderKanbanHtml(snapshot) {
+    const sections = COLUMNS.map((name) => {
+        const cards = snapshot.board[name];
+        return [
+            `<section class="column">`,
+            `<header><h2>${escapeHtml(name.replace(/_/g, " "))}</h2><span>${cards.length}</span></header>`,
+            `<div class="cards">${cards.map(renderCard).join("") || '<p class="empty">No cards</p>'}</div>`,
+            `</section>`,
+        ].join("");
+    }).join("");
+    return [
+        "<!doctype html>",
+        "<html lang=\"en\">",
+        "<head>",
+        "<meta charset=\"utf-8\" />",
+        "<meta name=\"viewport\" content=\"width=device-width, initial-scale=1\" />",
+        "<title>ACE Swarm Kanban</title>",
+        "<style>",
+        ":root{--bg:#f6f4ef;--ink:#1f1f1d;--line:#d8d2c5;--card:#fffcf4;--accent:#d56822}",
+        "*{box-sizing:border-box}",
+        "body{margin:0;font-family:'IBM Plex Sans','Segoe UI',sans-serif;background:radial-gradient(circle at 20% 20%,#fffaf0 0%,#f3efe4 45%,#ece6d8 100%);color:var(--ink)}",
+        "main{max-width:1600px;margin:0 auto;padding:20px}",
+        "header.top{display:flex;justify-content:space-between;align-items:flex-start;gap:12px;margin-bottom:16px}",
+        ".title{display:flex;align-items:center;gap:10px}",
+        ".spinner{width:14px;height:14px;border:2px solid var(--accent);border-top-color:transparent;border-radius:999px;animation:spin 1s linear infinite}",
+        "@keyframes spin{to{transform:rotate(360deg)}}",
+        "h1{margin:0;font-family:'Space Grotesk','Avenir Next',sans-serif;font-size:24px}",
+        ".stamp{margin:0;font-size:12px;opacity:.75}",
+        ".grid{display:grid;grid-template-columns:repeat(5,minmax(220px,1fr));gap:12px}",
+        ".column{background:rgba(255,255,255,.62);border:1px solid var(--line);border-radius:12px;min-height:220px}",
+        ".column>header{display:flex;justify-content:space-between;align-items:center;padding:10px 12px;border-bottom:1px solid var(--line)}",
+        ".column h2{margin:0;font-size:14px;text-transform:capitalize}",
+        ".column span{background:var(--accent);color:#fff;border-radius:999px;padding:2px 8px;font-size:12px}",
+        ".cards{display:flex;flex-direction:column;gap:8px;padding:10px}",
+        ".card{background:var(--card);border:1px solid var(--line);border-radius:10px;padding:10px}",
+        ".card h3{margin:0 0 6px;font-size:13px;line-height:1.35}",
+        ".meta{margin:0;font-size:11px;opacity:.75;word-break:break-all}",
+        ".empty{margin:0;padding:8px;font-size:12px;opacity:.55}",
+        "@media (max-width:1200px){.grid{grid-template-columns:repeat(2,minmax(220px,1fr));}}",
+        "@media (max-width:640px){.grid{grid-template-columns:1fr;}}",
+        "</style>",
+        "</head>",
+        "<body>",
+        "<main>",
+        "<header class=\"top\">",
+        "<div>",
+        "<div class=\"title\"><span class=\"spinner\" aria-hidden=\"true\"></span><h1>ACE Swarm Kanban</h1></div>",
+        `<p class="stamp">trigger: ${escapeHtml(snapshot.trigger)}</p>`,
+        "</div>",
+        `<p class="stamp">updated: ${escapeHtml(snapshot.generated_at)}</p>`,
+        "</header>",
+        `<section class="grid">${sections}</section>`,
+        "</main>",
+        "</body>",
+        "</html>",
+    ].join("");
+}
+export function refreshKanbanArtifacts(trigger) {
+    // Debounce: skip expensive re-render if within threshold
+    const now = Date.now();
+    if (now - lastKanbanRenderTimestamp < KANBAN_DEBOUNCE_MS) {
+        // Return cached snapshot if available
+        const cached = getOrRefreshKanbanSnapshot(trigger);
+        if (cached.generated_at)
+            return cached;
+    }
+    lastKanbanRenderTimestamp = now;
+    const board = emptyBoard();
+    addTodoCards(board);
+    addStatusCard(board);
+    addHandoffCard(board);
+    addHandoffRegistryCards(board);
+    normalizeBoardOrder(board);
+    const snapshot = {
+        version: 1,
+        generated_at: nowIso(),
+        trigger,
+        board,
+        counts: {
+            backlog: board.backlog.length,
+            blocked: board.blocked.length,
+            in_progress: board.in_progress.length,
+            gated: board.gated.length,
+            done: board.done.length,
+        },
+        html_path: wsPath(KANBAN_HTML_REL),
+        json_path: wsPath(KANBAN_JSON_REL),
+    };
+    safeWrite(KANBAN_HTML_REL, renderKanbanHtml(snapshot));
+    safeWrite(KANBAN_JSON_REL, JSON.stringify(snapshot, null, 2));
+    return snapshot;
+}
+export function getOrRefreshKanbanSnapshot(trigger) {
+    const raw = safeRead(KANBAN_JSON_REL);
+    if (!isReadError(raw)) {
+        const parsed = tryParseJson(raw);
+        const version = typeof parsed?.version === "number" ? parsed.version : undefined;
+        const generated = typeof parsed?.generated_at === "string" ? parsed.generated_at : undefined;
+        const board = parsed?.board;
+        const counts = parsed?.counts;
+        const htmlPath = typeof parsed?.html_path === "string" ? parsed.html_path : undefined;
+        const jsonPath = typeof parsed?.json_path === "string" ? parsed.json_path : undefined;
+        const savedTrigger = typeof parsed?.trigger === "string" ? parsed.trigger : "cached";
+        if (version === 1 && generated && board && counts && htmlPath && jsonPath) {
+            return {
+                version,
+                generated_at: generated,
+                trigger: savedTrigger,
+                board,
+                counts,
+                html_path: htmlPath,
+                json_path: jsonPath,
+            };
+        }
+    }
+    return refreshKanbanArtifacts(trigger);
+}
+export function shouldAutoRefreshKanbanForPath(path) {
+    const normalized = path.replace(/\\/g, "/").replace(/^\.?\//, "");
+    if (normalized === KANBAN_JSON_REL || normalized === KANBAN_HTML_REL) {
+        return false;
+    }
+    return (normalized.startsWith(`${ACE_TASKS_ROOT_REL}/`) ||
+        normalized.startsWith(`${ACE_ROOT_REL}/agent-state/`) ||
+        normalized.startsWith(`${ACE_ROOT_REL}/global-state/`) ||
+        normalized.startsWith("ace-mcp-server/src/") ||
+        /(^|\/)SWARM_HANDOFF\.[^/]+\.json$/.test(normalized));
+}
+//# sourceMappingURL=kanban.js.map

package/dist/local-model-runtime.d.ts

@@ -0,0 +1,40 @@
+import { type BridgeResult, type ModelBridgeClients } from "./model-bridge.js";
+import type { AceContextTier } from "./ace-context.js";
+export interface LocalModelRuntimeConfig {
+    workspaceRoot: string;
+    provider: string;
+    model: string;
+    baseUrl?: string;
+    ollamaUrl?: string;
+    providerBaseUrls: Record<string, string>;
+    notes: string[];
+}
+export interface RunLocalModelTaskOptions {
+    task: string;
+    role?: string;
+    workspaceRoot?: string;
+    provider?: string;
+    model?: string;
+    baseUrl?: string;
+    ollamaUrl?: string;
+    maxTurns?: number;
+    tier?: AceContextTier | "auto";
+    toolScope?: string[];
+    clients?: ModelBridgeClients;
+}
+export interface RunLocalModelTaskResult {
+    runtime: LocalModelRuntimeConfig;
+    role: string;
+    routingSummary?: string;
+    result: BridgeResult;
+}
+export declare function createDefaultModelBridgeClients(runtime: Pick<LocalModelRuntimeConfig, "providerBaseUrls">): ModelBridgeClients;
+export declare function resolveLocalModelRuntime(input: {
+    workspaceRoot?: string;
+    provider?: string;
+    model?: string;
+    baseUrl?: string;
+    ollamaUrl?: string;
+}): LocalModelRuntimeConfig;
+export declare function runLocalModelTask(options: RunLocalModelTaskOptions): Promise<RunLocalModelTaskResult>;
+//# sourceMappingURL=local-model-runtime.d.ts.map

package/dist/local-model-runtime.js

@@ -0,0 +1,174 @@
+import { existsSync, readFileSync } from "node:fs";
+import { resolve } from "node:path";
+import { ROLE_ENUM, scoreDomains } from "./shared.js";
+import { resolveWorkspaceRoot } from "./helpers.js";
+import { executeAceInternalTool } from "./ace-internal-tools.js";
+import { ModelBridge } from "./model-bridge.js";
+import { OllamaClient } from "./tui/ollama.js";
+import { OpenAICompatibleClient, diagnoseChatRuntimeConfig, } from "./tui/openai-compatible.js";
+import { discoverProviderContext } from "./tui/provider-discovery.js";
+function extractTextContent(result) {
+    if (!result || typeof result !== "object")
+        return "";
+    const content = Array.isArray(result.content) ? result.content : [];
+    return content
+        .filter((entry) => Boolean(entry) &&
+        typeof entry === "object" &&
+        entry.type === "text")
+        .map((entry) => String(entry.text ?? "").trim())
+        .filter(Boolean)
+        .join("\n");
+}
+function normalizeRoleCandidate(input) {
+    if (!input)
+        return undefined;
+    const normalized = input.trim().toLowerCase().replace(/^ace-/, "").replace(/[^a-z0-9]+/g, "");
+    const candidate = normalized === "coder" ? "coders" : normalized;
+    return ROLE_ENUM.options.includes(candidate)
+        ? candidate
+        : undefined;
+}
+function parseRoleFromRoutingSummary(summary) {
+    const match = summary.match(/\*\*Primary Swarm Agent\(s\):\*\*\s*([^\n]+)/i);
+    if (!match?.[1])
+        return undefined;
+    const firstAgent = match[1]
+        .split(",")
+        .map((entry) => entry.trim())
+        .find(Boolean);
+    return normalizeRoleCandidate(firstAgent);
+}
+function hasAlignedTaskContract(workspaceRoot) {
+    const required = [
+        "agent-state/TASK.md",
+        "agent-state/SCOPE.md",
+        "agent-state/QUALITY_GATES.md",
+        "agent-state/HANDOFF.json",
+    ];
+    return required.every((relativePath) => {
+        const absolute = resolve(workspaceRoot, relativePath);
+        if (!existsSync(absolute))
+            return false;
+        return readFileSync(absolute, "utf-8").trim().length > 0;
+    });
+}
+function fallbackRoleForTask(task, workspaceRoot) {
+    if (!hasAlignedTaskContract(workspaceRoot)) {
+        return "orchestrator";
+    }
+    const { domain } = scoreDomains(task);
+    switch (domain) {
+        case "engineering":
+            return "coders";
+        case "venture":
+            return "vos";
+        case "ux":
+            return "ui";
+        default:
+            return "orchestrator";
+    }
+}
+async function resolveRole(task, workspaceRoot, sessionId, requestedRole) {
+    const explicitRole = normalizeRoleCandidate(requestedRole);
+    if (explicitRole) {
+        return { role: explicitRole, routingSummary: undefined };
+    }
+    const routing = await executeAceInternalTool("route_task", { description: task, domain: "unknown" }, sessionId);
+    const routingSummary = extractTextContent(routing);
+    const routedRole = parseRoleFromRoutingSummary(routingSummary);
+    const fallbackRole = fallbackRoleForTask(task, workspaceRoot);
+    return {
+        role: routedRole && !(routedRole === "orchestrator" && fallbackRole !== "orchestrator")
+            ? routedRole
+            : fallbackRole,
+        routingSummary,
+    };
+}
+function resolveTier(requested, provider, model, role) {
+    if (requested && requested !== "auto")
+        return requested;
+    const normalizedProvider = provider.trim().toLowerCase();
+    const normalizedModel = model.trim().toLowerCase();
+    if (role === "orchestrator")
+        return "compressed";
+    if (normalizedProvider !== "ollama")
+        return "full";
+    if (/(70b|72b|90b|405b|claude|gpt-|codex|gemini|o[1345])/.test(normalizedModel)) {
+        return "full";
+    }
+    if (/(7b|8b|mini|small|phi|tiny)/.test(normalizedModel)) {
+        return "brief";
+    }
+    return "compressed";
+}
+export function createDefaultModelBridgeClients(runtime) {
+    const providerConfigs = {};
+    for (const [provider, baseUrl] of Object.entries(runtime.providerBaseUrls)) {
+        providerConfigs[provider] = { baseUrl };
+    }
+    return {
+        ollama: new OllamaClient(runtime.providerBaseUrls.ollama),
+        openai: new OpenAICompatibleClient({ providerConfigs }),
+    };
+}
+export function resolveLocalModelRuntime(input) {
+    const workspaceRoot = input.workspaceRoot
+        ? resolve(input.workspaceRoot)
+        : resolveWorkspaceRoot();
+    const discovered = discoverProviderContext({
+        workspaceRoot,
+        cliProvider: input.provider,
+        cliModel: input.model,
+        cliBaseUrl: input.baseUrl,
+        cliOllamaUrl: input.ollamaUrl,
+    });
+    if (discovered.provider === "ollama" && !discovered.ollamaUrl) {
+        throw new Error("Ollama base URL is not configured. Provide `--base-url`/`ollama_url`, set OLLAMA_HOST, or run `ace doctor --llm ollama --scan`.");
+    }
+    if (discovered.provider !== "ollama") {
+        const diagnosis = diagnoseChatRuntimeConfig(discovered.provider, discovered.model, {
+            baseUrl: discovered.baseUrl,
+        });
+        if (!diagnosis.ok) {
+            throw new Error(diagnosis.message);
+        }
+    }
+    return {
+        workspaceRoot,
+        provider: discovered.provider,
+        model: discovered.model,
+        baseUrl: discovered.baseUrl,
+        ollamaUrl: discovered.ollamaUrl,
+        providerBaseUrls: discovered.providerBaseUrls,
+        notes: discovered.notes,
+    };
+}
+export async function runLocalModelTask(options) {
+    const runtime = resolveLocalModelRuntime({
+        workspaceRoot: options.workspaceRoot,
+        provider: options.provider,
+        model: options.model,
+        baseUrl: options.baseUrl,
+        ollamaUrl: options.ollamaUrl,
+    });
+    const bridge = new ModelBridge(options.clients ?? createDefaultModelBridgeClients(runtime));
+    const { role, routingSummary } = await resolveRole(options.task, runtime.workspaceRoot, undefined, options.role);
+    const tier = resolveTier(options.tier, runtime.provider, runtime.model, role);
+    const result = await bridge.run({
+        task: options.task,
+        role,
+        workspace: runtime.workspaceRoot,
+        tier,
+        maxTurns: options.maxTurns ?? (role === "orchestrator" ? 6 : 4),
+        provider: runtime.provider,
+        model: runtime.model,
+        toolScope: options.toolScope,
+    });
+    return {
+        runtime,
+        role,
+        routingSummary,
+        result,
+    };
+}
+//# sourceMappingURL=local-model-runtime.js.map

package/dist/model-bridge.d.ts

@@ -0,0 +1,54 @@
+import { type AceContextTier } from "./ace-context.js";
+import type { OllamaClient } from "./tui/ollama.js";
+import type { OpenAICompatibleClient } from "./tui/openai-compatible.js";
+export interface BridgeToolCall {
+    tool: string;
+    input?: Record<string, unknown>;
+}
+export interface BridgeToolResult {
+    tool: string;
+    ok: boolean;
+    summary: string;
+    isError: boolean;
+}
+export interface BridgeResult {
+    bridge_id: string;
+    role: string;
+    status: "completed" | "needs_input" | "failed" | "max_turns";
+    summary: string;
+    turns: number;
+    tool_calls: BridgeToolResult[];
+    child_results: BridgeResult[];
+}
+export interface ModelBridgeClients {
+    ollama: Pick<OllamaClient, "chat" | "abort">;
+    openai: Pick<OpenAICompatibleClient, "chat" | "abort">;
+}
+export interface ModelBridgeRunOptions {
+    task: string;
+    role: string;
+    workspace: string;
+    tier?: AceContextTier;
+    numCtx?: number;
+    maxTurns: number;
+    provider: string;
+    model: string;
+    toolScope?: string[];
+    parentBridge?: string;
+    onToolCall?: (tool: string, args: Record<string, unknown>) => void;
+    onToolResult?: (tool: string, result: BridgeToolResult) => void;
+    onOutput?: (text: string) => void;
+    onThinking?: (text: string) => void;
+}
+export declare class ModelBridge {
+    private clients;
+    private activeProviderClient;
+    private bridgeId;
+    private currentRunChildResults;
+    constructor(clients: ModelBridgeClients);
+    interrupt(): void;
+    spawn(options: ModelBridgeRunOptions): Promise<BridgeResult>;
+    private selectToolScope;
+    run(options: ModelBridgeRunOptions): Promise<BridgeResult>;
+}
+//# sourceMappingURL=model-bridge.d.ts.map