@jaypie/llm 1.2.0-rc.2 → 1.2.0-rc.4

package/dist/cjs/index.cjs

@@ -338,6 +338,19 @@ var LlmResponseStatus;
     LlmResponseStatus["InProgress"] = "in_progress";
 })(LlmResponseStatus || (LlmResponseStatus = {}));
 
+//
+//
+// Types
+//
+exports.LlmStreamChunkType = void 0;
+(function (LlmStreamChunkType) {
+    LlmStreamChunkType["Done"] = "done";
+    LlmStreamChunkType["Error"] = "error";
+    LlmStreamChunkType["Text"] = "text";
+    LlmStreamChunkType["ToolCall"] = "tool_call";
+    LlmStreamChunkType["ToolResult"] = "tool_result";
+})(exports.LlmStreamChunkType || (exports.LlmStreamChunkType = {}));
+
 /**
  * Converts a string to a standardized LlmInputMessage
  * @param input - String to format
@@ -815,6 +828,90 @@ class AnthropicAdapter extends BaseProviderAdapter {
         const anthropic = client;
         return (await anthropic.messages.create(request));
     }
+    async *executeStreamRequest(client, request) {
+        const anthropic = client;
+        const streamRequest = {
+            ...request,
+            stream: true,
+        };
+        const stream = await anthropic.messages.create(streamRequest);
+        // Track current tool call being built
+        let currentToolCall = null;
+        // Track usage for final chunk
+        let inputTokens = 0;
+        let outputTokens = 0;
+        let model = streamRequest.model;
+        for await (const event of stream) {
+            if (event.type === "message_start") {
+                // Extract initial usage and model info
+                const message = event.message;
+                if (message.usage) {
+                    inputTokens = message.usage.input_tokens;
+                }
+                model = message.model;
+            }
+            else if (event.type === "content_block_start") {
+                const contentBlock = event.content_block;
+                if (contentBlock.type === "tool_use") {
+                    // Start building a tool call
+                    currentToolCall = {
+                        id: contentBlock.id,
+                        name: contentBlock.name,
+                        arguments: "",
+                    };
+                }
+            }
+            else if (event.type === "content_block_delta") {
+                const delta = event.delta;
+                if (delta.type === "text_delta") {
+                    yield {
+                        type: exports.LlmStreamChunkType.Text,
+                        content: delta.text,
+                    };
+                }
+                else if (delta.type === "input_json_delta" && currentToolCall) {
+                    // Accumulate tool call arguments
+                    currentToolCall.arguments += delta.partial_json;
+                }
+            }
+            else if (event.type === "content_block_stop") {
+                // If we were building a tool call, emit it now
+                if (currentToolCall) {
+                    yield {
+                        type: exports.LlmStreamChunkType.ToolCall,
+                        toolCall: {
+                            id: currentToolCall.id,
+                            name: currentToolCall.name,
+                            arguments: currentToolCall.arguments,
+                        },
+                    };
+                    currentToolCall = null;
+                }
+            }
+            else if (event.type === "message_delta") {
+                // Extract final usage
+                if (event.usage) {
+                    outputTokens = event.usage.output_tokens;
+                }
+            }
+            else if (event.type === "message_stop") {
+                // Emit done chunk with usage
+                yield {
+                    type: exports.LlmStreamChunkType.Done,
+                    usage: [
+                        {
+                            input: inputTokens,
+                            output: outputTokens,
+                            reasoning: 0,
+                            total: inputTokens + outputTokens,
+                            provider: this.name,
+                            model,
+                        },
+                    ],
+                };
+            }
+        }
+    }
     //
     // Response Parsing
     //
@@ -1147,6 +1244,77 @@ class GeminiAdapter extends BaseProviderAdapter {
         });
         return response;
     }
+    async *executeStreamRequest(client, request) {
+        const genAI = client;
+        const geminiRequest = request;
+        // Use generateContentStream for streaming
+        const stream = await genAI.models.generateContentStream({
+            model: geminiRequest.model,
+            contents: geminiRequest.contents,
+            config: geminiRequest.config,
+        });
+        // Track current function call being built
+        let currentFunctionCall = null;
+        // Track usage for final chunk
+        let inputTokens = 0;
+        let outputTokens = 0;
+        let reasoningTokens = 0;
+        const model = geminiRequest.model || this.defaultModel;
+        for await (const chunk of stream) {
+            // Extract text content from the chunk
+            const candidate = chunk.candidates?.[0];
+            if (candidate?.content?.parts) {
+                for (const part of candidate.content.parts) {
+                    // Handle text content (excluding thought parts)
+                    if (part.text && !part.thought) {
+                        yield {
+                            type: exports.LlmStreamChunkType.Text,
+                            content: part.text,
+                        };
+                    }
+                    // Handle function calls
+                    if (part.functionCall) {
+                        const functionCall = part.functionCall;
+                        currentFunctionCall = {
+                            id: functionCall.id || this.generateCallId(),
+                            name: functionCall.name || "",
+                            arguments: functionCall.args || {},
+                        };
+                        // Emit the function call immediately
+                        yield {
+                            type: exports.LlmStreamChunkType.ToolCall,
+                            toolCall: {
+                                id: currentFunctionCall.id,
+                                name: currentFunctionCall.name,
+                                arguments: JSON.stringify(currentFunctionCall.arguments),
+                            },
+                        };
+                        currentFunctionCall = null;
+                    }
+                }
+            }
+            // Extract usage metadata if present
+            if (chunk.usageMetadata) {
+                inputTokens = chunk.usageMetadata.promptTokenCount || 0;
+                outputTokens = chunk.usageMetadata.candidatesTokenCount || 0;
+                reasoningTokens = chunk.usageMetadata.thoughtsTokenCount || 0;
+            }
+        }
+        // Emit done chunk with final usage
+        yield {
+            type: exports.LlmStreamChunkType.Done,
+            usage: [
+                {
+                    input: inputTokens,
+                    output: outputTokens,
+                    reasoning: reasoningTokens,
+                    total: inputTokens + outputTokens,
+                    provider: this.name,
+                    model,
+                },
+            ],
+        };
+    }
     //
     // Response Parsing
     //
@@ -1612,6 +1780,95 @@ class OpenAiAdapter extends BaseProviderAdapter {
         // @ts-expect-error OpenAI SDK types don't match our request format exactly
         return await openai.responses.create(request);
     }
+    async *executeStreamRequest(client, request) {
+        const openai = client;
+        const baseRequest = request;
+        const streamRequest = {
+            ...baseRequest,
+            stream: true,
+        };
+        const stream = await openai.responses.create(streamRequest);
+        // Track current function call being built
+        let currentFunctionCall = null;
+        // Track usage for final chunk
+        let inputTokens = 0;
+        let outputTokens = 0;
+        let reasoningTokens = 0;
+        const model = baseRequest.model || this.defaultModel;
+        // Cast to async iterable - when stream: true, this is always a Stream<ResponseStreamEvent>
+        const asyncStream = stream;
+        for await (const event of asyncStream) {
+            const eventType = event.type;
+            if (eventType === "response.output_text.delta") {
+                // Text content delta
+                const delta = event.delta;
+                if (delta) {
+                    yield {
+                        type: exports.LlmStreamChunkType.Text,
+                        content: delta,
+                    };
+                }
+            }
+            else if (eventType === "response.function_call_arguments.delta") {
+                // Function call arguments delta - accumulate
+                const delta = event.delta;
+                if (delta && currentFunctionCall) {
+                    currentFunctionCall.arguments += delta;
+                }
+            }
+            else if (eventType === "response.output_item.added") {
+                // New output item - check if it's a function call
+                const item = event.item;
+                if (item?.type === "function_call") {
+                    currentFunctionCall = {
+                        id: item.id || "",
+                        callId: item.call_id || "",
+                        name: item.name || "",
+                        arguments: "",
+                    };
+                }
+            }
+            else if (eventType === "response.output_item.done") {
+                // Output item completed - emit function call if that's what we were building
+                if (currentFunctionCall) {
+                    yield {
+                        type: exports.LlmStreamChunkType.ToolCall,
+                        toolCall: {
+                            id: currentFunctionCall.callId,
+                            name: currentFunctionCall.name,
+                            arguments: currentFunctionCall.arguments,
+                        },
+                    };
+                    currentFunctionCall = null;
+                }
+            }
+            else if (eventType === "response.completed") {
+                // Response completed - extract final usage
+                const response = event.response;
+                if (response?.usage) {
+                    inputTokens = response.usage.input_tokens || 0;
+                    outputTokens = response.usage.output_tokens || 0;
+                    reasoningTokens = response.usage.output_tokens_details?.reasoning_tokens || 0;
+                }
+            }
+            else if (eventType === "response.done") {
+                // Stream done - emit final chunk with usage
+                yield {
+                    type: exports.LlmStreamChunkType.Done,
+                    usage: [
+                        {
+                            input: inputTokens,
+                            output: outputTokens,
+                            reasoning: reasoningTokens,
+                            total: inputTokens + outputTokens,
+                            provider: this.name,
+                            model,
+                        },
+                    ],
+                };
+            }
+        }
+    }
     //
     // Response Parsing
     //
@@ -1924,6 +2181,110 @@ class OpenRouterAdapter extends BaseProviderAdapter {
         });
         return response;
     }
+    async *executeStreamRequest(client, request) {
+        const openRouter = client;
+        const openRouterRequest = request;
+        // Use chat.send with stream: true for streaming responses
+        const stream = await openRouter.chat.send({
+            model: openRouterRequest.model,
+            messages: openRouterRequest.messages,
+            tools: openRouterRequest.tools,
+            toolChoice: openRouterRequest.tool_choice,
+            user: openRouterRequest.user,
+            stream: true,
+        });
+        // Track current tool call being built
+        let currentToolCall = null;
+        // Track usage for final chunk
+        let inputTokens = 0;
+        let outputTokens = 0;
+        const model = openRouterRequest.model || this.defaultModel;
+        for await (const chunk of stream) {
+            const typedChunk = chunk;
+            const choices = typedChunk.choices;
+            if (choices && choices.length > 0) {
+                const delta = choices[0].delta;
+                // Handle text content
+                if (delta?.content) {
+                    yield {
+                        type: exports.LlmStreamChunkType.Text,
+                        content: delta.content,
+                    };
+                }
+                // Handle tool calls
+                if (delta?.tool_calls && delta.tool_calls.length > 0) {
+                    for (const toolCallDelta of delta.tool_calls) {
+                        if (toolCallDelta.id) {
+                            // New tool call starting
+                            if (currentToolCall) {
+                                // Emit the previous tool call
+                                yield {
+                                    type: exports.LlmStreamChunkType.ToolCall,
+                                    toolCall: {
+                                        id: currentToolCall.id,
+                                        name: currentToolCall.name,
+                                        arguments: currentToolCall.arguments,
+                                    },
+                                };
+                            }
+                            currentToolCall = {
+                                id: toolCallDelta.id,
+                                name: toolCallDelta.function?.name || "",
+                                arguments: toolCallDelta.function?.arguments || "",
+                            };
+                        }
+                        else if (currentToolCall) {
+                            // Continuing existing tool call
+                            if (toolCallDelta.function?.name) {
+                                currentToolCall.name += toolCallDelta.function.name;
+                            }
+                            if (toolCallDelta.function?.arguments) {
+                                currentToolCall.arguments += toolCallDelta.function.arguments;
+                            }
+                        }
+                    }
+                }
+                // Check for finish reason
+                if (choices[0].finish_reason) {
+                    // Emit any pending tool call
+                    if (currentToolCall) {
+                        yield {
+                            type: exports.LlmStreamChunkType.ToolCall,
+                            toolCall: {
+                                id: currentToolCall.id,
+                                name: currentToolCall.name,
+                                arguments: currentToolCall.arguments,
+                            },
+                        };
+                        currentToolCall = null;
+                    }
+                }
+            }
+            // Extract usage if present (usually in the final chunk)
+            if (typedChunk.usage) {
+                inputTokens =
+                    typedChunk.usage.prompt_tokens || typedChunk.usage.promptTokens || 0;
+                outputTokens =
+                    typedChunk.usage.completion_tokens ||
+                        typedChunk.usage.completionTokens ||
+                        0;
+            }
+        }
+        // Emit done chunk with final usage
+        yield {
+            type: exports.LlmStreamChunkType.Done,
+            usage: [
+                {
+                    input: inputTokens,
+                    output: outputTokens,
+                    reasoning: 0,
+                    total: inputTokens + outputTokens,
+                    provider: this.name,
+                    model,
+                },
+            ],
+        };
+    }
     //
     // Response Parsing
     //
@@ -2771,7 +3132,7 @@ class RetryExecutor {
 //
 // Constants
 //
-const ERROR = {
+const ERROR$1 = {
     BAD_FUNCTION_CALL: "Bad Function Call",
 };
 //
@@ -2808,13 +3169,16 @@ class OperateLoop {
         this.client = config.client;
         this.hookRunnerInstance = config.hookRunner ?? hookRunner;
         this.inputProcessorInstance = config.inputProcessor ?? inputProcessor;
-        this.maxRetries = config.maxRetries ?? 6;
         this.retryPolicy = config.retryPolicy ?? defaultRetryPolicy;
     }
     /**
      * Execute the operate loop for multi-turn conversations with tool calling.
      */
     async execute(input, options = {}) {
+        // Log what was passed to operate
+        log$1.trace("[operate] Starting operate loop");
+        log$1.var({ "operate.input": input });
+        log$1.var({ "operate.options": options });
         // Initialize state
         const state = this.initializeState(input, options);
         const context = this.createContext(options);
@@ -2917,6 +3281,9 @@ class OperateLoop {
         });
         // Build provider-specific request
         const providerRequest = this.adapter.buildRequest(request);
