agentic-kit 1.0.3 → 1.3.0

package/esm/transform-messages.js

@@ -0,0 +1,139 @@
+export function transformMessages(messages, model) {
+    const toolCallIdMap = new Map();
+    const transformed = messages.flatMap((message) => {
+        if (message.role !== 'assistant') {
+            if (message.role === 'toolResult') {
+                const normalizedId = toolCallIdMap.get(message.toolCallId);
+                if (normalizedId && normalizedId !== message.toolCallId) {
+                    return [{ ...message, toolCallId: normalizedId }];
+                }
+            }
+            return [message];
+        }
+        if (message.stopReason === 'error' || message.stopReason === 'aborted') {
+            return [];
+        }
+        const sameModel = message.provider === model.provider &&
+            message.api === model.api &&
+            message.model === model.id;
+        const content = message.content.flatMap((block) => {
+            if (block.type === 'thinking') {
+                if (sameModel) {
+                    return [block];
+                }
+                if (!block.thinking.trim()) {
+                    return [];
+                }
+                const thinkingAsText = {
+                    type: 'text',
+                    text: `<thinking>${block.thinking}</thinking>`,
+                };
+                return [thinkingAsText];
+            }
+            if (block.type === 'toolCall') {
+                const normalizedId = normalizeToolCallId(block.id, model);
+                if (normalizedId !== block.id) {
+                    toolCallIdMap.set(block.id, normalizedId);
+                }
+                const toolCall = normalizedId === block.id ? block : { ...block, id: normalizedId };
+                return [toolCall];
+            }
+            return [block];
+        });
+        return [{ ...message, content }];
+    });
+    return insertSyntheticToolResults(transformed);
+}
+function insertSyntheticToolResults(messages) {
+    const result = [];
+    let pendingToolCalls = [];
+    let seenToolResults = new Set();
+    for (const message of messages) {
+        if (message.role === 'assistant') {
+            flushPendingToolCalls(result, pendingToolCalls, seenToolResults);
+            pendingToolCalls = message.content.filter((block) => block.type === 'toolCall');
+            seenToolResults = new Set();
+            result.push(message);
+            continue;
+        }
+        if (message.role === 'toolResult') {
+            seenToolResults.add(message.toolCallId);
+            result.push(message);
+            continue;
+        }
+        flushPendingToolCalls(result, pendingToolCalls, seenToolResults);
+        pendingToolCalls = [];
+        seenToolResults = new Set();
+        result.push(message);
+    }
+    flushPendingToolCalls(result, pendingToolCalls, seenToolResults);
+    return result;
+}
+function flushPendingToolCalls(result, pendingToolCalls, seenToolResults) {
+    if (pendingToolCalls.length === 0) {
+        return;
+    }
+    for (const toolCall of pendingToolCalls) {
+        if (seenToolResults.has(toolCall.id)) {
+            continue;
+        }
+        const synthetic = {
+            role: 'toolResult',
+            toolCallId: toolCall.id,
+            toolName: toolCall.name,
+            content: [{ type: 'text', text: 'No result provided.' }],
+            isError: true,
+            timestamp: Date.now(),
+        };
+        result.push(synthetic);
+    }
+}
+function normalizeToolCallId(id, model) {
+    const format = model.compat?.toolCallIdFormat ?? defaultToolCallIdFormat(model);
+    if (format === 'passthrough') {
+        return id;
+    }
+    if (format === 'mistral9') {
+        const alphanumeric = id.replace(/[^a-zA-Z0-9]/g, '');
+        if (alphanumeric.length >= 9) {
+            return alphanumeric.slice(0, 9);
+        }
+        return stableAlphanumericId(id, 9);
+    }
+    const safe = id.replace(/[^a-zA-Z0-9_-]/g, '_').slice(0, 64);
+    if (safe.length > 0) {
+        return safe;
+    }
+    return stableId(id, 24, /^[a-zA-Z0-9_-]+$/);
+}
+function defaultToolCallIdFormat(model) {
+    if (model.provider === 'anthropic' || model.api === 'anthropic-messages') {
+        return 'safe64';
+    }
+    return 'passthrough';
+}
+function stableId(input, length, pattern) {
+    let hash = 0;
+    for (let i = 0; i < input.length; i += 1) {
+        hash = (hash * 31 + input.charCodeAt(i)) >>> 0;
+    }
+    let value = `tc_${hash.toString(36)}`;
+    while (!pattern.test(value)) {
+        value = value.replace(/[^a-zA-Z0-9_-]/g, '_');
+    }
+    if (value.length >= length) {
+        return value.slice(0, length);
+    }
+    return value.padEnd(length, '0');
+}
+function stableAlphanumericId(input, length) {
+    let hash = 0;
+    for (let i = 0; i < input.length; i += 1) {
+        hash = (hash * 31 + input.charCodeAt(i)) >>> 0;
+    }
+    const value = `tc${hash.toString(36)}`.replace(/[^a-zA-Z0-9]/g, '');
+    if (value.length >= length) {
+        return value.slice(0, length);
+    }
+    return value.padEnd(length, '0');
+}

