c0de-agent 0.0.0 → 1.0.0

package/dist/db/schema.js

@@ -0,0 +1,112 @@
+import { sql } from 'drizzle-orm';
+import { index, integer, jsonb, pgTable, real, text, timestamp, uniqueIndex, uuid, } from 'drizzle-orm/pg-core';
+/**
+ * Projects table — git repos or plain directories tracked for agent workspaces.
+ * Identity: sha256(worktree)[:16]（git 仓库用仓库根，普通目录用绝对路径）。gitRemote 仅作
+ * 元数据，不参与 id——避免「先无 remote 注册、后加 remote」导致 id 漂移。
+ */
+export const projects = pgTable('projects', {
+    id: text('id').primaryKey(),
+    worktree: text('worktree').notNull(),
+    vcs: text('vcs'),
+    name: text('name'),
+    gitRemote: text('git_remote'),
+    createdAt: timestamp('created_at', { withTimezone: true }).notNull().defaultNow(),
+    updatedAt: timestamp('updated_at', { withTimezone: true }).notNull().defaultNow(),
+});
+/**
+ * Sessions table — conversation sessions with branching support.
+ * Root sessions have parentId = null. Forked sessions reference their parent.
+ */
+export const sessions = pgTable('sessions', {
+    id: uuid('id').primaryKey().defaultRandom(),
+    title: text('title').notNull(),
+    parentId: uuid('parent_id').references(() => sessions.id),
+    projectId: text('project_id').references(() => projects.id, {
+        onDelete: 'set null',
+    }),
+    branchPoint: integer('branch_point'),
+    metadata: jsonb('metadata').notNull().default({}),
+    agentType: text('agent_type'),
+    worktreePath: text('worktree_path'),
+    createdAt: timestamp('created_at', { withTimezone: true }).notNull().defaultNow(),
+    updatedAt: timestamp('updated_at', { withTimezone: true }).notNull().defaultNow(),
+}, (table) => [
+    index('idx_sessions_parent').on(table.parentId),
+    index('idx_sessions_project').on(table.projectId),
+]);
+/**
+ * Session entries table — unified storage for all session content types.
+ * The `tag` field discriminates: 'message' | 'tool_call' | 'tool_result' |
+ * 'compaction' | 'squash' | 'branch_summary' | 'steering' | 'file_snapshot'.
+ */
+export const sessionEntries = pgTable('session_entries', {
+    id: uuid('id').primaryKey().defaultRandom(),
+    sessionId: uuid('session_id')
+        .notNull()
+        .references(() => sessions.id, { onDelete: 'cascade' }),
+    tag: text('tag').notNull(),
+    role: text('role'),
+    content: jsonb('content').notNull(),
+    toolName: text('tool_name'),
+    tokenCount: integer('token_count').default(0),
+    createdAt: timestamp('created_at', { withTimezone: true }).notNull().defaultNow(),
+}, (table) => [index('idx_entries_session').on(table.sessionId, table.createdAt)]);
+/**
+ * Compaction archives — stores original entries that were compacted/squashed.
+ * Searchable via full-text search on `searchableText`.
+ */
+export const compactionArchives = pgTable('compaction_archives', {
+    id: uuid('id').primaryKey().defaultRandom(),
+    sessionId: uuid('session_id')
+        .notNull()
+        .references(() => sessions.id, { onDelete: 'cascade' }),
+    compactionId: uuid('compaction_id').notNull(),
+    archiveType: text('archive_type').notNull(),
+    originalEntries: jsonb('original_entries').notNull(),
+    fileSnapshots: jsonb('file_snapshots').default([]),
+    summary: text('summary').notNull(),
+    tokenCount: integer('token_count'),
+    searchableText: text('searchable_text'),
+    createdAt: timestamp('created_at', { withTimezone: true }).notNull().defaultNow(),
+}, (table) => [
+    index('idx_archives_session').on(table.sessionId),
+    // Full-text search index (GIN) for archive content search
+    sql `CREATE INDEX IF NOT EXISTS "idx_archives_search" ON "compaction_archives" USING gin(to_tsvector('english', coalesce(${table.searchableText}, '')))`,
+]);
+/**
+ * File snapshots — caches hot file content to avoid repeated read tool calls.
+ * Versioned per (session_id, file_path).
+ */
+export const fileSnapshots = pgTable('file_snapshots', {
+    id: uuid('id').primaryKey().defaultRandom(),
+    sessionId: uuid('session_id')
+        .notNull()
+        .references(() => sessions.id, { onDelete: 'cascade' }),
+    entryId: uuid('entry_id'),
+    filePath: text('file_path').notNull(),
+    content: text('content').notNull(),
+    contentHash: text('content_hash').notNull(),
+    tokenCount: integer('token_count').default(0),
+    version: integer('version').default(1),
+    createdAt: timestamp('created_at', { withTimezone: true }).notNull().defaultNow(),
+}, (table) => [
+    index('idx_snapshots_session_path').on(table.sessionId, table.filePath),
+    uniqueIndex('idx_snapshots_latest').on(table.sessionId, table.filePath, table.version),
+]);
+/**
+ * Tool metrics table — per-(model, tool, mode) success/latency stats used to
+ * auto-select the best tool mode (spec §16.5). One row per unique combination.
+ */
+export const toolMetrics = pgTable('tool_metrics', {
+    model: text('model').notNull(),
+    tool: text('tool').notNull(),
+    mode: text('mode').notNull(),
+    attempts: integer('attempts').notNull().default(0),
+    successes: integer('successes').notNull().default(0),
+    failures: integer('failures').notNull().default(0),
+    avgLatencyMs: real('avg_latency_ms').notNull().default(0),
+    lastUsed: timestamp('last_used', { withTimezone: true }).notNull().defaultNow(),
+}, (table) => [
+    uniqueIndex('uq_tool_metrics_model_tool_mode').on(table.model, table.tool, table.mode),
+]);