+        // Log what was passed to the model
+        log$1.trace("[operate] Calling model");
+        log$1.var({ "operate.request": providerRequest });
         // Execute beforeEachModelRequest hook
         await this.hookRunnerInstance.runBeforeModelRequest(context.hooks, {
             input: state.currentInput,
@@ -2932,6 +3299,9 @@ class OperateLoop {
             },
             hooks: context.hooks,
         });
+        // Log what was returned from the model
+        log$1.trace("[operate] Model response received");
+        log$1.var({ "operate.response": response });
         // Parse response
         const parsed = this.adapter.parseResponse(response, options);
         // Track usage
@@ -3020,7 +3390,7 @@ class OperateLoop {
                         state.responseBuilder.setError({
                             detail,
                             status: jaypieError.status,
-                            title: ERROR.BAD_FUNCTION_CALL,
+                            title: ERROR$1.BAD_FUNCTION_CALL,
                         });
                         log$1.error(`Error executing function call ${toolCall.name}`);
                         log$1.var({ error });
@@ -3151,6 +3521,325 @@ function createOperateLoop(config) {
     return new OperateLoop(config);
 }
 
+//
+//
+// Constants
+//
+const ERROR = {
+    BAD_FUNCTION_CALL: "Bad Function Call",
+};
+//
+//
+// Main
+//
+/**
+ * StreamLoop implements streaming multi-turn conversation loop.
+ * It orchestrates provider adapters and tool calling while yielding
+ * stream chunks as they become available.
+ */
+class StreamLoop {
+    constructor(config) {
+        this.adapter = config.adapter;
+        this.client = config.client;
+        this.hookRunnerInstance = config.hookRunner ?? hookRunner;
+        this.inputProcessorInstance = config.inputProcessor ?? inputProcessor;
+    }
+    /**
+     * Execute the streaming loop for multi-turn conversations with tool calling.
+     * Yields stream chunks as they become available.
+     */
+    async *execute(input, options = {}) {
+        // Verify adapter supports streaming
+        if (!this.adapter.executeStreamRequest) {
+            throw new errors.BadGatewayError(`Provider ${this.adapter.name} does not support streaming`);
+        }
+        // Initialize state
+        const state = this.initializeState(input, options);
+        const context = this.createContext(options);
+        // Build initial request
+        let request = this.buildInitialRequest(state, options);
+        // Multi-turn loop
+        while (state.currentTurn < state.maxTurns) {
+            state.currentTurn++;
+            // Execute one streaming turn
+            const { shouldContinue, toolCalls } = yield* this.executeOneStreamingTurn(request, state, context, options);
+            if (!shouldContinue) {
+                break;
+            }
+            // If we have tool calls, process them
+            if (toolCalls && toolCalls.length > 0 && state.toolkit) {
+                yield* this.processToolCalls(toolCalls, state, context, options);
+                // Check if we've reached max turns
+                if (state.currentTurn >= state.maxTurns) {
+                    const error = new errors.TooManyRequestsError();
+                    const detail = `Model requested function call but exceeded ${state.maxTurns} turns`;
+                    log$1.warn(detail);
+                    yield {
+                        type: exports.LlmStreamChunkType.Error,
+                        error: {
+                            detail,
+                            status: error.status,
+                            title: error.title,
+                        },
+                    };
+                    break;
+                }
+                // Rebuild request with updated history for next turn
+                request = {
+                    format: state.formattedFormat,
+                    instructions: options.instructions,
+                    messages: state.currentInput,
+                    model: options.model ?? this.adapter.defaultModel,
+                    providerOptions: options.providerOptions,
+                    system: options.system,
+                    tools: state.formattedTools,
+                    user: options.user,
+                };
+            }
+            else {
+                break;
+            }
+        }
+        // Emit final done chunk with accumulated usage
+        yield {
+            type: exports.LlmStreamChunkType.Done,
+            usage: state.usageItems,
+        };
+    }
+    //
+    // Private Methods
+    //
+    initializeState(input, options) {
+        // Process input with placeholders
+        const processedInput = this.inputProcessorInstance.process(input, options);
+        // Determine max turns
+        const maxTurns = maxTurnsFromOptions(options);
+        // Get toolkit
+        let toolkit;
+        if (options.tools) {
+            if (options.tools instanceof Toolkit) {
+                toolkit = options.tools;
+            }
+            else if (Array.isArray(options.tools) && options.tools.length > 0) {
+                const explain = options.explain ?? false;
+                toolkit = new Toolkit(options.tools, { explain });
+            }
+        }
+        // Format output schema through adapter if provided
+        let formattedFormat;
+        if (options.format) {
+            formattedFormat = this.adapter.formatOutputSchema(options.format);
+        }
+        // Format tools through adapter
+        const formattedTools = toolkit
+            ? this.adapter.formatTools(toolkit, formattedFormat)
+            : undefined;
+        return {
+            currentInput: processedInput.history,
+            currentTurn: 0,
+            formattedFormat,
+            formattedTools,
+            maxTurns,
+            toolkit,
+            usageItems: [],
+        };
+    }
+    createContext(options) {
+        return {
+            hooks: options.hooks ?? {},
+            options,
+        };
+    }
+    buildInitialRequest(state, options) {
+        return {
+            format: state.formattedFormat,
+            instructions: options.instructions,
+            messages: state.currentInput,
+            model: options.model ?? this.adapter.defaultModel,
+            providerOptions: options.providerOptions,
+            system: options.system,
+            tools: state.formattedTools,
+            user: options.user,
+        };
+    }
+    async *executeOneStreamingTurn(request, state, context, options) {
+        // Build provider-specific request
+        const providerRequest = this.adapter.buildRequest(request);
+        // Execute beforeEachModelRequest hook
+        await this.hookRunnerInstance.runBeforeModelRequest(context.hooks, {
+            input: state.currentInput,
+            options,
+            providerRequest,
+        });
+        // Collect tool calls from the stream
+        const collectedToolCalls = [];
+        // Execute streaming request
+        const streamGenerator = this.adapter.executeStreamRequest(this.client, providerRequest);
+        for await (const chunk of streamGenerator) {
+            // Pass through text chunks
+            if (chunk.type === exports.LlmStreamChunkType.Text) {
+                yield chunk;
+            }
+            // Collect tool calls
+            if (chunk.type === exports.LlmStreamChunkType.ToolCall) {
+                collectedToolCalls.push({
+                    callId: chunk.toolCall.id,
+                    name: chunk.toolCall.name,
+                    arguments: chunk.toolCall.arguments,
+                    raw: chunk.toolCall,
+                });
+                yield chunk;
+            }
+            // Track usage from done chunk (but don't yield it yet - we'll emit our own)
+            if (chunk.type === exports.LlmStreamChunkType.Done && chunk.usage) {
+                state.usageItems.push(...chunk.usage);
+            }
+            // Pass through error chunks
+            if (chunk.type === exports.LlmStreamChunkType.Error) {
+                yield chunk;
+            }
+        }
+        // Execute afterEachModelResponse hook
+        await this.hookRunnerInstance.runAfterModelResponse(context.hooks, {
+            content: "",
+            input: state.currentInput,
+            options,
+            providerRequest,
+            providerResponse: null,
+            usage: state.usageItems,
+        });
+        // If we have tool calls and a toolkit, continue the loop
+        if (collectedToolCalls.length > 0 && state.toolkit && state.maxTurns > 1) {
+            // Add tool calls to history
+            for (const toolCall of collectedToolCalls) {
+                state.currentInput.push({
+                    type: exports.LlmMessageType.FunctionCall,
+                    name: toolCall.name,
+                    arguments: toolCall.arguments,
+                    call_id: toolCall.callId,
+                    id: toolCall.callId,
+                });
+            }
+            return { shouldContinue: true, toolCalls: collectedToolCalls };
+        }
+        return { shouldContinue: false };
+    }
+    async *processToolCalls(toolCalls, state, context, _options) {
+        for (const toolCall of toolCalls) {
+            try {
+                // Execute beforeEachTool hook
+                await this.hookRunnerInstance.runBeforeTool(context.hooks, {
+                    args: toolCall.arguments,
+                    toolName: toolCall.name,
+                });
+                // Call the tool
+                log$1.trace(`[stream] Calling tool - ${toolCall.name}`);
+                const result = await state.toolkit.call({
+                    arguments: toolCall.arguments,
+                    name: toolCall.name,
+                });
+                // Execute afterEachTool hook
+                await this.hookRunnerInstance.runAfterTool(context.hooks, {
+                    args: toolCall.arguments,
+                    result,
+                    toolName: toolCall.name,
+                });
+                // Yield tool result chunk
+                yield {
+                    type: exports.LlmStreamChunkType.ToolResult,
+                    toolResult: {
+                        id: toolCall.callId,
+                        name: toolCall.name,
+                        result,
+                    },
+                };
+                // Add tool result to history
+                state.currentInput.push({
+                    type: exports.LlmMessageType.FunctionCallOutput,
+                    output: JSON.stringify(result),
+                    call_id: toolCall.callId,
+                    name: toolCall.name,
+                });
+            }
+            catch (error) {
+                // Execute onToolError hook
+                await this.hookRunnerInstance.runOnToolError(context.hooks, {
+                    args: toolCall.arguments,
+                    error: error,
+                    toolName: toolCall.name,
+                });
+                // Yield error chunk
+                const jaypieError = new errors.BadGatewayError();
+                const detail = [
+                    `Error executing function call ${toolCall.name}.`,
+                    error.message,
+                ].join("\n");
+                yield {
+                    type: exports.LlmStreamChunkType.Error,
+                    error: {
+                        detail,
+                        status: jaypieError.status,
+                        title: ERROR.BAD_FUNCTION_CALL,
+                    },
+                };
+                log$1.error(`Error executing function call ${toolCall.name}`);
+                log$1.var({ error });
+            }
+        }
+    }
+    /**
+     * Convert Gemini contents format to internal history format.
+     */
+    convertGeminiContentsToHistory(contents) {
+        const history = [];
+        for (const content of contents) {
+            if (!content.parts)
+                continue;
+            for (const part of content.parts) {
+                if (part.text && typeof part.text === "string") {
+                    history.push({
+                        role: content.role === "model"
+                            ? exports.LlmMessageRole.Assistant
+                            : exports.LlmMessageRole.User,
+                        content: part.text,
+                        type: exports.LlmMessageType.Message,
+                    });
+                }
+                else if (part.functionCall) {
+                    const fc = part.functionCall;
+                    history.push({
+                        type: exports.LlmMessageType.FunctionCall,
+                        name: fc.name || "",
+                        arguments: JSON.stringify(fc.args || {}),
+                        call_id: fc.id || "",
+                        id: fc.id || "",
+                    });
+                }
+                else if (part.functionResponse) {
+                    const fr = part.functionResponse;
+                    history.push({
+                        type: exports.LlmMessageType.FunctionCallOutput,
+                        output: JSON.stringify(fr.response || {}),
+                        call_id: "",
+                        name: fr.name || "",
+                    });
+                }
+            }
+        }
+        return history;
+    }
+}
+//
+//
+// Factory
+//
+/**
+ * Create a StreamLoop instance with the specified configuration.
+ */
+function createStreamLoop(config) {
+    return new StreamLoop(config);
+}
+
 // SDK loader with caching
 let cachedSdk$2 = null;
 async function loadSdk$2() {
@@ -3306,6 +3995,17 @@ class AnthropicProvider {
         });
         return this._operateLoop;
     }
