@effect/ai-openai 4.0.0-beta.7 → 4.0.0-beta.71

package/dist/OpenAiLanguageModel.js

@@ -1,26 +1,58 @@
 /**
- * OpenAI Language Model implementation.
+ * The `OpenAiLanguageModel` module provides the OpenAI Responses API
+ * implementation of Effect AI's `LanguageModel` service. It translates Effect
+ * AI prompts, files, tools, structured output requests, reasoning metadata, and
+ * provider options into OpenAI response requests, then converts OpenAI
+ * responses and streams back into Effect AI response parts.
  *
- * Provides a LanguageModel implementation for OpenAI's responses API,
- * supporting text generation, structured output, tool calling, and streaming.
+ * **Mental model**
  *
- * @since 1.0.0
+ * `OpenAiClient` owns HTTP transport and provider calls. This module owns
+ * protocol translation: request assembly, tool choice conversion, structured
+ * output codecs, streaming event handling, response metadata, and GenAI
+ * telemetry annotations. {@link model}, {@link layer}, and {@link make} all
+ * build the same OpenAI-backed `LanguageModel.LanguageModel` service from a
+ * model id and optional request defaults.
+ *
+ * **Common tasks**
+ *
+ * - Provide an OpenAI-backed `LanguageModel.LanguageModel` from an existing
+ *   `OpenAiClient`
+ * - Generate text or stream text through Effect AI's provider-neutral language
+ *   model API
+ * - Use OpenAI provider metadata for files, reasoning items, tool calls, and
+ *   response parts
+ * - Scope Responses API defaults with {@link Config} and
+ *   {@link withConfigOverride}
+ *
+ * **Gotchas**
+ *
+ * - Some OpenAI model families receive system instructions as developer
+ *   messages because the Responses API treats them differently.
+ * - File prompt parts are sent either as provider file ids or as base64
+ *   content, depending on `fileIdPrefixes`.
+ * - Structured output and tool-call behavior depends on both Effect AI tool
+ *   definitions and OpenAI model capabilities.
+ *
+ * @since 4.0.0
  */
+import * as Context from "effect/Context";
 import * as DateTime from "effect/DateTime";
 import * as Effect from "effect/Effect";
 import * as Encoding from "effect/Encoding";
 import { dual } from "effect/Function";
 import * as Layer from "effect/Layer";
+import * as Option from "effect/Option";
 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 { toCodecOpenAI } from "effect/unstable/ai/OpenAiStructuredOutput";
 import * as Tool from "effect/unstable/ai/Tool";
 import * as Generated from "./Generated.js";
 import * as InternalUtilities from "./internal/utilities.js";
@@ -34,36 +66,75 @@ const SharedModelIds = Generated.ModelIdsShared.members[1];
 /**
  * Service definition for OpenAI language model configuration.
  *
- * @since 1.0.0
+ * **When to use**
+ *
+ * Use when you need to provide OpenAI Responses API request defaults through
+ * Effect context for language model operations.
+ *
+ * **Details**
+ *
+ * Config values are merged with the config object passed to `model`, `make`, or
+ * `layer`, with scoped context values taking precedence.
+ *
+ * @see {@link withConfigOverride} for scoping language model request overrides
+ *
  * @category services
+ * @since 4.0.0
  */
-export class Config extends /*#__PURE__*/ServiceMap.Service()("@effect/ai-openai/OpenAiLanguageModel/Config") {}
+export class Config extends /*#__PURE__*/Context.Service()("@effect/ai-openai/OpenAiLanguageModel/Config") {}
 // =============================================================================
 // Language Model
 // =============================================================================
 /**
- * @since 1.0.0
+ * Creates an OpenAI model descriptor that can be provided with
+ * `Effect.provide`.
+ *
+ * **When to use**
+ *
+ * Use when you want an OpenAI language model value that carries provider and
+ * model metadata and can be supplied directly to an Effect program.
+ *
+ * @see {@link layer} for creating a `LanguageModel.LanguageModel` layer directly
+ * @see {@link make} for constructing the language model service effectfully
+ *
  * @category constructors
+ * @since 4.0.0
  */
