multiarena 0.1.0 → 0.1.3

package/dist/core/deliberation.js

@@ -0,0 +1,356 @@
+import { runTurn } from "./turn.js";
+import { ToolRegistry } from "../tools/registry.js";
+import { PermissionManager } from "../tools/permission.js";
+const ROLE_LABELS = {
+    draft: "起草",
+    revise: "修订",
+    polish: "润色",
+    review: "终审",
+};
+function buildSystemPrompt(role, task, isFinalRound, constraint, previousDocument, draftAuthor) {
+    const constraintBlock = constraint
+        ? `\n\n## 约束文档（必须遵守）\n${constraint}`
+        : "";
+    const header = "你正在参与一个多模型协作起草流程（R2D2：轮转审议起草）。";
+    switch (role) {
+        case "draft":
+            return `${header}你的角色是**起草者**。
+
+## 任务
+${task}
+${constraintBlock}
+
+## 要求
+- 写出一份完整的初稿
+- 严格对照约束文档，确保无违规
+- 覆盖任务描述中的所有要点
+- 后续其他模型会在你的基础上修改，请尽量全面
+- 输出完整的文档内容`;
+        case "revise": {
+            const finalRoundBlock = isFinalRound
+                ? `\n## 重要：这是最后一轮
+你是最终输出者。请输出一份面向用户的干净终稿：
+- 直接在你的修订版正文中完成所有修改，不要使用 [修订:] 标注
+- 如果之前文档中有 [修订:] 或 [补充:] 标注，将它们全部清理掉，只保留修改后的干净正文
+- 文档读起来应该像一篇自然的成品，没有任何过程标记`
+                : "";
+            return `${header}你的角色是**修订者**。
+${finalRoundBlock}
+## 原始任务
+${task}
+${constraintBlock}
+
+## ${draftAuthor ?? "起草者"} 的初稿
+${previousDocument}
+
+## 要求
+- 在初稿基础上修订，不要推倒重写
+- 对照约束文档，逐条检查违规项并修正
+- 补充你发现遗漏的要点
+- 改进表达不清或逻辑不严谨的地方
+${isFinalRound
+                ? "- 输出完整的干净终稿，不要包含任何过程标注"
+                : "- 在修改处用 [修订: 原文片段 → 修改后文本] 标注\n- 禁止笼统赞美，只做实质性修改\n- 输出完整的修订版文档"}`;
+        }
+        case "polish": {
+            const finalRoundBlock = isFinalRound
+                ? `\n## 重要：这是最后一轮
+你是最终输出者。请输出一份面向用户的干净终稿：
+- 如果之前文档中有 [修订:] 或 [补充:] 标注，将它们全部清理掉，只保留修改后的干净正文
+- 你新增的改进直接写入正文，不要使用 [补充:] 标注
+- 文档读起来应该像一篇自然的成品，没有任何过程标记`
+                : "";
+            return `${header}你的角色是**润色者**。
+${finalRoundBlock}
+## 原始任务
+${task}
+${constraintBlock}
+
+## 经过修订的文档
+${previousDocument}
+
+## 要求
+- 在现有基础上最终润色
+- 再次对照约束文档做合规检查
+- 优化语言流畅度和可读性
+${isFinalRound
+                ? "- 输出完整的干净终稿，不要包含任何过程标注"
+                : "- 补充你独有的见解（标注 [补充: 你的贡献]）\n- 保留所有之前的修订标注\n- 输出完整的文档"}`;
+        }
+        case "review":
+            return `${header}你的角色是**终审者**（最后一轮）。
+
+## 原始任务
+${task}
+${constraintBlock}
+
+## 经过多轮修改的文档
+${previousDocument}
+
+## 要求
+- 审查是否有修改偏离了原意
+- 对照约束文档逐条再过一遍
+- 清理所有 [修订:] 和 [补充:] 等过程标注，输出干净的最终版
+- 如果认可某处修改，直接保留正文；如果需要回退，直接改回并保持正文流畅
+- 这是一份面向用户的交付文档，不要包含任何过程标记或审查意见
+- 输出最终确认版`;
+        default:
+            return "";
+    }
+}
+/**
+ * Run the R2D2 (Round-Robin Deliberative Drafting) pipeline.
+ *
+ * Models take turns in sequence: the first drafts, the second revises,
+ * the third polishes, and optionally a fourth reviews. Each round's
+ * system prompt injects the task, constraint document, and previous
+ * round output for context. No central synthesizer — the document
+ * emerges through sequential refinement.
+ */
+export async function* runDeliberation(task, roundConfigs, constraint, worktreePath) {
+    const documents = [];
+    const totalRounds = roundConfigs.length;
+    for (let i = 0; i < roundConfigs.length; i++) {
+        const rc = roundConfigs[i];
+        const previousDocument = i > 0 ? documents[i - 1] : undefined;
+        const draftAuthor = i > 0 ? roundConfigs[0].modelName : undefined;
+        const systemPrompt = buildSystemPrompt(rc.role, task, i === roundConfigs.length - 1, constraint, previousDocument, draftAuthor);
+        yield {
+            type: "round_start",
+            round: i + 1,
+            totalRounds,
+            modelName: rc.modelName,
+            role: rc.role,
+        };
+        const messages = [
+            {
+                role: "user",
+                content: rc.role === "draft"
+                    ? `请起草以下文档：\n\n${task}`
+                    : "请根据你的角色要求和上述文档内容，输出修改后的完整文档。不要输出任何前言或后记，直接输出文档内容。",
+            },
+        ];
+        let buffer = "";
+        try {
+            const stream = runTurn({
+                modelName: rc.modelName,
+                config: rc.config,
+                messages,
+                systemPrompt,
+                tools: [],
+                registry: new ToolRegistry(),
+                permission: new PermissionManager(),
+                worktreePath: worktreePath ?? process.cwd(),
+            });
+            for await (const event of stream) {
+                if (event.type === "text") {
+                    buffer += event.content;
+                    yield {
+                        type: "text",
+                        round: i + 1,
+                        totalRounds,
+                        modelName: rc.modelName,
+                        role: rc.role,
+                        content: event.content,
+                    };
+                }
+                else if (event.type === "error") {
+                    buffer += `\n[错误: ${event.message}]`;
+                    yield {
+                        type: "text",
+                        round: i + 1,
+                        totalRounds,
+                        modelName: rc.modelName,
+                        role: rc.role,
+                        content: `\n[错误: ${event.message}]`,
+                    };
+                    break;
+                }
+            }
+        }
+        catch (err) {
+            yield {
+                type: "error",
+                round: i + 1,
+                totalRounds,
+                modelName: rc.modelName,
+                role: rc.role,
+                error: err.message,
+            };
+            return;
+        }
+        documents.push(buffer);
+        // Extract revision annotations for the process summary
+        const revisionMatches = buffer.match(/\[修订:\s*([^\]]+?)\]/g) ?? [];
+        const changeSamples = revisionMatches
+            .map((m) => m.replace(/^\[修订:\s*/, "").replace(/\]$/, ""))
+            .slice(0, 5);
+        yield {
+            type: "round_end",
+            round: i + 1,
+            totalRounds,
+            modelName: rc.modelName,
+            role: rc.role,
+            document: buffer,
+            changeCount: revisionMatches.length,
+            changeSamples: changeSamples.length > 0 ? changeSamples : undefined,
+        };
+        // Yield to the event loop so React renders the round's output
+        // before the next round_start event arrives, preventing batch
+        // collapse between round_end and round_start.
+        if (i < roundConfigs.length - 1) {
+            await new Promise((resolve) => setTimeout(resolve, 0));
+        }
+    }
+    yield {
+        type: "done",
+        round: totalRounds,
+        totalRounds,
+        document: documents[documents.length - 1],
+    };
+}
+/** Build round configs with mirror pattern: A→B→C→B→A. */
+export function autoAssignRounds(modelNames, models) {
+    const active = modelNames.filter((n) => models[n]);
+    if (active.length < 2)
+        return [];
+    const forwardRoles = ["draft", "revise", "polish"];
+    if (active.length >= 4)
+        forwardRoles.push("review");
+    // Forward pass: assign roles to first N models
+    const result = [];
+    const fwdCount = Math.min(active.length, forwardRoles.length);
+    for (let i = 0; i < fwdCount; i++) {
+        result.push({
+            modelName: active[i],
+            role: forwardRoles[i],
+            config: models[active[i]],
+        });
+    }
+    // Reverse pass: middle models revise again, first model reviews
+    if (active.length >= 2) {
+        // Middle models in reverse (skip first and last of forward pass)
+        for (let i = fwdCount - 2; i >= 1; i--) {
+            result.push({
+                modelName: active[i],
+                role: "revise",
+                config: models[active[i]],
+            });
+        }
+        // First model does final review
+        result.push({
+            modelName: active[0],
+            role: "review",
+            config: models[active[0]],
+        });
+    }
+    return result;
+}
+/** Human-readable label for a round role. */
+export function roundLabel(role) {
+    return ROLE_LABELS[role];
+}
+/**
+ * Synthesize existing model outputs into one final document.
+ * Single-turn: one model acts as the merger, combining all outputs
+ * into a coherent document with source annotations and conflict notes.
+ */
+export async function* runMerge(task, outputs, mergerConfig, mergerName) {
+    const outputBlock = outputs
+        .map((o) => `### ${o.modelName}\n\n${o.content}`)
+        .join("\n\n---\n\n");
+    const systemPrompt = `你正在执行多模型输出的合并合成任务。
+
+## 原始任务
+${task}
+
+## 各模型的输出
+${outputBlock}
+
+## 合并要求
+
+1. **识别共识** — 找出所有模型中一致或高度相似的论点、事实、建议，合并后作为 [共识] 部分
+2. **保留独有贡献** — 每个模型独有的观点、细节、角度，标注 [来源: 模型名]
+3. **标注分歧** — 如果模型之间对某个问题有不同意见，客观列出各方观点，标注 [分歧]
+4. **去重合并** — 相似内容合并而不是重复
+5. **保持完整** — 不要遗漏任何模型的任何实质内容
+6. **语言流畅** — 最终输出应读起来像一篇连贯的文档，而不是拼凑
+
+## 输出格式
+直接输出合并后的完整文档。每个段落/章节末尾用 [] 标注来源。
+禁止输出前言或后记。`;
+    yield {
+        type: "round_start",
+        round: 1,
+        totalRounds: 1,
+        modelName: mergerName,
+        role: "draft",
+    };
+    const messages = [
+        { role: "user", content: "请根据各模型的输出，合并生成一份最终文档。" },
+    ];
+    let buffer = "";
+    try {
+        const stream = runTurn({
+            modelName: mergerName,
+            config: mergerConfig,
+            messages,
+            systemPrompt,
+            tools: [],
+            registry: new ToolRegistry(),
+            permission: new PermissionManager(),
+            worktreePath: process.cwd(),
+        });
+        for await (const event of stream) {
+            if (event.type === "text") {
+                buffer += event.content;
+                yield {
+                    type: "text",
+                    round: 1,
+                    totalRounds: 1,
+                    modelName: mergerName,
+                    role: "draft",
+                    content: event.content,
+                };
+            }
+            else if (event.type === "error") {
+                buffer += `\n[错误: ${event.message}]`;
+                yield {
+                    type: "text",
+                    round: 1,
+                    totalRounds: 1,
+                    modelName: mergerName,
+                    role: "draft",
+                    content: `\n[错误: ${event.message}]`,
+                };
+                break;
+            }
+        }
+    }
+    catch (err) {
+        yield {
+            type: "error",
+            round: 1,
+            totalRounds: 1,
+            modelName: mergerName,
+            error: err.message,
+        };
+        return;
+    }
+    yield {
+        type: "round_end",
+        round: 1,
+        totalRounds: 1,
+        modelName: mergerName,
+        role: "draft",
+        document: buffer,
+    };
+    // Yield to the event loop so the UI renders before "done"
+    await new Promise((resolve) => setTimeout(resolve, 0));
+    yield {
+        type: "done",
+        round: 1,
+        totalRounds: 1,
+        document: buffer,
+    };
+}