+    async getStreamLoop() {
+        if (this._streamLoop) {
+            return this._streamLoop;
+        }
+        const client = await this.getClient();
+        this._streamLoop = createStreamLoop({
+            adapter: anthropicAdapter,
+            client,
+        });
+        return this._streamLoop;
+    }
     // Main send method
     async send(message, options) {
         const client = await this.getClient();
@@ -3342,6 +4042,18 @@ class AnthropicProvider {
         }
         return response;
     }
+    async *stream(input, options = {}) {
+        const streamLoop = await this.getStreamLoop();
+        const mergedOptions = { ...options, model: options.model ?? this.model };
+        // Create a merged history including both the tracked history and any explicitly provided history
+        if (this.conversationHistory.length > 0) {
+            mergedOptions.history = options.history
+                ? [...this.conversationHistory, ...options.history]
+                : [...this.conversationHistory];
+        }
+        // Execute stream loop
+        yield* streamLoop.execute(input, mergedOptions);
+    }
 }
 
 // SDK loader with caching
@@ -3418,6 +4130,17 @@ class GeminiProvider {
         });
         return this._operateLoop;
     }
+    async getStreamLoop() {
+        if (this._streamLoop) {
+            return this._streamLoop;
+        }
+        const client = await this.getClient();
+        this._streamLoop = createStreamLoop({
+            adapter: geminiAdapter,
+            client,
+        });
+        return this._streamLoop;
+    }
     async send(message, options) {
         const client = await this.getClient();
         const { messages } = prepareMessages$2(message, options);
@@ -3472,6 +4195,18 @@ class GeminiProvider {
         }
         return response;
     }
