@standardagents/openai 0.10.0-dev.ffffff

package/dist/index.js

@@ -0,0 +1,1218 @@
+// src/OpenAIProvider.ts
+import { ProviderError, defineTool } from "@standardagents/spec";
+import { z } from "zod";
+
+// src/transformers.ts
+import { mapReasoningLevel } from "@standardagents/spec";
+var DEFAULT_REASONING_LEVELS = {
+  0: null,
+  33: "low",
+  66: "medium",
+  100: "high"
+};
+var OPENAI_NATIVE_TOOLS = /* @__PURE__ */ new Set([
+  "image_generation",
+  "web_search",
+  "code_interpreter",
+  "file_search"
+]);
+function transformContentPart(part) {
+  if (part.type === "text") {
+    return { type: "input_text", text: part.text };
+  }
+  if (part.type === "image") {
+    const data = part.data || "";
+    const imageUrl = data.startsWith("data:") ? data : `data:${part.mediaType || "image/png"};base64,${data}`;
+    return {
+      type: "input_image",
+      image_url: imageUrl,
+      detail: part.detail || "auto"
+    };
+  }
+  if (part.type === "image_url") {
+    const url = part.image_url?.url || "";
+    const detail = part.image_url?.detail || "auto";
+    return {
+      type: "input_image",
+      image_url: url,
+      detail
+    };
+  }
+  const fileData = part.data || "";
+  return {
+    type: "input_file",
+    filename: part.filename,
+    file_data: fileData.startsWith("data:") ? fileData : `data:${part.mediaType || "application/octet-stream"};base64,${fileData}`
+  };
+}
+function transformMessageContent(content) {
+  if (typeof content === "string") {
+    return content;
+  }
+  return content.map(transformContentPart);
+}
+function transformUserMessage(msg) {
+  const content = transformMessageContent(msg.content);
+  return {
+    role: "user",
+    content: typeof content === "string" ? content : content
+  };
+}
+function transformAssistantMessage(msg) {
+  const items = [];
+  const hasToolCalls = msg.toolCalls && msg.toolCalls.length > 0;
+  if (msg.content || hasToolCalls) {
+    items.push({
+      type: "message",
+      role: "assistant",
+      content: msg.content ? [{ type: "output_text", text: msg.content }] : []
+      // Empty content array when only tool calls
+    });
+  }
+  if (msg.reasoning || msg.reasoningDetails) {
+    const reasoningItemsById = /* @__PURE__ */ new Map();
+    const defaultId = `rs_${crypto.randomUUID().replace(/-/g, "").slice(0, 24)}`;
+    const getOrCreateItem = (id) => {
+      let item = reasoningItemsById.get(id);
+      if (!item) {
+        item = {
+          id,
+          type: "reasoning",
+          summary: []
+        };
+        reasoningItemsById.set(id, item);
+      }
+      return item;
+    };
+    if (msg.reasoningDetails) {
+      for (const detail of msg.reasoningDetails) {
+        const itemId = detail.id || defaultId;
+        const item = getOrCreateItem(itemId);
+        if (detail.type === "encrypted" && detail.data) {
+          item.encrypted_content = detail.data;
+        } else if (detail.type === "summary" && detail.text) {
+          item.summary.push({ type: "summary_text", text: detail.text });
+        } else if (detail.type === "text" && detail.text) {
+          item.summary.push({ type: "summary_text", text: detail.text });
+        }
+      }
+    }
+    if (msg.reasoning && typeof msg.reasoning === "string") {
+      if (reasoningItemsById.size > 0) {
+        const firstItem = reasoningItemsById.values().next().value;
+        if (firstItem) {
+          firstItem.summary.unshift({ type: "summary_text", text: msg.reasoning });
+        }
+      } else {
+        const newItem = getOrCreateItem(defaultId);
+        newItem.summary = [{ type: "summary_text", text: msg.reasoning }];
+      }
+    }
+    for (const item of reasoningItemsById.values()) {
+      items.push(item);
+    }
+  }
+  if (msg.toolCalls && msg.toolCalls.length > 0) {
+    for (const tc of msg.toolCalls) {
+      if (OPENAI_NATIVE_TOOLS.has(tc.name) && tc.name !== "image_generation") {
+        continue;
+      }
+      items.push({
+        type: "function_call",
+        call_id: tc.id,
+        name: tc.name,
+        arguments: JSON.stringify(tc.arguments)
+      });
+    }
+  }
+  return items;
+}
+function transformToolMessage(msg) {
+  let output;
+  if (typeof msg.content === "string") {
+    output = msg.content;
+  } else if ("type" in msg.content) {
+    if (msg.content.type === "text") {
+      output = msg.content.text;
+    } else if (msg.content.type === "error") {
+      output = `Error: ${msg.content.error}`;
+    } else {
+      output = JSON.stringify(msg.content);
+    }
+  } else {
+    output = JSON.stringify(msg.content);
+  }
+  if (msg.attachments?.length) {
+    const imageAttachments = msg.attachments.filter((a) => a.type === "image" && a.data);
+    if (imageAttachments.length > 0) {
+      const outputContent = [];
+      if (output) {
+        outputContent.push({
+          type: "input_text",
+          text: output
+        });
+      }
+      for (const attachment of imageAttachments) {
+        const attachmentData = attachment.data || "";
+        const imageData = attachmentData.startsWith("data:") ? attachmentData : `data:${attachment.mediaType || "image/png"};base64,${attachmentData}`;
+        outputContent.push({
+          type: "input_image",
+          image_url: imageData,
+          detail: "auto"
+        });
+      }
+      return [{
+        type: "function_call_output",
+        call_id: msg.toolCallId,
+        output: outputContent
+      }];
+    }
+  }
+  return [{
+    type: "function_call_output",
+    call_id: msg.toolCallId,
+    output
+  }];
+}
+function transformMessages(messages) {
+  let instructions;
+  const input = [];
+  for (const msg of messages) {
+    switch (msg.role) {
+      case "system":
+        instructions = instructions ? `${instructions}
+
+${msg.content}` : msg.content;
+        break;
+      case "user":
+        input.push(transformUserMessage(msg));
+        break;
+      case "assistant":
+        input.push(...transformAssistantMessage(msg));
+        break;
+      case "tool":
+        input.push(...transformToolMessage(msg));
+        break;
+    }
+  }
+  return { input, instructions };
+}
+function transformTool(tool) {
+  const inputParams = tool.function.parameters;
+  let parameters;
+  if (inputParams && typeof inputParams === "object") {
+    parameters = {
+      ...inputParams,
+      additionalProperties: false
+    };
+  } else {
+    parameters = {
+      type: "object",
+      properties: {},
+      required: [],
+      additionalProperties: false
+    };
+  }
+  return {
+    type: "function",
+    name: tool.function.name,
+    description: tool.function.description || void 0,
+    parameters,
+    strict: true
+  };
+}
+function transformTools(tools) {
+  const functionTools = [];
+  const nativeTools = [];
+  for (const tool of tools) {
+    const toolName = tool.function.name;
+    console.log(`[transformTools] Tool "${toolName}": executionMode=${tool.executionMode}, isNativeTool=${OPENAI_NATIVE_TOOLS.has(toolName)}`);
+    if (tool.executionMode === "provider" && OPENAI_NATIVE_TOOLS.has(toolName)) {
+      console.log(`[transformTools] Adding "${toolName}" as native tool`);
+      nativeTools.push({ type: toolName });
+    } else {
+      console.log(`[transformTools] Adding "${toolName}" as function tool`);
+      functionTools.push(transformTool(tool));
+    }
+  }
+  console.log(`[transformTools] Result: ${functionTools.length} function tools, ${nativeTools.length} native tools`);
+  return { functionTools, nativeTools };
+}
+function transformToolChoice(choice) {
+  if (choice === "auto") {
+    return "auto";
+  }
+  if (choice === "none") {
+    return "none";
+  }
+  if (choice === "required") {
+    return "required";
+  }
+  if (typeof choice === "object" && "name" in choice) {
+    return { type: "function", name: choice.name };
+  }
+  return "auto";
+}
+function mapFinishReason(response) {
+  if (response.status === "failed") {
+    return "error";
+  }
+  if (response.status === "incomplete") {
+    if (response.incomplete_details?.reason === "max_output_tokens") {
+      return "length";
+    }
+    if (response.incomplete_details?.reason === "content_filter") {
+      return "content_filter";
+    }
+  }
+  const hasToolCalls = response.output.some(
+    (item) => item.type === "function_call"
+  );
+  if (hasToolCalls) {
+    return "tool_calls";
+  }
+  return "stop";
+}
+function extractTextContent(output) {
+  const textParts = [];
+  for (const item of output) {
+    if (item.type === "message" && item.role === "assistant") {
+      for (const content of item.content) {
+        if (content.type === "output_text") {
+          textParts.push(content.text);
+        }
+      }
+    }
+  }
+  return textParts.length > 0 ? textParts.join("") : null;
+}
+function extractReasoningContent(output) {
+  let reasoning = null;
+  const reasoningDetails = [];
+  for (const item of output) {
+    if (item.type === "reasoning") {
+      const reasoningId = item.id;
+      if (item.summary && item.summary.length > 0) {
+        const summaryText = item.summary.map((s) => s.text).join("\n");
+        reasoning = reasoning ? `${reasoning}
+${summaryText}` : summaryText;
+        reasoningDetails.push({ type: "summary", id: reasoningId, text: summaryText });
+      }
+      if (item.encrypted_content) {
+        reasoningDetails.push({ type: "encrypted", id: reasoningId, data: item.encrypted_content });
+      }
+    }
+  }
+  return {
+    reasoning,
+    reasoningDetails: reasoningDetails.length > 0 ? reasoningDetails : void 0
+  };
+}
+function extractToolCalls(output) {
+  const toolCalls = [];
+  for (const item of output) {
+    if (item.type === "function_call") {
+      let parsedArgs = {};
+      try {
+        parsedArgs = item.arguments ? JSON.parse(item.arguments) : {};
+      } catch {
+      }
+      toolCalls.push({
+        id: item.call_id,
+        name: item.name,
+        arguments: parsedArgs
+      });
+    }
+  }
+  return toolCalls.length > 0 ? toolCalls : void 0;
+}
+function extractProviderImages(output) {
+  const images = [];
+  for (const item of output) {
+    if (item.type === "image_generation_call" && item.result) {
+      images.push({
+        id: item.id,
+        toolName: "image_generation",
+        data: item.result,
+        mediaType: "image/png"
+        // Note: OpenAI SDK ImageGenerationCall doesn't expose revised_prompt
+      });
+    }
+  }
+  return images.length > 0 ? images : void 0;
+}
+function transformUsage(usage) {
+  if (!usage) {
+    return {
+      promptTokens: 0,
+      completionTokens: 0,
+      totalTokens: 0
+    };
+  }
+  return {
+    promptTokens: usage.input_tokens || 0,
+    completionTokens: usage.output_tokens || 0,
+    totalTokens: usage.total_tokens || 0,
+    reasoningTokens: usage.output_tokens_details?.reasoning_tokens,
+    cachedTokens: usage.input_tokens_details?.cached_tokens
+  };
+}
+function transformResponse(response) {
+  const content = extractTextContent(response.output);
+  const { reasoning, reasoningDetails } = extractReasoningContent(response.output);
+  const toolCalls = extractToolCalls(response.output);
+  const images = extractProviderImages(response.output);
+  return {
+    content,
+    reasoning,
+    reasoningDetails,
+    toolCalls,
+    images,
+    finishReason: mapFinishReason(response),
+    usage: transformUsage(response.usage),
+    metadata: {
+      model: response.model,
+      provider: "openai",
+      requestId: response.id
+    }
+  };
+}
+function buildCreateParams(request, reasoningLevels = DEFAULT_REASONING_LEVELS) {
+  const { input, instructions } = transformMessages(request.messages);
+  const params = {
+    model: request.model,
+    input,
+    store: false
+    // Always stateless
+  };
+  if (instructions) {
+    params.instructions = instructions;
+  }
+  if (request.tools && request.tools.length > 0) {
+    const { functionTools, nativeTools } = transformTools(request.tools);
+    const usedNativeTools = /* @__PURE__ */ new Set();
+    for (const msg of request.messages) {
+      if (msg.role === "tool" && msg.toolName && OPENAI_NATIVE_TOOLS.has(msg.toolName)) {
+        usedNativeTools.add(msg.toolName);
+      }
+    }
+    const availableNativeTools = nativeTools.filter((tool) => {
+      const toolType = tool.type;
+      if (usedNativeTools.has(toolType)) {
+        console.log(`[buildCreateParams] Excluding native tool "${toolType}" - already used in conversation`);
+        return false;
+      }
+      return true;
+    });
+    params.tools = [
+      ...functionTools,
+      ...availableNativeTools
+    ];
+    const hasWebSearch = availableNativeTools.some(
+      (tool) => tool.type === "web_search"
+    );
+    if (hasWebSearch) {
+      params.include = params.include || [];
+      if (!params.include.includes("web_search_call.results")) {
+        params.include.push("web_search_call.results");
+      }
+    }
+    if (request.toolChoice !== void 0) {
+      params.tool_choice = transformToolChoice(request.toolChoice);
+    }
+    if (request.parallelToolCalls !== void 0) {
+      params.parallel_tool_calls = request.parallelToolCalls;
+    }
+  }
+  if (request.maxOutputTokens !== void 0) {
+    params.max_output_tokens = request.maxOutputTokens;
+  }
+  if (request.temperature !== void 0) {
+    params.temperature = request.temperature;
+  }
+  if (request.topP !== void 0) {
+    params.top_p = request.topP;
+  }
+  if (request.reasoning?.level !== void 0) {
+    const effort = mapReasoningLevel(request.reasoning.level, reasoningLevels);
+    if (effort) {
+      params.reasoning = {
+        effort,
+        summary: "auto"
+      };
+      params.include = params.include || [];
+      if (!params.include.includes("reasoning.encrypted_content")) {
+        params.include.push("reasoning.encrypted_content");
+      }
+    }
+  }
+  if (request.responseFormat) {
+    if (request.responseFormat.type === "json") {
+      if (request.responseFormat.schema) {
+        params.text = {
+          format: {
+            type: "json_schema",
+            name: "response",
+            schema: request.responseFormat.schema,
+            strict: true
+          }
+        };
+      } else {
+        params.text = {
+          format: { type: "json_object" }
+        };
+      }
+    }
+  }
+  if (request.providerOptions) {
+    const { include: _providerInclude, ...otherOptions } = request.providerOptions;
+    Object.assign(params, otherOptions);
+  }
+  return params;
+}
+function createStreamState() {
+  return {
+    toolCalls: /* @__PURE__ */ new Map(),
+    imageGenerations: /* @__PURE__ */ new Map(),
+    webSearches: /* @__PURE__ */ new Map(),
+    reasoningContent: "",
+    hasContent: false,
+    hasReasoning: false,
+    currentItemId: null,
+    imageIndex: 0
+  };
+}
+function processStreamEvent(event, state) {
+  const chunks = [];
+  switch (event.type) {
+    // Text content streaming
+    case "response.output_text.delta":
+      state.hasContent = true;
+      chunks.push({ type: "content-delta", delta: event.delta });
+      break;
+    case "response.output_text.done":
+      break;
+    // Reasoning streaming
+    case "response.reasoning.delta":
+      state.hasReasoning = true;
+      if (typeof event.delta === "string") {
+        state.reasoningContent += event.delta;
+        chunks.push({ type: "reasoning-delta", delta: event.delta });
+      }
+      break;
+    case "response.reasoning.done":
+      break;
+    // Function call and image generation streaming
+    case "response.output_item.added":
+      if (event.item.type === "function_call") {
+        state.toolCalls.set(event.item.call_id, {
+          id: event.item.call_id,
+          name: event.item.name,
+          arguments: ""
+        });
+        chunks.push({
+          type: "tool-call-start",
+          id: event.item.call_id,
+          name: event.item.name
+        });
+      } else if (event.item.type === "image_generation_call") {
+        console.log(`[processStreamEvent] image_generation_call added: id=${event.item.id}, status=${event.item.status}`);
+        state.imageGenerations.set(event.item.id, {
+          id: event.item.id,
+          status: event.item.status
+        });
+      } else if (event.item.type === "web_search_call") {
+        console.log(`[processStreamEvent] web_search_call added: id=${event.item.id}, status=${event.item.status}`);
+        state.webSearches.set(event.item.id, {
+          id: event.item.id,
+          status: event.item.status
+        });
+      }
+      break;
+    case "response.output_item.done":
+      if (event.item.type === "image_generation_call") {
+        console.log(`[processStreamEvent] image_generation_call done: id=${event.item.id}, status=${event.item.status}, hasResult=${!!event.item.result}, resultLength=${event.item.result?.length || 0}`);
+        if (event.item.result) {
+          const imageIndex = state.imageIndex;
+          state.imageIndex++;
+          console.log(`[processStreamEvent] Emitting image-done chunk #${imageIndex}, id=${event.item.id}`);
+          chunks.push({
+            type: "image-done",
+            index: imageIndex,
+            image: {
+              id: event.item.id,
+              toolName: "image_generation",
+              data: event.item.result,
+              mediaType: "image/png"
+              // Note: OpenAI SDK ImageGenerationCall doesn't expose revised_prompt
+            }
+          });
+        }
+        state.imageGenerations.delete(event.item.id);
+      } else if (event.item.type === "web_search_call") {
+        console.log(`[processStreamEvent] web_search_call done: id=${event.item.id}, status=${event.item.status}`);
+        const webSearchItem = event.item;
+        const actions = [];
+        if (webSearchItem.action) {
+          actions.push({
+            type: webSearchItem.action.type,
+            query: webSearchItem.action.query,
+            url: webSearchItem.action.url,
+            pattern: webSearchItem.action.pattern,
+            sources: webSearchItem.action.sources
+          });
+        }
+        chunks.push({
+          type: "web-search-done",
+          result: {
+            id: event.item.id,
+            status: event.item.status,
+            actions: actions.length > 0 ? actions : void 0
+          }
+        });
+        state.webSearches.delete(event.item.id);
+      }
+      break;
+    case "response.function_call_arguments.delta": {
+      const deltaToolCall = Array.from(state.toolCalls.values()).find(
+        (tc) => tc.id === event.item_id
+      );
+      if (deltaToolCall) {
+        deltaToolCall.arguments += event.delta;
+        chunks.push({
+          type: "tool-call-delta",
+          id: deltaToolCall.id,
+          argumentsDelta: event.delta
+        });
+      }
+      break;
+    }
+    case "response.function_call_arguments.done": {
+      const doneToolCall = Array.from(state.toolCalls.values()).find(
+        (tc) => tc.id === event.item_id
+      );
+      if (doneToolCall) {
+        let parsedArgs = {};
+        try {
+          parsedArgs = doneToolCall.arguments ? JSON.parse(doneToolCall.arguments) : {};
+        } catch {
+        }
+        chunks.push({
+          type: "tool-call-done",
+          id: doneToolCall.id,
+          arguments: parsedArgs
+        });
+      }
+      break;
+    }
+    // Response completion
+    case "response.completed": {
+      if (state.hasContent) {
+        chunks.push({ type: "content-done" });
+      }
+      if (state.hasReasoning) {
+        chunks.push({ type: "reasoning-done" });
+      }
+      const { reasoningDetails } = extractReasoningContent(event.response.output);
+      chunks.push({
+        type: "finish",
+        finishReason: mapFinishReason(event.response),
+        usage: transformUsage(event.response.usage),
+        reasoningDetails
+      });
+      break;
+    }
+    case "response.failed":
+      chunks.push({
+        type: "error",
+        error: event.response.error?.message || "Response generation failed",
+        code: event.response.error?.code
+      });
+      break;
+    case "response.incomplete": {
+      if (state.hasContent) {
+        chunks.push({ type: "content-done" });
+      }
+      if (state.hasReasoning) {
+        chunks.push({ type: "reasoning-done" });
+      }
+      const { reasoningDetails: incompleteReasoningDetails } = extractReasoningContent(event.response.output);
+      chunks.push({
+        type: "finish",
+        finishReason: mapFinishReason(event.response),
+        usage: transformUsage(event.response.usage),
+        reasoningDetails: incompleteReasoningDetails
+      });
+      break;
+    }
+    // Ignore other events
+    default:
+      break;
+  }
+  return chunks;
+}
+function createErrorChunk(error, code) {
+  return { type: "error", error, code };
+}
+function isBase64Like(str) {
+  if (str.startsWith("data:")) return true;
+  if (str.length > 200) {
+    const base64Pattern = /^[A-Za-z0-9+/]+=*$/;
+    return base64Pattern.test(str.substring(0, 200));
+  }
+  return false;
+}
+function truncateBase64String(str, maxLength = 50) {
+  if (str.length <= maxLength) return str;
+  const preview = str.substring(0, maxLength);
+  return `${preview}...[truncated, ${str.length.toLocaleString()} chars]`;
+}
+function truncateBase64(obj, maxLength = 50) {
+  if (obj === null || obj === void 0) {
+    return obj;
+  }
+  if (typeof obj === "string") {
+    if (isBase64Like(obj)) {
+      return truncateBase64String(obj, maxLength);
+    }
+    return obj;
+  }
+  if (Array.isArray(obj)) {
+    return obj.map((item) => truncateBase64(item, maxLength));
+  }
+  if (typeof obj === "object") {
+    const result = {};
+    for (const [key, value] of Object.entries(obj)) {
+      result[key] = truncateBase64(value, maxLength);
+    }
+    return result;
+  }
+  return obj;
+}
+
+// src/icons.ts
+var OPENAI_ICON = `<svg xmlns="http://www.w3.org/2000/svg" width="48" height="48" viewBox="0 0 48 48" fill="none">
+<rect width="48" height="48" rx="24" fill="white"/>
+<path d="M19.3418 18.5599V14.7599C19.3418 14.4399 19.4608 14.1998 19.7382 14.04L27.3102 9.63997C28.3409 9.03999 29.5699 8.76014 30.8383 8.76014C35.5954 8.76014 38.6085 12.4802 38.6085 16.4401C38.6085 16.72 38.6085 17.04 38.5687 17.3601L30.7194 12.72C30.2437 12.4401 29.7678 12.4401 29.2922 12.72L19.3418 18.5599ZM37.0226 33.36V24.2799C37.0226 23.7197 36.7846 23.3197 36.309 23.0398L26.3586 17.1998L29.6093 15.3197C29.8868 15.1599 30.1247 15.1599 30.4022 15.3197L37.9741 19.7197C40.1547 20.9999 41.6213 23.7197 41.6213 26.3596C41.6213 29.3995 39.8375 32.1999 37.0226 33.36ZM17.0029 25.3601L13.7522 23.4402C13.4748 23.2804 13.3557 23.0402 13.3557 22.7202V13.9203C13.3557 9.64039 16.6065 6.40016 21.0069 6.40016C22.6722 6.40016 24.2179 6.96029 25.5265 7.96025L17.7168 12.5204C17.2412 12.8003 17.0033 13.2002 17.0033 13.7605L17.0029 25.3601ZM24 29.44L19.3418 26.8001V21.2003L24 18.5604L28.6578 21.2003V26.8001L24 29.44ZM26.993 41.6002C25.3278 41.6002 23.7821 41.04 22.4735 40.0402L30.2831 35.4799C30.7588 35.2001 30.9967 34.8001 30.9967 34.2399V22.6399L34.2873 24.5598C34.5646 24.7196 34.6837 24.9597 34.6837 25.2798V34.0797C34.6837 38.3596 31.3931 41.6002 26.993 41.6002ZM17.5975 32.6802L10.0255 28.2803C7.84493 27.0001 6.37833 24.2803 6.37833 21.6404C6.37833 18.5604 8.20193 15.8004 11.0164 14.6403V23.7602C11.0164 24.3204 11.2544 24.7204 11.73 25.0003L21.641 30.8001L18.3902 32.6802C18.1129 32.84 17.8749 32.84 17.5975 32.6802ZM17.1617 39.2402C12.682 39.2402 9.39151 35.8402 9.39151 31.6401C9.39151 31.3201 9.43125 31.0001 9.47066 30.68L17.2803 35.2402C17.7559 35.5201 18.2319 35.5201 18.7074 35.2402L28.6578 29.4404V33.2404C28.6578 33.5605 28.5388 33.8005 28.2614 33.9604L20.6894 38.3604C19.6586 38.9603 18.4301 39.2402 17.1617 39.2402ZM26.993 44C31.7899 44 35.7936 40.5601 36.7057 36C41.1457 34.8399 44 30.6399 44 26.36C44 23.5598 42.8108 20.8401 40.6701 18.88C40.8683 18.0399 40.9872 17.1998 40.9872 16.3602C40.9872 10.6403 36.3885 6.35998 31.0763 6.35998C30.0062 6.35998 28.9754 6.51979 27.9446 6.88001C26.1604 5.11992 23.7025 4 21.0069 4C16.2101 4 12.2064 7.4398 11.2943 12C6.8543 13.1601 4 17.3601 4 21.6399C4 24.4401 5.18916 27.1599 7.32995 29.1199C7.13174 29.96 7.01277 30.8001 7.01277 31.6398C7.01277 37.3597 11.6114 41.6399 16.9236 41.6399C17.9938 41.6399 19.0246 41.4801 20.0554 41.1199C21.8392 42.88 24.2971 44 26.993 44Z" fill="black"/>
+</svg>`;
+function svgToDataUri(svg) {
+  const encoded = encodeURIComponent(svg).replace(/'/g, "%27").replace(/"/g, "%22");
+  return `data:image/svg+xml,${encoded}`;
+}
+function getOpenAIIconDataUri() {
+  return svgToDataUri(OPENAI_ICON);
+}
+
+// src/OpenAIProvider.ts
+var OpenAIProvider = class _OpenAIProvider {
+  name = "openai";
+  specificationVersion = "1";
+  client = null;
+  config;
+  /** Cache for models list to avoid repeated API calls */
+  static modelsCache = null;
+  static modelsCacheTime = 0;
+  static CACHE_TTL = 5 * 60 * 1e3;
+  // 5 minutes
+  constructor(config) {
+    this.config = config;
+  }
+  async getClient() {
+    if (!this.client) {
+      const { default: OpenAI } = await import("openai");
+      this.client = new OpenAI({
+        apiKey: this.config.apiKey,
+        baseURL: this.config.baseUrl,
+        timeout: this.config.timeout
+      });
+    }
+    return this.client;
+  }
+  supportsModel(modelId) {
+    return modelId.startsWith("gpt-") || modelId.startsWith("o1") || modelId.startsWith("o3") || modelId.startsWith("o4") || modelId.startsWith("dall-e") || modelId.startsWith("chatgpt-");
+  }
+  /**
+   * Get the icon for this provider as a data URI.
+   * Always returns the OpenAI icon since all models are from OpenAI.
+   */
+  getIcon(_modelId) {
+    return getOpenAIIconDataUri();
+  }
+  // ============================================================================
+  // Model Capabilities
+  // ============================================================================
+  /**
+   * Hardcoded capability mappings for OpenAI models.
+   * OpenAI doesn't provide a capabilities API, so these are manually maintained.
+   */
+  static MODEL_CAPABILITIES = {
+    "gpt-4o": {
+      supportsImages: true,
+      supportsToolCalls: true,
+      supportsStreaming: true,
+      supportsJsonMode: true,
+      maxContextTokens: 128e3,
+      maxOutputTokens: 16384
+    },
+    "gpt-4o-mini": {
+      supportsImages: true,
+      supportsToolCalls: true,
+      supportsStreaming: true,
+      supportsJsonMode: true,
+      maxContextTokens: 128e3,
+      maxOutputTokens: 16384
+    },
+    "gpt-4-turbo": {
+      supportsImages: true,
+      supportsToolCalls: true,
+      supportsStreaming: true,
+      supportsJsonMode: true,
+      maxContextTokens: 128e3,
+      maxOutputTokens: 4096
+    },
+    "gpt-4": {
+      supportsImages: false,
+      supportsToolCalls: true,
+      supportsStreaming: true,
+      supportsJsonMode: true,
+      maxContextTokens: 8192,
+      maxOutputTokens: 4096
+    },
+    "gpt-3.5-turbo": {
+      supportsImages: false,
+      supportsToolCalls: true,
+      supportsStreaming: true,
+      supportsJsonMode: true,
+      maxContextTokens: 16385,
+      maxOutputTokens: 4096
+    },
+    "o1": {
+      supportsImages: true,
+      supportsToolCalls: true,
+      supportsStreaming: true,
+      supportsJsonMode: true,
+      maxContextTokens: 2e5,
+      maxOutputTokens: 1e5,
+      reasoningLevels: { 0: null, 33: "low", 66: "medium", 100: "high" }
+    },
+    "o1-preview": {
+      supportsImages: true,
+      supportsToolCalls: false,
+      supportsStreaming: true,
+      supportsJsonMode: false,
+      maxContextTokens: 128e3,
+      maxOutputTokens: 32768,
+      reasoningLevels: { 0: null, 33: "low", 66: "medium", 100: "high" }
+    },
+    "o1-mini": {
+      supportsImages: false,
+      supportsToolCalls: false,
+      supportsStreaming: true,
+      supportsJsonMode: false,
+      maxContextTokens: 128e3,
+      maxOutputTokens: 65536,
+      reasoningLevels: { 0: null, 33: "low", 66: "medium", 100: "high" }
+    },
+    "o3-mini": {
+      supportsImages: false,
+      supportsToolCalls: true,
+      supportsStreaming: true,
+      supportsJsonMode: true,
+      maxContextTokens: 2e5,
+      maxOutputTokens: 1e5,
+      reasoningLevels: { 0: null, 33: "low", 66: "medium", 100: "high" }
+    },
+    "o4-mini": {
+      supportsImages: true,
+      supportsToolCalls: true,
+      supportsStreaming: true,
+      supportsJsonMode: true,
+      maxContextTokens: 2e5,
+      maxOutputTokens: 1e5,
+      reasoningLevels: { 0: null, 33: "low", 66: "medium", 100: "high" }
+    }
+  };
+  /**
+   * Get capabilities for a specific model.
+   * Uses hardcoded mappings since OpenAI doesn't provide a capabilities API.
+   */
+  async getModelCapabilities(modelId) {
+    if (_OpenAIProvider.MODEL_CAPABILITIES[modelId]) {
+      return { ..._OpenAIProvider.MODEL_CAPABILITIES[modelId] };
+    }
+    for (const [prefix, caps] of Object.entries(_OpenAIProvider.MODEL_CAPABILITIES)) {
+      if (modelId.startsWith(prefix)) {
+        return { ...caps };
+      }
+    }
+    return {
+      supportsImages: false,
+      supportsToolCalls: true,
+      supportsStreaming: true,
+      supportsJsonMode: true,
+      maxContextTokens: 8192,
+      maxOutputTokens: 4096
+    };
+  }
+  /**
+   * Human-readable names and descriptions for models.
+   * Used to enrich API response data.
+   */
+  static MODEL_METADATA = {
+    "gpt-4o": { name: "GPT-4o", description: "Most capable GPT-4 model with vision" },
+    "gpt-4o-mini": { name: "GPT-4o Mini", description: "Fast and affordable GPT-4o variant" },
+    "gpt-4-turbo": { name: "GPT-4 Turbo", description: "GPT-4 Turbo with vision" },
+    "gpt-4": { name: "GPT-4", description: "Original GPT-4 model" },
+    "gpt-3.5-turbo": { name: "GPT-3.5 Turbo", description: "Fast and cost-effective" },
+    "o1": { name: "o1", description: "Advanced reasoning model" },
+    "o1-preview": { name: "o1 Preview", description: "Preview reasoning model" },
+    "o1-mini": { name: "o1 Mini", description: "Smaller reasoning model" },
+    "o3-mini": { name: "o3 Mini", description: "Latest compact reasoning model" },
+    "o4-mini": { name: "o4 Mini", description: "Next-gen compact reasoning model" },
+    "chatgpt-4o-latest": { name: "ChatGPT-4o Latest", description: "Latest ChatGPT model" }
+  };
+  /**
+   * Prefixes for chat-capable models (filter out embeddings, tts, whisper, dall-e, etc.)
+   */
+  static CHAT_MODEL_PREFIXES = ["gpt-", "o1", "o3", "o4", "chatgpt-"];
+  // ============================================================================
+  // Provider-Embedded Tools
+  // ============================================================================
+  /**
+   * Provider-embedded tools using defineTool().
+   * These are OpenAI's built-in tools that execute on OpenAI's servers.
+   * The execute function is a no-op since execution is handled by the provider.
+   */
+  static TOOLS = {
+    web_search: defineTool({
+      description: "Search the web for up-to-date information with citations",
+      args: z.object({
+        query: z.string().describe("Search query"),
+        searchContextSize: z.enum(["low", "medium", "high"]).default("medium").describe("Amount of context to gather")
+      }),
+      execute: async (_state, _args) => {
+        return { status: "success", result: "Handled by OpenAI" };
+      },
+      tenvs: z.object({
+        userLocation: z.string().optional().describe("User location for relevant results")
+      }),
+      executionMode: "provider",
+      executionProvider: "openai"
+    }),
+    file_search: defineTool({
+      description: "Search through uploaded files using vector embeddings",
+      args: z.object({
+        query: z.string().describe("Search query")
+      }),
+      execute: async (_state, _args) => {
+        return { status: "success", result: "Handled by OpenAI" };
+      },
+      tenvs: z.object({
+        vectorStoreId: z.string().describe("OpenAI Vector Store ID")
+      }),
+      executionMode: "provider",
+      executionProvider: "openai"
+    }),
+    code_interpreter: defineTool({
+      description: "Execute Python code in a sandboxed environment",
+      args: z.object({
+        code: z.string().describe("Python code to execute")
+      }),
+      execute: async (_state, _args) => {
+        return { status: "success", result: "Handled by OpenAI" };
+      },
+      tenvs: z.object({
+        containerId: z.string().optional().describe("Code interpreter container ID")
+      }),
+      executionMode: "provider",
+      executionProvider: "openai"
+    }),
+    image_generation: defineTool({
+      description: "Generate images using GPT-image-1",
+      args: z.object({
+        prompt: z.string().describe("Image generation prompt"),
+        quality: z.enum(["standard", "hd"]).default("standard").describe("Image quality"),
+        size: z.enum(["1024x1024", "1792x1024", "1024x1792"]).default("1024x1024").describe("Image size")
+      }),
+      execute: async (_state, _args) => {
+        return { status: "success", result: "Handled by OpenAI" };
+      },
+      executionMode: "provider",
+      executionProvider: "openai"
+    })
+  };
+  /**
+   * Which tools are available for each model.
+   */
+  static MODEL_TOOLS = {
+    "gpt-4o": ["web_search", "file_search", "code_interpreter", "image_generation"],
+    "gpt-4o-mini": ["web_search", "file_search", "code_interpreter"],
+    "o1": ["web_search", "code_interpreter"],
+    "o3-mini": ["web_search", "code_interpreter"],
+    "o4-mini": ["web_search", "file_search", "code_interpreter", "image_generation"]
+  };
+  /**
+   * Get tools embedded in this provider.
+   * These are OpenAI's built-in tools with tenv requirements.
+   *
+   * @param modelId - Optional filter to get tools available for a specific model
+   * @returns Record of tool name to tool definition
+   */
+  getTools(modelId) {
+    if (!modelId) {
+      return { ..._OpenAIProvider.TOOLS };
+    }
+    let toolNames = _OpenAIProvider.MODEL_TOOLS[modelId];
+    if (!toolNames) {
+      for (const [prefix, tools] of Object.entries(_OpenAIProvider.MODEL_TOOLS)) {
+        if (modelId.startsWith(prefix)) {
+          toolNames = tools;
+          break;
+        }
+      }
+    }
+    if (!toolNames) {
+      return { ..._OpenAIProvider.TOOLS };
+    }
+    const result = {};
+    for (const name of toolNames) {
+      if (_OpenAIProvider.TOOLS[name]) {
+        result[name] = _OpenAIProvider.TOOLS[name];
+      }
+    }
+    return result;
+  }
+  /**
+   * Fetch models from OpenAI API with caching.
+   */
+  async fetchModelsWithCache() {
+    const now = Date.now();
+    if (_OpenAIProvider.modelsCache && now - _OpenAIProvider.modelsCacheTime < _OpenAIProvider.CACHE_TTL) {
+      return _OpenAIProvider.modelsCache;
+    }
+    const client = await this.getClient();
+    const response = await client.models.list();
+    const models = [];
+    for await (const model of response) {
+      models.push(model);
+    }
+    _OpenAIProvider.modelsCache = models;
+    _OpenAIProvider.modelsCacheTime = now;
+    return models;
+  }
+  /**
+   * Check if a model ID is a chat-capable model.
+   */
+  isChatModel(modelId) {
+    return _OpenAIProvider.CHAT_MODEL_PREFIXES.some((prefix) => modelId.startsWith(prefix));
+  }
+  /**
+   * Get human-readable name for a model.
+   */
+  getModelName(modelId) {
+    if (_OpenAIProvider.MODEL_METADATA[modelId]) {
+      return _OpenAIProvider.MODEL_METADATA[modelId].name;
+    }
+    for (const [prefix, meta] of Object.entries(_OpenAIProvider.MODEL_METADATA)) {
+      if (modelId.startsWith(prefix + "-")) {
+        return `${meta.name} (${modelId.slice(prefix.length + 1)})`;
+      }
+    }
+    return modelId.split("-").map((part) => part.charAt(0).toUpperCase() + part.slice(1)).join(" ");
+  }
+  /**
+   * Get description for a model.
+   */
+  getModelDescription(modelId) {
+    if (_OpenAIProvider.MODEL_METADATA[modelId]) {
+      return _OpenAIProvider.MODEL_METADATA[modelId].description;
+    }
+    for (const [prefix, meta] of Object.entries(_OpenAIProvider.MODEL_METADATA)) {
+      if (modelId.startsWith(prefix + "-")) {
+        return meta.description;
+      }
+    }
+    return "";
+  }
+  /**
+   * Map OpenAI model info to ProviderModelInfo.
+   */
+  mapToProviderModelInfo(model) {
+    const caps = _OpenAIProvider.MODEL_CAPABILITIES[model.id];
+    let contextLength = caps?.maxContextTokens;
+    if (!contextLength) {
+      for (const [prefix, prefixCaps] of Object.entries(_OpenAIProvider.MODEL_CAPABILITIES)) {
+        if (model.id.startsWith(prefix)) {
+          contextLength = prefixCaps.maxContextTokens;
+          break;
+        }
+      }
+    }
+    return {
+      id: model.id,
+      name: this.getModelName(model.id),
+      description: this.getModelDescription(model.id),
+      contextLength,
+      iconId: this.getIcon(model.id)
+    };
+  }
+  /**
+   * Get list of available models from OpenAI.
+   * Fetches from the OpenAI API with caching.
+   *
+   * @param filter - Optional search string to filter models by name/id
+   */
+  async getModels(filter) {
+    try {
+      const rawModels = await this.fetchModelsWithCache();
+      let models = rawModels.filter((m) => this.isChatModel(m.id)).map((m) => this.mapToProviderModelInfo(m)).sort((a, b) => {
+        return a.name.localeCompare(b.name);
+      });
+      if (filter) {
+        const lowerFilter = filter.toLowerCase();
+        models = models.filter(
+          (m) => m.id.toLowerCase().includes(lowerFilter) || m.name.toLowerCase().includes(lowerFilter) || m.description && m.description.toLowerCase().includes(lowerFilter)
+        );
+      }
+      return models;
+    } catch (error) {
+      console.error("Failed to fetch models from OpenAI:", error);
+      return [];
+    }
+  }
+  // ============================================================================
+  // Generation Methods
+  // ============================================================================
+  async generate(request) {
+    const client = await this.getClient();
+    try {
+      const params = buildCreateParams(request, DEFAULT_REASONING_LEVELS);
+      const response = await client.responses.create(
+        { ...params, stream: false },
+        { signal: request.signal }
+      );
+      return transformResponse(response);
+    } catch (error) {
+      throw this.toProviderError(error);
+    }
+  }
+  async stream(request) {
+    const client = await this.getClient();
+    const self = this;
+    try {
+      const params = buildCreateParams(request, DEFAULT_REASONING_LEVELS);
+      console.log("[OpenAI] Sending request with", Array.isArray(params.input) ? params.input.length : 1, "input items:");
+      if (Array.isArray(params.input)) {
+        for (const item of params.input) {
+          const itemType = item.type || item.role || "unknown";
+          const hasImage = JSON.stringify(item).includes("input_image");
+          console.log(`  - ${itemType}${hasImage ? " (has image)" : ""}`);
+        }
+      }
+      const stream = await client.responses.create(
+        { ...params, stream: true },
+        { signal: request.signal }
+      );
+      return {
+        async *[Symbol.asyncIterator]() {
+          const state = createStreamState();
+          try {
+            for await (const event of stream) {
+              const chunks = processStreamEvent(event, state);
+              for (const chunk of chunks) {
+                yield chunk;
+              }
+            }
+          } catch (error) {
+            const providerError = self.toProviderError(error);
+            yield createErrorChunk(providerError.message, providerError.code);
+          }
+        }
+      };
+    } catch (error) {
+      throw this.toProviderError(error);
+    }
+  }
+  // ============================================================================
+  // Error Handling
+  // ============================================================================
+  toProviderError(error) {
+    if (error instanceof ProviderError) {
+      return error;
+    }
+    if (error instanceof Error) {
+      const anyError = error;
+      const status = anyError.status || anyError.statusCode;
+      const retryAfter = anyError.headers?.["retry-after"] ? parseInt(anyError.headers["retry-after"], 10) : void 0;
+      if (status === 429) {
+        return new ProviderError(error.message, "rate_limit", status, retryAfter);
+      }
+      if (status === 401 || status === 403) {
+        return new ProviderError(error.message, "auth_error", status);
+      }
+      if (status === 400) {
+        return new ProviderError(error.message, "invalid_request", status);
+      }
+      if (status >= 500) {
+        return new ProviderError(error.message, "server_error", status);
+      }
+      if (error.name === "AbortError" || anyError.code === "ETIMEDOUT") {
+        return new ProviderError(error.message, "timeout");
+      }
+      return new ProviderError(error.message, "unknown", status);
+    }
+    return new ProviderError(String(error), "unknown");
+  }
+  // ============================================================================
+  // Inspection
+  // ============================================================================
+  /**
+   * Transform a ProviderRequest to OpenAI Responses API format for inspection.
+   * Returns the exact request body that would be sent to OpenAI, with base64 data truncated.
+   */
+  async inspectRequest(request) {
+    const params = buildCreateParams(request, DEFAULT_REASONING_LEVELS);
+    return {
+      body: truncateBase64(params),
+      messagesPath: "input",
+      metadata: {
+        endpoint: "responses.create"
+      }
+    };
+  }
+};
+
+// src/providerOptions.ts
+import { z as z2 } from "zod";
+var openaiProviderOptions = z2.object({
+  /** Service tier for request: 'auto', 'default', or 'flex' */
+  service_tier: z2.enum(["auto", "default", "flex"]).optional(),
+  /** User identifier for abuse monitoring */
+  user: z2.string().optional(),
+  /** Seed for deterministic outputs (beta feature) */
+  seed: z2.number().int().optional(),
+  /** Frequency penalty (-2.0 to 2.0) - reduces repetition of tokens */
+  frequency_penalty: z2.number().min(-2).max(2).optional(),
+  /** Presence penalty (-2.0 to 2.0) - encourages new topics */
+  presence_penalty: z2.number().min(-2).max(2).optional(),
+  /** Whether to return log probabilities of output tokens */
+  logprobs: z2.boolean().optional(),
+  /** Number of most likely tokens to return at each position (0-20) */
+  top_logprobs: z2.number().int().min(0).max(20).optional(),
+  /** Whether to store the completion for future reference */
+  store: z2.boolean().optional(),
+  /** Metadata for stored completions */
+  metadata: z2.record(z2.string(), z2.string()).optional()
+}).passthrough();
+
+// src/index.ts
+var openai = Object.assign(
+  (config) => new OpenAIProvider(config),
+  { providerOptions: openaiProviderOptions }
+);
+export {
+  OpenAIProvider,
+  openai,
+  openaiProviderOptions
+};
+//# sourceMappingURL=index.js.map