package/dist/core/session.d.ts

@@ -28,7 +28,8 @@ export declare class Session {
     addAssistantMessage(modelName: string, content: string): void;
     /** Append tool result to a model's history */
     addToolResult(modelName: string, toolCallId: string, result: string): void;
-    /** Cycle Tab through targets: broadcast → model1 → model2 → ... → broadcast */
+    setTarget(target: TargetMode): void;
+    /** Cycle Tab through unmuted targets: broadcast → model1 → model2 → ... → broadcast */
     cycleTarget(): TargetMode;
     jumpToModel(modelName: string): void;
     jumpToBroadcast(): void;
@@ -38,3 +39,4 @@ export declare class Session {
     toJSON(): SessionSnapshot;
     private findModel;
 }
+export declare function contextLimitForModel(provider: string, explicit?: number): number;

package/dist/core/session.js

@@ -23,7 +23,7 @@ export class Session {
                     buffer: "",
                     isStreaming: false,
                     usage: { input: 0, output: 0 },
-                    contextLimit: contextLimitForModel(mc?.model ?? "", mc?.context_limit),
+                    contextLimit: contextLimitForModel(mc?.provider ?? "", mc?.context_limit),
                 };
             });
             this.state = {
@@ -71,18 +71,22 @@ export class Session {
             m.messages.push({ role: "tool", content: result, tool_call_id: toolCallId });
         }
     }