package/esm/types.js

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

package/event-stream.d.ts

@@ -0,0 +1,19 @@
+import type { AssistantMessage, AssistantMessageEvent, AssistantMessageEventStream } from './types.js';
+export declare class EventStream<TEvent, TResult = TEvent> implements AsyncIterable<TEvent> {
+    private readonly isTerminal;
+    private readonly extractResult;
+    private readonly queue;
+    private readonly waiting;
+    private done;
+    private readonly finalResultPromise;
+    private resolveFinalResult;
+    constructor(isTerminal: (event: TEvent) => boolean, extractResult: (event: TEvent) => TResult);
+    push(event: TEvent): void;
+    end(result?: TResult): void;
+    [Symbol.asyncIterator](): AsyncIterator<TEvent>;
+    result(): Promise<TResult>;
+}
+export declare class DefaultAssistantMessageEventStream extends EventStream<AssistantMessageEvent, AssistantMessage> implements AssistantMessageEventStream {
+    constructor();
+}
+export declare function createAssistantMessageEventStream(): DefaultAssistantMessageEventStream;

package/event-stream.js

@@ -0,0 +1,83 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DefaultAssistantMessageEventStream = exports.EventStream = void 0;
+exports.createAssistantMessageEventStream = createAssistantMessageEventStream;
+class EventStream {
+    isTerminal;
+    extractResult;
+    queue = [];
+    waiting = [];
+    done = false;
+    finalResultPromise;
+    resolveFinalResult;
+    constructor(isTerminal, extractResult) {
+        this.isTerminal = isTerminal;
+        this.extractResult = extractResult;
+        this.finalResultPromise = new Promise((resolve) => {
+            this.resolveFinalResult = resolve;
+        });
+    }
+    push(event) {
+        if (this.done) {
+            return;
+        }
+        if (this.isTerminal(event)) {
+            this.done = true;
+            this.resolveFinalResult(this.extractResult(event));
+        }
+        const waiter = this.waiting.shift();
+        if (waiter) {
+            waiter({ value: event, done: false });
+            return;
+        }
+        this.queue.push(event);
+    }
+    end(result) {
+        this.done = true;
+        if (result !== undefined) {
+            this.resolveFinalResult(result);
+        }
+        while (this.waiting.length > 0) {
+            this.waiting.shift()({ value: undefined, done: true });
+        }
+    }
+    async *[Symbol.asyncIterator]() {
+        while (true) {
+            if (this.queue.length > 0) {
+                yield this.queue.shift();
+                continue;
+            }
+            if (this.done) {
+                return;
+            }
+            const next = await new Promise((resolve) => {
+                this.waiting.push(resolve);
+            });
+            if (next.done) {
+                return;
+            }
+            yield next.value;
+        }
+    }
+    result() {
+        return this.finalResultPromise;
+    }
+}
+exports.EventStream = EventStream;
+class DefaultAssistantMessageEventStream extends EventStream {
+    constructor() {
+        super((event) => event.type === 'done' || event.type === 'error', (event) => {
+            if (event.type === 'done') {
+                return event.message;
+            }
+            if (event.type === 'error') {
+                return event.error;
+            }
+            throw new Error('Unexpected terminal event');
+        });
+    }
+}
+exports.DefaultAssistantMessageEventStream = DefaultAssistantMessageEventStream;
+function createAssistantMessageEventStream() {
+    return new DefaultAssistantMessageEventStream();
+}

package/index.d.ts

@@ -1,41 +1,37 @@
-import OllamaClient, { ChatMessage, GenerateInput } from '@agentic-kit/ollama';
 import { AnthropicAdapter, type AnthropicOptions } from '@agentic-kit/anthropic';