+    async *stream(input, options = {}) {
+        const streamLoop = await this.getStreamLoop();
+        const mergedOptions = { ...options, model: options.model ?? this.model };
+        // Create a merged history including both the tracked history and any explicitly provided history
+        if (this.conversationHistory.length > 0) {
+            mergedOptions.history = options.history
+                ? [...this.conversationHistory, ...options.history]
+                : [...this.conversationHistory];
+        }
+        // Execute stream loop
+        yield* streamLoop.execute(input, mergedOptions);
+    }
 }
 
 // Logger
@@ -3586,6 +4321,17 @@ class OpenAiProvider {
         });
         return this._operateLoop;
     }
+    async getStreamLoop() {
+        if (this._streamLoop) {
+            return this._streamLoop;
+        }
+        const client = await this.getClient();
+        this._streamLoop = createStreamLoop({
+            adapter: openAiAdapter,
+            client,
+        });
+        return this._streamLoop;
+    }
     async send(message, options) {
         const client = await this.getClient();
         const messages = prepareMessages$1(message, options || {});
@@ -3620,6 +4366,18 @@ class OpenAiProvider {
         }
         return response;
     }
+    async *stream(input, options = {}) {
+        const streamLoop = await this.getStreamLoop();
+        const mergedOptions = { ...options, model: options.model ?? this.model };
+        // Create a merged history including both the tracked history and any explicitly provided history
+        if (this.conversationHistory.length > 0) {
+            mergedOptions.history = options.history
+                ? [...this.conversationHistory, ...options.history]
+                : [...this.conversationHistory];
+        }
+        // Execute stream loop
+        yield* streamLoop.execute(input, mergedOptions);
+    }
 }
 
 // SDK loader with caching