-    /** Cycle Tab through targets: broadcast → model1 → model2 → ... → broadcast */
+    setTarget(target) {
+        this.state.targetMode = target;
+    }
+    /** Cycle Tab through unmuted targets: broadcast → model1 → model2 → ... → broadcast */
     cycleTarget() {
         const current = this.state.targetMode;
+        const unmuted = this.state.models.filter((m) => !m.muted);
         if (current.type === "broadcast") {
-            const first = this.state.models[0];
+            const first = unmuted[0];
             this.state.targetMode = first
                 ? { type: "directed", modelName: first.name }
                 : current;
         }
         else {
-            const idx = this.state.models.findIndex((m) => m.name === current.modelName);
-            const next = this.state.models[idx + 1];
+            const idx = unmuted.findIndex((m) => m.name === current.modelName);
+            const next = unmuted[idx + 1];
             this.state.targetMode = next
                 ? { type: "directed", modelName: next.name }
                 : { type: "broadcast" };
@@ -138,18 +142,17 @@ export class Session {
         return this.state.models.find((m) => m.name === name);
     }
 }
-function contextLimitForModel(model, explicit) {
+export function contextLimitForModel(provider, explicit) {
     if (explicit && explicit > 0)
         return explicit;
-    if (model.includes("claude"))
-        return 200000;
-    if (model.includes("gpt-4"))
-        return 128000;
-    if (model.includes("gpt-3.5"))
-        return 16384;
-    if (model.includes("gemini"))
-        return 1048576;
-    if (model.includes("deepseek"))
-        return 128000;
-    return 128000;
+    // Sensible defaults per provider. Users can override with context_limit in config.
+    switch (provider) {
+        case "anthropic": return 200000;
+        case "openai": return 128000;
+        case "google": return 1048576;
+        case "deepseek": return 1048576;
+        case "minimax": return 1048576;
+        case "ollama": return 128000;
+        default: return 128000;
+    }
 }

package/dist/core/turn.d.ts

@@ -29,3 +29,5 @@ export interface TurnResult {
  * have been pushed into ctx.messages — the caller only needs to persist.
  */
 export declare function runTurn(ctx: TurnContext): AsyncGenerator<StreamEvent>;
+/** Turn a tool name + args into a human-readable action label. */
+export declare function friendlyToolLabel(name: string, args: Record<string, unknown>): string;

package/dist/core/turn.js

@@ -65,15 +65,19 @@ export async function* runTurn(ctx) {
             });
             // Execute tools and feed results back
             for (const tc of pendingToolCalls) {
-                const toolLabel = `\n[Tool: ${tc.name}]\n`;
-                allText.push(toolLabel);
-                yield { type: "text", content: toolLabel };
+                if (!tc.name || tc.name.trim() === "") {
+                    const errMsg = "Tool call with empty name — skipped";
+                    ctx.messages.push({ role: "tool", content: errMsg, tool_call_id: tc.id });
+                    allText.push(errMsg + "\n");
+                    yield { type: "text", content: errMsg + "\n" };
+                    continue;
+                }
                 let args;
                 try {
-                    args = JSON.parse(tc.arguments);
+                    args = JSON.parse(tc.arguments || "{}");
                 }
                 catch {
-                    const errMsg = `Failed to parse tool arguments: ${tc.arguments}`;
+                    const errMsg = `Failed to parse tool arguments: ${tc.arguments || "(empty)"}`;
                     ctx.messages.push({ role: "tool", content: errMsg, tool_call_id: tc.id });
                     allText.push(errMsg + "\n");
                     yield { type: "text", content: errMsg + "\n" };
@@ -87,6 +91,10 @@ export async function* runTurn(ctx) {
                     yield { type: "text", content: errMsg + "\n" };
                     continue;
                 }
+                // Friendly label — shows what the model is doing in plain language
+                const label = friendlyToolLabel(tc.name, args);
+                allText.push(label);
+                yield { type: "text", content: label };
                 let result;
                 try {
                     result = await ctx.registry.execute(tc.name, args, ctx.worktreePath);
@@ -110,3 +118,22 @@ export async function* runTurn(ctx) {
         provider?.abort();
     }
 }
+/** Turn a tool name + args into a human-readable action label. */
+export function friendlyToolLabel(name, args) {
+    switch (name) {
+        case "bash":
+            return `\n$ ${args.command ?? "(no command)"}\n`;
+        case "read_file":
+            return `\nReading ${args.file_path ?? "(?)"}\n`;
+        case "write_file":
+            return `\nWriting ${args.file_path ?? "(?)"}\n`;
+        case "edit_file":
+            return `\nEditing ${args.file_path ?? "(?)"}\n`;
+        case "glob":
+            return `\nFinding ${args.pattern ?? "(?)"}\n`;
+        case "grep":
+            return `\nSearching "${args.pattern ?? "(?)"}"\n`;
+        default:
+            return `\nRunning ${name}...\n`;
+    }
+}

package/dist/index.js

@@ -1,62 +1,16 @@
 #!/usr/bin/env node
 import React from "react";
 import { render } from "ink";
-import * as fs from "node:fs";
-import * as path from "node:path";
-import { fileURLToPath } from "node:url";
 import { App } from "./ui/app.js";
 import { listSessions } from "./persistence/session.js";
-const __dirname = path.dirname(fileURLToPath(import.meta.url));
-const PKG_VERSION = (() => {
-    try {
-        const pkgPath = path.join(__dirname, "..", "package.json");
-        const pkg = JSON.parse(fs.readFileSync(pkgPath, "utf-8"));
-        return pkg.version ?? "0.1.0";
-    }
-    catch {
-        return "0.1.0";
-    }
-})();
-const HELP = `Arena — Multi-Model AI Coding Assistant
-
-Usage:
-  arena [options]
-
-Options:
-  --new              Start a new session (default)
-  --resume <id>      Resume a saved session
-  --list             List saved sessions
-  --help             Show this help
-  --version          Show version`;
-function parseArgs() {
-    const args = process.argv.slice(2);
-    if (args.includes("--help") || args.includes("-h")) {
-        return { listOnly: false, showHelp: true, showVersion: false };
-    }
-    if (args.includes("--version") || args.includes("-v")) {
-        return { listOnly: false, showHelp: false, showVersion: true };
-    }
-    const resumeIdx = args.indexOf("--resume");
-    if (resumeIdx >= 0 && args[resumeIdx + 1]) {
-        return {
-            sessionId: args[resumeIdx + 1],
-            listOnly: false,
-            showHelp: false,
-            showVersion: false,
-        };
-    }
-    if (args.includes("--list") || args.includes("--list-sessions")) {
-        return { listOnly: true, showHelp: false, showVersion: false };
-    }
-    return { listOnly: false, showHelp: false, showVersion: false };
-}
-const { sessionId, listOnly, showHelp, showVersion } = parseArgs();
+import { parseArgs, getPkgVersion, HELP } from "./cli/args.js";
+const { sessionId, listOnly, showHelp, showVersion } = parseArgs(process.argv.slice(2));
 if (showHelp) {
     console.log(HELP);
     process.exit(0);
 }
 if (showVersion) {
-    console.log(`arena v${PKG_VERSION}`);
+    console.log(`multiarena v${getPkgVersion()}`);
     process.exit(0);
 }
 if (listOnly) {

package/dist/isolation/worktree.d.ts

@@ -2,7 +2,7 @@ export declare class WorktreeManager {
     private git;
     private worktrees;
     constructor(repoPath: string);
-    /** Clean up orphaned arena branches and worktree directories from prior crashes. */
+    /** Clean up orphaned multiarena branches and worktree directories from prior crashes. */
     sweepOrphans(): Promise<number>;
     setup(taskId: string, modelNames: string[]): Promise<Map<string, string>>;
     getWorktreePath(modelName: string): string | undefined;

package/dist/isolation/worktree.js

@@ -8,7 +8,7 @@ export class WorktreeManager {
     constructor(repoPath) {
         this.git = simpleGit(repoPath);
     }
-    /** Clean up orphaned arena branches and worktree directories from prior crashes. */
+    /** Clean up orphaned multiarena branches and worktree directories from prior crashes. */
     async sweepOrphans() {
         let cleaned = 0;
         // Parse registered worktrees from `git worktree list --porcelain`
@@ -23,7 +23,7 @@ export class WorktreeManager {
                     registeredPaths.add(currentPath);
                 }
                 else if (line.startsWith("branch ") && currentPath) {
-                    // branch line looks like "branch refs/heads/arena/..."
+                    // branch line looks like "branch refs/heads/multiarena/..."
                     const ref = line.slice("branch ".length);
                     const branchName = ref.replace("refs/heads/", "");
                     registeredBranches.add(branchName);
@@ -33,10 +33,10 @@ export class WorktreeManager {
         catch {
             return cleaned;
         }
-        // Remove orphaned arena branches (branch exists but no worktree)
+        // Remove orphaned multiarena branches (branch exists but no worktree)
         const branches = await this.git.branchLocal();
         for (const branch of branches.all) {
-            if (!branch.startsWith("arena/"))
+            if (!branch.startsWith("multiarena/"))
                 continue;
             if (!registeredBranches.has(branch)) {
                 await this.git.deleteLocalBranch(branch, true).catch(() => { });
@@ -44,7 +44,7 @@ export class WorktreeManager {
             }
         }
         // Remove orphaned worktree directories (dir exists but not registered)
-        const arenaDir = path.join(os.tmpdir(), "arena-worktrees");
+        const arenaDir = path.join(os.tmpdir(), "multiarena-worktrees");
         if (fs.existsSync(arenaDir)) {
             let entries = [];
             try {
@@ -67,10 +67,10 @@ export class WorktreeManager {
         return cleaned;
     }
     async setup(taskId, modelNames) {
-        const baseName = `arena/${taskId}`;
+        const baseName = `multiarena/${taskId}`;
         for (const name of modelNames) {
             const branchName = `${baseName}-${name}`;
-            const worktreePath = path.join(os.tmpdir(), "arena-worktrees", `${taskId}-${name}`);
+            const worktreePath = path.join(os.tmpdir(), "multiarena-worktrees", `${taskId}-${name}`);
             // Ensure the parent directory exists; git worktree add creates the leaf directory
             fs.mkdirSync(path.dirname(worktreePath), { recursive: true });
             // Remove leftover directory from a previous run that wasn't cleaned up
@@ -109,7 +109,7 @@ export class WorktreeManager {
                 fs.rmSync(wtPath, { recursive: true, force: true });
             }
             await this.git
-                .deleteLocalBranch(`arena/${taskId}-${modelName}`, true)
+                .deleteLocalBranch(`multiarena/${taskId}-${modelName}`, true)
                 .catch(() => { });
             this.worktrees.delete(modelName);
         }

package/dist/persistence/session.js

@@ -1,7 +1,7 @@
 import * as fs from "node:fs";
 import * as path from "node:path";
 import * as os from "node:os";
-const SESSIONS_DIR = path.join(os.homedir(), ".arena", "sessions");
+const SESSIONS_DIR = path.join(os.homedir(), ".multiarena", "sessions");
 export function saveSession(session) {
     fs.mkdirSync(SESSIONS_DIR, { recursive: true });
     const filePath = path.join(SESSIONS_DIR, `${session.id}.json`);

package/dist/provider/adapters/openai.d.ts

@@ -1,5 +1,20 @@
 import { Provider } from "../provider.js";
 import { ChatRequest, StreamEvent } from "../types.js";
+export interface ThinkFilterState {
+    inThink: boolean;
+    buf: string;
+}
+/**
+ * Filter think blocks from reasoning model output (DeepSeek-R1, MiniMax).
+ * Returns the text that should be yielded to the user, and updates state.
+ * Callers yield the returned text and replace their state with the returned state.
+ */
+export declare function filterThinkText(deltaText: string, state: ThinkFilterState): {
+    text: string;
+    state: ThinkFilterState;
+};
+/** Called when the stream ends (finish_reason = stop). Flush any buffered think content. */
+export declare function flushThinkBuf(state: ThinkFilterState): string;
 export declare class OpenAIProvider implements Provider {
     private client;
     private activeController;