+import { OllamaAdapter, OllamaClient } from '@agentic-kit/ollama';
 import { OpenAIAdapter, type OpenAIOptions } from '@agentic-kit/openai';
-export type { ChatMessage, GenerateInput };
-export { OllamaClient };
-export { AnthropicAdapter, type AnthropicOptions };
-export { OpenAIAdapter, type OpenAIOptions };
-export interface StreamingOptions {
-    onChunk?: (chunk: string) => void;
-    onStateChange?: (state: string) => void;
-    onError?: (error: Error) => void;
-    onComplete?: () => void;
-}
-export interface AgentProvider {
-    readonly name: string;
-    generate(input: GenerateInput): Promise<string>;
-    generateStreaming(input: GenerateInput, onChunk: (chunk: string) => void): Promise<void>;
-    listModels?(): Promise<string[]>;
-}
-export declare class OllamaAdapter implements AgentProvider {
-    readonly name = "ollama";
-    private client;
-    constructor(baseUrl?: string);
-    generate(input: GenerateInput): Promise<string>;
-    generateStreaming(input: GenerateInput, onChunk: (chunk: string) => void): Promise<void>;
-    listModels(): Promise<string[]>;
-}
+import { createAssistantMessageEventStream, EventStream } from './event-stream.js';
+import { clearModels, getModel, getModels, getProviders as getModelProviders, registerModel, registerModels } from './model-registry.js';
+import { clearProviders, getProvider as getRegisteredProvider, getProviders as getRegisteredProviders, registerProvider, unregisterProviders } from './provider-registry.js';
+import type { AssistantMessage, AssistantMessageEventStream, Context, LegacyChatMessage, LegacyGenerateInput, LegacyStreamingOptions, ModelDescriptor, ProviderAdapter, StreamOptions } from './types.js';
+export * from './event-stream.js';
+export * from './messages.js';
+export * from './transform-messages.js';
+export * from './types.js';
+export { createAssistantMessageEventStream, EventStream, OllamaClient };
+export { AnthropicAdapter, OllamaAdapter, OpenAIAdapter };
+export type { AnthropicOptions, OpenAIOptions };
+export type ChatMessage = LegacyChatMessage;
+export type GenerateInput = LegacyGenerateInput;
+type NamedProviderAdapter = ProviderAdapter & {
+    name?: string;
+};
+export declare function stream(model: ModelDescriptor, context: Context, options?: StreamOptions): AssistantMessageEventStream;
+export declare function complete(model: ModelDescriptor, context: Context, options?: StreamOptions): Promise<AssistantMessage>;
+export declare function completeText(model: ModelDescriptor, context: Context, options?: StreamOptions): Promise<string>;
 export declare class AgentKit {
-    private providers;
+    private readonly providers;
     private current?;
-    addProvider(provider: AgentProvider): this;
+    addProvider(provider: NamedProviderAdapter): this;
     setProvider(name: string): this;
-    getCurrentProvider(): AgentProvider | undefined;
+    getCurrentProvider(): NamedProviderAdapter | undefined;
     listProviders(): string[];
-    generate(input: GenerateInput, options?: StreamingOptions): Promise<string | void>;
+    generate(input: LegacyGenerateInput, options?: LegacyStreamingOptions): Promise<string | void>;
     listModels(): Promise<string[]>;
 }
 export declare function createOllamaKit(baseUrl?: string): AgentKit;
 export declare function createAnthropicKit(options: AnthropicOptions | string): AgentKit;
-export declare function createOpenAIKit(options: OpenAIOptions | string): AgentKit;
+export declare function createOpenAIKit(options?: OpenAIOptions | string): AgentKit;
 export declare function createMultiProviderKit(): AgentKit;
+export { clearModels, clearProviders, getModel, getModelProviders, getModels, getRegisteredProvider as getProvider, getRegisteredProviders, registerModel, registerModels, registerProvider, unregisterProviders, };

package/index.js

