@effect/ai-openai 0.29.1 → 0.30.1

package/dist/cjs/OpenAiLanguageModel.js

@@ -3,33 +3,30 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.withConfigOverride = exports.modelWithTokenizer = exports.model = exports.make = exports.layerWithTokenizer = exports.layer = exports.ProviderMetadata = exports.Config = void 0;
-var _AiError = require("@effect/ai/AiError");
-var AiLanguageModel = _interopRequireWildcard(require("@effect/ai/AiLanguageModel"));
-var AiModel = _interopRequireWildcard(require("@effect/ai/AiModel"));
-var AiResponse = _interopRequireWildcard(require("@effect/ai/AiResponse"));
-var Arr = _interopRequireWildcard(require("effect/Array"));
+exports.withConfigOverride = exports.modelWithTokenizer = exports.model = exports.make = exports.layerWithTokenizer = exports.layer = exports.Config = void 0;
+var AiError = _interopRequireWildcard(require("@effect/ai/AiError"));
+var IdGenerator = _interopRequireWildcard(require("@effect/ai/IdGenerator"));
+var LanguageModel = _interopRequireWildcard(require("@effect/ai/LanguageModel"));
+var AiModel = _interopRequireWildcard(require("@effect/ai/Model"));
+var Tool = _interopRequireWildcard(require("@effect/ai/Tool"));
 var Context = _interopRequireWildcard(require("effect/Context"));
+var DateTime = _interopRequireWildcard(require("effect/DateTime"));
 var Effect = _interopRequireWildcard(require("effect/Effect"));
 var Encoding = _interopRequireWildcard(require("effect/Encoding"));
 var _Function = require("effect/Function");
 var Layer = _interopRequireWildcard(require("effect/Layer"));
-var Option = _interopRequireWildcard(require("effect/Option"));
 var Predicate = _interopRequireWildcard(require("effect/Predicate"));
 var Stream = _interopRequireWildcard(require("effect/Stream"));
-var _utilities = _interopRequireWildcard(require("./internal/utilities.js"));
-var InternalUtilities = _utilities;
+var InternalUtilities = _interopRequireWildcard(require("./internal/utilities.js"));
 var _OpenAiClient = require("./OpenAiClient.js");
 var _OpenAiTelemetry = require("./OpenAiTelemetry.js");
 var OpenAiTokenizer = _interopRequireWildcard(require("./OpenAiTokenizer.js"));
+var OpenAiTool = _interopRequireWildcard(require("./OpenAiTool.js"));
 function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function (e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != typeof e && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (const t in e) "default" !== t && {}.hasOwnProperty.call(e, t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, t)) && (i.get || i.set) ? o(f, t, i) : f[t] = e[t]); return f; })(e, t); }
 /**
  * @since 1.0.0
  */
 
-const constDisableValidation = {
-  disableValidation: true
-};
 // =============================================================================
 // Configuration
 // =============================================================================
@@ -44,32 +41,23 @@ class Config extends /*#__PURE__*/Context.Tag("@effect/ai-openai/OpenAiLanguageM
   static getOrUndefined = /*#__PURE__*/Effect.map(/*#__PURE__*/Effect.context(), context => context.unsafeMap.get(Config.key));
 }
 // =============================================================================
-// Anthropic Provider Metadata
+// OpenAI Language Model
 // =============================================================================
 /**
  * @since 1.0.0
- * @category Context
+ * @category Ai Models
  */
 exports.Config = Config;