@@ -3710,6 +4468,17 @@ class OpenRouterProvider {
         });
         return this._operateLoop;
     }
+    async getStreamLoop() {
+        if (this._streamLoop) {
+            return this._streamLoop;
+        }
+        const client = await this.getClient();
+        this._streamLoop = createStreamLoop({
+            adapter: openRouterAdapter,
+            client,
+        });
+        return this._streamLoop;
+    }
     async send(message, options) {
         const client = await this.getClient();
         const messages = prepareMessages(message, options);
@@ -3759,6 +4528,18 @@ class OpenRouterProvider {
         }
         return response;
     }
+    async *stream(input, options = {}) {
+        const streamLoop = await this.getStreamLoop();
+        const mergedOptions = { ...options, model: options.model ?? this.model };
+        // Create a merged history including both the tracked history and any explicitly provided history
+        if (this.conversationHistory.length > 0) {
+            mergedOptions.history = options.history
+                ? [...this.conversationHistory, ...options.history]
+                : [...this.conversationHistory];
+        }
+        // Execute stream loop
+        yield* streamLoop.execute(input, mergedOptions);
+    }
 }
 
 class Llm {
@@ -3826,6 +4607,12 @@ class Llm {
         }
         return this._llm.operate(input, options);
     }
+    async *stream(input, options = {}) {
+        if (!this._llm.stream) {
+            throw new errors.NotImplementedError(`Provider ${this._provider} does not support stream method`);
+        }
+        yield* this._llm.stream(input, options);
+    }
     static async send(message, options) {
         const { llm, apiKey, model, ...messageOptions } = options || {};
         const instance = new Llm(llm, { apiKey, model });
@@ -3852,6 +4639,27 @@ class Llm {
         const instance = new Llm(finalLlm, { apiKey, model: finalModel });
         return instance.operate(input, operateOptions);
     }
+    static stream(input, options) {
+        const { llm, apiKey, model, ...streamOptions } = options || {};
+        let finalLlm = llm;
+        let finalModel = model;
+        if (!llm && model) {
+            const determined = determineModelProvider(model);
+            if (determined.provider) {
+                finalLlm = determined.provider;
+            }
+        }
+        else if (llm && model) {
+            // When both llm and model are provided, check if they conflict
+            const determined = determineModelProvider(model);
+            if (determined.provider && determined.provider !== llm) {
+                // Don't pass the conflicting model to the constructor
+                finalModel = undefined;
+            }
+        }
+        const instance = new Llm(finalLlm, { apiKey, model: finalModel });
+        return instance.stream(input, streamOptions);
+    }
 }
 
 const random = {