@@ -1,88 +1,151 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.AgentKit = exports.OllamaAdapter = exports.OpenAIAdapter = exports.AnthropicAdapter = exports.OllamaClient = void 0;
+exports.unregisterProviders = exports.registerProvider = exports.registerModels = exports.registerModel = exports.getRegisteredProviders = exports.getProvider = exports.getModels = exports.getModelProviders = exports.getModel = exports.clearProviders = exports.clearModels = exports.AgentKit = exports.OpenAIAdapter = exports.OllamaAdapter = exports.AnthropicAdapter = exports.OllamaClient = exports.EventStream = exports.createAssistantMessageEventStream = void 0;
+exports.stream = stream;
+exports.complete = complete;
+exports.completeText = completeText;
 exports.createOllamaKit = createOllamaKit;
 exports.createAnthropicKit = createAnthropicKit;
 exports.createOpenAIKit = createOpenAIKit;
 exports.createMultiProviderKit = createMultiProviderKit;
-const ollama_1 = __importDefault(require("@agentic-kit/ollama"));
-exports.OllamaClient = ollama_1.default;
 const anthropic_1 = require("@agentic-kit/anthropic");
 Object.defineProperty(exports, "AnthropicAdapter", { enumerable: true, get: function () { return anthropic_1.AnthropicAdapter; } });
+const ollama_1 = require("@agentic-kit/ollama");
+Object.defineProperty(exports, "OllamaAdapter", { enumerable: true, get: function () { return ollama_1.OllamaAdapter; } });
+Object.defineProperty(exports, "OllamaClient", { enumerable: true, get: function () { return ollama_1.OllamaClient; } });
 const openai_1 = require("@agentic-kit/openai");
 Object.defineProperty(exports, "OpenAIAdapter", { enumerable: true, get: function () { return openai_1.OpenAIAdapter; } });
