@kjerneverk/execution-openai 1.0.7 → 1.0.8-dev.20260212012315.eb02292

package/dist/index.d.ts

@@ -41,6 +41,10 @@ declare class OpenAIProvider implements Provider {
      * Execute a request against OpenAI
      */
     execute(request: Request_2, options?: ExecutionOptions): Promise<ProviderResponse>;
+    /**
+     * Execute a request with streaming response
+     */
+    executeStream(request: Request_2, options?: ExecutionOptions): AsyncIterable<StreamChunk>;
 }
 export { OpenAIProvider }
 export default OpenAIProvider;
@@ -48,6 +52,7 @@ export default OpenAIProvider;
 export declare interface Provider {
     readonly name: string;
     execute(request: Request_2, options?: ExecutionOptions): Promise<ProviderResponse>;
+    executeStream?(request: Request_2, options?: ExecutionOptions): AsyncIterable<StreamChunk>;
     supportsModel?(model: Model): boolean;
 }
 
@@ -73,10 +78,49 @@ declare interface Request_2 {
     model: Model;
     responseFormat?: any;
     validator?: any;
+    tools?: ToolDefinition[];
     addMessage(message: Message): void;
 }
 export { Request_2 as Request }
 
+export declare interface StreamChunk {
+    type: StreamChunkType;
+    text?: string;
+    toolCall?: {
+        id?: string;
+        index?: number;
+        name?: string;
+        argumentsDelta?: string;
+    };
+    usage?: {
+        inputTokens: number;
+        outputTokens: number;
+    };
+}
+
+export declare type StreamChunkType = 'text' | 'tool_call_start' | 'tool_call_delta' | 'tool_call_end' | 'usage' | 'done';
+
+export declare interface ToolDefinition {
+    name: string;
+    description: string;
+    parameters: ToolParameterSchema;
+}
+
+export declare interface ToolParameterSchema {
+    type: 'object';
+    properties: Record<string, {
+        type: string;
+        description?: string;
+        enum?: string[];
+        items?: {
+            type: string;
+        };
+        default?: any;
+    }>;
+    required?: string[];
+    additionalProperties?: boolean;
+}
+
 /**
  * Package version
  */

package/dist/index.js