-export const model = (model, config) => AiModel.make("openai", layer({
+export const model = (model, config) => AiModel.make("openai", model, layer({
   model,
   config
 }));
 // TODO
 // /**
-//  * @since 1.0.0
+//  * @since 4.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 }))
+//   AiModel.make("openai", model, layerWithTokenizer({ model, config }))
 /**
- * Creates an OpenAI language model service.
+ * Creates an OpenAI `LanguageModel` service from a model identifier and
+ * optional request defaults.
+ *
+ * **When to use**
+ *
+ * Use when an Effect needs to construct a `LanguageModel.Service` value backed
+ * by `OpenAiClient`.
+ *
+ * **Details**
+ *
+ * The returned effect requires `OpenAiClient`. Request defaults from the
+ * `config` option are merged with any `Config` service in the context, with
+ * context values taking precedence. The service supports both `generateText`
+ * and `streamText`.
+ *
+ * @see {@link layer} for providing the service as a `Layer`
+ * @see {@link model} for creating a model descriptor for `Effect.provide`
  *
- * @since 1.0.0
  * @category constructors
+ * @since 4.0.0
  */
 export const make = /*#__PURE__*/Effect.fnUntraced(function* ({
   model,
@@ -71,7 +142,7 @@ export const make = /*#__PURE__*/Effect.fnUntraced(function* ({
 }) {
   const client = yield* OpenAiClient;
   const makeConfig = Effect.gen(function* () {
-    const services = yield* Effect.services();
+    const services = yield* Effect.context();
     return {
       model,
       ...providerConfig,
@@ -100,28 +171,31 @@ export const make = /*#__PURE__*/Effect.fnUntraced(function* ({
       options,
       toolNameMapper
     });
-    const responseFormat = prepareResponseFormat({
+    const responseFormat = yield* prepareResponseFormat({
       config,
       options
     });
+    const {
+      fileIdPrefixes: _fip,
+      strictJsonSchema: _sjs,
+      ...apiConfig
+    } = config;
     const request = {
-      ...config,
+      ...apiConfig,
       input: messages,
-      include: include.size > 0 ? Array.from(include) : null,
+      include: include.size > 0 ? Array.from(include) : undefined,
       text: {
-        verbosity: config.text?.verbosity ?? null,
+        verbosity: config.text?.verbosity ?? undefined,
         format: responseFormat
-      },
-      ...(Predicate.isNotUndefined(tools) ? {
-        tools
-      } : undefined),
-      ...(Predicate.isNotUndefined(toolChoice) ? {
-        tool_choice: toolChoice
-      } : undefined)
+      }
     };
+    if (tools) request.tools = tools;
+    if (toolChoice) request.tool_choice = toolChoice;
+    if (options.previousResponseId) request.previous_response_id = options.previousResponseId;
     return request;
   });
   return yield* LanguageModel.make({
+    codecTransformer: toCodecOpenAI,
     generateText: Effect.fnUntraced(function* (options) {
       const config = yield* makeConfig;
       const toolNameMapper = new Tool.NameMapper(options.tools);
@@ -164,17 +238,49 @@ export const make = /*#__PURE__*/Effect.fnUntraced(function* ({
   });
 });
 /**
- * Creates a layer for the OpenAI language model.
+ * Creates a layer that provides the OpenAI `LanguageModel.LanguageModel`
+ * service.
+ *
+ * **When to use**
+ *
+ * Use when composing application layers and you want OpenAI to satisfy
+ * `LanguageModel.LanguageModel` while supplying `OpenAiClient` from another
+ * layer.
+ *
+ * **Details**
+ *
+ * The `config` option supplies request defaults for the selected model. Scoped
+ * values from `withConfigOverride` are merged when each request is built and
+ * take precedence over these defaults.
+ *
+ * @see {@link make} for constructing the language model service effectfully
+ * @see {@link model} for creating a model descriptor for `Effect.provide`
+ * @see {@link withConfigOverride} for scoped request configuration overrides
  *
- * @since 1.0.0
  * @category layers
+ * @since 4.0.0
  */
 export const layer = options => Layer.effect(LanguageModel.LanguageModel, make(options));
 /**
- * Provides config overrides for OpenAI language model operations.
+ * Provides scoped config overrides for OpenAI language model operations.
+ *
+ * **When to use**
+ *
+ * Use to apply OpenAI Responses API config overrides around one or more
+ * language model operations without changing the defaults passed to `model`,
+ * `make`, or `layer`.
+ *
+ * **Details**
+ *
+ * The override is dual, so it can be used in pipe form or as
+ * `withConfigOverride(effect, overrides)`. Overrides are merged with any
+ * existing `Config` service in the current context, and the override values take
+ * precedence.
+ *
+ * @see {@link Config} for the scoped configuration service consumed by this function
  *
- * @since 1.0.0
  * @category configuration
+ * @since 4.0.0
  */
 export const withConfigOverride = /*#__PURE__*/dual(2, (self, overrides) => Effect.flatMap(Effect.serviceOption(Config), config => Effect.provideService(self, Config, {
   ...(config._tag === "Some" ? config.value : {}),
@@ -207,14 +313,15 @@ const prepareMessages = /*#__PURE__*/Effect.fnUntraced(function* ({
   if (config.store === false && capabilities.isReasoningModel) {
     include.add("reasoning.encrypted_content");
   }
-  if (Predicate.isNotUndefined(codeInterpreterTool)) {
+  if (codeInterpreterTool) {
     include.add("code_interpreter_call.outputs");
   }
-  if (Predicate.isNotUndefined(webSearchTool) || Predicate.isNotUndefined(webSearchPreviewTool)) {
+  if (webSearchTool || webSearchPreviewTool) {
     include.add("web_search_call.action.sources");
   }
   const messages = [];
-  for (const message of options.prompt.content) {
+  const prompt = options.incrementalPrompt ?? options.prompt;
+  for (const message of prompt.content) {
     switch (message.role) {
       case "system":
         {
@@ -378,7 +485,9 @@ const prepareMessages = /*#__PURE__*/Effect.fnUntraced(function* ({
                           type: "reasoning",
                           id,
                           summary: summaryParts,
-                          encrypted_content: encryptedContent ?? null
+                          ...(Predicate.isNotNull(encryptedContent) ? {
+                            encrypted_content: encryptedContent
+                          } : undefined)
                         };
                         messages.push(reasoningMessages[id]);
                       } else {
@@ -569,13 +678,15 @@ const buildHttpRequestDetails = request => ({
   method: request.method,
   url: request.url,
   urlParams: Array.from(request.urlParams),
-  hash: request.hash,
+  hash: Option.getOrUndefined(request.hash),
   headers: Redactable.redact(request.headers)
 });
 const buildHttpResponseDetails = response => ({
   status: response.status,
   headers: Redactable.redact(response.headers)
 });
+const knownResponseStreamEventTypes = /*#__PURE__*/new Set(["response.created", "response.completed", "response.incomplete", "response.failed", "response.output_item.added", "response.output_item.done", "response.output_text.delta", "response.output_text.annotation.added", "response.reasoning_summary_part.added", "response.reasoning_summary_part.done", "response.reasoning_summary_text.delta", "response.function_call_arguments.delta", "response.function_call_arguments.done", "response.code_interpreter_call_code.delta", "response.code_interpreter_call_code.done", "response.apply_patch_call_operation_diff.delta", "response.apply_patch_call_operation_diff.done", "response.image_generation_call.partial_image", "error"]);
+const isKnownResponseStreamEvent = event => knownResponseStreamEventTypes.has(event.type);
 const makeResponse = /*#__PURE__*/Effect.fnUntraced(function* ({
   options,
   rawResponse,
@@ -609,9 +720,7 @@ const makeResponse = /*#__PURE__*/Effect.fnUntraced(function* ({
               operation: part.operation
             },
             metadata: {
-              openai: {
-                ...makeItemIdMetadata(part.id)
-              }
+              openai: makeItemIdMetadata(part.id)
             }
           });
           break;
@@ -669,9 +778,8 @@ const makeResponse = /*#__PURE__*/Effect.fnUntraced(function* ({
         {
           hasToolCalls = true;
           const toolName = part.name;
-          const toolParams = part.arguments;
-          const params = yield* Effect.try({
-            try: () => Tool.unsafeSecureJsonParse(toolParams),
+          const toolParams = yield* Effect.try({
+            try: () => Tool.unsafeSecureJsonParse(part.arguments),
             catch: cause => AiError.make({
               module: "OpenAiLanguageModel",
               method: "makeResponse",
@@ -682,15 +790,14 @@ const makeResponse = /*#__PURE__*/Effect.fnUntraced(function* ({
               })
             })
           });
+          const params = yield* transformToolCallParams(options.tools, part.name, toolParams);
           parts.push({
             type: "tool-call",
             id: part.call_id,
             name: toolName,
             params,
             metadata: {
-              openai: {
-                ...makeItemIdMetadata(part.id)
-              }
+              openai: makeItemIdMetadata(part.id)
             }
           });
           break;
@@ -727,9 +834,7 @@ const makeResponse = /*#__PURE__*/Effect.fnUntraced(function* ({
               action: part.action
             },
             metadata: {
-              openai: {
-                ...makeItemIdMetadata(part.id)
-              }
+              openai: makeItemIdMetadata(part.id)
             }
           });
           break;
@@ -737,12 +842,19 @@ const makeResponse = /*#__PURE__*/Effect.fnUntraced(function* ({
       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}`;
+          const {
+            toolName,
+            params
+          } = yield* normalizeMcpToolCall({
+            toolNameMapper,
+            toolParams: part.arguments,
+            method: "makeResponse"
+          });
           parts.push({
             type: "tool-call",
             id: toolId,
             name: toolName,
-            params: part.arguments,
+            params,
             providerExecuted: true
           });
           parts.push({
@@ -752,7 +864,7 @@ const makeResponse = /*#__PURE__*/Effect.fnUntraced(function* ({
             isFailure: false,
             providerExecuted: true,
             result: {
-              type: "call",
+              type: "mcp_call",
               name: part.name,
               arguments: part.arguments,
               server_label: part.server_label,
@@ -764,9 +876,7 @@ const makeResponse = /*#__PURE__*/Effect.fnUntraced(function* ({
               } : undefined)
             },
             metadata: {
-              openai: {
-                ...makeItemIdMetadata(part.id)
-              }
+              openai: makeItemIdMetadata(part.id)
             }
           });
           break;
@@ -780,18 +890,13 @@ const makeResponse = /*#__PURE__*/Effect.fnUntraced(function* ({
         {
           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}`
-              })
-            })
+          const {
+            toolName,
+            params
+          } = yield* normalizeMcpToolCall({
+            toolNameMapper,
+            toolParams: part.arguments,
+            method: "makeResponse"
           });
           parts.push({
             type: "tool-call",
@@ -952,9 +1057,7 @@ const makeResponse = /*#__PURE__*/Effect.fnUntraced(function* ({
               action: part.action
             },
             metadata: {
-              openai: {
-                ...makeItemIdMetadata(part.id)
-              }
+              openai: makeItemIdMetadata(part.id)
             }
           });
           break;
@@ -990,13 +1093,7 @@ const makeResponse = /*#__PURE__*/Effect.fnUntraced(function* ({
     reason: finishReason,
     usage: getUsage(rawResponse.usage),
     response: buildHttpResponseDetails(response),
-    ...(rawResponse.service_tier && {
-      metadata: {
-        openai: {
-          serviceTier: rawResponse.service_tier
-        }
-      }
-    })
+    ...toServiceTier(rawResponse.service_tier)
   });
   return parts;
 });
@@ -1015,11 +1112,29 @@ const makeStreamResponse = /*#__PURE__*/Effect.fnUntraced(function* ({
   const activeAnnotations = [];
   // Track active reasoning items with state machine for proper concluding logic
   const activeReasoning = {};
+  const getOrCreateReasoningPart = (itemId, encryptedContent) => {
+    const activePart = activeReasoning[itemId];
+    if (Predicate.isNotUndefined(activePart)) {
+      if (Predicate.isNotNullish(encryptedContent)) {
+        activePart.encryptedContent = encryptedContent;
+      }
+      return activePart;
+    }
+    const reasoningPart = {
+      encryptedContent: Predicate.isNotNullish(encryptedContent) ? encryptedContent : undefined,
+      summaryParts: {}
+    };
+    activeReasoning[itemId] = reasoningPart;
+    return reasoningPart;
+  };
   // 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 = [];
+    if (!isKnownResponseStreamEvent(event)) {
+      return parts;
+    }
     switch (event.type) {
       case "response.created":
         {
@@ -1050,13 +1165,7 @@ const makeStreamResponse = /*#__PURE__*/Effect.fnUntraced(function* ({
             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
-                }
-              }
-            })
+            ...toServiceTier(event.response.service_tier)
           });
           break;
         }
@@ -1157,7 +1266,10 @@ const makeStreamResponse = /*#__PURE__*/Effect.fnUntraced(function* ({
               {
                 activeToolCalls[event.output_index] = {
                   id: event.item.call_id,
-                  name: event.item.name
+                  name: event.item.name,
+                  functionCall: {
+                    emitted: false
+                  }
                 };
                 parts.push({
                   type: "tool-params-start",
@@ -1195,39 +1307,34 @@ const makeStreamResponse = /*#__PURE__*/Effect.fnUntraced(function* ({
                   type: "text-start",
                   id: event.item.id,
                   metadata: {
-                    openai: {
-                      ...makeItemIdMetadata(event.item.id)
-                    }
+                    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)
+                const reasoningPart = getOrCreateReasoningPart(event.item.id, event.item.encrypted_content);
+                if (Predicate.isUndefined(reasoningPart.summaryParts[0])) {
+                  reasoningPart.summaryParts[0] = "active";
+                  parts.push({
+                    type: "reasoning-start",
+                    id: `${event.item.id}:0`,
+                    metadata: {
+                      openai: {
+                        ...makeItemIdMetadata(event.item.id),
+                        ...makeEncryptedContentMetadata(reasoningPart.encryptedContent)
+                      }
                     }
-                  }
-                });
+                  });
+                }
                 break;
               }
             case "shell_call":
               {
                 const toolName = toolNameMapper.getCustomName("shell");
                 activeToolCalls[event.output_index] = {
-                  id: event.item.id,
+                  id: event.item.id ?? event.item.call_id,
                   name: toolName
                 };
                 break;
@@ -1272,7 +1379,7 @@ const makeStreamResponse = /*#__PURE__*/Effect.fnUntraced(function* ({
                     parts.push({
                       type: "tool-params-delta",
                       id: toolCall.id,
-                      delta: InternalUtilities.escapeJSONDelta(event.item.operation.diff)
+                      delta: InternalUtilities.escapeJSONDelta(event.item.operation.diff ?? "")
                     });
                   }
                   parts.push({
@@ -1298,9 +1405,7 @@ const makeStreamResponse = /*#__PURE__*/Effect.fnUntraced(function* ({
                       operation: event.item.operation
                     },
                     metadata: {
-                      openai: {
-                        ...makeItemIdMetadata(event.item.id)
-                      }
+                      openai: makeItemIdMetadata(event.item.id)
                     }
                   });
                 }
@@ -1372,12 +1477,17 @@ const makeStreamResponse = /*#__PURE__*/Effect.fnUntraced(function* ({
               }
             case "function_call":
               {
+                const toolCall = activeToolCalls[event.output_index];
+                if (Predicate.isNotUndefined(toolCall?.functionCall?.emitted) && toolCall.functionCall.emitted) {
+                  delete activeToolCalls[event.output_index];
+                  break;
+                }
                 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),
+                const toolArgs = event.item.arguments;
+                const toolParams = yield* Effect.try({
+                  try: () => Tool.unsafeSecureJsonParse(toolArgs),
                   catch: cause => AiError.make({
                     module: "OpenAiLanguageModel",
                     method: "makeStreamResponse",
@@ -1388,6 +1498,7 @@ const makeStreamResponse = /*#__PURE__*/Effect.fnUntraced(function* ({
                     })
                   })
                 });
+                const params = yield* transformToolCallParams(options.tools, toolName, toolParams);
                 parts.push({
                   type: "tool-params-end",
                   id: event.item.call_id
@@ -1398,9 +1509,7 @@ const makeStreamResponse = /*#__PURE__*/Effect.fnUntraced(function* ({
                   name: toolName,
                   params,
                   metadata: {
-                    openai: {
-                      ...makeItemIdMetadata(event.item.id)
-                    }
+                    openai: makeItemIdMetadata(event.item.id)
                   }
                 });
                 break;
@@ -1431,9 +1540,7 @@ const makeStreamResponse = /*#__PURE__*/Effect.fnUntraced(function* ({
                     action: event.item.action
                   },
                   metadata: {
-                    openai: {
-                      ...makeItemIdMetadata(event.item.id)
-                    }
+                    openai: makeItemIdMetadata(event.item.id)
                   }
                 });
                 break;
@@ -1443,12 +1550,19 @@ const makeStreamResponse = /*#__PURE__*/Effect.fnUntraced(function* ({
                 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}`;
+                const {
+                  toolName,
+                  params
+                } = yield* normalizeMcpToolCall({
+                  toolNameMapper,
+                  toolParams: event.item.arguments,
+                  method: "makeStreamResponse"
+                });
                 parts.push({
                   type: "tool-call",
                   id: toolId,
                   name: toolName,
-                  params: event.item.arguments,
+                  params,
                   providerExecuted: true
                 });
                 parts.push({
@@ -1458,7 +1572,7 @@ const makeStreamResponse = /*#__PURE__*/Effect.fnUntraced(function* ({
                   isFailure: false,
                   providerExecuted: true,
                   result: {
-                    type: "call",
+                    type: "mcp_call",
                     name: event.item.name,
                     arguments: event.item.arguments,
                     server_label: event.item.server_label,
@@ -1470,9 +1584,7 @@ const makeStreamResponse = /*#__PURE__*/Effect.fnUntraced(function* ({
                     } : undefined)
                   },
                   metadata: {
-                    openai: {
-                      ...makeItemIdMetadata(event.item.id)
-                    }
+                    openai: makeItemIdMetadata(event.item.id)
                   }
                 });
                 break;
@@ -1487,12 +1599,19 @@ const makeStreamResponse = /*#__PURE__*/Effect.fnUntraced(function* ({
                 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}`;
+                const {
+                  toolName,
+                  params
+                } = yield* normalizeMcpToolCall({
+                  toolNameMapper,
+                  toolParams: event.item.arguments,
+                  method: "makeStreamResponse"
+                });
                 parts.push({
                   type: "tool-call",
                   id: toolId,
                   name: toolName,
-                  params: event.item.arguments,
+                  params,
                   providerExecuted: true
                 });
                 parts.push({
@@ -1521,7 +1640,7 @@ const makeStreamResponse = /*#__PURE__*/Effect.fnUntraced(function* ({
               }
             case "reasoning":
               {
-                const reasoningPart = activeReasoning[event.item.id];
+                const reasoningPart = getOrCreateReasoningPart(event.item.id, event.item.encrypted_content);
                 for (const [summaryIndex, status] of Object.entries(reasoningPart.summaryParts)) {
                   if (status === "active" || status === "can-conclude") {
                     parts.push({
@@ -1530,7 +1649,7 @@ const makeStreamResponse = /*#__PURE__*/Effect.fnUntraced(function* ({
                       metadata: {
                         openai: {
                           ...makeItemIdMetadata(event.item.id),
-                          ...makeEncryptedContentMetadata(event.item.encrypted_content)
+                          ...makeEncryptedContentMetadata(reasoningPart.encryptedContent)
                         }
                       }
                     });
@@ -1545,15 +1664,13 @@ const makeStreamResponse = /*#__PURE__*/Effect.fnUntraced(function* ({
                 const toolName = toolNameMapper.getCustomName("shell");
                 parts.push({
                   type: "tool-call",
-                  id: event.item.id,
+                  id: event.item.id ?? event.item.call_id,
                   name: toolName,
                   params: {
                     action: event.item.action
                   },
                   metadata: {
-                    openai: {
-                      ...makeItemIdMetadata(event.item.id)
-                    }
+                    openai: makeItemIdMetadata(event.item.id)
                   }
                 });
                 break;
@@ -1670,6 +1787,41 @@ const makeStreamResponse = /*#__PURE__*/Effect.fnUntraced(function* ({
           }
           break;
         }
+      case "response.function_call_arguments.done":
+        {
+          const toolCall = activeToolCalls[event.output_index];
+          if (Predicate.isNotUndefined(toolCall?.functionCall) && !toolCall.functionCall.emitted) {
+            hasToolCalls = true;
+            const toolParams = yield* Effect.try({
+              try: () => Tool.unsafeSecureJsonParse(event.arguments),
+              catch: cause => AiError.make({
+                module: "OpenAiLanguageModel",
+                method: "makeStreamResponse",
+                reason: new AiError.ToolParameterValidationError({
+                  toolName: toolCall.name,
+                  toolParams: {},
+                  description: `Failed securely JSON parse tool parameters: ${cause}`
+                })
+              })
+            });
+            const params = yield* transformToolCallParams(options.tools, toolCall.name, toolParams);
+            parts.push({
+              type: "tool-params-end",
+              id: toolCall.id
+            });
+            parts.push({
+              type: "tool-call",
+              id: toolCall.id,
+              name: toolCall.name,
+              params,
+              metadata: {
+                openai: makeItemIdMetadata(event.item_id)
+              }
+            });
+            toolCall.functionCall.emitted = true;
+          }
+          break;
+        }
       case "response.apply_patch_call_operation_diff.delta":
         {
           const toolCall = activeToolCalls[event.output_index];
@@ -1765,28 +1917,27 @@ const makeStreamResponse = /*#__PURE__*/Effect.fnUntraced(function* ({
         }
       case "response.reasoning_summary_part.added":
         {
-          // The first reasoning start is pushed in the `response.output_item.added` block
+          const reasoningPart = getOrCreateReasoningPart(event.item_id);
           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)
-                      }
+            // 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[Number(summaryIndex)] = "concluded";
               }
-              reasoningPart.summaryParts[event.summary_index] = "active";
             }
+          }
+          if (Predicate.isUndefined(reasoningPart.summaryParts[event.summary_index])) {
+            reasoningPart.summaryParts[event.summary_index] = "active";
             parts.push({
               type: "reasoning-start",
               id: `${event.item_id}:${event.summary_index}`,
@@ -1807,15 +1958,14 @@ const makeStreamResponse = /*#__PURE__*/Effect.fnUntraced(function* ({
             id: `${event.item_id}:${event.summary_index}`,
             delta: event.delta,
             metadata: {
-              openai: {
-                ...makeItemIdMetadata(event.item_id)
-              }
+              openai: makeItemIdMetadata(event.item_id)
             }
           });
           break;
         }
       case "response.reasoning_summary_part.done":
         {
+          const reasoningPart = getOrCreateReasoningPart(event.item_id);
           // 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) {
@@ -1823,17 +1973,15 @@ const makeStreamResponse = /*#__PURE__*/Effect.fnUntraced(function* ({
               type: "reasoning-end",
               id: `${event.item_id}:${event.summary_index}`,
               metadata: {
-                openai: {
-                  ...makeItemIdMetadata(event.item_id)
-                }
+                openai: makeItemIdMetadata(event.item_id)
               }
             });
             // Mark the summary part concluded
-            activeReasoning[event.item_id].summaryParts[event.summary_index] = "concluded";
+            reasoningPart.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";
+            reasoningPart.summaryParts[event.summary_index] = "can-conclude";
           }
           break;
         }
@@ -1936,14 +2084,18 @@ const prepareTools = /*#__PURE__*/Effect.fnUntraced(function* ({
   }
   // Convert the tools in the toolkit to the provider-defined format
   for (const tool of allowedTools) {
-    if (Tool.isUserDefined(tool)) {
+    if (Tool.isUserDefined(tool) || Tool.isDynamic(tool)) {
       const strict = Tool.getStrictMode(tool) ?? config.strictJsonSchema ?? true;
+      const description = Tool.getDescription(tool);
+      const parameters = yield* tryToolJsonSchema(tool, "prepareTools");
       tools.push({
         type: "function",
         name: tool.name,
-        description: Tool.getDescription(tool) ?? null,
-        parameters: Tool.getJsonSchema(tool),
-        strict
+        parameters,
+        strict,
+        ...(Predicate.isNotUndefined(description) ? {
+          description
+        } : undefined)
       });
     }
     if (Tool.isProviderDefined(tool)) {
@@ -2111,29 +2263,53 @@ const getEncryptedContent = part => part.options.openai?.encryptedContent ?? nul
 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 = ({
+const unsupportedSchemaError = (error, method) => AiError.make({
+  module: "OpenAiLanguageModel",
+  method,
+  reason: new AiError.UnsupportedSchemaError({
+    description: error instanceof Error ? error.message : String(error)
+  })
+});
+const tryCodecTransform = (schema, method) => Effect.try({
+  try: () => toCodecOpenAI(schema),
+  catch: error => unsupportedSchemaError(error, method)
+});
+const tryJsonSchema = (schema, method) => Effect.try({
+  try: () => Tool.getJsonSchemaFromSchema(schema, {
+    transformer: toCodecOpenAI
+  }),
+  catch: error => unsupportedSchemaError(error, method)
+});
+const tryToolJsonSchema = (tool, method) => Effect.try({
+  try: () => Tool.getJsonSchema(tool, {
+    transformer: toCodecOpenAI
+  }),
+  catch: error => unsupportedSchemaError(error, method)
+});
+const prepareResponseFormat = /*#__PURE__*/Effect.fnUntraced(function* ({
   config,
   options
-}) => {
+}) {
   if (options.responseFormat.type === "json") {
     const name = options.responseFormat.objectName;
     const schema = options.responseFormat.schema;
+    const jsonSchema = yield* tryJsonSchema(schema, "prepareResponseFormat");
     return {
       type: "json_schema",
       name,
       description: AST.resolveDescription(schema.ast) ?? "Response with a JSON object",
-      schema: Tool.getJsonSchemaFromSchema(schema),
+      schema: jsonSchema,
       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");
@@ -2170,6 +2346,35 @@ const getApprovalRequestIdMapping = prompt => {
   }
   return mapping;
 };
+const normalizeMcpToolCall = /*#__PURE__*/Effect.fnUntraced(function* ({
+  toolNameMapper,
+  toolParams,
+  method
+}) {
+  const toolName = toolNameMapper.getCustomName("mcp");
+  if (typeof toolParams !== "string") {
+    return {
+      toolName,
+      params: toolParams
+    };
+  }
+  const params = yield* Effect.try({
+    try: () => Tool.unsafeSecureJsonParse(toolParams),
+    catch: cause => AiError.make({
+      module: "OpenAiLanguageModel",
+      method,
+      reason: new AiError.ToolParameterValidationError({
+        toolName,
+        toolParams,
+        description: `Failed to securely JSON parse tool parameters: ${cause}`
+      })
+    })
+  });
+  return {
+    toolName,
+    params
+  };
+});
 const getUsage = usage => {
   if (Predicate.isNullish(usage)) {
     return {
@@ -2188,8 +2393,8 @@ const getUsage = usage => {
   }
   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;
+  const cachedTokens = getUsageTokenDetail(usage.input_tokens_details, "cached_tokens");
+  const reasoningTokens = getUsageTokenDetail(usage.output_tokens_details, "reasoning_tokens");
   return {
     inputTokens: {
       uncached: inputTokens - cachedTokens,
@@ -2204,4 +2409,49 @@ const getUsage = usage => {
     }
   };
 };
+const toServiceTier = value => {
+  switch (value) {
+    case "default":
+    case "auto":
+    case "flex":
+    case "scale":
+    case "priority":
+      return {
+        metadata: {
+          openai: {
+            serviceTier: value
+          }
+        }
+      };
+    default:
+      return undefined;
+  }
+};
+const getUsageTokenDetail = (details, key) => Predicate.hasProperty(details, key) && typeof details[key] === "number" ? details[key] : 0;
+const transformToolCallParams = /*#__PURE__*/Effect.fnUntraced(function* (tools, toolName, toolParams) {
+  const tool = tools.find(tool => tool.name === toolName);
+  if (Predicate.isUndefined(tool)) {
+    return yield* AiError.make({
+      module: "OpenAiLanguageModel",
+      method: "makeResponse",
+      reason: new AiError.ToolNotFoundError({
+        toolName,
+        availableTools: tools.map(tool => tool.name)
+      })
+    });
+  }
+  const {
+    codec
+  } = yield* tryCodecTransform(tool.parametersSchema, "makeResponse");
+  const transform = Schema.decodeEffect(codec);
+  return yield* transform(toolParams).pipe(Effect.mapError(error => AiError.make({
+    module: "OpenAiLanguageModel",
+    method: "makeResponse",
+    reason: new AiError.ToolParameterValidationError({
+      toolName,
+      toolParams,
+      description: error.issue.toString()
+    })
+  })));
+});
 //# sourceMappingURL=OpenAiLanguageModel.js.map