@effect/ai-openai 0.37.2 → 4.0.0-beta.1

package/dist/OpenAiLanguageModel.js

@@ -0,0 +1,2207 @@
+/**
+ * OpenAI Language Model implementation.
+ *
+ * Provides a LanguageModel implementation for OpenAI's responses API,
+ * supporting text generation, structured output, tool calling, and streaming.
+ *
+ * @since 1.0.0
+ */
+import * as DateTime from "effect/DateTime";
+import * as Effect from "effect/Effect";
+import * as Base64 from "effect/encoding/Base64";
+import { dual } from "effect/Function";
+import * as Layer from "effect/Layer";
+import * as Predicate from "effect/Predicate";
+import * as Redactable from "effect/Redactable";
+import * as Schema from "effect/Schema";
+import * as AST from "effect/SchemaAST";
+import * as ServiceMap from "effect/ServiceMap";
+import * as Stream from "effect/Stream";
+import * as AiError from "effect/unstable/ai/AiError";
+import * as IdGenerator from "effect/unstable/ai/IdGenerator";
+import * as LanguageModel from "effect/unstable/ai/LanguageModel";
+import * as AiModel from "effect/unstable/ai/Model";
+import * as Tool from "effect/unstable/ai/Tool";
+import * as Generated from "./Generated.js";
+import * as InternalUtilities from "./internal/utilities.js";
+import { OpenAiClient } from "./OpenAiClient.js";
+import { addGenAIAnnotations } from "./OpenAiTelemetry.js";
+const ResponseModelIds = Generated.ModelIdsResponses.members[1];
+const SharedModelIds = Generated.ModelIdsShared.members[1];
+// =============================================================================
+// Configuration
+// =============================================================================
+/**
+ * Service definition for OpenAI language model configuration.
+ *
+ * @since 1.0.0
+ * @category services
+ */
+export class Config extends /*#__PURE__*/ServiceMap.Service()("@effect/ai-openai/OpenAiLanguageModel/Config") {}
+// =============================================================================
+// Language Model
+// =============================================================================
+/**
+ * @since 1.0.0
+ * @category constructors
+ */
+export const model = (model, config) => AiModel.make("openai", layer({
+  model,
+  config
+}));
+// TODO
+// /**
+//  * @since 1.0.0
+//  * @category constructors
+//  */
+// export const modelWithTokenizer = (
+//   model: (string & {}) | Model,
+//   config?: Omit<typeof Config.Service, "model">
+// ): AiModel.Model<"openai", LanguageModel.LanguageModel | Tokenizer.Tokenizer, OpenAiClient> =>
+//   AiModel.make("openai", layerWithTokenizer({ model, config }))
+/**
+ * Creates an OpenAI language model service.
+ *
+ * @since 1.0.0
+ * @category constructors
+ */
+export const make = /*#__PURE__*/Effect.fnUntraced(function* ({
+  model,
+  config: providerConfig
+}) {
+  const client = yield* OpenAiClient;
+  const makeConfig = Effect.gen(function* () {
+    const services = yield* Effect.services();
+    return {
+      model,
+      ...providerConfig,
+      ...services.mapUnsafe.get(Config.key)
+    };
+  });
+  const makeRequest = Effect.fnUntraced(function* ({
+    config,
+    options,
+    toolNameMapper
+  }) {
+    const include = new Set();
+    const capabilities = getModelCapabilities(config.model);
+    const messages = yield* prepareMessages({
+      config,
+      options,
+      capabilities,
+      include,
+      toolNameMapper
+    });
+    const {
+      toolChoice,
+      tools
+    } = yield* prepareTools({
+      config,
+      options,
+      toolNameMapper
+    });
+    const responseFormat = prepareResponseFormat({
+      config,
+      options
+    });
+    const request = {
+      ...config,
+      input: messages,
+      include: include.size > 0 ? Array.from(include) : null,
+      text: {
+        verbosity: config.text?.verbosity ?? null,
+        format: responseFormat
+      },
+      ...(Predicate.isNotUndefined(tools) ? {
+        tools
+      } : undefined),
+      ...(Predicate.isNotUndefined(toolChoice) ? {
+        tool_choice: toolChoice
+      } : undefined)
+    };
+    return request;
+  });
+  return yield* LanguageModel.make({
+    generateText: Effect.fnUntraced(function* (options) {
+      const config = yield* makeConfig;
+      const toolNameMapper = new Tool.NameMapper(options.tools);
+      const request = yield* makeRequest({
+        config,
+        options,
+        toolNameMapper
+      });
+      annotateRequest(options.span, request);
+      const [rawResponse, response] = yield* client.createResponse(request);
+      annotateResponse(options.span, rawResponse);
+      return yield* makeResponse({
+        options,
+        rawResponse,
+        response,
+        toolNameMapper
+      });
+    }),
+    streamText: Effect.fnUntraced(function* (options) {
+      const config = yield* makeConfig;
+      const toolNameMapper = new Tool.NameMapper(options.tools);
+      const request = yield* makeRequest({
+        config,
+        options,
+        toolNameMapper
+      });
+      annotateRequest(options.span, request);
+      const [response, stream] = yield* client.createResponseStream(request);
+      return yield* makeStreamResponse({
+        stream,
+        response,
+        config,
+        options,
+        toolNameMapper
+      });
+    }, (effect, options) => effect.pipe(Stream.unwrap, Stream.map(response => {
+      annotateStreamResponse(options.span, response);
+      return response;
+    })))
+  });
+});
+/**
+ * Creates a layer for the OpenAI language model.
+ *
+ * @since 1.0.0
+ * @category layers
+ */
+export const layer = options => Layer.effect(LanguageModel.LanguageModel, make(options));
+/**
+ * Provides config overrides for OpenAI language model operations.
+ *
+ * @since 1.0.0
+ * @category configuration
+ */
+export const withConfigOverride = /*#__PURE__*/dual(2, (self, overrides) => Effect.flatMap(Effect.serviceOption(Config), config => Effect.provideService(self, Config, {
+  ...(config._tag === "Some" ? config.value : {}),
+  ...overrides
+})));
+// =============================================================================
+// 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* ({
+  config,
+  options,
+  capabilities,
+  include,
+  toolNameMapper
+}) {
+  const processedApprovalIds = new Set();
+  const hasConversation = Predicate.isNotNullish(config.conversation);
+  // Provider-Defined Tools
+  const applyPatchTool = options.tools.find(tool => Tool.isProviderDefined(tool) && tool.name === "OpenAiApplyPatch");
+  const codeInterpreterTool = options.tools.find(tool => Tool.isProviderDefined(tool) && tool.name === "OpenAiCodeInterpreter");
+  const shellTool = options.tools.find(tool => Tool.isProviderDefined(tool) && tool.name === "OpenAiFunctionShell");
+  const localShellTool = options.tools.find(tool => Tool.isProviderDefined(tool) && tool.name === "OpenAiLocalShell");
+  const webSearchTool = options.tools.find(tool => Tool.isProviderDefined(tool) && tool.name === "OpenAiWebSearch");
+  const webSearchPreviewTool = options.tools.find(tool => Tool.isProviderDefined(tool) && tool.name === "OpenAiWebSearchPreview");
+  // Handle Included Features
+  if (Predicate.isNotUndefined(config.top_logprobs)) {
+    include.add("message.output_text.logprobs");
+  }
+  if (config.store === false && capabilities.isReasoningModel) {
+    include.add("reasoning.encrypted_content");
+  }
+  if (Predicate.isNotUndefined(codeInterpreterTool)) {
+    include.add("code_interpreter_call.outputs");
+  }
+  if (Predicate.isNotUndefined(webSearchTool) || Predicate.isNotUndefined(webSearchPreviewTool)) {
+    include.add("web_search_call.action.sources");
+  }
+  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":
+        {
+          const content = [];
+          for (let index = 0; index < message.content.length; index++) {
+            const part = message.content[index];
+            switch (part.type) {
+              case "text":
+                {
+                  content.push({
+                    type: "input_text",
+                    text: part.text
+                  });
+                  break;
+                }
+              case "file":
+                {
+                  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 = Base64.encode(part.data);
+                      const imageUrl = `data:${mediaType};base64,${base64}`;
+                      content.push({
+                        type: "input_image",
+                        image_url: imageUrl,
+                        detail
+                      });
+                    }
+                  } else 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 = Base64.encode(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
+                      });
+                    }
+                  } else {
+                    return yield* AiError.make({
+                      module: "OpenAiLanguageModel",
+                      method: "prepareMessages",
+                      reason: new AiError.InvalidRequestError({
+                        description: `Detected unsupported media type for file: '${part.mediaType}'`
+                      })
+                    });
+                  }
+                }
+            }
+          }
+          messages.push({
+            role: "user",
+            content
+          });
+          break;
+        }
+      case "assistant":
+        {
+          const reasoningMessages = {};
+          for (const part of message.content) {
+            switch (part.type) {
+              case "text":
+                {
+                  const id = getItemId(part);
+                  // When in conversation mode, skip items that already exist in the
+                  // conversation context to avoid "Duplicate item found" errors
+                  if (hasConversation && Predicate.isNotNull(id)) {
+                    break;
+                  }
+                  if (config.store === true && Predicate.isNotNull(id)) {
+                    messages.push({
+                      type: "item_reference",
+                      id
+                    });
+                    break;
+                  }
+                  messages.push({
+                    id: id,
+                    type: "message",
+                    role: "assistant",
+                    status: part.options.openai?.status ?? "completed",
+                    content: [{
+                      type: "output_text",
+                      text: part.text,
+                      annotations: part.options.openai?.annotations ?? [],
+                      logprobs: []
+                    }]
+                  });
+                  break;
+                }
+              case "reasoning":
+                {
+                  const id = getItemId(part);
+                  const encryptedContent = getEncryptedContent(part);
+                  if (hasConversation && Predicate.isNotNull(id)) {
+                    break;
+                  }
+                  if (Predicate.isNotNull(id)) {
+                    const message = reasoningMessages[id];
+                    if (config.store === true) {
+                      // Use item references to refer to reasoning (single reference)
+                      // when the first part is encountered
+                      if (Predicate.isUndefined(message)) {
+                        messages.push({
+                          type: "item_reference",
+                          id
+                        });
+                        // Store unused reasoning message to mark its id as used
+                        reasoningMessages[id] = {
+                          type: "reasoning",
+                          id,
+                          summary: []
+                        };
+                      }
+                    } else {
+                      const summaryParts = [];
+                      if (part.text.length > 0) {
+                        summaryParts.push({
+                          type: "summary_text",
+                          text: part.text
+                        });
+                      }
+                      if (Predicate.isUndefined(message)) {
+                        reasoningMessages[id] = {
+                          type: "reasoning",
+                          id,
+                          summary: summaryParts,
+                          encrypted_content: encryptedContent ?? null
+                        };
+                        messages.push(reasoningMessages[id]);
+                      } else {
+                        message.summary.push(...summaryParts);
+                        // Update encrypted content to enable setting it in the
+                        // last summary part
+                        if (Predicate.isNotNull(encryptedContent)) {
+                          message.encrypted_content = encryptedContent;
+                        }
+                      }
+                    }
+                  }
+                  break;
+                }
+              case "tool-call":
+                {
+                  const id = getItemId(part);
+                  const status = getStatus(part);
+                  if (hasConversation && Predicate.isNotNull(id)) {
+                    break;
+                  }
+                  if (config.store && Predicate.isNotNull(id)) {
+                    messages.push({
+                      type: "item_reference",
+                      id
+                    });
+                    break;
+                  }
+                  if (part.providerExecuted) {
+                    break;
+                  }
+                  const toolName = toolNameMapper.getProviderName(part.name);
+                  if (Predicate.isNotUndefined(localShellTool) && toolName === "local_shell") {
+                    const params = yield* Schema.decodeUnknownEffect(localShellTool.parametersSchema)(part.params).pipe(Effect.mapError(error => AiError.make({
+                      module: "OpenAiLanguageModel",
+                      method: "prepareMessages",
+                      reason: new AiError.ToolParameterValidationError({
+                        toolName: "local_shell",
+                        toolParams: part.params,
+                        description: error.message
+                      })
+                    })));
+                    messages.push({
+                      id: id,
+                      type: "local_shell_call",
+                      call_id: part.id,
+                      status: status ?? "completed",
+                      action: params.action
+                    });
+                    break;
+                  }
+                  if (Predicate.isNotUndefined(shellTool) && toolName === "shell") {
+                    const params = yield* Schema.decodeUnknownEffect(shellTool.parametersSchema)(part.params).pipe(Effect.mapError(error => AiError.make({
+                      module: "OpenAiLanguageModel",
+                      method: "prepareMessages",
+                      reason: new AiError.ToolParameterValidationError({
+                        toolName: "shell",
+                        toolParams: part.params,
+                        description: error.message
+                      })
+                    })));
+                    messages.push({
+                      id: id,
+                      type: "shell_call",
+                      call_id: part.id,
+                      status: status ?? "completed",
+                      action: params.action
+                    });
+                    break;
+                  }
+                  messages.push({
+                    type: "function_call",
+                    name: toolName,
+                    call_id: part.id,
+                    arguments: JSON.stringify(part.params),
+                    ...(Predicate.isNotNull(id) ? {
+                      id
+                    } : {}),
+                    ...(Predicate.isNotNull(status) ? {
+                      status
+                    } : {})
+                  });
+                  break;
+                }
+              // Assistant tool-result parts are always provider executed
+              case "tool-result":
+                {
+                  // Skip execution denied results - these have no corresponding
+                  // item in OpenAI's store
+                  if (Predicate.hasProperty(part.result, "type") && part.result.type === "execution-denied") {
+                    break;
+                  }
+                  if (hasConversation) {
+                    break;
+                  }
+                  if (config.store === true) {
+                    const id = getItemId(part) ?? part.id;
+                    messages.push({
+                      type: "item_reference",
+                      id
+                    });
+                  }
+                }
+            }
+          }
+          break;
+        }
+      case "tool":
+        {
+          for (const part of message.content) {
+            if (part.type === "tool-approval-response") {
+              if (processedApprovalIds.has(part.approvalId)) {
+                continue;
+              }
+              processedApprovalIds.add(part.approvalId);
+              if (config.store === true) {
+                messages.push({
+                  type: "item_reference",
+                  id: part.approvalId
+                });
+              }
+              messages.push({
+                type: "mcp_approval_response",
+                approval_request_id: part.approvalId,
+                approve: part.approved
+              });
+              continue;
+            }
+            // Skip execution-denied results that already have an approvalId -
+            // this indicates that the part was already handled via tool-approval-response
+            if (Predicate.hasProperty(part.result, "type") && part.result.type === "execution-denied") {
+              if (Predicate.isNotNullish(part.options.openai?.approvalId)) {
+                continue;
+              }
+            }
+            const id = getItemId(part) ?? part.id;
+            const status = getStatus(part);
+            const toolName = toolNameMapper.getProviderName(part.name);
+            if (Predicate.isNotUndefined(applyPatchTool) && toolName === "apply_patch") {
+              messages.push({
+                id,
+                type: "apply_patch_call_output",
+                call_id: part.id,
+                ...part.result
+              });
+            }
+            if (Predicate.isNotUndefined(shellTool) && toolName === "shell") {
+              messages.push({
+                id,
+                type: "shell_call_output",
+                call_id: part.id,
+                output: part.result,
+                ...(Predicate.isNotNull(status) ? {
+                  status
+                } : {})
+              });
+            }
+            if (Predicate.isNotUndefined(localShellTool) && toolName === "local_shell") {
+              messages.push({
+                id,
+                type: "local_shell_call_output",
+                call_id: part.id,
+                output: part.result,
+                ...(Predicate.isNotNull(status) ? {
+                  status
+                } : {})
+              });
+            }
+            messages.push({
+              type: "function_call_output",
+              call_id: part.id,
+              output: JSON.stringify(part.result),
+              ...(Predicate.isNotNull(status) ? {
+                status
+              } : {})
+            });
+          }
+          break;
+        }
+    }
+  }
+  return messages;
+});
+// =============================================================================
+// HTTP Details
+// =============================================================================
+const buildHttpRequestDetails = request => ({
+  method: request.method,
+  url: request.url,
+  urlParams: Array.from(request.urlParams),
+  hash: request.hash,
+  headers: Redactable.redact(request.headers)
+});
+const buildHttpResponseDetails = response => ({
+  status: response.status,
+  headers: Redactable.redact(response.headers)
+});
+const makeResponse = /*#__PURE__*/Effect.fnUntraced(function* ({
+  options,
+  rawResponse,
+  response,
+  toolNameMapper
+}) {
+  const idGenerator = yield* IdGenerator.IdGenerator;
+  const approvalRequests = getApprovalRequestIdMapping(options.prompt);
+  const webSearchTool = options.tools.find(tool => Tool.isProviderDefined(tool) && (tool.name === "OpenAiWebSearch" || tool.name === "OpenAiWebSearchPreview"));
+  let hasToolCalls = false;
+  const parts = [];
+  const createdAt = new Date(rawResponse.created_at * 1000);
+  parts.push({
+    type: "response-metadata",
+    id: rawResponse.id,
+    modelId: rawResponse.model,
+    timestamp: DateTime.formatIso(DateTime.fromDateUnsafe(createdAt)),
+    request: buildHttpRequestDetails(response.request)
+  });
+  for (const part of rawResponse.output) {
+    switch (part.type) {
+      case "apply_patch_call":
+        {
+          const toolName = toolNameMapper.getCustomName("apply_patch");
+          parts.push({
+            type: "tool-call",
+            id: part.call_id,
+            name: toolName,
+            params: {
+              call_id: part.call_id,
+              operation: part.operation
+            },
+            metadata: {
+              openai: {
+                ...makeItemIdMetadata(part.id)
+              }
+            }
+          });
+          break;
+        }
+      case "code_interpreter_call":
+        {
+          const toolName = toolNameMapper.getCustomName("code_interpreter");
+          parts.push({
+            type: "tool-call",
+            id: part.id,
+            name: toolName,
+            params: {
+              code: part.code,
+              container_id: part.container_id
+            },
+            providerExecuted: true
+          });
+          parts.push({
+            type: "tool-result",
+            id: part.id,
+            name: toolName,
+            isFailure: false,
+            result: {
+              outputs: part.outputs
+            },
+            providerExecuted: true
+          });
+          break;
+        }
+      case "file_search_call":
+        {
+          const toolName = toolNameMapper.getCustomName("file_search");
+          parts.push({
+            type: "tool-call",
+            id: part.id,
+            name: toolName,
+            params: {},
+            providerExecuted: true
+          });
+          parts.push({
+            type: "tool-result",
+            id: part.id,
+            name: toolName,
+            isFailure: false,
+            result: {
+              status: part.status,
+              queries: part.queries,
+              results: part.results ?? null
+            },
+            providerExecuted: true
+          });
+          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 => AiError.make({
+              module: "OpenAiLanguageModel",
+              method: "makeResponse",
+              reason: new AiError.ToolParameterValidationError({
+                toolName,
+                toolParams: {},
+                description: `Faled to securely JSON parse tool parameters: ${cause}`
+              })
+            })
+          });
+          parts.push({
+            type: "tool-call",
+            id: part.call_id,
+            name: toolName,
+            params,
+            metadata: {
+              openai: {
+                ...makeItemIdMetadata(part.id)
+              }
+            }
+          });
+          break;
+        }
+      case "image_generation_call":
+        {
+          const toolName = toolNameMapper.getCustomName("image_generation");
+          parts.push({
+            type: "tool-call",
+            id: part.id,
+            name: toolName,
+            params: {},
+            providerExecuted: true
+          });
+          parts.push({
+            type: "tool-result",
+            id: part.id,
+            name: toolName,
+            isFailure: false,
+            result: {
+              result: part.result
+            }
+          });
+          break;
+        }
+      case "local_shell_call":
+        {
+          const toolName = toolNameMapper.getCustomName("local_shell");
+          parts.push({
+            type: "tool-call",
+            id: part.call_id,
+            name: toolName,
+            params: {
+              action: part.action
+            },
+            metadata: {
+              openai: {
+                ...makeItemIdMetadata(part.id)
+              }
+            }
+          });
+          break;
+        }
+      case "mcp_call":
+        {
+          const toolId = Predicate.isNotNullish(part.approval_request_id) ? approvalRequests.get(part.approval_request_id) ?? part.id : part.id;
+          const toolName = `mcp.${part.name}`;
+          parts.push({
+            type: "tool-call",
+            id: toolId,
+            name: toolName,
+            params: part.arguments,
+            providerExecuted: true
+          });
+          parts.push({
+            type: "tool-result",
+            id: toolId,
+            name: toolName,
+            isFailure: false,
+            providerExecuted: true,
+            result: {
+              type: "call",
+              name: part.name,
+              arguments: part.arguments,
+              server_label: part.server_label,
+              ...(Predicate.isNotNullish(part.output) ? {
+                output: part.output
+              } : undefined),
+              ...(Predicate.isNotNullish(part.error) ? {
+                error: part.error
+              } : undefined)
+            },
+            metadata: {
+              openai: {
+                ...makeItemIdMetadata(part.id)
+              }
+            }
+          });
+          break;
+        }
+      case "mcp_list_tools":
+        {
+          // Skip
+          break;
+        }
+      case "mcp_approval_request":
+        {
+          const approvalRequestId = part.approval_request_id ?? part.id;
+          const toolId = yield* idGenerator.generateId();
+          const toolName = `mcp.${part.name}`;
+          const params = yield* Effect.try({
+            try: () => Tool.unsafeSecureJsonParse(part.arguments),
+            catch: cause => AiError.make({
+              module: "OpenAiLanguageModel",
+              method: "makeResponse",
+              reason: new AiError.ToolParameterValidationError({
+                toolName,
+                toolParams: {},
+                description: `Failed securely JSON parse tool parameters: ${cause}`
+              })
+            })
+          });
+          parts.push({
+            type: "tool-call",
+            id: toolId,
+            name: toolName,
+            params,
+            providerExecuted: true
+          });
+          parts.push({
+            type: "tool-approval-request",
+            toolCallId: toolId,
+            approvalId: approvalRequestId
+          });
+          break;
+        }
+      case "message":
+        {
+          for (const contentPart of part.content) {
+            switch (contentPart.type) {
+              case "output_text":
+                {
+                  const annotations = contentPart.annotations.length > 0 ? {
+                    annotations: contentPart.annotations
+                  } : undefined;
+                  parts.push({
+                    type: "text",
+                    text: contentPart.text,
+                    metadata: {
+                      openai: {
+                        ...makeItemIdMetadata(part.id),
+                        ...annotations
+                      }
+                    }
+                  });
+                  for (const annotation of contentPart.annotations) {
+                    if (annotation.type === "container_file_citation") {
+                      parts.push({
+                        type: "source",
+                        sourceType: "document",
+                        id: yield* idGenerator.generateId(),
+                        mediaType: "text/plain",
+                        title: annotation.filename,
+                        fileName: annotation.filename,
+                        metadata: {
+                          openai: {
+                            type: annotation.type,
+                            fileId: annotation.file_id,
+                            containerId: annotation.container_id
+                          }
+                        }
+                      });
+                    }
+                    if (annotation.type === "file_citation") {
+                      parts.push({
+                        type: "source",
+                        sourceType: "document",
+                        id: yield* idGenerator.generateId(),
+                        mediaType: "text/plain",
+                        title: annotation.filename,
+                        fileName: annotation.filename,
+                        metadata: {
+                          openai: {
+                            type: annotation.type,
+                            fileId: annotation.file_id,
+                            index: annotation.index
+                          }
+                        }
+                      });
+                    }
+                    if (annotation.type === "file_path") {
+                      parts.push({
+                        type: "source",
+                        sourceType: "document",
+                        id: yield* idGenerator.generateId(),
+                        mediaType: "application/octet-stream",
+                        title: annotation.file_id,
+                        fileName: annotation.file_id,
+                        metadata: {
+                          openai: {
+                            type: annotation.type,
+                            fileId: annotation.file_id,
+                            index: annotation.index
+                          }
+                        }
+                      });
+                    }
+                    if (annotation.type === "url_citation") {
+                      parts.push({
+                        type: "source",
+                        sourceType: "url",
+                        id: yield* idGenerator.generateId(),
+                        url: annotation.url,
+                        title: annotation.title,
+                        metadata: {
+                          openai: {
+                            type: annotation.type,
+                            startIndex: annotation.start_index,
+                            endIndex: annotation.end_index
+                          }
+                        }
+                      });
+                    }
+                  }
+                  break;
+                }
+              case "refusal":
+                {
+                  parts.push({
+                    type: "text",
+                    text: "",
+                    metadata: {
+                      openai: {
+                        refusal: contentPart.refusal
+                      }
+                    }
+                  });
+                  break;
+                }
+            }
+          }
+          break;
+        }
+      case "reasoning":
+        {
+          const metadata = {
+            openai: {
+              ...makeItemIdMetadata(part.id),
+              ...makeEncryptedContentMetadata(part.encrypted_content)
+            }
+          };
+          // If there are no summary parts, we have to add an empty one to
+          // propagate the part identifier and encrypted content
+          if (part.summary.length === 0) {
+            parts.push({
+              type: "reasoning",
+              text: "",
+              metadata
+            });
+          } else {
+            for (const summary of part.summary) {
+              parts.push({
+                type: "reasoning",
+                text: summary.text,
+                metadata
+              });
+            }
+          }
+          break;
+        }
+      case "shell_call":
+        {
+          const toolName = toolNameMapper.getCustomName("shell");
+          parts.push({
+            type: "tool-call",
+            id: part.call_id,
+            name: toolName,
+            params: {
+              action: part.action
+            },
+            metadata: {
+              openai: {
+                ...makeItemIdMetadata(part.id)
+              }
+            }
+          });
+          break;
+        }
+      case "web_search_call":
+        {
+          const toolName = toolNameMapper.getCustomName(webSearchTool?.name ?? "web_search");
+          parts.push({
+            type: "tool-call",
+            id: part.id,
+            name: toolName,
+            params: {},
+            providerExecuted: true
+          });
+          parts.push({
+            type: "tool-result",
+            id: part.id,
+            name: toolName,
+            isFailure: false,
+            result: {
+              action: part.action,
+              status: part.status
+            },
+            providerExecuted: true
+          });
+          break;
+        }
+    }
+  }
+  const finishReason = InternalUtilities.resolveFinishReason(rawResponse.incomplete_details?.reason, hasToolCalls);
+  parts.push({
+    type: "finish",
+    reason: finishReason,
+    usage: getUsage(rawResponse.usage),
+    response: buildHttpResponseDetails(response),
+    ...(rawResponse.service_tier && {
+      metadata: {
+        openai: {
+          serviceTier: rawResponse.service_tier
+        }
+      }
+    })
+  });
+  return parts;
+});
+const makeStreamResponse = /*#__PURE__*/Effect.fnUntraced(function* ({
+  stream,
+  response,
+  config,
+  options,
+  toolNameMapper
+}) {
+  const idGenerator = yield* IdGenerator.IdGenerator;
+  const approvalRequests = getApprovalRequestIdMapping(options.prompt);
+  const streamApprovalRequests = new Map();
+  let hasToolCalls = false;
+  // Track annotations for current message to include in text-end metadata
+  const activeAnnotations = [];
+  // Track active reasoning items with state machine for proper concluding logic
+  const activeReasoning = {};
+  // Track active tool calls with optional provider-specific state
+  const activeToolCalls = {};
+  const webSearchTool = options.tools.find(tool => Tool.isProviderDefined(tool) && (tool.name === "OpenAiWebSearch" || tool.name === "OpenAiWebSearchPreview"));
+  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.fromDateUnsafe(createdAt)),
+            request: buildHttpRequestDetails(response.request)
+          });
+          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: getUsage(event.response.usage),
+            response: buildHttpResponseDetails(response),
+            ...(event.response.service_tier && {
+              metadata: {
+                openai: {
+                  serviceTier: event.response.service_tier
+                }
+              }
+            })
+          });
+          break;
+        }
+      case "response.output_item.added":
+        {
+          switch (event.item.type) {
+            case "apply_patch_call":
+              {
+                const toolId = event.item.call_id;
+                const toolName = toolNameMapper.getCustomName("apply_patch");
+                const operation = event.item.operation;
+                activeToolCalls[event.output_index] = {
+                  id: toolId,
+                  name: toolName,
+                  applyPatch: {
+                    hasDiff: operation.type !== "delete_file",
+                    endEmitted: operation.type === "delete_file"
+                  }
+                };
+                parts.push({
+                  type: "tool-params-start",
+                  id: toolId,
+                  name: toolName
+                });
+                if (operation.type === "delete_file") {
+                  parts.push({
+                    type: "tool-params-delta",
+                    id: toolId,
+                    delta: JSON.stringify({
+                      call_id: toolId,
+                      operation: operation
+                    })
+                  });
+                  parts.push({
+                    type: "tool-params-end",
+                    id: toolId
+                  });
+                } else {
+                  parts.push({
+                    type: "tool-params-delta",
+                    id: toolId,
+                    delta: `{"call_id":"${InternalUtilities.escapeJSONDelta(toolId)}",` + `"operation":{"type":"${InternalUtilities.escapeJSONDelta(operation.type)}",` + `"path":"${InternalUtilities.escapeJSONDelta(operation.path)}","diff":"`
+                  });
+                }
+                break;
+              }
+            case "code_interpreter_call":
+              {
+                const toolName = toolNameMapper.getCustomName("code_interpreter");
+                activeToolCalls[event.output_index] = {
+                  id: event.item.id,
+                  name: toolName,
+                  codeInterpreter: {
+                    containerId: event.item.container_id
+                  }
+                };
+                parts.push({
+                  type: "tool-params-start",
+                  id: event.item.id,
+                  name: toolName,
+                  providerExecuted: true
+                });
+                parts.push({
+                  type: "tool-params-delta",
+                  id: event.item.id,
+                  delta: `{"containerId":"${event.item.container_id}","code":"`
+                });
+                break;
+              }
+            case "computer_call":
+              {
+                const toolName = toolNameMapper.getCustomName("computer_use");
+                activeToolCalls[event.output_index] = {
+                  id: event.item.id,
+                  name: toolName
+                };
+                parts.push({
+                  type: "tool-params-start",
+                  id: event.item.id,
+                  name: toolName,
+                  providerExecuted: true
+                });
+                break;
+              }
+            case "file_search_call":
+              {
+                const toolName = toolNameMapper.getCustomName("file_search");
+                parts.push({
+                  type: "tool-call",
+                  id: event.item.id,
+                  name: toolName,
+                  params: {},
+                  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 "image_generation_call":
+              {
+                const toolName = toolNameMapper.getCustomName("image_generation");
+                parts.push({
+                  type: "tool-call",
+                  id: event.item.id,
+                  name: toolName,
+                  params: {},
+                  providerExecuted: true
+                });
+                break;
+              }
+            case "mcp_call":
+            case "mcp_list_tools":
+            case "mcp_approval_request":
+              {
+                // We emit MCP tool call / approvals on `output_item.done` to facilitate:
+                // - Aliasing tool call identifiers when an approval request id exists
+                // - Emit a proper tool-approval-request part for MCP approvals
+                break;
+              }
+            case "message":
+              {
+                // Clear annotations for new message
+                activeAnnotations.length = 0;
+                parts.push({
+                  type: "text-start",
+                  id: event.item.id,
+                  metadata: {
+                    openai: {
+                      ...makeItemIdMetadata(event.item.id)
+                    }
+                  }
+                });
+                break;
+              }
+            case "reasoning":
+              {
+                const encryptedContent = event.item.encrypted_content ?? undefined;
+                activeReasoning[event.item.id] = {
+                  encryptedContent,
+                  summaryParts: {
+                    0: "active"
+                  }
+                };
+                parts.push({
+                  type: "reasoning-start",
+                  id: `${event.item.id}:0`,
+                  metadata: {
+                    openai: {
+                      ...makeItemIdMetadata(event.item.id),
+                      ...makeEncryptedContentMetadata(event.item.encrypted_content)
+                    }
+                  }
+                });
+                break;
+              }
+            case "shell_call":
+              {
+                const toolName = toolNameMapper.getCustomName("shell");
+                activeToolCalls[event.output_index] = {
+                  id: event.item.id,
+                  name: toolName
+                };
+                break;
+              }
+            case "web_search_call":
+              {
+                const toolName = toolNameMapper.getCustomName(webSearchTool?.providerName ?? "web_search");
+                activeToolCalls[event.output_index] = {
+                  id: event.item.id,
+                  name: toolName
+                };
+                parts.push({
+                  type: "tool-params-start",
+                  id: event.item.id,
+                  name: webSearchTool?.name ?? "OpenAiWebSearch",
+                  providerExecuted: true
+                });
+                parts.push({
+                  type: "tool-params-end",
+                  id: event.item.id
+                });
+                parts.push({
+                  type: "tool-call",
+                  id: event.item.id,
+                  name: toolName,
+                  params: {},
+                  providerExecuted: true
+                });
+                break;
+              }
+          }
+          break;
+        }
+      case "response.output_item.done":
+        {
+          switch (event.item.type) {
+            case "apply_patch_call":
+              {
+                const toolCall = activeToolCalls[event.output_index];
+                if (Predicate.isNotUndefined(toolCall.applyPatch) && !toolCall.applyPatch.endEmitted && event.item.operation.type !== "delete_file") {
+                  if (!toolCall.applyPatch.hasDiff) {
+                    parts.push({
+                      type: "tool-params-delta",
+                      id: toolCall.id,
+                      delta: InternalUtilities.escapeJSONDelta(event.item.operation.diff)
+                    });
+                  }
+                  parts.push({
+                    type: "tool-params-delta",
+                    id: toolCall.id,
+                    delta: `"}}`
+                  });
+                  parts.push({
+                    type: "tool-params-end",
+                    id: toolCall.id
+                  });
+                  toolCall.applyPatch.endEmitted = true;
+                }
+                // Emit the final tool call with the complete diff when the status is completed
+                if (Predicate.isNotUndefined(toolCall) && event.item.status === "completed") {
+                  const toolName = toolNameMapper.getCustomName("apply_patch");
+                  parts.push({
+                    type: "tool-call",
+                    id: toolCall.id,
+                    name: toolName,
+                    params: {
+                      call_id: event.item.call_id,
+                      operation: event.item.operation
+                    },
+                    metadata: {
+                      openai: {
+                        ...makeItemIdMetadata(event.item.id)
+                      }
+                    }
+                  });
+                }
+                delete activeToolCalls[event.output_index];
+                break;
+              }
+            case "code_interpreter_call":
+              {
+                delete activeToolCalls[event.output_index];
+                const toolName = toolNameMapper.getCustomName("code_interpreter");
+                parts.push({
+                  type: "tool-result",
+                  id: event.item.id,
+                  name: toolName,
+                  isFailure: false,
+                  result: {
+                    outputs: event.item.outputs
+                  },
+                  providerExecuted: true
+                });
+                break;
+              }
+            case "computer_call":
+              {
+                delete activeToolCalls[event.output_index];
+                const toolName = toolNameMapper.getCustomName("computer_use");
+                parts.push({
+                  type: "tool-params-end",
+                  id: event.item.id
+                });
+                parts.push({
+                  type: "tool-call",
+                  id: event.item.id,
+                  name: toolName,
+                  params: {},
+                  providerExecuted: true
+                });
+                parts.push({
+                  type: "tool-result",
+                  id: event.item.id,
+                  name: toolName,
+                  isFailure: false,
+                  result: {
+                    status: event.item.status ?? "completed"
+                  }
+                });
+                break;
+              }
+            case "file_search_call":
+              {
+                delete activeToolCalls[event.output_index];
+                const toolName = toolNameMapper.getCustomName("file_search");
+                const results = Predicate.isNotNullish(event.item.results) ? {
+                  results: event.item.results
+                } : undefined;
+                parts.push({
+                  type: "tool-result",
+                  id: event.item.id,
+                  name: toolName,
+                  isFailure: false,
+                  result: {
+                    ...results,
+                    status: event.item.status,
+                    queries: event.item.queries
+                  },
+                  providerExecuted: true
+                });
+                break;
+              }
+            case "function_call":
+              {
+                delete activeToolCalls[event.output_index];
+                hasToolCalls = true;
+                const toolName = event.item.name;
+                const toolParams = event.item.arguments;
+                const params = yield* Effect.try({
+                  try: () => Tool.unsafeSecureJsonParse(toolParams),
+                  catch: cause => AiError.make({
+                    module: "OpenAiLanguageModel",
+                    method: "makeStreamResponse",
+                    reason: new AiError.ToolParameterValidationError({
+                      toolName,
+                      toolParams: {},
+                      description: `Failed securely JSON parse tool parameters: ${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: {
+                      ...makeItemIdMetadata(event.item.id)
+                    }
+                  }
+                });
+                break;
+              }
+            case "image_generation_call":
+              {
+                const toolName = toolNameMapper.getCustomName("image_generation");
+                parts.push({
+                  type: "tool-result",
+                  id: event.item.id,
+                  name: toolName,
+                  isFailure: false,
+                  result: {
+                    result: event.item.result
+                  },
+                  providerExecuted: true
+                });
+                break;
+              }
+            case "local_shell_call":
+              {
+                const toolName = toolNameMapper.getCustomName("local_shell");
+                parts.push({
+                  type: "tool-call",
+                  id: event.item.call_id,
+                  name: toolName,
+                  params: {
+                    action: event.item.action
+                  },
+                  metadata: {
+                    openai: {
+                      ...makeItemIdMetadata(event.item.id)
+                    }
+                  }
+                });
+                break;
+              }
+            case "mcp_call":
+              {
+                const approvalRequestId = event.item.approval_request_id;
+                // Track approval with our own tool call identifiers
+                const toolId = Predicate.isNotNullish(approvalRequestId) ? streamApprovalRequests.get(approvalRequestId) ?? approvalRequests.get(approvalRequestId) ?? event.item.id : event.item.id;
+                const toolName = `mcp.${event.item.name}`;
+                parts.push({
+                  type: "tool-call",
+                  id: toolId,
+                  name: toolName,
+                  params: event.item.arguments,
+                  providerExecuted: true
+                });
+                parts.push({
+                  type: "tool-result",
+                  id: toolId,
+                  name: toolName,
+                  isFailure: false,
+                  providerExecuted: true,
+                  result: {
+                    type: "call",
+                    name: event.item.name,
+                    arguments: event.item.arguments,
+                    server_label: event.item.server_label,
+                    ...(Predicate.isNotNullish(event.item.output) ? {
+                      output: event.item.output
+                    } : undefined),
+                    ...(Predicate.isNotNullish(event.item.error) ? {
+                      error: event.item.error
+                    } : undefined)
+                  },
+                  metadata: {
+                    openai: {
+                      ...makeItemIdMetadata(event.item.id)
+                    }
+                  }
+                });
+                break;
+              }
+            case "mcp_list_tools":
+              {
+                // Skip
+                break;
+              }
+            case "mcp_approval_request":
+              {
+                const toolId = yield* idGenerator.generateId();
+                const approvalRequestId = event.item.approval_request_id ?? event.item.id;
+                streamApprovalRequests.set(approvalRequestId, toolId);
+                const toolName = `mcp.${event.item.name}`;
+                parts.push({
+                  type: "tool-call",
+                  id: toolId,
+                  name: toolName,
+                  params: event.item.arguments,
+                  providerExecuted: true
+                });
+                parts.push({
+                  type: "tool-approval-request",
+                  approvalId: approvalRequestId,
+                  toolCallId: toolId
+                });
+                break;
+              }
+            case "message":
+              {
+                const annotations = activeAnnotations.length > 0 ? {
+                  annotations: activeAnnotations.slice()
+                } : undefined;
+                parts.push({
+                  type: "text-end",
+                  id: event.item.id,
+                  metadata: {
+                    openai: {
+                      ...annotations,
+                      ...makeItemIdMetadata(event.item.id)
+                    }
+                  }
+                });
+                break;
+              }
+            case "reasoning":
+              {
+                const reasoningPart = activeReasoning[event.item.id];
+                for (const [summaryIndex, status] of Object.entries(reasoningPart.summaryParts)) {
+                  if (status === "active" || status === "can-conclude") {
+                    parts.push({
+                      type: "reasoning-end",
+                      id: `${event.item.id}:${summaryIndex}`,
+                      metadata: {
+                        openai: {
+                          ...makeItemIdMetadata(event.item.id),
+                          ...makeEncryptedContentMetadata(event.item.encrypted_content)
+                        }
+                      }
+                    });
+                  }
+                }
+                delete activeReasoning[event.item.id];
+                break;
+              }
+            case "shell_call":
+              {
+                delete activeToolCalls[event.output_index];
+                const toolName = toolNameMapper.getCustomName("shell");
+                parts.push({
+                  type: "tool-call",
+                  id: event.item.id,
+                  name: toolName,
+                  params: {
+                    action: event.item.action
+                  },
+                  metadata: {
+                    openai: {
+                      ...makeItemIdMetadata(event.item.id)
+                    }
+                  }
+                });
+                break;
+              }
+            case "web_search_call":
+              {
+                delete activeToolCalls[event.output_index];
+                const toolName = toolNameMapper.getCustomName(webSearchTool?.name ?? "web_search");
+                parts.push({
+                  type: "tool-result",
+                  id: event.item.id,
+                  name: toolName,
+                  isFailure: false,
+                  result: {
+                    action: event.item.action,
+                    status: event.item.status
+                  },
+                  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":
+        {
+          const annotation = event.annotation;
+          // Track annotation for text-end metadata
+          activeAnnotations.push(annotation);
+          if (annotation.type === "container_file_citation") {
+            parts.push({
+              type: "source",
+              sourceType: "document",
+              id: yield* idGenerator.generateId(),
+              mediaType: "text/plain",
+              title: annotation.filename,
+              fileName: annotation.filename,
+              metadata: {
+                openai: {
+                  type: annotation.type,
+                  fileId: annotation.file_id,
+                  containerId: annotation.container_id
+                }
+              }
+            });
+          } else if (annotation.type === "file_citation") {
+            parts.push({
+              type: "source",
+              sourceType: "document",
+              id: yield* idGenerator.generateId(),
+              mediaType: "text/plain",
+              title: annotation.filename,
+              fileName: annotation.filename,
+              metadata: {
+                openai: {
+                  type: annotation.type,
+                  fileId: annotation.file_id,
+                  index: annotation.index
+                }
+              }
+            });
+          } else if (annotation.type === "file_path") {
+            parts.push({
+              type: "source",
+              sourceType: "document",
+              id: yield* idGenerator.generateId(),
+              mediaType: "application/octet-stream",
+              title: annotation.file_id,
+              fileName: annotation.file_id,
+              metadata: {
+                openai: {
+                  type: annotation.type,
+                  fileId: annotation.file_id,
+                  index: annotation.index
+                }
+              }
+            });
+          } else if (annotation.type === "url_citation") {
+            parts.push({
+              type: "source",
+              sourceType: "url",
+              id: yield* idGenerator.generateId(),
+              url: annotation.url,
+              title: annotation.title,
+              metadata: {
+                openai: {
+                  type: annotation.type,
+                  startIndex: annotation.start_index,
+                  endIndex: annotation.end_index
+                }
+              }
+            });
+          }
+          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.apply_patch_call_operation_diff.delta":
+        {
+          const toolCall = activeToolCalls[event.output_index];
+          if (Predicate.isNotUndefined(toolCall?.applyPatch)) {
+            parts.push({
+              type: "tool-params-delta",
+              id: toolCall.id,
+              delta: InternalUtilities.escapeJSONDelta(event.delta)
+            });
+            toolCall.applyPatch.hasDiff = true;
+          }
+          break;
+        }
+      case "response.apply_patch_call_operation_diff.done":
+        {
+          const toolCall = activeToolCalls[event.output_index];
+          if (Predicate.isNotUndefined(toolCall?.applyPatch) && !toolCall.applyPatch.endEmitted) {
+            if (!toolCall.applyPatch.hasDiff && Predicate.isNotUndefined(event.delta)) {
+              parts.push({
+                type: "tool-params-delta",
+                id: toolCall.id,
+                delta: InternalUtilities.escapeJSONDelta(event.delta)
+              });
+              toolCall.applyPatch.hasDiff = true;
+            }
+            parts.push({
+              type: "tool-params-delta",
+              id: toolCall.id,
+              delta: `"}}`
+            });
+            parts.push({
+              type: "tool-params-end",
+              id: toolCall.id
+            });
+            toolCall.applyPatch.endEmitted = true;
+          }
+          break;
+        }
+      case "response.code_interpreter_call_code.delta":
+        {
+          const toolCall = activeToolCalls[event.output_index];
+          if (Predicate.isNotUndefined(toolCall)) {
+            parts.push({
+              type: "tool-params-delta",
+              id: toolCall.id,
+              delta: InternalUtilities.escapeJSONDelta(event.delta)
+            });
+          }
+          break;
+        }
+      case "response.code_interpreter_call_code.done":
+        {
+          const toolCall = activeToolCalls[event.output_index];
+          if (Predicate.isNotUndefined(toolCall) && Predicate.isNotUndefined(toolCall.codeInterpreter)) {
+            const toolName = toolNameMapper.getCustomName("code_interpreter");
+            parts.push({
+              type: "tool-params-delta",
+              id: toolCall.id,
+              delta: "\"}"
+            });
+            parts.push({
+              type: "tool-params-end",
+              id: toolCall.id
+            });
+            parts.push({
+              type: "tool-call",
+              id: toolCall.id,
+              name: toolName,
+              params: {
+                code: event.code,
+                container_id: toolCall.codeInterpreter.containerId
+              },
+              providerExecuted: true
+            });
+          }
+          break;
+        }
+      case "response.image_generation_call.partial_image":
+        {
+          const toolName = toolNameMapper.getCustomName("image_generation");
+          parts.push({
+            type: "tool-result",
+            id: event.item_id,
+            name: toolName,
+            isFailure: false,
+            providerExecuted: false,
+            result: {
+              result: event.partial_image_b64
+            },
+            preliminary: true
+          });
+          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)) {
+              // Conclude all can-conclude parts before starting new one
+              for (const [summaryIndex, status] of Object.entries(reasoningPart.summaryParts)) {
+                if (status === "can-conclude") {
+                  parts.push({
+                    type: "reasoning-end",
+                    id: `${event.item_id}:${summaryIndex}`,
+                    metadata: {
+                      openai: {
+                        ...makeItemIdMetadata(event.item_id),
+                        ...makeEncryptedContentMetadata(reasoningPart.encryptedContent)
+                      }
+                    }
+                  });
+                  reasoningPart.summaryParts[Number(summaryIndex)] = "concluded";
+                }
+              }
+              reasoningPart.summaryParts[event.summary_index] = "active";
+            }
+            parts.push({
+              type: "reasoning-start",
+              id: `${event.item_id}:${event.summary_index}`,
+              metadata: {
+                openai: {
+                  ...makeItemIdMetadata(event.item_id),
+                  ...makeEncryptedContentMetadata(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: {
+                ...makeItemIdMetadata(event.item_id)
+              }
+            }
+          });
+          break;
+        }
+      case "response.reasoning_summary_part.done":
+        {
+          // When OpenAI stores message data, we can immediately conclude the
+          // reasoning part given that we do not need the encrypted content
+          if (config.store === true) {
+            parts.push({
+              type: "reasoning-end",
+              id: `${event.item_id}:${event.summary_index}`,
+              metadata: {
+                openai: {
+                  ...makeItemIdMetadata(event.item_id)
+                }
+              }
+            });
+            // Mark the summary part concluded
+            activeReasoning[event.item_id].summaryParts[event.summary_index] = "concluded";
+          } else {
+            // Mark the summary part as can-conclude given we still need a
+            // final summary part with the encrypted content
+            activeReasoning[event.item_id].summaryParts[event.summary_index] = "can-conclude";
+          }
+          break;
+        }
+    }
+    return parts;
+  })), Stream.flattenIterable);
+});
+// =============================================================================
+// Telemetry
+// =============================================================================
+const annotateRequest = (span, request) => {
+  addGenAIAnnotations(span, {
+    system: "openai",
+    operation: {
+      name: "chat"
+    },
+    request: {
+      model: request.model,
+      temperature: request.temperature,
+      topP: request.top_p,
+      maxTokens: request.max_output_tokens
+    },
+    openai: {
+      request: {
+        responseFormat: request.text?.format?.type,
+        serviceTier: request.service_tier
+      }
+    }
+  });
+};
+const annotateResponse = (span, response) => {
+  const finishReason = response.incomplete_details?.reason;
+  addGenAIAnnotations(span, {
+    response: {
+      id: response.id,
+      model: response.model,
+      finishReasons: Predicate.isNotUndefined(finishReason) ? [finishReason] : undefined
+    },
+    usage: {
+      inputTokens: response.usage?.input_tokens,
+      outputTokens: response.usage?.output_tokens
+    },
+    openai: {
+      response: {
+        serviceTier: response.service_tier
+      }
+    }
+  });
+};
+const annotateStreamResponse = (span, part) => {
+  if (part.type === "response-metadata") {
+    addGenAIAnnotations(span, {
+      response: {
+        id: part.id,
+        model: part.modelId
+      }
+    });
+  }
+  if (part.type === "finish") {
+    const serviceTier = part.metadata?.openai?.serviceTier;
+    addGenAIAnnotations(span, {
+      response: {
+        finishReasons: [part.reason]
+      },
+      usage: {
+        inputTokens: part.usage.inputTokens.total,
+        outputTokens: part.usage.outputTokens.total
+      },
+      openai: {
+        response: {
+          serviceTier
+        }
+      }
+    });
+  }
+};
+const prepareTools = /*#__PURE__*/Effect.fnUntraced(function* ({
+  config,
+  options,
+  toolNameMapper
+}) {
+  // 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)) {
+      const strict = Tool.getStrictMode(tool) ?? config.strictJsonSchema ?? true;
+      tools.push({
+        type: "function",
+        name: tool.name,
+        description: Tool.getDescription(tool) ?? null,
+        parameters: Tool.getJsonSchema(tool),
+        strict
+      });
+    }
+    if (Tool.isProviderDefined(tool)) {
+      const openAiTool = tool;
+      switch (openAiTool.name) {
+        case "OpenAiApplyPatch":
+          {
+            tools.push({
+              type: "apply_patch"
+            });
+            break;
+          }
+        case "OpenAiCodeInterpreter":
+          {
+            const args = yield* Schema.decodeUnknownEffect(openAiTool.argsSchema)(tool.args).pipe(Effect.mapError(error => AiError.make({
+              module: "OpenAiLanguageModel",
+              method: "prepareTools",
+              reason: new AiError.ToolConfigurationError({
+                toolName: openAiTool.name,
+                description: error.message
+              })
+            })));
+            tools.push({
+              ...args,
+              type: "code_interpreter"
+            });
+            break;
+          }
+        case "OpenAiFileSearch":
+          {
+            const args = yield* Schema.decodeUnknownEffect(openAiTool.argsSchema)(tool.args).pipe(Effect.mapError(error => AiError.make({
+              module: "OpenAiLanguageModel",
+              method: "prepareTools",
+              reason: new AiError.ToolConfigurationError({
+                toolName: openAiTool.name,
+                description: error.message
+              })
+            })));
+            tools.push({
+              ...args,
+              type: "file_search"
+            });
+            break;
+          }
+        case "OpenAiShell":
+          {
+            tools.push({
+              type: "shell"
+            });
+            break;
+          }
+        case "OpenAiImageGeneration":
+          {
+            const args = yield* Schema.decodeUnknownEffect(openAiTool.argsSchema)(tool.args).pipe(Effect.mapError(error => AiError.make({
+              module: "OpenAiLanguageModel",
+              method: "prepareTools",
+              reason: new AiError.ToolConfigurationError({
+                toolName: openAiTool.name,
+                description: error.message
+              })
+            })));
+            tools.push({
+              ...args,
+              type: "image_generation"
+            });
+            break;
+          }
+        case "OpenAiLocalShell":
+          {
+            tools.push({
+              type: "local_shell"
+            });
+            break;
+          }
+        case "OpenAiMcp":
+          {
+            const args = yield* Schema.decodeUnknownEffect(openAiTool.argsSchema)(tool.args).pipe(Effect.mapError(error => AiError.make({
+              module: "OpenAiLanguageModel",
+              method: "prepareTools",
+              reason: new AiError.ToolConfigurationError({
+                toolName: openAiTool.name,
+                description: error.message
+              })
+            })));
+            tools.push({
+              ...args,
+              type: "mcp"
+            });
+            break;
+          }
+        case "OpenAiWebSearch":
+          {
+            const args = yield* Schema.decodeUnknownEffect(openAiTool.argsSchema)(tool.args).pipe(Effect.mapError(error => AiError.make({
+              module: "OpenAiLanguageModel",
+              method: "prepareTools",
+              reason: new AiError.ToolConfigurationError({
+                toolName: openAiTool.name,
+                description: error.message
+              })
+            })));
+            tools.push({
+              ...args,
+              type: "web_search"
+            });
+            break;
+          }
+        case "OpenAiWebSearchPreview":
+          {
+            const args = yield* Schema.decodeUnknownEffect(openAiTool.argsSchema)(tool.args).pipe(Effect.mapError(error => AiError.make({
+              module: "OpenAiLanguageModel",
+              method: "prepareTools",
+              reason: new AiError.ToolConfigurationError({
+                toolName: openAiTool.name,
+                description: error.message
+              })
+            })));
+            tools.push({
+              ...args,
+              type: "web_search_preview"
+            });
+            break;
+          }
+        default:
+          {
+            return yield* AiError.make({
+              module: "OpenAiLanguageModel",
+              method: "prepareTools",
+              reason: new AiError.InvalidRequestError({
+                description: `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) {
+    const toolName = toolNameMapper.getProviderName(options.toolChoice.tool);
+    const providerNames = toolNameMapper.providerNames;
+    if (providerNames.includes(toolName)) {
+      toolChoice = {
+        type: toolName
+      };
+    } else {
+      toolChoice = {
+        type: "function",
+        name: options.toolChoice.tool
+      };
+    }
+  }
+  return {
+    tools,
+    toolChoice
+  };
+});
+// =============================================================================
+// Utilities
+// =============================================================================
+const isFileId = (data, config) => config.fileIdPrefixes != null && config.fileIdPrefixes.some(prefix => data.startsWith(prefix));
+const getItemId = part => part.options.openai?.itemId ?? null;
+const getStatus = part => part.options.openai?.status ?? null;
+const getEncryptedContent = part => part.options.openai?.encryptedContent ?? null;
+const getImageDetail = part => part.options.openai?.imageDetail ?? "auto";
+const makeItemIdMetadata = itemId => Predicate.isNotUndefined(itemId) ? {
+  itemId
+} : undefined;
+const makeEncryptedContentMetadata = encryptedContent => Predicate.isNotNullish(encryptedContent) ? {
+  encryptedContent
+} : undefined;
+const prepareResponseFormat = ({
+  config,
+  options
+}) => {
+  if (options.responseFormat.type === "json") {
+    const name = options.responseFormat.objectName;
+    const schema = options.responseFormat.schema;
+    return {
+      type: "json_schema",
+      name,
+      description: AST.resolveDescription(schema.ast) ?? "Response with a JSON object",
+      schema: Tool.getJsonSchemaFromSchema(schema),
+      strict: config.strictJsonSchema ?? true
+    };
+  }
+  return {
+    type: "text"
+  };
+};
+const getModelCapabilities = modelId => {
+  const supportsFlexProcessing = modelId.startsWith("o3") || modelId.startsWith("o4-mini") || modelId.startsWith("gpt-5") && !modelId.startsWith("gpt-5-chat");
+  const supportsPriorityProcessing = modelId.startsWith("gpt-4") || modelId.startsWith("gpt-5-mini") || modelId.startsWith("gpt-5") && !modelId.startsWith("gpt-5-nano") && !modelId.startsWith("gpt-5-chat") || modelId.startsWith("o3") || modelId.startsWith("o4-mini");
+  // Use allowlist approach: only known reasoning models should use 'developer' role
+  // This prevents issues with fine-tuned models, third-party models, and custom models
+  const isReasoningModel = modelId.startsWith("o1") || modelId.startsWith("o3") || modelId.startsWith("o4-mini") || modelId.startsWith("codex-mini") || modelId.startsWith("computer-use-preview") || modelId.startsWith("gpt-5") && !modelId.startsWith("gpt-5-chat");
+  // https://platform.openai.com/docs/guides/latest-model#gpt-5-1-parameter-compatibility
+  // GPT-5.1 and GPT-5.2 support temperature, topP, logProbs when reasoningEffort is none
+  const supportsNonReasoningParameters = modelId.startsWith("gpt-5.1") || modelId.startsWith("gpt-5.2");
+  const systemMessageMode = isReasoningModel ? "developer" : "system";
+  return {
+    supportsFlexProcessing,
+    supportsPriorityProcessing,
+    isReasoningModel,
+    systemMessageMode,
+    supportsNonReasoningParameters
+  };
+};
+const getApprovalRequestIdMapping = prompt => {
+  const mapping = new Map();
+  for (const message of prompt.content) {
+    if (message.role !== "assistant") {
+      continue;
+    }
+    for (const part of message.content) {
+      if (part.type !== "tool-call") {
+        continue;
+      }
+      const approvalRequestId = part.options.openai?.approvalRequestId;
+      if (Predicate.isNotNullish(approvalRequestId)) {
+        mapping.set(approvalRequestId, part.id);
+      }
+    }
+  }
+  return mapping;
+};
+const getUsage = usage => {
+  if (Predicate.isNullish(usage)) {
+    return {
+      inputTokens: {
+        uncached: undefined,
+        total: undefined,
+        cacheRead: undefined,
+        cacheWrite: undefined
+      },
+      outputTokens: {
+        total: undefined,
+        text: undefined,
+        reasoning: undefined
+      }
+    };
+  }
+  const inputTokens = usage.input_tokens;
+  const outputTokens = usage.output_tokens;
+  const cachedTokens = usage.input_tokens_details.cached_tokens;
+  const reasoningTokens = usage.output_tokens_details.reasoning_tokens;
+  return {
+    inputTokens: {
+      uncached: inputTokens - cachedTokens,
+      total: inputTokens,
+      cacheRead: cachedTokens,
+      cacheWrite: undefined
+    },
+    outputTokens: {
+      total: outputTokens,
+      text: outputTokens - reasoningTokens,
+      reasoning: reasoningTokens
+    }
+  };
+};
+//# sourceMappingURL=OpenAiLanguageModel.js.map