@@ -23725,19 +23725,45 @@ class OpenAIProvider {
       const client2 = new OpenAI(clientOptions);
       const model = options.model || request2.model || "gpt-4";
       const messages = request2.messages.map((msg) => {
-        const role = msg.role === "developer" ? "system" : msg.role;
-        return {
-          role,
-          content: typeof msg.content === "string" ? msg.content : JSON.stringify(msg.content),
-          name: msg.name
-        };
+        if (msg.role === "tool") {
+          return {
+            role: "tool",
+            content: typeof msg.content === "string" ? msg.content : JSON.stringify(msg.content),
+            tool_call_id: msg.tool_call_id || ""
+          };
+        } else if (msg.role === "assistant" && msg.tool_calls) {
+          return {
+            role: "assistant",
+            content: msg.content,
+            tool_calls: msg.tool_calls
+          };
+        } else {
+          const role = msg.role === "developer" ? "system" : msg.role;
+          return {
+            role,
+            content: typeof msg.content === "string" ? msg.content : JSON.stringify(msg.content),
+            name: msg.name
+          };
+        }
       });
+      let openaiTools;
+      if (request2.tools && request2.tools.length > 0) {
+        openaiTools = request2.tools.map((tool) => ({
+          type: "function",
+          function: {
+            name: tool.name,
+            description: tool.description,
+            parameters: tool.parameters
+          }
+        }));
+      }
       const response2 = await client2.chat.completions.create({
         model,
         messages,
         temperature: options.temperature,
         max_tokens: options.maxTokens,
-        response_format: request2.responseFormat
+        response_format: request2.responseFormat,
+        ...openaiTools ? { tools: openaiTools } : {}
       });
       const choice = response2.choices[0];
       return {
@@ -23760,6 +23786,129 @@ class OpenAIProvider {
       throw createSafeError(error, { provider: "openai" });
     }
   }
+  /**
+   * Execute a request with streaming response
+   */
+  async *executeStream(request2, options = {}) {
+    const apiKey = options.apiKey || process.env.OPENAI_API_KEY;
+    if (!apiKey) {
+      throw new Error("OpenAI API key is required. Set OPENAI_API_KEY environment variable.");
+    }
+    const validation = redactor.validateKey(apiKey, "openai");
+    if (!validation.valid) {
+      throw new Error("Invalid OpenAI API key format");
+    }
+    try {
+      const client2 = new OpenAI({ apiKey });
+      const model = options.model || request2.model || "gpt-4";
+      const messages = request2.messages.map((msg) => {
+        if (msg.role === "tool") {
+          return {
+            role: "tool",
+            content: typeof msg.content === "string" ? msg.content : JSON.stringify(msg.content),
+            tool_call_id: msg.tool_call_id || ""
+          };
+        } else if (msg.role === "assistant" && msg.tool_calls) {
+          return {
+            role: "assistant",
+            content: msg.content,
+            tool_calls: msg.tool_calls
+          };
+        } else {
+          const role = msg.role === "developer" ? "system" : msg.role;
+          return {
+            role,
+            content: typeof msg.content === "string" ? msg.content : JSON.stringify(msg.content),
+            name: msg.name
+          };
+        }
+      });
+      let openaiTools;
+      if (request2.tools && request2.tools.length > 0) {
+        openaiTools = request2.tools.map((tool) => ({
+          type: "function",
+          function: {
+            name: tool.name,
+            description: tool.description,
+            parameters: tool.parameters
+          }
+        }));
+      }
+      const stream = await client2.chat.completions.create({
+        model,
+        messages,
+        temperature: options.temperature,
+        max_tokens: options.maxTokens,
+        stream: true,
+        stream_options: { include_usage: true },
+        ...openaiTools ? { tools: openaiTools } : {}
+      });
+      const toolCallsInProgress = /* @__PURE__ */ new Map();
+      for await (const chunk of stream) {
+        const delta = chunk.choices[0]?.delta;
+        if (delta?.content) {
+          yield { type: "text", text: delta.content };
+        }
+        if (delta?.tool_calls) {
+          for (const tc of delta.tool_calls) {
+            const index = tc.index;
+            if (tc.id) {
+              toolCallsInProgress.set(index, {
+                id: tc.id,
+                name: tc.function?.name || "",
+                arguments: ""
+              });
+              yield {
+                type: "tool_call_start",
+                toolCall: {
+                  id: tc.id,
+                  index,
+                  name: tc.function?.name
+                }
+              };
+            }
+            if (tc.function?.arguments) {
+              const toolCall = toolCallsInProgress.get(index);
+              if (toolCall) {
+                toolCall.arguments += tc.function.arguments;
+                yield {
+                  type: "tool_call_delta",
+                  toolCall: {
+                    index,
+                    argumentsDelta: tc.function.arguments
+                  }
+                };
+              }
+            }
+          }
+        }
+        if (chunk.choices[0]?.finish_reason === "tool_calls") {
+          for (const [index, toolCall] of toolCallsInProgress) {
+            yield {
+              type: "tool_call_end",
+              toolCall: {
+                id: toolCall.id,
+                index,
+                name: toolCall.name
+              }
+            };
+          }
+        }
+        if (chunk.usage) {
+          yield {
+            type: "usage",
+            usage: {
+              inputTokens: chunk.usage.prompt_tokens,
+              outputTokens: chunk.usage.completion_tokens
+            }
+          };
+        }
+      }
+      yield { type: "done" };
+    } catch (error) {
+      throw createSafeError(error, { provider: "openai" });
+    }
+  }
 }
 function createOpenAIProvider() {
   return new OpenAIProvider();