-// ─── Ollama Adapter ───────────────────────────────────────────────────────────
-class OllamaAdapter {
-    name = 'ollama';
-    client;
-    constructor(baseUrl) {
-        this.client = new ollama_1.default(baseUrl);
-    }
-    async generate(input) {
-        return this.client.generate(input);
-    }
-    async generateStreaming(input, onChunk) {
-        return this.client.generate(input, onChunk);
-    }
-    async listModels() {
-        return this.client.listModels();
+const event_stream_js_1 = require("./event-stream.js");
+Object.defineProperty(exports, "createAssistantMessageEventStream", { enumerable: true, get: function () { return event_stream_js_1.createAssistantMessageEventStream; } });
+Object.defineProperty(exports, "EventStream", { enumerable: true, get: function () { return event_stream_js_1.EventStream; } });
+const messages_js_1 = require("./messages.js");
+const model_registry_js_1 = require("./model-registry.js");
+Object.defineProperty(exports, "clearModels", { enumerable: true, get: function () { return model_registry_js_1.clearModels; } });
+Object.defineProperty(exports, "getModel", { enumerable: true, get: function () { return model_registry_js_1.getModel; } });
+Object.defineProperty(exports, "getModels", { enumerable: true, get: function () { return model_registry_js_1.getModels; } });
+Object.defineProperty(exports, "getModelProviders", { enumerable: true, get: function () { return model_registry_js_1.getProviders; } });
+Object.defineProperty(exports, "registerModel", { enumerable: true, get: function () { return model_registry_js_1.registerModel; } });
+Object.defineProperty(exports, "registerModels", { enumerable: true, get: function () { return model_registry_js_1.registerModels; } });
+const provider_registry_js_1 = require("./provider-registry.js");
+Object.defineProperty(exports, "clearProviders", { enumerable: true, get: function () { return provider_registry_js_1.clearProviders; } });
+Object.defineProperty(exports, "getProvider", { enumerable: true, get: function () { return provider_registry_js_1.getProvider; } });
+Object.defineProperty(exports, "getRegisteredProviders", { enumerable: true, get: function () { return provider_registry_js_1.getProviders; } });
+Object.defineProperty(exports, "registerProvider", { enumerable: true, get: function () { return provider_registry_js_1.registerProvider; } });
+Object.defineProperty(exports, "unregisterProviders", { enumerable: true, get: function () { return provider_registry_js_1.unregisterProviders; } });
+const transform_messages_js_1 = require("./transform-messages.js");
+__exportStar(require("./event-stream.js"), exports);
+__exportStar(require("./messages.js"), exports);
+__exportStar(require("./transform-messages.js"), exports);
+__exportStar(require("./types.js"), exports);
+(0, model_registry_js_1.registerModels)([...openai_1.OPENAI_COMPATIBLE_MODELS, ...anthropic_1.ANTHROPIC_MODELS, ...ollama_1.OLLAMA_MODELS]);
+(0, provider_registry_js_1.registerProvider)(new openai_1.OpenAIAdapter());
+(0, provider_registry_js_1.registerProvider)(new anthropic_1.AnthropicAdapter({ apiKey: '' }));
+(0, provider_registry_js_1.registerProvider)(new ollama_1.OllamaAdapter());
+function stream(model, context, options) {
+    const provider = (0, provider_registry_js_1.getProvider)(model.api);
+    if (!provider) {
+        throw new Error(`No provider registered for api '${model.api}'`);
     }
+    return streamWithProvider(provider, model, context, options);
+}
+async function complete(model, context, options) {
+    const response = stream(model, context, options);
+    return response.result();
+}
+async function completeText(model, context, options) {
+    const message = await complete(model, context, options);
+    return (0, messages_js_1.getMessageText)(message);
 }
-exports.OllamaAdapter = OllamaAdapter;
-// ─── AgentKit ─────────────────────────────────────────────────────────────────
 class AgentKit {
     providers = new Map();
     current;
     addProvider(provider) {
-        this.providers.set(provider.name, provider);
-        if (!this.current)
+        this.providers.set(getProviderName(provider), provider);
+        if (!this.current) {
             this.current = provider;
+        }
         return this;
     }
     setProvider(name) {
         const provider = this.providers.get(name);
-        if (!provider)
+        if (!provider) {
             throw new Error(`Provider '${name}' not found`);
+        }
         this.current = provider;
         return this;
     }
-    getCurrentProvider() { return this.current; }
-    listProviders() { return Array.from(this.providers.keys()); }
+    getCurrentProvider() {
+        return this.current;
+    }
+    listProviders() {
+        return Array.from(this.providers.keys());
+    }
     async generate(input, options) {
-        if (!this.current)
+        if (!this.current) {
             throw new Error('No provider set. Call addProvider() first.');
-        if (options?.onChunk) {
+        }
+        const provider = this.current;
+        const model = createLegacyModel(provider, input.model, input.maxTokens);
+        const context = legacyInputToContext(input);
+        const streamOptions = {
+            maxTokens: input.maxTokens,
+            temperature: input.temperature,
+        };
+        if (options?.onChunk || input.stream) {
+            options?.onStateChange?.('streaming');
             try {
-                await this.current.generateStreaming(input, options.onChunk);
-                options.onComplete?.();
+                const response = streamWithProvider(provider, model, context, streamOptions);
+                for await (const event of response) {
+                    if (event.type === 'text_delta') {
+                        options?.onChunk?.(event.delta);
+                    }
+                }
+                assertLegacyGenerateSucceeded(await response.result());
+                options?.onComplete?.();
             }
-            catch (err) {
-                options.onError?.(err);
-                throw err;
+            catch (error) {
+                options?.onError?.(error);
+                throw error;
             }
             return;
         }
         try {
-            const result = await this.current.generate(input);
+            const message = assertLegacyGenerateSucceeded(await completeWithProvider(provider, model, context, streamOptions));
+            options?.onStateChange?.('complete');
+            const text = (0, messages_js_1.getMessageText)(message);
             options?.onComplete?.();
-            return result;
+            return text;
         }
-        catch (err) {
-            options?.onError?.(err);
-            throw err;
+        catch (error) {
+            options?.onError?.(error);
+            throw error;
         }
     }
     async listModels() {
-        return this.current?.listModels?.() ?? [];
+        if (!this.current?.listModels) {
+            return [];
+        }
+        const models = await this.current.listModels();
+        return models.map((model) => (typeof model === 'string' ? model : model.id));
     }
 }
 exports.AgentKit = AgentKit;
-// ─── Factory helpers ──────────────────────────────────────────────────────────
 function createOllamaKit(baseUrl) {
-    return new AgentKit().addProvider(new OllamaAdapter(baseUrl));
+    return new AgentKit().addProvider(new ollama_1.OllamaAdapter(baseUrl));
 }
 function createAnthropicKit(options) {
     return new AgentKit().addProvider(new anthropic_1.AnthropicAdapter(options));
@@ -93,3 +156,70 @@ function createOpenAIKit(options) {
 function createMultiProviderKit() {
     return new AgentKit();
 }
+function legacyInputToContext(input) {
+    const messages = input.messages
+        ? input.messages
+            .filter((message) => message.role !== 'system')
+            .map((message) => message.role === 'assistant'
+            ? {
+                role: 'assistant',
+                api: 'legacy',
+                provider: 'legacy',
+                model: input.model,
+                content: [{ type: 'text', text: message.content }],
+                usage: (0, messages_js_1.createEmptyUsage)(),
+                stopReason: 'stop',
+                timestamp: Date.now(),
+            }
+            : {
+                role: 'user',
+                content: message.content,
+                timestamp: Date.now(),
+            })
+        : [{ role: 'user', content: input.prompt ?? '', timestamp: Date.now() }];
+    const systemPrompt = input.system ?? input.messages?.find((message) => message.role === 'system')?.content;
+    return {
+        systemPrompt,
+        messages,
+    };
+}
+function createLegacyModel(provider, modelId, maxTokens) {
+    if (provider.createModel) {
+        return provider.createModel(modelId, {
+            maxOutputTokens: maxTokens,
+        });
+    }
+    return {
+        id: modelId,
+        name: modelId,
+        api: provider.api,
+        provider: getProviderName(provider),
+        baseUrl: '',
+        input: ['text'],
+        reasoning: false,
+        tools: true,
+        maxOutputTokens: maxTokens,
+    };
+}
+function streamWithProvider(provider, model, context, options) {
+    const normalized = (0, messages_js_1.normalizeContext)(context);
+    const transformedContext = {
+        ...normalized,
+        messages: (0, transform_messages_js_1.transformMessages)(normalized.messages, model),
+    };
+    return provider.stream(model, transformedContext, options);
+}
+async function completeWithProvider(provider, model, context, options) {
+    const response = streamWithProvider(provider, model, context, options);
+    return response.result();
+}
+function getProviderName(provider) {
+    return provider.name ?? provider.provider;
+}
+function assertLegacyGenerateSucceeded(message) {
+    if (message.stopReason === 'error' || message.stopReason === 'aborted') {
+        throw new Error(message.errorMessage ??
+            (message.stopReason === 'aborted' ? 'Generation aborted.' : 'Generation failed.'), { cause: message });
+    }
+    return message;
+}

package/messages.d.ts

@@ -0,0 +1,33 @@
+import type { AssistantMessage, Context, ImageContent, Message, ModelDescriptor, TextContent, ToolCallContent, ToolResultMessage, Usage, UserMessage } from './types.js';
+export declare function createEmptyUsage(): Usage;
+export declare function calculateUsageCost(model: ModelDescriptor, usage: Usage): void;
+export declare function snapshotUsage(usage: Usage): Usage;
+export declare function addUsage(target: Usage, delta: Usage): Usage;
+export declare function createAssistantMessage(model: ModelDescriptor): AssistantMessage;
+export declare function createTextContent(text?: string): TextContent;
+export declare function createImageContent(data: string, mimeType: string): ImageContent;
+export declare function createToolCall(id: string, name: string): ToolCallContent;
+export declare function createUserMessage(content: UserMessage['content']): UserMessage;
+export declare function createToolResultMessage(toolCallId: string, toolName: string, content: ToolResultMessage['content'], isError?: boolean): ToolResultMessage;
+export declare function getMessageText(message: AssistantMessage): string;
+export interface InjectDeferralResultsOptions {
+    /** Text body for synthesized results. Defaults to a generic continue prompt. */
+    deferralText?: string;
+    /** Stamped onto each synthesized result's `details` field — typically `{ deferred: true }` so renderers can hide a "Done" badge. */
+    details?: unknown;
+}
+/**
+ * Synthesize toolResult messages for every toolCall that lacks both a decision
+ * and a paired toolResult. Returns input unchanged (referentially equal) when
+ * nothing needs synthesizing.
+ *
+ * Use case: user types a message instead of clicking approve/deny on a paused
+ * tool. The agent can't resume on text alone — every dangling toolCall needs
+ * a result before the next request. Compose with sendMessages to forward the
+ * conversation cleanly:
+ *
+ *   await sendMessages([...injectDeferralResults(messages), createUserMessage(text)]);
+ */
+export declare function injectDeferralResults(messages: Message[], optionsOrText?: InjectDeferralResultsOptions | string): Message[];
+export declare function cloneMessage<TMessage extends Message>(message: TMessage): TMessage;
+export declare function normalizeContext(context: Context): Context;