package/dist/db/types.d.ts

@@ -0,0 +1,11 @@
+/** Database driver selection. */
+type DBDriver = 'pglite' | 'postgres';
+/** Configuration for creating a database connection. */
+type DBConfig = {
+    driver: 'pglite';
+    dataDir?: string;
+} | {
+    driver: 'postgres';
+    connectionString: string;
+};
+export type { DBConfig, DBDriver };

package/dist/db/types.js

@@ -0,0 +1 @@
+export {};

package/dist/llm/index.d.ts

@@ -0,0 +1,13 @@
+export type { RouteConfig } from './protocols/openai-compat.js';
+export { openAICompatRoute } from './protocols/openai-compat.js';
+export type { ChatOptions, ProviderContext } from './provider.js';
+export { buildInternalRequest, chat, chatStream, toInternalMessage, toStreamChunk, } from './provider.js';
+export { isContextOverflow, isContextOverflowFailure } from './provider-error.js';
+export type { ProviderInput, Registry, ResolveResult } from './registry.js';
+export { builtinCapabilities, createRegistry, registerProvider, resolveModelByRole, resolveRoute, setRole, } from './registry.js';
+export type { Retryable, RetryOptions } from './retry.js';
+export { delay, retryable, withRetry } from './retry.js';
+export type { FallbackChain } from './routing.js';
+export { runWithFallback, shouldFallOver } from './routing.js';
+export * from './schema/index.js';
+export { estimateTokens } from './token.js';

package/dist/llm/index.js

@@ -0,0 +1,8 @@
+export { openAICompatRoute } from './protocols/openai-compat.js';
+export { buildInternalRequest, chat, chatStream, toInternalMessage, toStreamChunk, } from './provider.js';
+export { isContextOverflow, isContextOverflowFailure } from './provider-error.js';
+export { builtinCapabilities, createRegistry, registerProvider, resolveModelByRole, resolveRoute, setRole, } from './registry.js';
+export { delay, retryable, withRetry } from './retry.js';
+export { runWithFallback, shouldFallOver } from './routing.js';
+export * from './schema/index.js';
+export { estimateTokens } from './token.js';

