@mariozechner/pi-ai 0.5.27 → 0.5.28

package/dist/providers/openai-completions.js

@@ -1,32 +1,16 @@
 import OpenAI from "openai";
+import { QueuedGenerateStream } from "../generate.js";
 import { calculateCost } from "../models.js";
 import { transformMessages } from "./utils.js";
-export class OpenAICompletionsLLM {
-    client;
-    modelInfo;
-    constructor(model, apiKey) {
-        if (!apiKey) {
-            if (!process.env.OPENAI_API_KEY) {
-                throw new Error("OpenAI API key is required. Set OPENAI_API_KEY environment variable or pass it as an argument.");
-            }
-            apiKey = process.env.OPENAI_API_KEY;
-        }
-        this.client = new OpenAI({ apiKey, baseURL: model.baseUrl, dangerouslyAllowBrowser: true });
-        this.modelInfo = model;
-    }
-    getModel() {
-        return this.modelInfo;
-    }
-    getApi() {
-        return "openai-completions";
-    }
-    async generate(request, options) {
+export const streamOpenAICompletions = (model, context, options) => {
+    const stream = new QueuedGenerateStream();
+    (async () => {
         const output = {
             role: "assistant",
             content: [],
-            api: this.getApi(),
-            provider: this.modelInfo.provider,
-            model: this.modelInfo.id,
+            api: model.api,
+            provider: model.provider,
+            model: model.id,
             usage: {
                 input: 0,
                 output: 0,
@@ -37,40 +21,12 @@ export class OpenAICompletionsLLM {
             stopReason: "stop",
         };
         try {
-            const messages = this.convertMessages(request.messages, request.systemPrompt);
-            const params = {
-                model: this.modelInfo.id,
-                messages,
-                stream: true,
-                stream_options: { include_usage: true },
-            };
-            // Cerebras/xAI dont like the "store" field
-            if (!this.modelInfo.baseUrl?.includes("cerebras.ai") && !this.modelInfo.baseUrl?.includes("api.x.ai")) {
-                params.store = false;
-            }
-            if (options?.maxTokens) {
-                params.max_completion_tokens = options?.maxTokens;
-            }
-            if (options?.temperature !== undefined) {
-                params.temperature = options?.temperature;
-            }
-            if (request.tools) {
-                params.tools = this.convertTools(request.tools);
-            }
-            if (options?.toolChoice) {
-                params.tool_choice = options.toolChoice;
-            }
-            if (options?.reasoningEffort &&
-                this.modelInfo.reasoning &&
-                !this.modelInfo.id.toLowerCase().includes("grok")) {
-                params.reasoning_effort = options.reasoningEffort;
-            }
-            const stream = await this.client.chat.completions.create(params, {
-                signal: options?.signal,
-            });
-            options?.onEvent?.({ type: "start", model: this.modelInfo.id, provider: this.modelInfo.provider });
+            const client = createClient(model, options?.apiKey);
+            const params = buildParams(model, context, options);
+            const openaiStream = await client.chat.completions.create(params, { signal: options?.signal });
+            stream.push({ type: "start", partial: output });
             let currentBlock = null;
-            for await (const chunk of stream) {
+            for await (const chunk of openaiStream) {
                 if (chunk.usage) {
                     output.usage = {
                         input: chunk.usage.prompt_tokens || 0,
@@ -86,128 +42,158 @@ export class OpenAICompletionsLLM {
                             total: 0,
                         },
                     };
-                    calculateCost(this.modelInfo, output.usage);
+                    calculateCost(model, output.usage);
                 }
                 const choice = chunk.choices[0];
                 if (!choice)
                     continue;
-                // Capture finish reason
                 if (choice.finish_reason) {
-                    output.stopReason = this.mapStopReason(choice.finish_reason);
+                    output.stopReason = mapStopReason(choice.finish_reason);
                 }
                 if (choice.delta) {
-                    // Handle text content
                     if (choice.delta.content !== null &&
                         choice.delta.content !== undefined &&
                         choice.delta.content.length > 0) {
-                        // Check if we need to switch to text block
                         if (!currentBlock || currentBlock.type !== "text") {
-                            // Save current block if exists
                             if (currentBlock) {
                                 if (currentBlock.type === "thinking") {
-                                    options?.onEvent?.({ type: "thinking_end", content: currentBlock.thinking });
+                                    stream.push({
+                                        type: "thinking_end",
+                                        content: currentBlock.thinking,
+                                        partial: output,
+                                    });
                                 }
                                 else if (currentBlock.type === "toolCall") {
                                     currentBlock.arguments = JSON.parse(currentBlock.partialArgs || "{}");
                                     delete currentBlock.partialArgs;
-                                    options?.onEvent?.({ type: "toolCall", toolCall: currentBlock });
+                                    stream.push({
+                                        type: "toolCall",
+                                        toolCall: currentBlock,
+                                        partial: output,
+                                    });
                                 }
                             }
-                            // Start new text block
                             currentBlock = { type: "text", text: "" };
                             output.content.push(currentBlock);
-                            options?.onEvent?.({ type: "text_start" });
+                            stream.push({ type: "text_start", partial: output });
                         }
-                        // Append to text block
                         if (currentBlock.type === "text") {
                             currentBlock.text += choice.delta.content;
-                            options?.onEvent?.({
+                            stream.push({
                                 type: "text_delta",
-                                content: currentBlock.text,
                                 delta: choice.delta.content,
+                                partial: output,
                             });
                         }
                     }
-                    // Handle reasoning_content field
+                    // Some endpoints return reasoning in reasoning_content (llama.cpp)
                     if (choice.delta.reasoning_content !== null &&
                         choice.delta.reasoning_content !== undefined &&
                         choice.delta.reasoning_content.length > 0) {
-                        // Check if we need to switch to thinking block
                         if (!currentBlock || currentBlock.type !== "thinking") {
-                            // Save current block if exists
                             if (currentBlock) {
                                 if (currentBlock.type === "text") {
-                                    options?.onEvent?.({ type: "text_end", content: currentBlock.text });
+                                    stream.push({
+                                        type: "text_end",
+                                        content: currentBlock.text,
+                                        partial: output,
+                                    });
                                 }
                                 else if (currentBlock.type === "toolCall") {
                                     currentBlock.arguments = JSON.parse(currentBlock.partialArgs || "{}");
                                     delete currentBlock.partialArgs;
-                                    options?.onEvent?.({ type: "toolCall", toolCall: currentBlock });
+                                    stream.push({
+                                        type: "toolCall",
+                                        toolCall: currentBlock,
+                                        partial: output,
+                                    });
                                 }
                             }
-                            // Start new thinking block
-                            currentBlock = { type: "thinking", thinking: "", thinkingSignature: "reasoning_content" };
+                            currentBlock = {
+                                type: "thinking",
+                                thinking: "",
+                                thinkingSignature: "reasoning_content",
+                            };
                             output.content.push(currentBlock);
-                            options?.onEvent?.({ type: "thinking_start" });
+                            stream.push({ type: "thinking_start", partial: output });
                         }
-                        // Append to thinking block
                         if (currentBlock.type === "thinking") {
                             const delta = choice.delta.reasoning_content;
                             currentBlock.thinking += delta;
-                            options?.onEvent?.({ type: "thinking_delta", content: currentBlock.thinking, delta });
+                            stream.push({
+                                type: "thinking_delta",
+                                delta,
+                                partial: output,
+                            });
                         }
                     }
-                    // Handle reasoning field
+                    // Some endpoints return reasoning in reasining (ollama, xAI, ...)
                     if (choice.delta.reasoning !== null &&
                         choice.delta.reasoning !== undefined &&
                         choice.delta.reasoning.length > 0) {
-                        // Check if we need to switch to thinking block
                         if (!currentBlock || currentBlock.type !== "thinking") {
-                            // Save current block if exists
                             if (currentBlock) {
                                 if (currentBlock.type === "text") {
-                                    options?.onEvent?.({ type: "text_end", content: currentBlock.text });
+                                    stream.push({
+                                        type: "text_end",
+                                        content: currentBlock.text,
+                                        partial: output,
+                                    });
                                 }
                                 else if (currentBlock.type === "toolCall") {
                                     currentBlock.arguments = JSON.parse(currentBlock.partialArgs || "{}");
                                     delete currentBlock.partialArgs;
-                                    options?.onEvent?.({ type: "toolCall", toolCall: currentBlock });
+                                    stream.push({
+                                        type: "toolCall",
+                                        toolCall: currentBlock,
+                                        partial: output,
+                                    });
                                 }
                             }
-                            // Start new thinking block
-                            currentBlock = { type: "thinking", thinking: "", thinkingSignature: "reasoning" };
+                            currentBlock = {
+                                type: "thinking",
+                                thinking: "",
+                                thinkingSignature: "reasoning",
+                            };
                             output.content.push(currentBlock);
-                            options?.onEvent?.({ type: "thinking_start" });
+                            stream.push({ type: "thinking_start", partial: output });
                         }
-                        // Append to thinking block
                         if (currentBlock.type === "thinking") {
                             const delta = choice.delta.reasoning;
                             currentBlock.thinking += delta;
-                            options?.onEvent?.({ type: "thinking_delta", content: currentBlock.thinking, delta });
+                            stream.push({ type: "thinking_delta", delta, partial: output });
                         }
                     }
-                    // Handle tool calls
                     if (choice?.delta?.tool_calls) {
                         for (const toolCall of choice.delta.tool_calls) {
-                            // Check if we need a new tool call block
                             if (!currentBlock ||
                                 currentBlock.type !== "toolCall" ||
                                 (toolCall.id && currentBlock.id !== toolCall.id)) {
-                                // Save current block if exists
                                 if (currentBlock) {
                                     if (currentBlock.type === "text") {
-                                        options?.onEvent?.({ type: "text_end", content: currentBlock.text });
+                                        stream.push({
+                                            type: "text_end",
+                                            content: currentBlock.text,
+                                            partial: output,
+                                        });
                                     }
                                     else if (currentBlock.type === "thinking") {
-                                        options?.onEvent?.({ type: "thinking_end", content: currentBlock.thinking });
+                                        stream.push({
+                                            type: "thinking_end",
+                                            content: currentBlock.thinking,
+                                            partial: output,
+                                        });
                                     }
                                     else if (currentBlock.type === "toolCall") {
                                         currentBlock.arguments = JSON.parse(currentBlock.partialArgs || "{}");
                                         delete currentBlock.partialArgs;
-                                        options?.onEvent?.({ type: "toolCall", toolCall: currentBlock });
+                                        stream.push({
+                                            type: "toolCall",
+                                            toolCall: currentBlock,
+                                            partial: output,
+                                        });
                                     }
                                 }
-                                // Start new tool call block
                                 currentBlock = {
                                     type: "toolCall",
                                     id: toolCall.id || "",
@@ -217,7 +203,6 @@ export class OpenAICompletionsLLM {
                                 };
                                 output.content.push(currentBlock);
                             }
-                            // Accumulate tool call data
                             if (currentBlock.type === "toolCall") {
                                 if (toolCall.id)
                                     currentBlock.id = toolCall.id;
@@ -231,151 +216,198 @@ export class OpenAICompletionsLLM {
                     }
                 }
             }
-            // Save final block if exists
             if (currentBlock) {
                 if (currentBlock.type === "text") {
-                    options?.onEvent?.({ type: "text_end", content: currentBlock.text });
+                    stream.push({
+                        type: "text_end",
+                        content: currentBlock.text,
+                        partial: output,
+                    });
                 }
                 else if (currentBlock.type === "thinking") {
-                    options?.onEvent?.({ type: "thinking_end", content: currentBlock.thinking });
+                    stream.push({
+                        type: "thinking_end",
+                        content: currentBlock.thinking,
+                        partial: output,
+                    });
                 }
                 else if (currentBlock.type === "toolCall") {
                     currentBlock.arguments = JSON.parse(currentBlock.partialArgs || "{}");
                     delete currentBlock.partialArgs;
-                    options?.onEvent?.({ type: "toolCall", toolCall: currentBlock });
+                    stream.push({
+                        type: "toolCall",
+                        toolCall: currentBlock,
+                        partial: output,
+                    });
                 }
             }
             if (options?.signal?.aborted) {
                 throw new Error("Request was aborted");
             }
-            options?.onEvent?.({ type: "done", reason: output.stopReason, message: output });
+            stream.push({ type: "done", reason: output.stopReason, message: output });
+            stream.end();
             return output;
         }
         catch (error) {
-            // Update output with error information
             output.stopReason = "error";
             output.error = error instanceof Error ? error.message : String(error);
-            options?.onEvent?.({ type: "error", error: output.error });
-            return output;
+            stream.push({ type: "error", error: output.error, partial: output });
+            stream.end();
         }
-    }
-    convertMessages(messages, systemPrompt) {
-        const params = [];
-        // Transform messages for cross-provider compatibility
-        const transformedMessages = transformMessages(messages, this.modelInfo, this.getApi());
-        // Add system prompt if provided
-        if (systemPrompt) {
-            // Cerebras/xAi don't like the "developer" role
-            const useDeveloperRole = this.modelInfo.reasoning &&
-                !this.modelInfo.baseUrl?.includes("cerebras.ai") &&
-                !this.modelInfo.baseUrl?.includes("api.x.ai");
-            const role = useDeveloperRole ? "developer" : "system";
-            params.push({ role: role, content: systemPrompt });
+    })();
+    return stream;
+};
+function createClient(model, apiKey) {
+    if (!apiKey) {
+        if (!process.env.OPENAI_API_KEY) {
+            throw new Error("OpenAI API key is required. Set OPENAI_API_KEY environment variable or pass it as an argument.");
         }
-        // Convert messages
-        for (const msg of transformedMessages) {
-            if (msg.role === "user") {
-                // Handle both string and array content
-                if (typeof msg.content === "string") {
-                    params.push({
-                        role: "user",
-                        content: msg.content,
-                    });
-                }
-                else {
-                    // Convert array content to OpenAI format
-                    const content = msg.content.map((item) => {
-                        if (item.type === "text") {
-                            return {
-                                type: "text",
-                                text: item.text,
-                            };
-                        }
-                        else {
-                            // Image content - OpenAI uses data URLs
-                            return {
-                                type: "image_url",
-                                image_url: {
-                                    url: `data:${item.mimeType};base64,${item.data}`,
-                                },
-                            };
-                        }
-                    });
-                    const filteredContent = !this.modelInfo?.input.includes("image")
-                        ? content.filter((c) => c.type !== "image_url")
-                        : content;
-                    params.push({
-                        role: "user",
-                        content: filteredContent,
-                    });
-                }
+        apiKey = process.env.OPENAI_API_KEY;
+    }
+    return new OpenAI({ apiKey, baseURL: model.baseUrl, dangerouslyAllowBrowser: true });
+}
+function buildParams(model, context, options) {
+    const messages = convertMessages(model, context);
+    const params = {
+        model: model.id,
+        messages,
+        stream: true,
+        stream_options: { include_usage: true },
+    };
+    // Cerebras/xAI dont like the "store" field
+    if (!model.baseUrl.includes("cerebras.ai") && !model.baseUrl.includes("api.x.ai")) {
+        params.store = false;
+    }
+    if (options?.maxTokens) {
+        params.max_completion_tokens = options?.maxTokens;
+    }
+    if (options?.temperature !== undefined) {
+        params.temperature = options?.temperature;
+    }
+    if (context.tools) {
+        params.tools = convertTools(context.tools);
+    }
+    if (options?.toolChoice) {
+        params.tool_choice = options.toolChoice;
+    }
+    // Grok models don't like reasoning_effort
+    if (options?.reasoningEffort && model.reasoning && !model.id.toLowerCase().includes("grok")) {
+        params.reasoning_effort = options.reasoningEffort;
+    }
+    return params;
+}
+function convertMessages(model, context) {
+    const params = [];
+    const transformedMessages = transformMessages(context.messages, model);
+    if (context.systemPrompt) {
+        // Cerebras/xAi don't like the "developer" role
+        const useDeveloperRole = model.reasoning && !model.baseUrl.includes("cerebras.ai") && !model.baseUrl.includes("api.x.ai");
+        const role = useDeveloperRole ? "developer" : "system";
+        params.push({ role: role, content: context.systemPrompt });
+    }
+    for (const msg of transformedMessages) {
+        if (msg.role === "user") {
+            if (typeof msg.content === "string") {
+                params.push({
+                    role: "user",
+                    content: msg.content,
+                });
             }
-            else if (msg.role === "assistant") {
-                const assistantMsg = {
-                    role: "assistant",
-                    content: null,
-                };
-                // Build content from blocks
-                const textBlocks = msg.content.filter((b) => b.type === "text");
-                if (textBlocks.length > 0) {
-                    assistantMsg.content = textBlocks.map((b) => b.text).join("");
-                }
-                // Handle thinking blocks for llama.cpp server + gpt-oss
-                const thinkingBlocks = msg.content.filter((b) => b.type === "thinking");
-                if (thinkingBlocks.length > 0) {
-                    // Use the signature from the first thinking block if available
-                    const signature = thinkingBlocks[0].thinkingSignature;
-                    if (signature && signature.length > 0) {
-                        assistantMsg[signature] = thinkingBlocks.map((b) => b.thinking).join("");
+            else {
+                const content = msg.content.map((item) => {
+                    if (item.type === "text") {
+                        return {
+                            type: "text",
+                            text: item.text,
+                        };
                     }
-                }
-                // Handle tool calls
-                const toolCalls = msg.content.filter((b) => b.type === "toolCall");
-                if (toolCalls.length > 0) {
-                    assistantMsg.tool_calls = toolCalls.map((tc) => ({
-                        id: tc.id,
-                        type: "function",
-                        function: {
-                            name: tc.name,
-                            arguments: JSON.stringify(tc.arguments),
-                        },
-                    }));
-                }
-                params.push(assistantMsg);
-            }
-            else if (msg.role === "toolResult") {
+                    else {
+                        return {
+                            type: "image_url",
+                            image_url: {
+                                url: `data:${item.mimeType};base64,${item.data}`,
+                            },
+                        };
+                    }
+                });
+                const filteredContent = !model.input.includes("image")
+                    ? content.filter((c) => c.type !== "image_url")
+                    : content;
+                if (filteredContent.length === 0)
+                    continue;
                 params.push({
-                    role: "tool",
-                    content: msg.content,
-                    tool_call_id: msg.toolCallId,
+                    role: "user",
+                    content: filteredContent,
                 });
             }
         }
-        return params;
-    }
-    convertTools(tools) {
-        return tools.map((tool) => ({
-            type: "function",
-            function: {
-                name: tool.name,
-                description: tool.description,
-                parameters: tool.parameters,
-            },
-        }));
+        else if (msg.role === "assistant") {
+            const assistantMsg = {
+                role: "assistant",
+                content: null,
+            };
+            const textBlocks = msg.content.filter((b) => b.type === "text");
+            if (textBlocks.length > 0) {
+                assistantMsg.content = textBlocks.map((b) => b.text).join("");
+            }
+            // Handle thinking blocks for llama.cpp server + gpt-oss
+            const thinkingBlocks = msg.content.filter((b) => b.type === "thinking");
+            if (thinkingBlocks.length > 0) {
+                // Use the signature from the first thinking block if available
+                const signature = thinkingBlocks[0].thinkingSignature;
+                if (signature && signature.length > 0) {
+                    assistantMsg[signature] = thinkingBlocks.map((b) => b.thinking).join("");
+                }
+            }
+            const toolCalls = msg.content.filter((b) => b.type === "toolCall");
+            if (toolCalls.length > 0) {
+                assistantMsg.tool_calls = toolCalls.map((tc) => ({
+                    id: tc.id,
+                    type: "function",
+                    function: {
+                        name: tc.name,
+                        arguments: JSON.stringify(tc.arguments),
+                    },
+                }));
+            }
+            params.push(assistantMsg);
+        }
+        else if (msg.role === "toolResult") {
+            params.push({
+                role: "tool",
+                content: msg.content,
+                tool_call_id: msg.toolCallId,
+            });
+        }
     }
-    mapStopReason(reason) {
-        switch (reason) {
-            case "stop":
-                return "stop";
-            case "length":
-                return "length";
-            case "function_call":
-            case "tool_calls":
-                return "toolUse";
-            case "content_filter":
-                return "safety";
-            default:
-                return "stop";
+    return params;
+}
+function convertTools(tools) {
+    return tools.map((tool) => ({
+        type: "function",
+        function: {
+            name: tool.name,
+            description: tool.description,
+            parameters: tool.parameters,
+        },
+    }));
+}
+function mapStopReason(reason) {
+    if (reason === null)
+        return "stop";
+    switch (reason) {
+        case "stop":
+            return "stop";
+        case "length":
+            return "length";
+        case "function_call":
+        case "tool_calls":
+            return "toolUse";
+        case "content_filter":
+            return "safety";
+        default: {
+            const _exhaustive = reason;
+            throw new Error(`Unhandled stop reason: ${_exhaustive}`);
         }
     }
 }