-class ProviderMetadata extends /*#__PURE__*/Context.Tag(InternalUtilities.ProviderMetadataKey)() {}
-// =============================================================================
-// OpenAi Language Model
-// =============================================================================
-/**
- * @since 1.0.0
- * @category AiModel
- */
-exports.ProviderMetadata = ProviderMetadata;
-const model = (model, config) => AiModel.make(layer({
+const model = (model, config) => AiModel.make("openai", layer({
   model,
   config
 }));
 /**
  * @since 1.0.0
- * @category AiModel
+ * @category Ai Models
  */
 exports.model = model;
-const modelWithTokenizer = (model, config) => AiModel.make(layerWithTokenizer({
+const modelWithTokenizer = (model, config) => AiModel.make("openai", layerWithTokenizer({
   model,
   config
 }));
@@ -80,87 +68,57 @@ const modelWithTokenizer = (model, config) => AiModel.make(layerWithTokenizer({
 exports.modelWithTokenizer = modelWithTokenizer;
 const make = exports.make = /*#__PURE__*/Effect.fnUntraced(function* (options) {
   const client = yield* _OpenAiClient.OpenAiClient;
-  const makeRequest = Effect.fnUntraced(function* (method, {
-    prompt,
-    system,
-    toolChoice,
-    tools
-  }) {
+  const makeRequest = Effect.fnUntraced(function* (providerOptions) {
     const context = yield* Effect.context();
-    const useStructured = tools.length === 1 && tools[0].structured;
-    let tool_choice = undefined;
-    if (Predicate.isNotUndefined(toolChoice) && !useStructured && tools.length > 0) {
-      if (toolChoice === "auto" || toolChoice === "required") {
-        tool_choice = toolChoice;
-      } else if (typeof toolChoice === "object") {
-        tool_choice = {
-          type: "function",
-          function: {
-            name: toolChoice.tool
-          }
-        };
-      }
-    }
-    const messages = yield* makeMessages(method, system, prompt);
-    return {
+    const config = {
       model: options.model,
       ...options.config,
-      ...context.unsafeMap.get(Config.key),
-      messages,
-      response_format: useStructured ? {
-        type: "json_schema",
-        json_schema: {
-          strict: true,
-          name: tools[0].name,
-          description: tools[0].description,
-          schema: tools[0].parameters
-        }
-      } : undefined,
-      tools: !useStructured && tools.length > 0 ? tools.map(tool => ({
-        type: "function",
-        function: {
-          name: tool.name,
-          description: tool.description,
-          parameters: tool.parameters,
-          strict: true
-        }
-      })) : undefined,
-      tool_choice
+      ...context.unsafeMap.get(Config.key)
+    };
+    const messages = yield* prepareMessages(providerOptions, config);
+    const {
+      toolChoice,
+      tools
+    } = yield* prepareTools(providerOptions);
+    const include = prepareInclude(providerOptions, config);
+    const responseFormat = prepareResponseFormat(providerOptions);
+    const verbosity = config.text?.verbosity;
+    const request = {
+      ...config,
+      input: messages,
+      include,
+      text: {
+        format: responseFormat,
+        verbosity
+      },
+      tools,
+      tool_choice: toolChoice
     };
+    return request;
   });
-  return yield* AiLanguageModel.make({
+  return yield* LanguageModel.make({
     generateText: Effect.fnUntraced(function* (options) {
-      const structuredTool = options.tools.length === 1 && options.tools[0].structured ? options.tools[0] : undefined;
-      const request = yield* makeRequest("generateText", options);
+      const request = yield* makeRequest(options);
       annotateRequest(options.span, request);
-      const rawResponse = yield* client.client.createChatCompletion(request);
-      annotateChatResponse(options.span, rawResponse);
-      const response = yield* makeResponse(rawResponse, "generateText", structuredTool);
+      const rawResponse = yield* client.createResponse(request);
+      annotateResponse(options.span, rawResponse);
+      return yield* makeResponse(rawResponse, options);
+    }),
+    streamText: Effect.fnUntraced(function* (options) {
+      const request = yield* makeRequest(options);
+      annotateRequest(options.span, request);
+      return client.createResponseStream(request);
+    }, (effect, options) => effect.pipe(Effect.flatMap(stream => makeStreamResponse(stream, options)), Stream.unwrap, Stream.map(response => {
+      annotateStreamResponse(options.span, response);
       return response;
-    }, Effect.catchAll(cause => _AiError.AiError.is(cause) ? cause : new _AiError.AiError({
-      module: "OpenAiLanguageModel",
-      method: "generateText",
-      description: "An error occurred",
-      cause
-    }))),
-    streamText(options) {
-      return makeRequest("streamText", options).pipe(Effect.tap(request => annotateRequest(options.span, request)), Effect.map(client.stream), Stream.unwrap, Stream.map(response => {
-        annotateStreamResponse(options.span, response);
-        return response;
-      }), Stream.catchAll(cause => _AiError.AiError.is(cause) ? cause : new _AiError.AiError({
-        module: "OpenAiLanguageModel",
-        method: "streamText",
-        description: "An error occurred",
-        cause
-      })));
-    }
+    })))
   });
 });
 /**
  * @since 1.0.0
  * @category Layers
  */
-const layer = options => Layer.effect(AiLanguageModel.AiLanguageModel, make({
+const layer = options => Layer.effect(LanguageModel.LanguageModel, make({
   model: options.model,
   config: options.config
 }));
@@ -179,262 +137,817 @@ const withConfigOverride = exports.withConfigOverride = /*#__PURE__*/(0, _Functi
   ...config,
   ...overrides
 })));
-const makeMessages = /*#__PURE__*/Effect.fnUntraced(function* (method, system, prompt) {
-  const messages = Option.match(system, {
-    onNone: () => [],
-    onSome: content => [{
-      role: "system",
-      content
-    }]
-  });
-  for (const message of prompt.messages) {
-    switch (message._tag) {
-      case "AssistantMessage":
+// =============================================================================
+// Prompt Conversion
+// =============================================================================
+const getSystemMessageMode = model => model.startsWith("o") || model.startsWith("gpt-5") || model.startsWith("codex-") || model.startsWith("computer-use") ? "developer" : "system";
+const prepareMessages = /*#__PURE__*/Effect.fnUntraced(function* (options, config) {
+  const messages = [];
+  for (const message of options.prompt.content) {
+    switch (message.role) {
+      case "system":
+        {
+          messages.push({
+            role: getSystemMessageMode(config.model),
+            content: message.content
+          });
+          break;
+        }
+      case "user":
         {
-          let text = "";
-          const toolCalls = [];
-          for (const part of message.parts) {
-            switch (part._tag) {
-              case "TextPart":
+          const content = [];
+          for (let index = 0; index < message.content.length; index++) {
+            const part = message.content[index];
+            switch (part.type) {
+              case "text":
                 {
-                  text += part.text;
+                  content.push({
+                    type: "input_text",
+                    text: part.text
+                  });
                   break;
                 }
-              case "ToolCallPart":
+              case "file":
                 {
-                  toolCalls.push({
-                    id: part.id,
-                    type: "function",
-                    function: {
-                      name: part.name,
-                      arguments: JSON.stringify(part.params)
+                  if (part.mediaType.startsWith("image/")) {
+                    const detail = getImageDetail(part);
+                    const mediaType = part.mediaType === "image/*" ? "image/jpeg" : part.mediaType;
+                    if (typeof part.data === "string" && isFileId(part.data, config)) {
+                      content.push({
+                        type: "input_image",
+                        file_id: part.data,
+                        detail
+                      });
+                    }
+                    if (part.data instanceof URL) {
+                      content.push({
+                        type: "input_image",
+                        image_url: part.data.toString(),
+                        detail
+                      });
+                    }
+                    if (part.data instanceof Uint8Array) {
+                      const base64 = Encoding.encodeBase64(part.data);
+                      const imageUrl = `data:${mediaType};base64,${base64}`;
+                      content.push({
+                        type: "input_image",
+                        image_url: imageUrl,
+                        detail
+                      });
                     }
+                  }
+                  if (part.mediaType === "application/pdf") {
+                    if (typeof part.data === "string" && isFileId(part.data, config)) {
+                      content.push({
+                        type: "input_file",
+                        file_id: part.data
+                      });
+                    }
+                    if (part.data instanceof URL) {
+                      content.push({
+                        type: "input_file",
+                        file_url: part.data.toString()
+                      });
+                    }
+                    if (part.data instanceof Uint8Array) {
+                      const base64 = Encoding.encodeBase64(part.data);
+                      const fileName = part.fileName ?? `part-${index}.pdf`;
+                      const fileData = `data:application/pdf;base64,${base64}`;
+                      content.push({
+                        type: "input_file",
+                        filename: fileName,
+                        file_data: fileData
+                      });
+                    }
+                  }
+                  return yield* new AiError.MalformedInput({
+                    module: "OpenAiLanguageModel",
+                    method: "prepareMessages",
+                    description: `Detected unsupported media type for file: '${part.mediaType}'`
                   });
-                  break;
                 }
             }
           }
           messages.push({
-            role: "assistant",
-            content: text,
-            tool_calls: toolCalls.length > 0 ? toolCalls : undefined
+            role: "user",
+            content
           });
           break;
         }
-      case "ToolMessage":
+      case "assistant":
         {
-          for (const part of message.parts) {
-            messages.push({
-              role: "tool",
-              tool_call_id: part.id,
-              content: JSON.stringify(part.result)
-            });
+          const reasoningMessages = {};
+          for (const part of message.content) {
+            switch (part.type) {
+              case "text":
+                {
+                  messages.push({
+                    role: "assistant",
+                    content: [{
+                      type: "output_text",
+                      text: part.text
+                    }],
+                    id: getItemId(part)
+                  });
+                  break;
+                }
+              case "reasoning":
+                {
+                  const options = part.options.openai;
+                  if (Predicate.isNotUndefined(options?.itemId)) {
+                    const reasoningMessage = reasoningMessages[options.itemId];
+                    const summaryParts = [];
+                    if (part.text.length > 0) {
+                      summaryParts.push({
+                        type: "summary_text",
+                        text: part.text
+                      });
+                    }
+                    if (Predicate.isUndefined(reasoningMessage)) {
+                      reasoningMessages[options.itemId] = {
+                        id: options.itemId,
+                        type: "reasoning",
+                        summary: summaryParts,
+                        encrypted_content: options.encryptedContent
+                      };
+                      messages.push(reasoningMessages[options.itemId]);
+                    } else {
+                      for (const summaryPart of summaryParts) {
+                        reasoningMessage.summary.push(summaryPart);
+                      }
+                    }
+                  }
+                  break;
+                }
+              case "tool-call":
+                {
+                  if (!part.providerExecuted) {
+                    messages.push({
+                      id: getItemId(part),
+                      type: "function_call",
+                      call_id: part.id,
+                      name: part.name,
+                      arguments: JSON.stringify(part.params)
+                    });
+                  }
+                  break;
+                }
+            }
           }
           break;
         }
-      case "UserMessage":
+      case "tool":
         {
-          // Handle the case where the message content is just a single piece of text
-          if (message.parts.length === 1 && message.parts[0]._tag === "TextPart") {
+          for (const part of message.content) {
             messages.push({
-              role: "user",
-              content: message.parts[0].text
+              type: "function_call_output",
+              call_id: part.id,
+              result: JSON.stringify(part.result)
             });
-            break;
           }
-          const content = [];
-          for (let index = 0; index < message.parts.length; index++) {
-            const part = message.parts[index];
-            switch (part._tag) {
-              // TODO: review file inputs
-              case "FilePart":
+          break;
+        }
+    }
+  }
+  return messages;
+});
+// =============================================================================
+// Response Conversion
+// =============================================================================
+const makeResponse = /*#__PURE__*/Effect.fnUntraced(function* (response, options) {
+  const idGenerator = yield* IdGenerator.IdGenerator;
+  const webSearchTool = options.tools.find(tool => Tool.isProviderDefined(tool) && (tool.id === "openai.web_search" || tool.id === "openai.web_search_preview"));
+  let hasToolCalls = false;
+  const parts = [];
+  const createdAt = new Date(response.created_at * 1000);
+  parts.push({
+    type: "response-metadata",
+    id: response.id,
+    modelId: response.model,
+    timestamp: DateTime.formatIso(DateTime.unsafeFromDate(createdAt))
+  });
+  for (const part of response.output) {
+    switch (part.type) {
+      case "message":
+        {
+          for (const contentPart of part.content) {
+            switch (contentPart.type) {
+              case "output_text":
                 {
-                  const data = Encoding.encodeBase64(part.data);
-                  switch (part.mediaType) {
-                    case "audio/wav":
-                      {
-                        content.push({
-                          type: "input_audio",
-                          input_audio: {
-                            data,
-                            format: "wav"
-                          }
-                        });
-                        break;
-                      }
-                    case "audio/mp3":
-                    case "audio/mpeg":
-                      {
-                        content.push({
-                          type: "input_audio",
-                          input_audio: {
-                            data,
-                            format: "mp3"
-                          }
-                        });
-                        break;
-                      }
-                    case "application/pdf":
-                      {
-                        content.push({
-                          type: "file",
-                          file: {
-                            filename: part.name ?? `part-${index}.pdf`,
-                            file_data: `data:application/pdf;base64,${data}`
-                          }
-                        });
-                        break;
-                      }
-                    default:
-                      {
-                        return yield* new _AiError.AiError({
-                          module: "OpenAiLanguageModel",
-                          method: "",
-                          description: `OpenAi does not support file inputs of type "${part.mediaType}"`
-                        });
+                  parts.push({
+                    type: "text",
+                    text: contentPart.text,
+                    metadata: {
+                      openai: {
+                        itemId: part.id
                       }
+                    }
+                  });
+                  for (const annotation of contentPart.annotations) {
+                    if (annotation.type === "file_citation") {
+                      const metadata = {
+                        type: annotation.type,
+                        index: annotation.index
+                      };
+                      parts.push({
+                        type: "source",
+                        sourceType: "document",
+                        id: yield* idGenerator.generateId(),
+                        mediaType: "text/plain",
+                        title: annotation.filename ?? "Untitled Document",
+                        metadata: {
+                          openai: metadata
+                        }
+                      });
+                    }
+                    if (annotation.type === "url_citation") {
+                      const metadata = {
+                        type: annotation.type,
+                        startIndex: annotation.start_index,
+                        endIndex: annotation.end_index
+                      };
+                      parts.push({
+                        type: "source",
+                        sourceType: "url",
+                        id: yield* idGenerator.generateId(),
+                        url: annotation.url,
+                        title: annotation.title,
+                        metadata: {
+                          openai: metadata
+                        }
+                      });
+                    }
                   }
                   break;
                 }
-              case "FileUrlPart":
+              case "refusal":
                 {
-                  return yield* new _AiError.AiError({
-                    module: "OpenAiLanguageModel",
-                    method,
-                    description: "OpenAi does not support file content parts with URL data"
-                  });
-                }
-              case "TextPart":
-                {
-                  content.push({
+                  parts.push({
                     type: "text",
-                    text: part.text
-                  });
-                  break;
-                }
-              case "ImagePart":
-                {
-                  const mediaType = part.mediaType ?? "image/jpeg";
-                  const base64 = Encoding.encodeBase64(part.data);
-                  const url = `data:${mediaType};base64,${base64}`;
-                  content.push({
-                    type: "image_url",
-                    image_url: {
-                      url
+                    text: "",
+                    metadata: {
+                      openai: {
+                        refusal: contentPart.refusal
+                      }
                     }
                   });
                   break;
                 }
-              case "ImageUrlPart":
-                {
-                  // TODO: provider options
-                  // const detail = part.providerOptions?.openai?.imageDetail as any
-                  content.push({
-                    type: "image_url",
-                    image_url: {
-                      url: part.url.toString()
-                    }
-                  });
-                }
             }
           }
-          if (Arr.isNonEmptyArray(content)) {
-            messages.push({
-              role: "user",
-              name: message.userName,
-              content
+          break;
+        }
+      case "function_call":
+        {
+          hasToolCalls = true;
+          const toolName = part.name;
+          const toolParams = part.arguments;
+          const params = yield* Effect.try({
+            try: () => Tool.unsafeSecureJsonParse(toolParams),
+            catch: cause => new AiError.MalformedOutput({
+              module: "OpenAiLanguageModel",
+              method: "makeResponse",
+              description: "Failed to securely parse tool call parameters " + `for tool '${toolName}':\nParameters: ${toolParams}`,
+              cause
+            })
+          });
+          parts.push({
+            type: "tool-call",
+            id: part.call_id,
+            name: toolName,
+            params,
+            metadata: {
+              openai: {
+                itemId: part.id
+              }
+            }
+          });
+          break;
+        }
+      case "code_interpreter_call":
+        {
+          parts.push({
+            type: "tool-call",
+            id: part.id,
+            name: "OpenAiCodeInterpreter",
+            params: {
+              code: part.code,
+              container_id: part.container_id
+            },
+            providerName: "code_interpreter",
+            providerExecuted: true
+          });
+          parts.push({
+            type: "tool-result",
+            id: part.id,
+            name: "OpenAiCodeInterpreter",
+            result: {
+              outputs: part.outputs
+            },
+            providerName: "code_interpreter",
+            providerExecuted: true
+          });
+          break;
+        }
+      case "file_search_call":
+        {
+          parts.push({
+            type: "tool-call",
+            id: part.id,
+            name: "OpenAiFileSearch",
+            params: {},
+            providerName: "file_search",
+            providerExecuted: true
+          });
+          parts.push({
+            type: "tool-result",
+            id: part.id,
+            name: "OpenAiFileSearch",
+            result: {
+              status: part.status,
+              queries: part.queries,
+              ...(part.results && {
+                results: part.results
+              })
+            },
+            providerName: "file_search",
+            providerExecuted: true
+          });
+          break;
+        }
+      case "web_search_call":
+        {
+          parts.push({
+            type: "tool-call",
+            id: part.id,
+            name: webSearchTool?.name ?? "OpenAiWebSearch",
+            params: {
+              action: part.action
+            },
+            providerName: webSearchTool?.providerName ?? "web_search",
+            providerExecuted: true
+          });
+          parts.push({
+            type: "tool-result",
+            id: part.id,
+            name: webSearchTool?.name ?? "OpenAiWebSearch",
+            result: {
+              status: part.status
+            },
+            providerName: webSearchTool?.providerName ?? "web_search",
+            providerExecuted: true
+          });
+          break;
+        }
+      // TODO(Max): support computer use
+      // case "computer_call": {
+      //   parts.push({
+      //     type: "tool-call",
+      //     id: part.id,
+      //     name: "OpenAiComputerUse",
+      //     params: { action: part.action },
+      //     providerName: webSearchTool?.providerName ?? "web_search",
+      //     providerExecuted: true
+      //   })
+      //
+      //   parts.push({
+      //     type: "tool-result",
+      //     id: part.id,
+      //     name: webSearchTool?.name ?? "OpenAiWebSearch",
+      //     result: { status: part.status },
+      //     providerName: webSearchTool?.providerName ?? "web_search",
+      //     providerExecuted: true
+      //   })
+      //   break
+      // }
+      case "reasoning":
+        {
+          // If there are no summary parts, we have to add an empty one to
+          // propagate the part identifier
+          if (part.summary.length === 0) {
+            parts.push({
+              type: "reasoning",
+              text: "",
+              metadata: {
+                openai: {
+                  itemId: part.id
+                }
+              }
             });
+          } else {
+            for (const summary of part.summary) {
+              const metadata = {
+                itemId: part.id,
+                encryptedContent: part.encrypted_content ?? undefined
+              };
+              parts.push({
+                type: "reasoning",
+                text: summary.text,
+                metadata: {
+                  openai: metadata
+                }
+              });
+            }
           }
           break;
         }
     }
   }
-  if (Arr.isNonEmptyReadonlyArray(messages)) {
-    return messages;
-  }
-  return yield* new _AiError.AiError({
-    module: "OpenAiLanguageModel",
-    method,
-    description: "Prompt contained no messages"
+  const finishReason = InternalUtilities.resolveFinishReason(response.incomplete_details?.reason, hasToolCalls);
+  const metadata = {
+    serviceTier: response.service_tier
+  };
+  parts.push({
+    type: "finish",
+    reason: finishReason,
+    usage: {
+      inputTokens: response.usage?.input_tokens,
+      outputTokens: response.usage?.output_tokens,
+      totalTokens: (response.usage?.input_tokens ?? 0) + (response.usage?.output_tokens ?? 0),
+      reasoningTokens: response.usage?.output_tokens_details?.reasoning_tokens,
+      cachedInputTokens: response.usage?.input_tokens_details?.cached_tokens
+    },
+    metadata: {
+      openai: metadata
+    }
   });
+  return parts;
 });
-const makeResponse = /*#__PURE__*/Effect.fnUntraced(function* (response, method, structuredTool) {
-  const choice = response.choices[0];
-  if (Predicate.isUndefined(choice)) {
-    return yield* new _AiError.AiError({
-      module: "OpenAiLanguageModel",
-      method,
-      description: "Could not get response"
-    });
-  }
-  const parts = [];
-  parts.push(new AiResponse.MetadataPart({
-    id: response.id,
-    model: response.model,
-    // OpenAi returns the `created` time in seconds
-    timestamp: new Date(response.created * 1000)
-  }, constDisableValidation));
-  const finishReason = (0, _utilities.resolveFinishReason)(choice.finish_reason);
-  const inputTokens = response.usage?.prompt_tokens ?? 0;
-  const outputTokens = response.usage?.completion_tokens ?? 0;
-  const totalTokens = inputTokens + outputTokens;
-  const metadata = {};
-  if (Predicate.isNotUndefined(response.service_tier)) {
-    metadata.serviceTier = response.service_tier;
-  }
-  if (Predicate.isNotUndefined(response.system_fingerprint)) {
-    metadata.systemFingerprint = response.system_fingerprint;
-  }
-  if (Predicate.isNotUndefined(response.usage?.completion_tokens_details?.accepted_prediction_tokens)) {
-    metadata.acceptedPredictionTokens = response.usage?.completion_tokens_details?.accepted_prediction_tokens ?? 0;
-  }
-  if (Predicate.isNotUndefined(response.usage?.completion_tokens_details?.rejected_prediction_tokens)) {
-    metadata.rejectedPredictionTokens = response.usage?.completion_tokens_details?.rejected_prediction_tokens ?? 0;
-  }
-  if (Predicate.isNotUndefined(response.usage?.prompt_tokens_details?.audio_tokens)) {
-    metadata.inputAudioTokens = response.usage?.prompt_tokens_details?.audio_tokens ?? 0;
-  }
-  if (Predicate.isNotUndefined(response.usage?.completion_tokens_details?.audio_tokens)) {
-    metadata.outputAudioTokens = response.usage?.completion_tokens_details?.audio_tokens ?? 0;
-  }
-  parts.push(new AiResponse.FinishPart({
-    reason: finishReason,
-    usage: new AiResponse.Usage({
-      inputTokens,
-      outputTokens,
-      totalTokens,
-      reasoningTokens: response.usage?.completion_tokens_details?.reasoning_tokens ?? 0,
-      cacheReadInputTokens: response.usage?.prompt_tokens_details?.cached_tokens ?? 0,
-      cacheWriteInputTokens: 0
-    }, constDisableValidation),
-    providerMetadata: {
-      [InternalUtilities.ProviderMetadataKey]: metadata
+const makeStreamResponse = /*#__PURE__*/Effect.fnUntraced(function* (stream, options) {
+  const idGenerator = yield* IdGenerator.IdGenerator;
+  let hasToolCalls = false;
+  const activeReasoning = {};
+  const activeToolCalls = {};
+  const webSearchTool = options.tools.find(tool => Tool.isProviderDefined(tool) && (tool.id === "openai.web_search" || tool.id === "openai.web_search_preview"));
+  return stream.pipe(Stream.mapEffect(Effect.fnUntraced(function* (event) {
+    const parts = [];
+    switch (event.type) {
+      case "response.created":
+        {
+          const createdAt = new Date(event.response.created_at * 1000);
+          parts.push({
+            type: "response-metadata",
+            id: event.response.id,
+            modelId: event.response.model,
+            timestamp: DateTime.formatIso(DateTime.unsafeFromDate(createdAt))
+          });
+          break;
+        }
+      case "error":
+        {
+          parts.push({
+            type: "error",
+            error: event
+          });
+          break;
+        }
+      case "response.completed":
+      case "response.incomplete":
+      case "response.failed":
+        {
+          parts.push({
+            type: "finish",
+            reason: InternalUtilities.resolveFinishReason(event.response.incomplete_details?.reason, hasToolCalls),
+            usage: {
+              inputTokens: event.response.usage?.input_tokens,
+              outputTokens: event.response.usage?.output_tokens,
+              totalTokens: (event.response.usage?.input_tokens ?? 0) + (event.response.usage?.output_tokens ?? 0),
+              reasoningTokens: event.response.usage?.output_tokens_details?.reasoning_tokens,
+              cachedInputTokens: event.response.usage?.input_tokens_details?.cached_tokens
+            },
+            metadata: {
+              openai: {
+                serviceTier: event.response.service_tier
+              }
+            }
+          });
+          break;
+        }
+      case "response.output_item.added":
+        {
+          switch (event.item.type) {
+            case "computer_call":
+              {
+                // TODO(Max): support computer use
+                break;
+              }
+            case "file_search_call":
+              {
+                activeToolCalls[event.output_index] = {
+                  id: event.item.id,
+                  name: "OpenAiFileSearch"
+                };
+                parts.push({
+                  type: "tool-params-start",
+                  id: event.item.id,
+                  name: "OpenAiFileSearch",
+                  providerName: "file_search",
+                  providerExecuted: true
+                });
+                break;
+              }
+            case "function_call":
+              {
+                activeToolCalls[event.output_index] = {
+                  id: event.item.call_id,
+                  name: event.item.name
+                };
+                parts.push({
+                  type: "tool-params-start",
+                  id: event.item.call_id,
+                  name: event.item.name
+                });
+                break;
+              }
+            case "message":
+              {
+                parts.push({
+                  type: "text-start",
+                  id: event.item.id,
+                  metadata: {
+                    openai: {
+                      itemId: event.item.id
+                    }
+                  }
+                });
+                break;
+              }
+            case "reasoning":
+              {
+                activeReasoning[event.item.id] = {
+                  summaryParts: [0],
+                  encryptedContent: event.item.encrypted_content
+                };
+                parts.push({
+                  type: "reasoning-start",
+                  id: `${event.item.id}:0`,
+                  metadata: {
+                    openai: {
+                      itemId: event.item.id,
+                      encryptedContent: event.item.encrypted_content
+                    }
+                  }
+                });
+                break;
+              }
+            case "web_search_call":
+              {
+                activeToolCalls[event.output_index] = {
+                  id: event.item.id,
+                  name: webSearchTool?.name ?? "OpenAiWebSearch"
+                };
+                parts.push({
+                  type: "tool-params-start",
+                  id: event.item.id,
+                  name: webSearchTool?.name ?? "OpenAiWebSearch",
+                  providerName: webSearchTool?.providerName ?? "web_search",
+                  providerExecuted: true
+                });
+                break;
+              }
+          }
+          break;
+        }
+      case "response.output_item.done":
+        {
+          switch (event.item.type) {
+            case "code_interpreter_call":
+              {
+                parts.push({
+                  type: "tool-call",
+                  id: event.item.id,
+                  name: "OpenAiCodeInterpreter",
+                  params: {
+                    code: event.item.code,
+                    container_id: event.item.container_id
+                  },
+                  providerName: "code_interpreter",
+                  providerExecuted: true
+                });
+                parts.push({
+                  type: "tool-result",
+                  id: event.item.id,
+                  name: "OpenAiCodeInterpreter",
+                  result: {
+                    outputs: event.item.outputs
+                  },
+                  providerName: "code_interpreter",
+                  providerExecuted: true
+                });
+                break;
+              }
+            // TODO(Max): support computer use
+            case "computer_call":
+              {
+                break;
+              }
+            case "file_search_call":
+              {
+                delete activeToolCalls[event.output_index];
+                parts.push({
+                  type: "tool-params-end",
+                  id: event.item.id
+                });
+                parts.push({
+                  type: "tool-call",
+                  id: event.item.id,
+                  name: "OpenAiFileSearch",
+                  params: {},
+                  providerName: "file_search",
+                  providerExecuted: true
+                });
+                parts.push({
+                  type: "tool-result",
+                  id: event.item.id,
+                  name: "OpenAiFileSearch",
+                  result: {
+                    status: event.item.status,
+                    queries: event.item.queries,
+                    ...(event.item.results && {
+                      results: event.item.results
+                    })
+                  },
+                  providerName: "file_search",
+                  providerExecuted: true
+                });
+                break;
+              }
+            case "function_call":
+              {
+                hasToolCalls = true;
+                const toolName = event.item.name;
+                const toolParams = event.item.arguments;
+                const params = yield* Effect.try({
+                  try: () => Tool.unsafeSecureJsonParse(toolParams),
+                  catch: cause => new AiError.MalformedOutput({
+                    module: "OpenAiLanguageModel",
+                    method: "makeStreamResponse",
+                    description: "Failed to securely parse tool call parameters " + `for tool '${toolName}':\nParameters: ${toolParams}`,
+                    cause
+                  })
+                });
+                parts.push({
+                  type: "tool-params-end",
+                  id: event.item.call_id
+                });
+                parts.push({
+                  type: "tool-call",
+                  id: event.item.call_id,
+                  name: toolName,
+                  params,
+                  metadata: {
+                    openai: {
+                      itemId: event.item.id
+                    }
+                  }
+                });
+                delete activeToolCalls[event.output_index];
+                break;
+              }
+            case "message":
+              {
+                parts.push({
+                  type: "text-end",
+                  id: event.item.id
+                });
+                break;
+              }
+            case "reasoning":
+              {
+                const reasoningPart = activeReasoning[event.item.id];
+                for (const summaryIndex of reasoningPart.summaryParts) {
+                  parts.push({
+                    type: "reasoning-end",
+                    id: `${event.item.id}:${summaryIndex}`,
+                    metadata: {
+                      openai: {
+                        itemId: event.item.id,
+                        encryptedContent: event.item.encrypted_content
+                      }
+                    }
+                  });
+                }
+                delete activeReasoning[event.item.id];
+                break;
+              }
+            case "web_search_call":
+              {
+                delete activeToolCalls[event.output_index];
+                parts.push({
+                  type: "tool-params-end",
+                  id: event.item.id
+                });
+                parts.push({
+                  type: "tool-call",
+                  id: event.item.id,
+                  name: "OpenAiWebSearch",
+                  params: {
+                    action: event.item.action
+                  },
+                  providerName: "web_search",
+                  providerExecuted: true
+                });
+                parts.push({
+                  type: "tool-result",
+                  id: event.item.id,
+                  name: "OpenAiWebSearch",
+                  result: {
+                    status: event.item.status
+                  },
+                  providerName: "web_search",
+                  providerExecuted: true
+                });
+                break;
+              }
+          }
+          break;
+        }
+      case "response.output_text.delta":
+        {
+          parts.push({
+            type: "text-delta",
+            id: event.item_id,
+            delta: event.delta
+          });
+          break;
+        }
+      case "response.output_text.annotation.added":
+        {
+          if (event.annotation.type === "file_citation") {
+            parts.push({
+              type: "source",
+              sourceType: "document",
+              id: yield* idGenerator.generateId(),
+              mediaType: "text/plain",
+              title: event.annotation.filename ?? "Untitled Document",
+              fileName: event.annotation.filename ?? event.annotation.file_id
+            });
+          }
+          if (event.annotation.type === "url_citation") {
+            parts.push({
+              type: "source",
+              sourceType: "url",
+              id: yield* idGenerator.generateId(),
+              url: event.annotation.url,
+              title: event.annotation.title
+            });
+          }
+          break;
+        }
+      case "response.function_call_arguments.delta":
+        {
+          const toolCallPart = activeToolCalls[event.output_index];
+          if (Predicate.isNotUndefined(toolCallPart)) {
+            parts.push({
+              type: "tool-params-delta",
+              id: toolCallPart.id,
+              delta: event.delta
+            });
+          }
+          break;
+        }
+      case "response.reasoning_summary_part.added":
+        {
+          // The first reasoning start is pushed in the `response.output_item.added` block
+          if (event.summary_index > 0) {
+            const reasoningPart = activeReasoning[event.item_id];
+            if (Predicate.isNotUndefined(reasoningPart)) {
+              reasoningPart.summaryParts.push(event.summary_index);
+            }
+            parts.push({
+              type: "reasoning-start",
+              id: `${event.item_id}:${event.summary_index}`,
+              metadata: {
+                openai: {
+                  itemId: event.item_id,
+                  encryptedContent: reasoningPart?.encryptedContent
+                }
+              }
+            });
+          }
+          break;
+        }
+      case "response.reasoning_summary_text.delta":
+        {
+          parts.push({
+            type: "reasoning-delta",
+            id: `${event.item_id}:${event.summary_index}`,
+            delta: event.delta,
+            metadata: {
+              openai: {
+                itemId: event.item_id
+              }
+            }
+          });
+          break;
+        }
     }
-  }, constDisableValidation));
-  if (Predicate.isNotNullable(choice.message.content)) {
-    parts.push(new AiResponse.TextPart({
-      text: choice.message.content
-    }, constDisableValidation));
-  }
-  const output = new AiResponse.AiResponse({
-    parts
-  }, constDisableValidation);
-  if (Predicate.isNotUndefined(structuredTool)) {
-    return yield* AiResponse.withToolCallsJson(output, [{
-      id: response.id,
-      name: structuredTool.name,
-      params: choice.message.content
-    }]);
-  }
-  if (Predicate.isNotUndefined(choice.message.tool_calls) && choice.message.tool_calls.length > 0) {
-    return yield* AiResponse.withToolCallsJson(output, choice.message.tool_calls.map(tool => ({
-      id: tool.id,
-      name: tool.function.name,
-      params: tool.function.arguments
-    })));
-  }
-  return output;
+    return parts;
+  })), Stream.flattenIterables);
 });
+// =============================================================================
+// Telemetry
+// =============================================================================
 const annotateRequest = (span, request) => {
   (0, _OpenAiTelemetry.addGenAIAnnotations)(span, {
     system: "openai",
@@ -445,59 +958,186 @@ const annotateRequest = (span, request) => {
       model: request.model,
       temperature: request.temperature,
       topP: request.top_p,
-      maxTokens: request.max_tokens,
-      stopSequences: Arr.ensure(request.stop).filter(Predicate.isNotNullable),
-      frequencyPenalty: request.frequency_penalty,
-      presencePenalty: request.presence_penalty,
-      seed: request.seed
+      maxTokens: request.max_output_tokens
     },
     openai: {
       request: {
-        responseFormat: request.response_format?.type,
+        responseFormat: request.text?.format?.type,
         serviceTier: request.service_tier
       }
     }
   });
 };
-const annotateChatResponse = (span, response) => {
+const annotateResponse = (span, response) => {
+  const finishReason = response.incomplete_details?.reason;
   (0, _OpenAiTelemetry.addGenAIAnnotations)(span, {
     response: {
       id: response.id,
       model: response.model,
-      finishReasons: response.choices.map(choice => choice.finish_reason)
+      finishReasons: Predicate.isNotUndefined(finishReason) ? [finishReason] : undefined
     },
     usage: {
-      inputTokens: response.usage?.prompt_tokens,
-      outputTokens: response.usage?.completion_tokens
+      inputTokens: response.usage?.input_tokens,
+      outputTokens: response.usage?.output_tokens
     },
     openai: {
       response: {
-        systemFingerprint: response.system_fingerprint,
         serviceTier: response.service_tier
       }
     }
   });
 };
-const annotateStreamResponse = (span, response) => {
-  const metadataPart = response.parts.find(part => part._tag === "MetadataPart");
-  const finishPart = response.parts.find(part => part._tag === "FinishPart");
-  const providerMetadata = finishPart?.providerMetadata[ProviderMetadata.key];
-  (0, _OpenAiTelemetry.addGenAIAnnotations)(span, {
-    response: {
-      id: metadataPart?.id,
-      model: metadataPart?.model,
-      finishReasons: finishPart?.reason ? [finishPart.reason] : undefined
-    },
-    usage: {
-      inputTokens: finishPart?.usage.inputTokens,
-      outputTokens: finishPart?.usage.outputTokens
-    },
-    openai: {
+const annotateStreamResponse = (span, part) => {
+  if (part.type === "response-metadata") {
+    (0, _OpenAiTelemetry.addGenAIAnnotations)(span, {
+      response: {
+        id: part.id,
+        model: part.modelId
+      }
+    });
+  }
+  if (part.type === "finish") {
+    const serviceTier = part.metadata?.openai?.serviceTier;
+    (0, _OpenAiTelemetry.addGenAIAnnotations)(span, {
       response: {
-        serviceTier: providerMetadata?.serviceTier,
-        systemFingerprint: providerMetadata?.systemFingerprint
+        finishReasons: [part.reason]
+      },
+      usage: {
+        inputTokens: part.usage.inputTokens,
+        outputTokens: part.usage.outputTokens
+      },
+      openai: {
+        response: {
+          serviceTier
+        }
+      }
+    });
+  }
+};
+const prepareTools = /*#__PURE__*/Effect.fnUntraced(function* (options) {
+  // Return immediately if no tools are in the toolkit
+  if (options.tools.length === 0) {
+    return {
+      tools: undefined,
+      toolChoice: undefined
+    };
+  }
+  const tools = [];
+  let toolChoice = undefined;
+  // Filter the incoming tools down to the set of allowed tools as indicated by
+  // the tool choice. This must be done here given that there is no tool name
+  // in OpenAI's provider-defined tools, so there would be no way to perform
+  // this filter otherwise
+  let allowedTools = options.tools;
+  if (typeof options.toolChoice === "object" && "oneOf" in options.toolChoice) {
+    const allowedToolNames = new Set(options.toolChoice.oneOf);
+    allowedTools = options.tools.filter(tool => allowedToolNames.has(tool.name));
+    toolChoice = options.toolChoice.mode === "required" ? "required" : "auto";
+  }
+  // Convert the tools in the toolkit to the provider-defined format
+  for (const tool of allowedTools) {
+    if (Tool.isUserDefined(tool)) {
+      tools.push({
+        type: "function",
+        name: tool.name,
+        description: Tool.getDescription(tool),
+        parameters: Tool.getJsonSchema(tool),
+        strict: true
+      });
+    }
+    if (Tool.isProviderDefined(tool)) {
+      switch (tool.id) {
+        case "openai.code_interpreter":
+          {
+            tools.push({
+              ...tool.args,
+              type: "code_interpreter"
+            });
+            break;
+          }
+        case "openai.file_search":
+          {
+            tools.push({
+              ...tool.args,
+              type: "file_search"
+            });
+            break;
+          }
+        case "openai.web_search":
+          {
+            tools.push({
+              ...tool.args,
+              type: "web_search"
+            });
+            break;
+          }
+        case "openai.web_search_preview":
+          {
+            tools.push({
+              ...tool.args,
+              type: "web_search_preview"
+            });
+            break;
+          }
+        default:
+          {
+            return yield* new AiError.MalformedInput({
+              module: "AnthropicLanguageModel",
+              method: "prepareTools",
+              description: `Received request to call unknown provider-defined tool '${tool.name}'`
+            });
+          }
       }
     }
-  });
+  }
+  if (options.toolChoice === "auto" || options.toolChoice === "none" || options.toolChoice === "required") {
+    toolChoice = options.toolChoice;
+  }
+  if (typeof options.toolChoice === "object" && "tool" in options.toolChoice) {
+    toolChoice = Predicate.isUndefined(OpenAiTool.getProviderDefinedToolName(options.toolChoice.tool)) ? {
+      type: "function",
+      name: options.toolChoice.tool
+    } : {
+      type: options.toolChoice.tool
+    };
+  }
+  return {
+    tools,
+    toolChoice
+  };
+});
+// =============================================================================
+// Utilities
+// =============================================================================
+const isFileId = (data, config) => Predicate.isNotUndefined(config.fileIdPrefixes) && config.fileIdPrefixes.some(prefix => data.startsWith(prefix));
+const getItemId = part => part.options.openai?.itemId;
+const getImageDetail = part => part.options.openai?.imageDetail ?? "auto";
+const prepareInclude = (options, config) => {
+  const include = new Set(config.include ?? []);
+  const codeInterpreterTool = options.tools.find(tool => Tool.isProviderDefined(tool) && tool.id === "openai.code_interpreter");
+  if (Predicate.isNotUndefined(codeInterpreterTool)) {
+    include.add("code_interpreter_call.outputs");
+  }
+  const webSearchTool = options.tools.find(tool => Tool.isProviderDefined(tool) && (tool.id === "openai.web_search" || tool.id === "openai.web_search_preview"));
+  if (Predicate.isNotUndefined(webSearchTool)) {
+    include.add("web_search_call.action.sources");
+  }
+  return Array.from(include);
+};
+const prepareResponseFormat = options => {
+  if (options.responseFormat.type === "json") {
+    const name = options.responseFormat.objectName;
+    const schema = options.responseFormat.schema;
+    return {
+      type: "json_schema",
+      name,
+      description: Tool.getDescriptionFromSchemaAst(schema.ast) ?? "Response with a JSON object",
+      schema: Tool.getJsonSchemaFromSchemaAst(schema.ast),
+      strict: true
+    };
+  }
+  return {
+    type: "text"
+  };
 };
 //# sourceMappingURL=OpenAiLanguageModel.js.map