package/dist/llm/protocols/openai-compat.d.ts

@@ -0,0 +1,139 @@
+import type { StreamEvent } from '../schema/events.js';
+import type { FinishReason } from '../schema/ids.js';
+import type { InternalRequest } from '../schema/messages.js';
+import type { RouteDefaults } from '../schema/options.js';
+import { type LifecycleState } from './utils/lifecycle.js';
+import { type ToolStreamState } from './utils/tool-stream.js';
+type OpenAIChatRole = 'system' | 'user' | 'assistant' | 'tool';
+type OpenAIContentPart = {
+    type: 'text';
+    text: string;
+} | {
+    type: 'image_url';
+    image_url: {
+        url: string;
+    };
+};
+type OpenAIMessage = {
+    role: OpenAIChatRole;
+    content: string | OpenAIContentPart[];
+    tool_call_id?: string;
+    tool_calls?: {
+        id: string;
+        type: 'function';
+        function: {
+            name: string;
+            arguments: string;
+        };
+    }[];
+};
+type OpenAITool = {
+    type: 'function';
+    function: {
+        name: string;
+        description: string;
+        parameters: Record<string, unknown>;
+    };
+};
+type OpenAIBody = {
+    model: string;
+    messages: OpenAIMessage[];
+    tools?: OpenAITool[];
+    tool_choice?: 'auto' | 'none' | 'required' | {
+        type: 'function';
+        function: {
+            name: string;
+        };
+    };
+    stream: true;
+    max_tokens?: number;
+    temperature?: number;
+    top_p?: number;
+    stream_options?: {
+        include_usage: boolean;
+    };
+};
+/** Build an OpenAI Chat Completions request body from an InternalRequest. */
+declare const bodyFrom: (request: InternalRequest) => OpenAIBody;
+type OpenAIDelta = {
+    content?: string;
+    reasoning_content?: string;
+    reasoning?: string;
+    tool_calls?: {
+        index: number;
+        id?: string;
+        function?: {
+            name?: string;
+            arguments?: string;
+        };
+    }[];
+};
+type OpenAIChoice = {
+    delta?: OpenAIDelta;
+    finish_reason?: string | null;
+};
+type OpenAIStreamChunk = {
+    choices?: OpenAIChoice[];
+    usage?: {
+        prompt_tokens?: number;
+        completion_tokens?: number;
+        total_tokens?: number;
+        prompt_tokens_details?: {
+            cached_tokens?: number;
+        };
+    };
+};
+declare const mapFinishReason: (raw: string | null | undefined) => FinishReason;
+type StepState = {
+    lifecycle: LifecycleState;
+    tools: ToolStreamState;
+    /** Finish reason seen but not yet finalized (waiting for trailing usage chunk). */
+    pendingFinish: FinishReason | null;
+};
+declare const initialStepState: () => StepState;
+/**
+ * Fold one OpenAI stream chunk into (next state, events).
+ *
+ * OpenAI sends finish_reason in the penultimate chunk and usage in a SEPARATE
+ * trailing chunk (choices: []) when stream_options.include_usage is set. So we
+ * defer finalization: on finish_reason without usage we stash the reason; the
+ * trailing usage chunk triggers the finish. `done` is only true once finalized.
+ */
+declare const step: (state: StepState, chunk: OpenAIStreamChunk) => {
+    state: StepState;
+    events: StreamEvent[];
+    done: boolean;
+};
+/** Finalize a stream that ended without a trailing usage chunk (no-op if already finished). */
+declare const finalizeStream: (state: StepState) => {
+    events: StreamEvent[];
+};
+/** Parse a raw SSE data string into an OpenAI stream chunk; throws on bad JSON. */
+declare const parseChunk: (routeId: string, raw: string) => OpenAIStreamChunk;
+type RouteConfig = {
+    id: string;
+    provider: string;
+    baseURL: string;
+    apiKey: string;
+    /** Optional extra headers (e.g. anthropic-version on compat proxies). */
+    headers?: () => Record<string, string>;
+    defaults?: RouteDefaults;
+    /** Path override; defaults to /v1/chat/completions. */
+    path?: string;
+};
+/** Build a complete route descriptor for an OpenAI-compatible provider. */
+declare const openAICompatRoute: (config: RouteConfig) => {
+    id: string;
+    provider: string;
+    protocol: "openai-compat";
+    baseURL: string;
+    path: string;
+    headers: () => Record<string, string>;
+    auth: {
+        type: "bearer";
+        apiKey: string;
+    };
+    defaults?: RouteDefaults;
+};
+export type { OpenAIBody, OpenAIChatRole, OpenAIChoice, OpenAIContentPart, OpenAIMessage, OpenAIStreamChunk, OpenAITool, RouteConfig, StepState, };
+export { bodyFrom, finalizeStream, initialStepState, mapFinishReason, openAICompatRoute, parseChunk, step, };

package/dist/llm/protocols/openai-compat.js

@@ -0,0 +1,214 @@
+import { llmError } from '../schema/errors.js';
+import { finish as lifecycleFinish, initial as lifecycleInitial, reasoningDelta, textDelta, } from './utils/lifecycle.js';
+import { appendOrStart, empty as emptyTools, finishAll, } from './utils/tool-stream.js';
+/** Merge system parts into a single system string (OpenAI Chat has one system slot). */
+const joinSystem = (request) => request.system.map((p) => p.text).join('\n\n');
+const toOpenAIContent = (part) => {
+    if (part.type === 'text')
+        return { type: 'text', text: part.text };
+    return { type: 'text', text: '' };
+};
+const messageToOpenAI = (msg) => {
+    if (msg.role === 'system') {
+        return {
+            role: 'system',
+            content: msg.content.map((p) => (p.type === 'text' ? p.text : '')).join(''),
+        };
+    }
+    if (msg.role === 'tool') {
+        const toolPart = msg.content.find((p) => p.type === 'tool-result');
+        if (toolPart && toolPart.type === 'tool-result') {
+            const text = toolPart.result.type === 'text'
+                ? String(toolPart.result.value)
+                : JSON.stringify(toolPart.result.value);
+            return { role: 'tool', content: text, tool_call_id: toolPart.id };
+        }
+        return { role: 'tool', content: '' };
+    }
+    const textParts = msg.content.filter((p) => p.type === 'text');
+    const toolCalls = msg.content.filter((p) => p.type === 'tool-call');
+    const content = msg.role === 'user'
+        ? textParts.map(toOpenAIContent)
+        : textParts.map((p) => (p.type === 'text' ? p.text : '')).join('');
+    const message = {
+        role: msg.role,
+        content,
+    };
+    if (toolCalls.length > 0) {
+        message.tool_calls = toolCalls.map((tc) => ({
+            id: tc.id,
+            type: 'function',
+            function: { name: tc.name, arguments: JSON.stringify(tc.input ?? {}) },
+        }));
+    }
+    return message;
+};
+const toolToOpenAI = (tool) => ({
+    type: 'function',
+    function: {
+        name: tool.name,
+        description: tool.description,
+        parameters: tool.inputSchema,
+    },
+});
+/** Build an OpenAI Chat Completions request body from an InternalRequest. */
+const bodyFrom = (request) => {
+    const systemText = joinSystem(request);
+    const messages = [];
+    if (systemText.length > 0) {
+        messages.push({ role: 'system', content: systemText });
+    }
+    for (const msg of request.messages) {
+        messages.push(messageToOpenAI(msg));
+    }
+    const generation = request.generation;
+    const body = {
+        model: request.model.id,
+        messages,
+        stream: true,
+        stream_options: { include_usage: true },
+    };
+    if (request.tools.length > 0) {
+        body.tools = request.tools.map(toolToOpenAI);
+        if (request.toolChoice !== undefined) {
+            body.tool_choice =
+                request.toolChoice.type === 'tool'
+                    ? { type: 'function', function: { name: request.toolChoice.name } }
+                    : request.toolChoice.type;
+        }
+    }
+    if (generation?.maxTokens !== undefined)
+        body.max_tokens = generation.maxTokens;
+    if (generation?.temperature !== undefined)
+        body.temperature = generation.temperature;
+    if (generation?.topP !== undefined)
+        body.top_p = generation.topP;
+    return body;
+};
+const mapFinishReason = (raw) => {
+    switch (raw) {
+        case 'stop':
+            return 'stop';
+        case 'length':
+            return 'length';
+        case 'tool_calls':
+        case 'function_call':
+            return 'tool-calls';
+        case 'content_filter':
+            return 'content-filter';
+        default:
+            return 'unknown';
+    }
+};
+const initialStepState = () => ({
+    lifecycle: lifecycleInitial(),
+    tools: emptyTools(),
+    pendingFinish: null,
+});
+/** Map an OpenAI usage object to the internal Usage fields. */
+const mapUsage = (raw) => ({
+    inputTokens: raw.prompt_tokens,
+    outputTokens: raw.completion_tokens,
+    cacheReadInputTokens: raw.prompt_tokens_details?.cached_tokens,
+    totalTokens: raw.total_tokens,
+    providerMetadata: { openai: raw },
+});
+/** Finalize the stream: close open blocks, emit step-finish + finish. */
+const finalize = (lifecycle, events, reason, usage) => lifecycleFinish(lifecycle, events, { reason, usage }).state;
+/**
+ * Fold one OpenAI stream chunk into (next state, events).
+ *
+ * OpenAI sends finish_reason in the penultimate chunk and usage in a SEPARATE
+ * trailing chunk (choices: []) when stream_options.include_usage is set. So we
+ * defer finalization: on finish_reason without usage we stash the reason; the
+ * trailing usage chunk triggers the finish. `done` is only true once finalized.
+ */
+const step = (state, chunk) => {
+    const events = [];
+    let lifecycle = state.lifecycle;
+    let tools = state.tools;
+    let pendingFinish = state.pendingFinish;
+    let done = false;
+    const choice = chunk.choices?.[0];
+    if (choice !== undefined && choice.delta !== undefined) {
+        const delta = choice.delta;
+        if (delta.content !== undefined && delta.content.length > 0) {
+            lifecycle = textDelta(lifecycle, events, 'text-main', delta.content).state;
+        }
+        const reasoning = delta.reasoning_content ?? delta.reasoning;
+        if (reasoning !== undefined && reasoning.length > 0) {
+            lifecycle = reasoningDelta(lifecycle, events, 'reasoning-main', reasoning).state;
+        }
+        if (delta.tool_calls !== undefined) {
+            for (const tc of delta.tool_calls) {
+                const outcome = appendOrStart(tools, {
+                    index: tc.index,
+                    id: tc.id,
+                    name: tc.function?.name,
+                    argumentsDelta: tc.function?.arguments,
+                });
+                tools = outcome.state;
+                events.push(...outcome.events);
+            }
+        }
+        // 排除空字符串：部分 provider（如 sensenova）在进行中的 chunk 发送
+        // finish_reason:"" 而非标准 null。若不排除，每个 chunk 都会触发 finishAll，
+        // 在 tool arguments 尚未累积完毕时就把 input 解析为 {}，并清空 tools 状态，
+        // 导致后续 arguments delta 全部丢失（tool 参数永远为空，工具调用全部失败）。
+        if (choice.finish_reason !== undefined &&
+            choice.finish_reason !== null &&
+            choice.finish_reason !== '') {
+            const finishTools = finishAll(tools);
+            tools = finishTools.state;
+            events.push(...finishTools.events);
+            pendingFinish = mapFinishReason(choice.finish_reason);
+            if (chunk.usage !== undefined) {
+                lifecycle = finalize(lifecycle, events, pendingFinish, mapUsage(chunk.usage));
+                done = true;
+                pendingFinish = null;
+            }
+        }
+    }
+    else if (chunk.usage !== undefined) {
+        // Trailing usage-only chunk (choices empty) — finalize with stashed reason.
+        const reason = pendingFinish ?? 'stop';
+        lifecycle = finalize(lifecycle, events, reason, mapUsage(chunk.usage));
+        done = true;
+        pendingFinish = null;
+    }
+    return { state: { lifecycle, tools, pendingFinish }, events, done };
+};
+/** Finalize a stream that ended without a trailing usage chunk (no-op if already finished). */
+const finalizeStream = (state) => {
+    if (state.pendingFinish === null)
+        return { events: [] };
+    const events = [];
+    const lifecycle = finalize(state.lifecycle, events, state.pendingFinish);
+    void lifecycle;
+    return { events };
+};
+/** Parse a raw SSE data string into an OpenAI stream chunk; throws on bad JSON. */
+const parseChunk = (routeId, raw) => {
+    try {
+        return JSON.parse(raw);
+    }
+    catch {
+        throw llmError(routeId, 'stream', {
+            _tag: 'InvalidProviderOutput',
+            message: 'Invalid OpenAI stream event',
+            raw,
+        });
+    }
+};
+/** Build a complete route descriptor for an OpenAI-compatible provider. */
+const openAICompatRoute = (config) => ({
+    id: config.id,
+    provider: config.provider,
+    protocol: 'openai-compat',
+    baseURL: config.baseURL,
+    path: config.path ?? '/v1/chat/completions',
+    headers: config.headers ?? (() => ({})),
+    auth: { type: 'bearer', apiKey: config.apiKey },
+    defaults: config.defaults,
+});
+export { bodyFrom, finalizeStream, initialStepState, mapFinishReason, openAICompatRoute, parseChunk, step, };

package/dist/llm/protocols/utils/index.d.ts

@@ -0,0 +1,2 @@
+export * from './lifecycle.js';
+export * from './tool-stream.js';

package/dist/llm/protocols/utils/index.js

@@ -0,0 +1,2 @@
+export * from './lifecycle.js';
+export * from './tool-stream.js';

package/dist/llm/protocols/utils/lifecycle.d.ts

@@ -0,0 +1,23 @@
+import type { StreamEvent, Usage } from '../../schema/events.js';
+import type { ContentBlockID, FinishReason } from '../../schema/ids.js';
+type LifecycleState = {
+    stepStarted: boolean;
+    text: Set<ContentBlockID>;
+    reasoning: Set<ContentBlockID>;
+};
+declare const initial: () => LifecycleState;
+type Result = {
+    state: LifecycleState;
+    events: StreamEvent[];
+};
+declare const textDelta: (state: LifecycleState, events: StreamEvent[], id: ContentBlockID, text: string) => Result;
+declare const reasoningDelta: (state: LifecycleState, events: StreamEvent[], id: ContentBlockID, text: string) => Result;
+declare const closeOpenBlocks: (state: LifecycleState, events: StreamEvent[]) => void;
+type FinishInput = {
+    reason: FinishReason;
+    usage?: Usage;
+};
+/** Close any open blocks, then emit a step-finish and finish event; reset stepStarted. */
+declare const finish: (state: LifecycleState, events: StreamEvent[], input: FinishInput) => Result;
+export type { FinishInput, LifecycleState, Result };
+export { closeOpenBlocks, finish, initial, reasoningDelta, textDelta };

package/dist/llm/protocols/utils/lifecycle.js

@@ -0,0 +1,46 @@
+const initial = () => ({
+    stepStarted: false,
+    text: new Set(),
+    reasoning: new Set(),
+});
+const ensureStepStart = (state, events) => {
+    if (state.stepStarted)
+        return state;
+    events.push({ type: 'step-start', index: 0 });
+    return { ...state, stepStarted: true };
+};
+const textDelta = (state, events, id, text) => {
+    const withStep = ensureStepStart(state, events);
+    if (!withStep.text.has(id)) {
+        events.push({ type: 'text-start', id });
+        withStep.text.add(id);
+    }
+    events.push({ type: 'text-delta', id, text });
+    return { state: withStep, events };
+};
+const reasoningDelta = (state, events, id, text) => {
+    const withStep = ensureStepStart(state, events);
+    if (!withStep.reasoning.has(id)) {
+        events.push({ type: 'reasoning-start', id });
+        withStep.reasoning.add(id);
+    }
+    events.push({ type: 'reasoning-delta', id, text });
+    return { state: withStep, events };
+};
+const closeOpenBlocks = (state, events) => {
+    for (const id of state.reasoning)
+        events.push({ type: 'reasoning-end', id });
+    for (const id of state.text)
+        events.push({ type: 'text-end', id });
+    state.reasoning.clear();
+    state.text.clear();
+};
+/** Close any open blocks, then emit a step-finish and finish event; reset stepStarted. */
+const finish = (state, events, input) => {
+    const withStep = ensureStepStart(state, events);
+    closeOpenBlocks(withStep, events);
+    events.push({ type: 'step-finish', index: 0, reason: input.reason, usage: input.usage });
+    events.push({ type: 'finish', reason: input.reason, usage: input.usage });
+    return { state: { ...withStep, stepStarted: false }, events };
+};
+export { closeOpenBlocks, finish, initial, reasoningDelta, textDelta };

package/dist/llm/protocols/utils/tool-stream.d.ts

@@ -0,0 +1,46 @@
+import type { StreamEvent } from '../../schema/events.js';
+import type { ToolCallID } from '../../schema/ids.js';
+type PendingTool = {
+    id: ToolCallID;
+    name: string;
+    input: string;
+    started: boolean;
+};
+type ToolStreamState = Record<number, PendingTool>;
+type DeltaInput = {
+    index: number;
+    id?: string;
+    name?: string;
+    /** Fragment of the JSON arguments string. */
+    argumentsDelta?: string;
+};
+type AppendOutcome = {
+    state: ToolStreamState;
+    events: StreamEvent[];
+};
+declare const empty: () => ToolStreamState;
+/**
+ * Append a tool-call delta. If the index is new, emit a `tool-input-start`
+ * (using the delta's id/name if present, else synthesized). Then emit a
+ * `tool-input-delta` when an argument fragment is present.
+ */
+declare const appendOrStart: (state: ToolStreamState, delta: DeltaInput) => AppendOutcome;
+type FinishedTool = {
+    id: ToolCallID;
+    name: string;
+    input: unknown;
+};
+type FinishAllOutcome = {
+    state: ToolStreamState;
+    events: StreamEvent[];
+    tools: FinishedTool[];
+};
+/** Parse a raw JSON arguments string; empty string becomes `{}`. */
+declare const parseToolInput: (raw: string) => unknown;
+/**
+ * Finalize all pending tool calls (OpenAI Chat style — no per-tool stop event).
+ * Emits `tool-input-end` + parsed `tool-call` for each, and clears state.
+ */
+declare const finishAll: (state: ToolStreamState) => FinishAllOutcome;
+export type { AppendOutcome, DeltaInput, FinishAllOutcome, FinishedTool, ToolStreamState };
+export { appendOrStart, empty, finishAll, parseToolInput };