@effect/ai-openai 0.37.1 → 4.0.0-beta.0

package/src/OpenAiLanguageModel.ts

@@ -1,114 +1,117 @@
 /**
+ * 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 AiError from "@effect/ai/AiError"
-import * as IdGenerator from "@effect/ai/IdGenerator"
-import * as LanguageModel from "@effect/ai/LanguageModel"
-import * as AiModel from "@effect/ai/Model"
-import type * as Prompt from "@effect/ai/Prompt"
-import type * as Response from "@effect/ai/Response"
-import type * as Tokenizer from "@effect/ai/Tokenizer"
-import * as Tool from "@effect/ai/Tool"
-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 * 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 type { Span } from "effect/Tracer"
-import type { DeepMutable, Mutable, Simplify } from "effect/Types"
-import type * as Generated from "./Generated.js"
-import * as InternalUtilities from "./internal/utilities.js"
-import type { ResponseStreamEvent } from "./OpenAiClient.js"
-import { OpenAiClient } from "./OpenAiClient.js"
-import { addGenAIAnnotations } from "./OpenAiTelemetry.js"
-import * as OpenAiTokenizer from "./OpenAiTokenizer.js"
-import * as OpenAiTool from "./OpenAiTool.js"
+import type { DeepMutable, Simplify } from "effect/Types"
+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 type * as Prompt from "effect/unstable/ai/Prompt"
+import type * as Response from "effect/unstable/ai/Response"
+import * as Tool from "effect/unstable/ai/Tool"
+import type * as HttpClientRequest from "effect/unstable/http/HttpClientRequest"
+import type * as HttpClientResponse from "effect/unstable/http/HttpClientResponse"
+import * as Generated from "./Generated.ts"
+import * as InternalUtilities from "./internal/utilities.ts"
+import { OpenAiClient } from "./OpenAiClient.ts"
+import { addGenAIAnnotations } from "./OpenAiTelemetry.ts"
+import type * as OpenAiTool from "./OpenAiTool.ts"
+
+const ResponseModelIds = Generated.ModelIdsResponses.members[1]
+const SharedModelIds = Generated.ModelIdsShared.members[1]
 
 /**
  * @since 1.0.0
- * @category Models
+ * @category models
  */
-export type Model = typeof Generated.ChatModel.Encoded | typeof Generated.ModelIdsResponsesEnum.Encoded
+export type Model = typeof ResponseModelIds.Encoded | typeof SharedModelIds.Encoded
+
+/**
+ * Image detail level for vision requests.
+ */
+type ImageDetail = "auto" | "low" | "high"
 
 // =============================================================================
 // Configuration
 // =============================================================================
 
 /**
+ * Service definition for OpenAI language model configuration.
+ *
  * @since 1.0.0
- * @category Context
+ * @category services
  */
-export class Config extends Context.Tag("@effect/ai-openai/OpenAiLanguageModel/Config")<
+export class Config extends ServiceMap.Service<
   Config,
-  Config.Service
->() {
-  /**
-   * @since 1.0.0
-   */
-  static readonly getOrUndefined: Effect.Effect<Config.Service | undefined> = Effect.map(
-    Effect.context<never>(),
-    (context) => context.unsafeMap.get(Config.key)
-  )
-}
-
-/**
- * @since 1.0.0
- */
-export declare namespace Config {
-  /**
-   * @since 1.0.0
-   * @category Models
-   */
-  export interface Service extends
-    Simplify<
-      Partial<
-        Omit<
-          typeof Generated.CreateResponse.Encoded,
-          "input" | "tools" | "tool_choice" | "stream" | "text"
-        >
+  Simplify<
+    & Partial<
+      Omit<
+        typeof Generated.CreateResponse.Encoded,
+        "input" | "tools" | "tool_choice" | "stream" | "text"
       >
     >
-  {
-    /**
-     * File ID prefixes used to identify file IDs in Responses API.
-     * When undefined, all file data is treated as base64 content.
-     *
-     * Examples:
-     * - OpenAI: ['file-'] for IDs like 'file-abc123'
-     * - Azure OpenAI: ['assistant-'] for IDs like 'assistant-abc123'
-     */
-    readonly fileIdPrefixes?: ReadonlyArray<string>
-    /**
-     * Configuration options for a text response from the model.
-     */
-    readonly text?: {
+    & {
+      /**
+       * File ID prefixes used to identify file IDs in Responses API.
+       * When undefined, all file data is treated as base64 content.
+       *
+       * Examples:
+       * - OpenAI: ['file-'] for IDs like 'file-abc123'
+       * - Azure OpenAI: ['assistant-'] for IDs like 'assistant-abc123'
+       */
+      readonly fileIdPrefixes?: ReadonlyArray<string> | undefined
+      /**
+       * Configuration options for a text response from the model.
+       */
+      readonly text?: {
+        /**
+         * Constrains the verbosity of the model's response. Lower values will
+         * result in more concise responses, while higher values will result in
+         * more verbose responses.
+         *
+         * Defaults to `"medium"`.
+         */
+        readonly verbosity?: "low" | "medium" | "high" | undefined
+      } | undefined
       /**
-       * Constrains the verbosity of the model's response. Lower values will
-       * result in more concise responses, while higher values will result in
-       * more verbose responses.
+       * Whether to use strict JSON schema validation.
        *
-       * Defaults to `"medium"`.
+       * Defaults to `true`.
        */
-      readonly verbosity?: "low" | "medium" | "high"
+      readonly strictJsonSchema?: boolean | undefined
     }
-  }
-}
+  >
+>()("@effect/ai-openai/OpenAiLanguageModel/Config") {}
 
 // =============================================================================
-// OpenAI Provider Options / Metadata
+// Provider Options / Metadata
 // =============================================================================
 
-declare module "@effect/ai/Prompt" {
+declare module "effect/unstable/ai/Prompt" {
   export interface FilePartOptions extends ProviderOptions {
     readonly openai?: {
       /**
        * The detail level of the image to be sent to the model. One of `high`, `low`, or `auto`. Defaults to `auto`.
        */
-      readonly imageDetail?: typeof Generated.ImageDetail.Encoded | undefined
-    } | undefined
+      readonly imageDetail?: ImageDetail | null
+    } | null
   }
 
   export interface ReasoningPartOptions extends ProviderOptions {
@@ -116,14 +119,14 @@ declare module "@effect/ai/Prompt" {
       /**
        * The ID of the item to reference.
        */
-      readonly itemId?: string | undefined
+      readonly itemId?: string | null
       /**
        * The encrypted content of the reasoning item - populated when a response
        * is generated with `reasoning.encrypted_content` in the `include`
        * parameter.
        */
-      readonly encryptedContent?: string | undefined
-    } | undefined
+      readonly encryptedContent?: string | null
+    } | null
   }
 
   export interface ToolCallPartOptions extends ProviderOptions {
@@ -131,8 +134,33 @@ declare module "@effect/ai/Prompt" {
       /**
        * The ID of the item to reference.
        */
-      readonly itemId?: string | undefined
-    } | undefined
+      readonly itemId?: string | null
+      /**
+       * The status of item.
+       */
+      readonly status?: typeof Generated.Message.Encoded["status"] | null
+      /**
+       * The ID of the approval request.
+       */
+      readonly approvalRequestId?: string | null
+    } | null
+  }
+
+  export interface ToolResultPartOptions extends ProviderOptions {
+    readonly openai?: {
+      /**
+       * The ID of the item to reference.
+       */
+      readonly itemId?: string | null
+      /**
+       * The status of item.
+       */
+      readonly status?: typeof Generated.Message.Encoded["status"] | null
+      /**
+       * The ID of the approval request.
+       */
+      readonly approvalId?: string | null
+    } | null
   }
 
   export interface TextPartOptions extends ProviderOptions {
@@ -140,71 +168,122 @@ declare module "@effect/ai/Prompt" {
       /**
        * The ID of the item to reference.
        */
-      readonly itemId?: string | undefined
-    } | undefined
+      readonly itemId?: string | null
+      /**
+       * The status of item.
+       */
+      readonly status?: typeof Generated.Message.Encoded["status"] | null
+      /**
+       * A list of annotations that apply to the output text.
+       */
+      readonly annotations?: ReadonlyArray<typeof Generated.Annotation.Encoded> | null
+    } | null
   }
 }
 
-declare module "@effect/ai/Response" {
+declare module "effect/unstable/ai/Response" {
   export interface TextPartMetadata extends ProviderMetadata {
     readonly openai?: {
-      readonly itemId?: string | undefined
+      readonly itemId?: string | null
       /**
        * If the model emits a refusal content part, the refusal explanation
        * from the model will be contained in the metadata of an empty text
        * part.
        */
-      readonly refusal?: string | undefined
-    } | undefined
+      readonly refusal?: string | null
+      /**
+       * The status of item.
+       */
+      readonly status?: typeof Generated.Message.Encoded["status"] | null
+      /**
+       * The text content part annotations.
+       */
+      readonly annotations?: ReadonlyArray<typeof Generated.Annotation.Encoded> | null
+    }
   }
 
   export interface TextStartPartMetadata extends ProviderMetadata {
     readonly openai?: {
-      readonly itemId?: string | undefined
-    } | undefined
+      readonly itemId?: string | null
+    } | null
+  }
+
+  export interface TextEndPartMetadata extends ProviderMetadata {
+    readonly openai?: {
+      readonly itemId?: string | null
+      readonly annotations?: ReadonlyArray<typeof Generated.Annotation.Encoded> | null
+    } | null
   }
 
   export interface ReasoningPartMetadata extends ProviderMetadata {
     readonly openai?: {
-      readonly itemId?: string | undefined
-      readonly encryptedContent?: string | undefined
-    } | undefined
+      readonly itemId?: string | null
+      readonly encryptedContent?: string | null
+    } | null
   }
 
   export interface ReasoningStartPartMetadata extends ProviderMetadata {
     readonly openai?: {
-      readonly itemId?: string | undefined
-      readonly encryptedContent?: string | undefined
-    } | undefined
+      readonly itemId?: string | null
+      readonly encryptedContent?: string | null
+    } | null
   }
 
   export interface ReasoningDeltaPartMetadata extends ProviderMetadata {
     readonly openai?: {
-      readonly itemId?: string | undefined
-    } | undefined
+      readonly itemId?: string | null
+    } | null
   }
 
   export interface ReasoningEndPartMetadata extends ProviderMetadata {
     readonly openai?: {
-      readonly itemId?: string | undefined
-      readonly encryptedContent?: string | undefined
-    } | undefined
+      readonly itemId?: string | null
+      readonly encryptedContent?: string
+    } | null
   }
 
   export interface ToolCallPartMetadata extends ProviderMetadata {
     readonly openai?: {
-      readonly itemId?: string | undefined
-    } | undefined
+      readonly itemId?: string | null
+    } | null
   }
 
   export interface DocumentSourcePartMetadata extends ProviderMetadata {
-    readonly openai?: {
-      readonly type: "file_citation"
-      /**
-       * The index of the file in the list of files.
-       */
-      readonly index: number
-    } | undefined
+    readonly openai?:
+      | {
+        readonly type: "file_citation"
+        /**
+         * The index of the file in the list of files.
+         */
+        readonly index: number
+        /**
+         * The ID of the file.
+         */
+        readonly fileId: string
+      }
+      | {
+        readonly type: "file_path"
+        /**
+         * The index of the file in the list of files.
+         */
+        readonly index: number
+        /**
+         * The ID of the file.
+         */
+        readonly fileId: string
+      }
+      | {
+        readonly type: "container_file_citation"
+        /**
+         * The ID of the file.
+         */
+        readonly fileId: string
+        /**
+         * The ID of the container file.
+         */
+        readonly containerId: string
+      }
+      | null
   }
 
   export interface UrlSourcePartMetadata extends ProviderMetadata {
@@ -218,82 +297,92 @@ declare module "@effect/ai/Response" {
        * The index of the last character of the URL citation in the message.
        */
       readonly endIndex: number
-    } | undefined
+    } | null
   }
 
   export interface FinishPartMetadata extends ProviderMetadata {
     readonly openai?: {
-      readonly serviceTier?: "default" | "auto" | "flex" | "scale" | "priority" | undefined
-    } | undefined
-  }
-}
-
-/**
- * @since 1.0.0
- */
-export declare namespace ProviderMetadata {
-  /**
-   * @since 1.0.0
-   * @category Provider Metadata
-   */
-  export interface Service {
-    "source": {} | {}
+      readonly serviceTier?: "default" | "auto" | "flex" | "scale" | "priority" | null
+    } | null
   }
 }
 
 // =============================================================================
-// OpenAI Language Model
+// Language Model
 // =============================================================================
 
 /**
  * @since 1.0.0
- * @category Ai Models
+ * @category constructors
  */
 export const model = (
   model: (string & {}) | Model,
-  config?: Omit<Config.Service, "model">
+  config?: Omit<typeof Config.Service, "model">
 ): AiModel.Model<"openai", LanguageModel.LanguageModel, OpenAiClient> =>
   AiModel.make("openai", layer({ model, config }))
 
-/**
- * @since 1.0.0
- * @category Ai Models
- */
-export const modelWithTokenizer = (
-  model: (string & {}) | Model,
-  config?: Omit<Config.Service, "model">
-): AiModel.Model<"openai", LanguageModel.LanguageModel | Tokenizer.Tokenizer, OpenAiClient> =>
-  AiModel.make("openai", layerWithTokenizer({ 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
+ * @category constructors
  */
-export const make = Effect.fnUntraced(function*(options: {
+export const make = Effect.fnUntraced(function*({ model, config: providerConfig }: {
   readonly model: (string & {}) | Model
-  readonly config?: Omit<Config.Service, "model">
-}) {
+  readonly config?: Omit<typeof Config.Service, "model"> | undefined
+}): Effect.fn.Return<LanguageModel.Service, never, OpenAiClient> {
   const client = yield* OpenAiClient
 
-  const makeRequest: (providerOptions: LanguageModel.ProviderOptions) => Effect.Effect<
-    typeof Generated.CreateResponse.Encoded,
-    AiError.AiError
-  > = Effect.fnUntraced(
-    function*(providerOptions) {
-      const context = yield* Effect.context<never>()
-      const config = { model: options.model, ...options.config, ...context.unsafeMap.get(Config.key) }
-      const messages = yield* prepareMessages(providerOptions, config)
-      const { toolChoice, tools } = yield* prepareTools(providerOptions)
-      const include = prepareInclude(providerOptions, config)
-      const responseFormat = prepareResponseFormat(providerOptions)
-      const verbosity = config.text?.verbosity
+  const makeConfig = Effect.gen(function*() {
+    const services = yield* Effect.services<never>()
+    return { model, ...providerConfig, ...services.mapUnsafe.get(Config.key) }
+  })
+
+  const makeRequest = Effect.fnUntraced(
+    function*<Tools extends ReadonlyArray<Tool.Any>>({ config, options, toolNameMapper }: {
+      readonly config: typeof Config.Service
+      readonly options: LanguageModel.ProviderOptions
+      readonly toolNameMapper: Tool.NameMapper<Tools>
+    }): Effect.fn.Return<typeof Generated.CreateResponse.Encoded, AiError.AiError> {
+      const include = new Set<typeof Generated.IncludeEnum.Encoded>()
+      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: typeof Generated.CreateResponse.Encoded = {
         ...config,
         input: messages,
-        include,
-        text: { format: responseFormat, verbosity },
-        tools,
-        tool_choice: toolChoice
+        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
     }
@@ -302,22 +391,37 @@ export const make = Effect.fnUntraced(function*(options: {
   return yield* LanguageModel.make({
     generateText: Effect.fnUntraced(
       function*(options) {
-        const request = yield* makeRequest(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 = yield* client.createResponse(request)
+        const [rawResponse, response] = yield* client.createResponse(request)
         annotateResponse(options.span, rawResponse)
-        return yield* makeResponse(rawResponse, options)
+        return yield* makeResponse({
+          options,
+          rawResponse,
+          response,
+          toolNameMapper
+        })
       }
     ),
     streamText: Effect.fnUntraced(
       function*(options) {
-        const request = yield* makeRequest(options)
+        const config = yield* makeConfig
+        const toolNameMapper = new Tool.NameMapper(options.tools)
+        const request = yield* makeRequest({ config, options, toolNameMapper })
         annotateRequest(options.span, request)
-        return client.createResponseStream(request)
+        const [response, stream] = yield* client.createResponseStream(request)
+        return yield* makeStreamResponse({
+          stream,
+          response,
+          config,
+          options,
+          toolNameMapper
+        })
       },
       (effect, options) =>
         effect.pipe(
-          Effect.flatMap((stream) => makeStreamResponse(stream, options)),
           Stream.unwrap,
           Stream.map((response) => {
             annotateStreamResponse(options.span, response)
@@ -329,55 +433,61 @@ export const make = Effect.fnUntraced(function*(options: {
 })
 
 /**
+ * Creates a layer for the OpenAI language model.
+ *
  * @since 1.0.0
- * @category Layers
+ * @category layers
  */
 export const layer = (options: {
   readonly model: (string & {}) | Model
-  readonly config?: Omit<Config.Service, "model">
+  readonly config?: Omit<typeof Config.Service, "model"> | undefined
 }): Layer.Layer<LanguageModel.LanguageModel, never, OpenAiClient> =>
-  Layer.effect(LanguageModel.LanguageModel, make({ model: options.model, config: options.config }))
-
-/**
- * @since 1.0.0
- * @category Layers
- */
-export const layerWithTokenizer = (options: {
-  readonly model: (string & {}) | Model
-  readonly config?: Omit<Config.Service, "model">
-}): Layer.Layer<LanguageModel.LanguageModel | Tokenizer.Tokenizer, never, OpenAiClient> =>
-  Layer.merge(layer(options), OpenAiTokenizer.layer(options))
+  Layer.effect(LanguageModel.LanguageModel, make(options))
 
 /**
+ * Provides config overrides for OpenAI language model operations.
+ *
  * @since 1.0.0
- * @category Configuration
+ * @category configuration
  */
 export const withConfigOverride: {
   /**
+   * Provides config overrides for OpenAI language model operations.
+   *
    * @since 1.0.0
-   * @category Configuration
+   * @category configuration
    */
-  (overrides: Config.Service): <A, E, R>(self: Effect.Effect<A, E, R>) => Effect.Effect<A, E, R>
+  (overrides: typeof Config.Service): <A, E, R>(self: Effect.Effect<A, E, R>) => Effect.Effect<A, E, Exclude<R, Config>>
   /**
+   * Provides config overrides for OpenAI language model operations.
+   *
    * @since 1.0.0
-   * @category Configuration
+   * @category configuration
    */
-  <A, E, R>(self: Effect.Effect<A, E, R>, overrides: Config.Service): Effect.Effect<A, E, R>
+  <A, E, R>(self: Effect.Effect<A, E, R>, overrides: typeof Config.Service): Effect.Effect<A, E, Exclude<R, Config>>
 } = dual<
   /**
+   * Provides config overrides for OpenAI language model operations.
+   *
    * @since 1.0.0
-   * @category Configuration
+   * @category configuration
    */
-  (overrides: Config.Service) => <A, E, R>(self: Effect.Effect<A, E, R>) => Effect.Effect<A, E, R>,
+  (overrides: typeof Config.Service) => <A, E, R>(self: Effect.Effect<A, E, R>) => Effect.Effect<A, E, Exclude<R, Config>>,
   /**
+   * Provides config overrides for OpenAI language model operations.
+   *
    * @since 1.0.0
-   * @category Configuration
+   * @category configuration
    */
-  <A, E, R>(self: Effect.Effect<A, E, R>, overrides: Config.Service) => Effect.Effect<A, E, R>
+  <A, E, R>(self: Effect.Effect<A, E, R>, overrides: typeof Config.Service) => Effect.Effect<A, E, Exclude<R, Config>>
 >(2, (self, overrides) =>
   Effect.flatMap(
-    Config.getOrUndefined,
-    (config) => Effect.provideService(self, Config, { ...config, ...overrides })
+    Effect.serviceOption(Config),
+    (config) =>
+      Effect.provideService(self, Config, {
+        ...(config._tag === "Some" ? config.value : {}),
+        ...overrides
+      })
   ))
 
 // =============================================================================
@@ -392,467 +502,898 @@ const getSystemMessageMode = (model: string): "system" | "developer" =>
     ? "developer"
     : "system"
 
-const prepareMessages: (
-  options: LanguageModel.ProviderOptions,
-  config: Config.Service
-) => Effect.Effect<
-  ReadonlyArray<typeof Generated.InputItem.Encoded>,
-  AiError.AiError
-> = Effect.fnUntraced(function*(options, config) {
-  const messages: Array<typeof Generated.InputItem.Encoded> = []
-
-  for (const message of options.prompt.content) {
-    switch (message.role) {
-      case "system": {
-        messages.push({
-          role: getSystemMessageMode(config.model!),
-          content: message.content
-        })
-        break
-      }
+const prepareMessages = Effect.fnUntraced(
+  function*<Tools extends ReadonlyArray<Tool.Any>>({
+    config,
+    options,
+    capabilities,
+    include,
+    toolNameMapper
+  }: {
+    readonly config: typeof Config.Service
+    readonly options: LanguageModel.ProviderOptions
+    readonly include: Set<typeof Generated.IncludeEnum.Encoded>
+    readonly capabilities: ModelCapabilities
+    readonly toolNameMapper: Tool.NameMapper<Tools>
+  }): Effect.fn.Return<ReadonlyArray<typeof Generated.InputItem.Encoded>, AiError.AiError> {
+    const processedApprovalIds = new Set<string>()
+
+    const hasConversation = Predicate.isNotNullish(config.conversation)
+
+    // Provider-Defined Tools
+    const applyPatchTool = options.tools.find((tool): tool is ReturnType<typeof OpenAiTool.ApplyPatch> =>
+      Tool.isProviderDefined(tool) && tool.name === "OpenAiApplyPatch"
+    )
+    const codeInterpreterTool = options.tools.find((tool): tool is ReturnType<typeof OpenAiTool.CodeInterpreter> =>
+      Tool.isProviderDefined(tool) && tool.name === "OpenAiCodeInterpreter"
+    )
+    const shellTool = options.tools.find((tool): tool is ReturnType<typeof OpenAiTool.Shell> =>
+      Tool.isProviderDefined(tool) && tool.name === "OpenAiFunctionShell"
+    )
+    const localShellTool = options.tools.find((tool): tool is ReturnType<typeof OpenAiTool.LocalShell> =>
+      Tool.isProviderDefined(tool) && tool.name === "OpenAiLocalShell"
+    )
+    const webSearchTool = options.tools.find((tool): tool is ReturnType<typeof OpenAiTool.WebSearch> =>
+      Tool.isProviderDefined(tool) && tool.name === "OpenAiWebSearch"
+    )
+    const webSearchPreviewTool = options.tools.find((tool): tool is ReturnType<typeof OpenAiTool.WebSearchPreview> =>
+      Tool.isProviderDefined(tool) && tool.name === "OpenAiWebSearchPreview"
+    )
 
-      case "user": {
-        const content: Array<typeof Generated.InputContent.Encoded> = []
+    // 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")
+    }
 
-        for (let index = 0; index < message.content.length; index++) {
-          const part = message.content[index]
+    const messages: Array<typeof Generated.InputItem.Encoded> = []
 
-          switch (part.type) {
-            case "text": {
-              content.push({ type: "input_text", text: part.text })
-              break
-            }
+    for (const message of options.prompt.content) {
+      switch (message.role) {
+        case "system": {
+          messages.push({
+            role: getSystemMessageMode(config.model!),
+            content: message.content
+          })
+          break
+        }
 
-            case "file": {
-              if (part.mediaType.startsWith("image/")) {
-                const detail = getImageDetail(part)
-                const mediaType = part.mediaType === "image/*" ? "image/jpeg" : part.mediaType
+        case "user": {
+          const content: Array<typeof Generated.InputContent.Encoded> = []
 
-                if (typeof part.data === "string" && isFileId(part.data, config)) {
-                  content.push({ type: "input_image", file_id: part.data, detail })
-                }
+          for (let index = 0; index < message.content.length; index++) {
+            const part = message.content[index]
 
-                if (part.data instanceof URL) {
-                  content.push({ type: "input_image", image_url: part.data.toString(), detail })
-                }
+            switch (part.type) {
+              case "text": {
+                content.push({ type: "input_text", text: part.text })
+                break
+              }
 
-                if (part.data instanceof Uint8Array) {
-                  const base64 = Encoding.encodeBase64(part.data)
-                  const imageUrl = `data:${mediaType};base64,${base64}`
-                  content.push({ type: "input_image", image_url: imageUrl, detail })
-                }
-              } else if (part.mediaType === "application/pdf") {
-                if (typeof part.data === "string" && isFileId(part.data, config)) {
-                  content.push({ type: "input_file", file_id: part.data })
-                }
+              case "file": {
+                if (part.mediaType.startsWith("image/")) {
+                  const detail = getImageDetail(part)
+                  const mediaType = part.mediaType === "image/*" ? "image/jpeg" : part.mediaType
 
-                if (part.data instanceof URL) {
-                  content.push({ type: "input_file", file_url: part.data.toString() })
-                }
+                  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 Uint8Array) {
-                  const base64 = Encoding.encodeBase64(part.data)
-                  const fileName = part.fileName ?? `part-${index}.pdf`
-                  const fileData = `data:application/pdf;base64,${base64}`
-                  content.push({ type: "input_file", filename: fileName, file_data: fileData })
+                  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}'`
+                    })
+                  })
                 }
-              } else {
-                return yield* new AiError.MalformedInput({
-                  module: "OpenAiLanguageModel",
-                  method: "prepareMessages",
-                  description: `Detected unsupported media type for file: '${part.mediaType}'`
-                })
               }
             }
           }
+
+          messages.push({ role: "user", content })
+
+          break
         }
 
-        messages.push({ role: "user", content })
+        case "assistant": {
+          const reasoningMessages: Record<string, DeepMutable<typeof Generated.ReasoningItem.Encoded>> = {}
 
-        break
-      }
+          for (const part of message.content) {
+            switch (part.type) {
+              case "text": {
+                const id = getItemId(part)
 
-      case "assistant": {
-        const reasoningMessages: Record<string, DeepMutable<typeof Generated.ReasoningItem.Encoded>> = {}
+                // 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
+                }
 
-        for (const part of message.content) {
-          switch (part.type) {
-            case "text": {
-              messages.push({
-                role: "assistant",
-                content: [{ type: "output_text", text: part.text }],
-                id: getItemId(part)
-              })
-              break
-            }
+                if (config.store === true && Predicate.isNotNull(id)) {
+                  messages.push({ type: "item_reference", id })
+                  break
+                }
 
-            case "reasoning": {
-              const options = part.options.openai
+                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
+              }
 
-              if (Predicate.isNotUndefined(options?.itemId)) {
-                const reasoningMessage = reasoningMessages[options.itemId]
-                const summaryParts: Mutable<typeof Generated.ReasoningItem.fields.summary.Encoded> = []
+              case "reasoning": {
+                const id = getItemId(part)
+                const encryptedContent = getEncryptedContent(part)
 
-                if (part.text.length > 0) {
-                  summaryParts.push({ type: "summary_text", text: part.text })
+                if (hasConversation && Predicate.isNotNull(id)) {
+                  break
                 }
 
-                if (Predicate.isUndefined(reasoningMessage)) {
-                  reasoningMessages[options.itemId] = {
-                    id: options.itemId,
-                    type: "reasoning",
-                    summary: summaryParts,
-                    encrypted_content: options.encryptedContent
-                  }
-                  messages.push(reasoningMessages[options.itemId])
-                } else {
-                  for (const summaryPart of summaryParts) {
-                    reasoningMessage.summary.push(summaryPart)
+                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: Array<typeof Generated.SummaryTextContent.Encoded> = []
+
+                    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
               }
 
-              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 as Schema.Json,
+                          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 as Schema.Json,
+                          description: error.message
+                        })
+                      })
+                    )
+                  )
+
+                  messages.push({
+                    id: id!,
+                    type: "shell_call",
+                    call_id: part.id,
+                    status: status ?? "completed",
+                    action: params.action
+                  })
+
+                  break
+                }
 
-            case "tool-call": {
-              if (!part.providerExecuted) {
                 messages.push({
-                  id: getItemId(part),
                   type: "function_call",
+                  name: toolName,
                   call_id: part.id,
-                  name: part.name,
-                  arguments: JSON.stringify(part.params)
+                  arguments: JSON.stringify(part.params),
+                  ...(Predicate.isNotNull(id) ? { id } : {}),
+                  ...(Predicate.isNotNull(status) ? { status } : {})
                 })
+
+                break
               }
 
-              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
         }
 
-        break
-      }
+        case "tool": {
+          for (const part of message.content) {
+            if (part.type === "tool-approval-response") {
+              if (processedApprovalIds.has(part.approvalId)) {
+                continue
+              }
 
-      case "tool": {
-        for (const part of message.content) {
-          messages.push({
-            type: "function_call_output",
-            call_id: part.id,
-            output: JSON.stringify(part.result)
-          })
-        }
+              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
+              } as any)
+
+              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 as any)
+              })
+            }
+
+            if (Predicate.isNotUndefined(shellTool) && toolName === "shell") {
+              messages.push({
+                id,
+                type: "shell_call_output",
+                call_id: part.id,
+                output: part.result as any,
+                ...(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 as any,
+                ...(Predicate.isNotNull(status) ? { status } : {})
+              })
+            }
+
+            messages.push({
+              type: "function_call_output",
+              call_id: part.id,
+              output: JSON.stringify(part.result),
+              ...(Predicate.isNotNull(status) ? { status } : {})
+            })
+          }
 
-        break
+          break
+        }
       }
     }
+
+    return messages
   }
+)
+
+// =============================================================================
+// HTTP Details
+// =============================================================================
+
+const buildHttpRequestDetails = (
+  request: HttpClientRequest.HttpClientRequest
+): typeof Response.HttpRequestDetails.Type => ({
+  method: request.method,
+  url: request.url,
+  urlParams: Array.from(request.urlParams),
+  hash: request.hash,
+  headers: Redactable.redact(request.headers) as Record<string, string>
+})
 
-  return messages
+const buildHttpResponseDetails = (
+  response: HttpClientResponse.HttpClientResponse
+): typeof Response.HttpResponseDetails.Type => ({
+  status: response.status,
+  headers: Redactable.redact(response.headers) as Record<string, string>
 })
 
 // =============================================================================
 // Response Conversion
 // =============================================================================
 
-const makeResponse: (
-  response: Generated.Response,
-  options: LanguageModel.ProviderOptions
-) => Effect.Effect<
-  Array<Response.PartEncoded>,
-  AiError.AiError,
-  IdGenerator.IdGenerator
-> = Effect.fnUntraced(
-  function*(response, options) {
+type ResponseStreamEvent = typeof Generated.ResponseStreamEvent.Type
+
+const makeResponse = Effect.fnUntraced(
+  function*<Tools extends ReadonlyArray<Tool.Any>>({
+    options,
+    rawResponse,
+    response,
+    toolNameMapper
+  }: {
+    readonly options: LanguageModel.ProviderOptions
+    readonly rawResponse: Generated.Response
+    readonly response: HttpClientResponse.HttpClientResponse
+    readonly toolNameMapper: Tool.NameMapper<Tools>
+  }): Effect.fn.Return<
+    Array<Response.PartEncoded>,
+    AiError.AiError,
+    IdGenerator.IdGenerator
+  > {
     const idGenerator = yield* IdGenerator.IdGenerator
 
+    const approvalRequests = getApprovalRequestIdMapping(options.prompt)
+
     const webSearchTool = options.tools.find((tool) =>
       Tool.isProviderDefined(tool) &&
-      (tool.id === "openai.web_search" ||
-        tool.id === "openai.web_search_preview")
+      (tool.name === "OpenAiWebSearch" ||
+        tool.name === "OpenAiWebSearchPreview")
     ) as Tool.AnyProviderDefined | undefined
 
     let hasToolCalls = false
     const parts: Array<Response.PartEncoded> = []
 
-    const createdAt = new Date(response.created_at * 1000)
+    const createdAt = new Date(rawResponse.created_at * 1000)
     parts.push({
       type: "response-metadata",
-      id: response.id,
-      modelId: response.model,
-      timestamp: DateTime.formatIso(DateTime.unsafeFromDate(createdAt))
+      id: rawResponse.id,
+      modelId: rawResponse.model as string,
+      timestamp: DateTime.formatIso(DateTime.fromDateUnsafe(createdAt)),
+      request: buildHttpRequestDetails(response.request)
     })
 
-    for (const part of response.output) {
+    for (const part of rawResponse.output) {
       switch (part.type) {
-        case "message": {
-          for (const contentPart of part.content) {
-            switch (contentPart.type) {
-              case "output_text": {
-                parts.push({
-                  type: "text",
-                  text: contentPart.text,
-                  metadata: { openai: { itemId: part.id } }
-                })
+        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
+        }
 
-                for (const annotation of contentPart.annotations) {
-                  if (annotation.type === "file_citation") {
-                    const metadata = {
-                      type: annotation.type,
-                      index: annotation.index
-                    }
-
-                    parts.push({
-                      type: "source",
-                      sourceType: "document",
-                      id: yield* idGenerator.generateId(),
-                      mediaType: "text/plain",
-                      title: annotation.filename ?? "Untitled Document",
-                      metadata: { openai: metadata }
-                    })
-                  }
-
-                  if (annotation.type === "url_citation") {
-                    const metadata = {
-                      type: annotation.type,
-                      startIndex: annotation.start_index,
-                      endIndex: annotation.end_index
-                    }
-
-                    parts.push({
-                      type: "source",
-                      sourceType: "url",
-                      id: yield* idGenerator.generateId(),
-                      url: annotation.url,
-                      title: annotation.title,
-                      metadata: { openai: metadata }
-                    })
-                  }
-                }
-
-                break
-              }
-              case "refusal": {
-                parts.push({
-                  type: "text",
-                  text: "",
-                  metadata: { openai: { refusal: contentPart.refusal } }
-                })
-
-                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) =>
-              new AiError.MalformedOutput({
+              AiError.make({
                 module: "OpenAiLanguageModel",
                 method: "makeResponse",
-                description: "Failed to securely parse tool call parameters " +
-                  `for tool '${toolName}':\nParameters: ${toolParams}`,
-                cause
+                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: { itemId: part.id } }
+            metadata: { openai: { ...makeItemIdMetadata(part.id) } }
           })
-
           break
         }
 
-        case "code_interpreter_call": {
+        case "image_generation_call": {
+          const toolName = toolNameMapper.getCustomName("image_generation")
           parts.push({
             type: "tool-call",
             id: part.id,
-            name: "OpenAiCodeInterpreter",
-            params: { code: part.code, container_id: part.container_id },
-            providerName: "code_interpreter",
+            name: toolName,
+            params: {},
             providerExecuted: true
           })
-
           parts.push({
             type: "tool-result",
             id: part.id,
-            name: "OpenAiCodeInterpreter",
+            name: toolName,
             isFailure: false,
-            result: part.outputs,
-            providerName: "code_interpreter",
-            providerExecuted: true
+            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 "file_search_call": {
+        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: part.id,
-            name: "OpenAiFileSearch",
-            params: {},
-            providerName: "file_search",
+            id: toolId,
+            name: toolName,
+            params: part.arguments,
             providerExecuted: true
           })
 
           parts.push({
             type: "tool-result",
-            id: part.id,
-            name: "OpenAiFileSearch",
+            id: toolId,
+            name: toolName,
             isFailure: false,
+            providerExecuted: true,
             result: {
-              status: part.status,
-              queries: part.queries,
-              ...(part.results && { results: part.results })
+              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)
             },
-            providerName: "file_search",
-            providerExecuted: true
+            metadata: { openai: { ...makeItemIdMetadata(part.id) } }
           })
 
           break
         }
 
-        case "web_search_call": {
+        case "mcp_list_tools": {
+          // Skip
+          break
+        }
+
+        case "mcp_approval_request": {
+          const approvalRequestId = (part as any).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: part.id,
-            name: webSearchTool?.name ?? "OpenAiWebSearch",
-            params: { action: part.action },
-            providerName: webSearchTool?.providerName ?? "web_search",
+            id: toolId,
+            name: toolName,
+            params,
             providerExecuted: true
           })
 
           parts.push({
-            type: "tool-result",
-            id: part.id,
-            name: webSearchTool?.name ?? "OpenAiWebSearch",
-            isFailure: false,
-            result: { status: part.status },
-            providerName: webSearchTool?.providerName ?? "web_search",
-            providerExecuted: true
+            type: "tool-approval-request",
+            toolCallId: toolId,
+            approvalId: approvalRequestId
           })
 
           break
         }
 
-        // TODO(Max): support computer use
-        // case "computer_call": {
-        //   parts.push({
-        //     type: "tool-call",
-        //     id: part.id,
-        //     name: "OpenAiComputerUse",
-        //     params: { action: part.action },
-        //     providerName: webSearchTool?.providerName ?? "web_search",
-        //     providerExecuted: true
-        //   })
-        //
-        //   parts.push({
-        //     type: "tool-result",
-        //     id: part.id,
-        //     name: webSearchTool?.name ?? "OpenAiWebSearch",
-        //     result: { status: part.status },
-        //     providerName: webSearchTool?.providerName ?? "web_search",
-        //     providerExecuted: true
-        //   })
-        //   break
-        // }
+        case "message": {
+          for (const contentPart of part.content) {
+            switch (contentPart.type) {
+              case "output_text": {
+                const annotations = contentPart.annotations.length > 0
+                  ? { annotations: contentPart.annotations as any }
+                  : 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
+          // propagate the part identifier and encrypted content
           if (part.summary.length === 0) {
-            parts.push({
-              type: "reasoning",
-              text: "",
-              metadata: { openai: { itemId: part.id } }
-            })
+            parts.push({ type: "reasoning", text: "", metadata })
           } else {
             for (const summary of part.summary) {
-              const metadata = {
-                itemId: part.id,
-                encryptedContent: part.encrypted_content ?? undefined
-              }
-              parts.push({
-                type: "reasoning",
-                text: summary.text,
-                metadata: { openai: metadata }
-              })
+              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(
-      response.incomplete_details?.reason,
+      rawResponse.incomplete_details?.reason,
       hasToolCalls
     )
 
-    const metadata = {
-      serviceTier: response.service_tier
-    }
-
     parts.push({
       type: "finish",
       reason: finishReason,
-      usage: {
-        inputTokens: response.usage?.input_tokens,
-        outputTokens: response.usage?.output_tokens,
-        totalTokens: (response.usage?.input_tokens ?? 0) + (response.usage?.output_tokens ?? 0),
-        reasoningTokens: response.usage?.output_tokens_details?.reasoning_tokens,
-        cachedInputTokens: response.usage?.input_tokens_details?.cached_tokens
-      },
-      metadata: { openai: metadata }
+      usage: getUsage(rawResponse.usage),
+      response: buildHttpResponseDetails(response),
+      ...(rawResponse.service_tier && { metadata: { openai: { serviceTier: rawResponse.service_tier } } })
     })
 
     return parts
   }
 )
 
-const makeStreamResponse: (
-  stream: Stream.Stream<ResponseStreamEvent, AiError.AiError>,
-  options: LanguageModel.ProviderOptions
-) => Effect.Effect<
-  Stream.Stream<Response.StreamPartEncoded, AiError.AiError>,
-  never,
-  IdGenerator.IdGenerator
-> = Effect.fnUntraced(
-  function*(stream, options) {
+const makeStreamResponse = Effect.fnUntraced(
+  function*<Tools extends ReadonlyArray<Tool.Any>>({
+    stream,
+    response,
+    config,
+    options,
+    toolNameMapper
+  }: {
+    readonly config: typeof Config.Service
+    readonly stream: Stream.Stream<ResponseStreamEvent, AiError.AiError>
+    readonly response: HttpClientResponse.HttpClientResponse
+    readonly options: LanguageModel.ProviderOptions
+    readonly toolNameMapper: Tool.NameMapper<Tools>
+  }): Effect.fn.Return<
+    Stream.Stream<Response.StreamPartEncoded, AiError.AiError>,
+    AiError.AiError,
+    IdGenerator.IdGenerator
+  > {
     const idGenerator = yield* IdGenerator.IdGenerator
 
+    const approvalRequests = getApprovalRequestIdMapping(options.prompt)
+    const streamApprovalRequests = new Map<string, string>()
+
     let hasToolCalls = false
 
+    // Track annotations for current message to include in text-end metadata
+    const activeAnnotations: Array<typeof Generated.Annotation.Encoded> = []
+
+    // Track active reasoning items with state machine for proper concluding logic
     const activeReasoning: Record<string, {
-      readonly summaryParts: Array<number>
       readonly encryptedContent: string | undefined
+      readonly summaryParts: Record<number, "active" | "can-conclude" | "concluded">
     }> = {}
 
+    // Track active tool calls with optional provider-specific state
     const activeToolCalls: Record<number, {
       readonly id: string
       readonly name: string
+      readonly applyPatch?: {
+        hasDiff: boolean
+        endEmitted: boolean
+      }
+      readonly codeInterpreter?: {
+        readonly containerId: string
+      }
     }> = {}
 
     const webSearchTool = options.tools.find((tool) =>
       Tool.isProviderDefined(tool) &&
-      (tool.id === "openai.web_search" ||
-        tool.id === "openai.web_search_preview")
-    ) as Tool.AnyProviderDefined | undefined
+      (tool.name === "OpenAiWebSearch" ||
+        tool.name === "OpenAiWebSearchPreview")
+    ) as ReturnType<typeof OpenAiTool.WebSearch> | ReturnType<typeof OpenAiTool.WebSearchPreview> | undefined
 
     return stream.pipe(
       Stream.mapEffect(Effect.fnUntraced(function*(event) {
@@ -865,7 +1406,8 @@ const makeStreamResponse: (
               type: "response-metadata",
               id: event.response.id,
               modelId: event.response.model,
-              timestamp: DateTime.formatIso(DateTime.unsafeFromDate(createdAt))
+              timestamp: DateTime.formatIso(DateTime.fromDateUnsafe(createdAt)),
+              request: buildHttpRequestDetails(response.request)
             })
             break
           }
@@ -884,35 +1426,101 @@ const makeStreamResponse: (
                 event.response.incomplete_details?.reason,
                 hasToolCalls
               ),
-              usage: {
-                inputTokens: event.response.usage?.input_tokens,
-                outputTokens: event.response.usage?.output_tokens,
-                totalTokens: (event.response.usage?.input_tokens ?? 0) + (event.response.usage?.output_tokens ?? 0),
-                reasoningTokens: event.response.usage?.output_tokens_details?.reasoning_tokens,
-                cachedInputTokens: event.response.usage?.input_tokens_details?.cached_tokens
-              },
-              metadata: { openai: { serviceTier: event.response.service_tier } }
+              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 "computer_call": {
-                // TODO(Max): support computer use
+              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 "file_search_call": {
+              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: "OpenAiFileSearch"
+                  name: toolName
                 }
                 parts.push({
                   type: "tool-params-start",
                   id: event.item.id,
-                  name: "OpenAiFileSearch",
-                  providerName: "file_search",
+                  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
@@ -931,43 +1539,89 @@ const makeStreamResponse: (
                 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: { itemId: event.item.id } }
+                  metadata: { openai: { ...makeItemIdMetadata(event.item.id) } }
                 })
                 break
               }
 
               case "reasoning": {
+                const encryptedContent = event.item.encrypted_content ?? undefined
                 activeReasoning[event.item.id] = {
-                  summaryParts: [0],
-                  encryptedContent: event.item.encrypted_content
+                  encryptedContent,
+                  summaryParts: { 0: "active" }
                 }
                 parts.push({
                   type: "reasoning-start",
                   id: `${event.item.id}:0`,
                   metadata: {
                     openai: {
-                      itemId: event.item.id,
-                      encryptedContent: event.item.encrypted_content
+                      ...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: webSearchTool?.name ?? "OpenAiWebSearch"
+                  name: toolName
                 }
                 parts.push({
                   type: "tool-params-start",
                   id: event.item.id,
                   name: webSearchTool?.name ?? "OpenAiWebSearch",
-                  providerName: webSearchTool?.providerName ?? "web_search",
+                  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
@@ -979,34 +1633,63 @@ const makeStreamResponse: (
 
           case "response.output_item.done": {
             switch (event.item.type) {
-              case "code_interpreter_call": {
-                parts.push({
-                  type: "tool-call",
-                  id: event.item.id,
-                  name: "OpenAiCodeInterpreter",
-                  params: { code: event.item.code, container_id: event.item.container_id },
-                  providerName: "code_interpreter",
-                  providerExecuted: true
-                })
+              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: "OpenAiCodeInterpreter",
+                  name: toolName,
                   isFailure: false,
                   result: { outputs: event.item.outputs },
-                  providerName: "code_interpreter",
                   providerExecuted: true
                 })
                 break
               }
 
-              // TODO(Max): support computer use
               case "computer_call": {
-                break
-              }
-
-              case "file_search_call": {
                 delete activeToolCalls[event.output_index]
+                const toolName = toolNameMapper.getCustomName("computer_use")
                 parts.push({
                   type: "tool-params-end",
                   id: event.item.id
@@ -1014,110 +1697,214 @@ const makeStreamResponse: (
                 parts.push({
                   type: "tool-call",
                   id: event.item.id,
-                  name: "OpenAiFileSearch",
+                  name: toolName,
                   params: {},
-                  providerName: "file_search",
                   providerExecuted: true
                 })
                 parts.push({
                   type: "tool-result",
                   id: event.item.id,
-                  name: "OpenAiFileSearch",
+                  name: toolName,
                   isFailure: false,
-                  result: {
-                    status: event.item.status,
-                    queries: event.item.queries,
-                    ...(event.item.results && { results: event.item.results })
-                  },
-                  providerName: "file_search",
+                  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) =>
-                    new AiError.MalformedOutput({
+                    AiError.make({
                       module: "OpenAiLanguageModel",
                       method: "makeStreamResponse",
-                      description: "Failed to securely parse tool call parameters " +
-                        `for tool '${toolName}':\nParameters: ${toolParams}`,
-                      cause
+                      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: { itemId: event.item.id } }
+                  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
+              }
 
-                delete activeToolCalls[event.output_index]
+              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 as any).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
+                  id: event.item.id,
+                  metadata: { openai: { ...annotations, ...makeItemIdMetadata(event.item.id) } }
                 })
                 break
               }
 
               case "reasoning": {
                 const reasoningPart = activeReasoning[event.item.id]
-                for (const summaryIndex of reasoningPart.summaryParts) {
-                  parts.push({
-                    type: "reasoning-end",
-                    id: `${event.item.id}:${summaryIndex}`,
-                    metadata: {
-                      openai: {
-                        itemId: event.item.id,
-                        encryptedContent: event.item.encrypted_content
+                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 "web_search_call": {
+              case "shell_call": {
                 delete activeToolCalls[event.output_index]
-                parts.push({
-                  type: "tool-params-end",
-                  id: event.item.id
-                })
+                const toolName = toolNameMapper.getCustomName("shell")
                 parts.push({
                   type: "tool-call",
                   id: event.item.id,
-                  name: "OpenAiWebSearch",
+                  name: toolName,
                   params: { action: event.item.action },
-                  providerName: "web_search",
-                  providerExecuted: true
+                  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: "OpenAiWebSearch",
+                  name: toolName,
                   isFailure: false,
-                  result: { status: event.item.status },
-                  providerName: "web_search",
+                  result: { action: event.item.action, status: event.item.status },
                   providerExecuted: true
                 })
                 break
@@ -1137,23 +1924,71 @@ const makeStreamResponse: (
           }
 
           case "response.output_text.annotation.added": {
-            if (event.annotation.type === "file_citation") {
+            const annotation = event.annotation as typeof Generated.Annotation.Encoded
+            // 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: event.annotation.filename ?? "Untitled Document",
-                fileName: event.annotation.filename ?? event.annotation.file_id
+                title: annotation.filename,
+                fileName: annotation.filename,
+                metadata: {
+                  openai: {
+                    type: annotation.type,
+                    fileId: annotation.file_id,
+                    containerId: annotation.container_id
+                  }
+                }
               })
-            }
-            if (event.annotation.type === "url_citation") {
+            } 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: event.annotation.url,
-                title: event.annotation.title
+                url: annotation.url,
+                title: annotation.title,
+                metadata: {
+                  openai: {
+                    type: annotation.type,
+                    startIndex: annotation.start_index,
+                    endIndex: annotation.end_index
+                  }
+                }
               })
             }
             break
@@ -1171,20 +2006,124 @@ const makeStreamResponse: (
             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)) {
-                reasoningPart.summaryParts.push(event.summary_index)
+                // 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: {
-                    itemId: event.item_id,
-                    encryptedContent: reasoningPart?.encryptedContent
+                    ...makeItemIdMetadata(event.item_id),
+                    ...makeEncryptedContentMetadata(reasoningPart.encryptedContent)
                   }
                 }
               })
@@ -1197,15 +2136,34 @@ const makeStreamResponse: (
               type: "reasoning-delta",
               id: `${event.item_id}:${event.summary_index}`,
               delta: event.delta,
-              metadata: { openai: { itemId: event.item_id } }
+              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.flattenIterables
+      Stream.flattenIterable
     )
   }
 )
@@ -1222,35 +2180,35 @@ const annotateRequest = (
     system: "openai",
     operation: { name: "chat" },
     request: {
-      model: request.model,
-      temperature: request.temperature,
-      topP: request.top_p,
-      maxTokens: request.max_output_tokens
+      model: request.model as string,
+      temperature: request.temperature as number | undefined,
+      topP: request.top_p as number | undefined,
+      maxTokens: request.max_output_tokens as number | undefined
     },
     openai: {
       request: {
-        responseFormat: request.text?.format?.type,
-        serviceTier: request.service_tier
+        responseFormat: (request.text as any)?.format?.type,
+        serviceTier: request.service_tier as string | undefined
       }
     }
   })
 }
 
 const annotateResponse = (span: Span, response: Generated.Response): void => {
-  const finishReason = response.incomplete_details?.reason
+  const finishReason = response.incomplete_details?.reason as string | undefined
   addGenAIAnnotations(span, {
     response: {
       id: response.id,
-      model: response.model,
+      model: response.model as string,
       finishReasons: Predicate.isNotUndefined(finishReason) ? [finishReason] : undefined
     },
     usage: {
-      inputTokens: response.usage?.input_tokens,
-      outputTokens: response.usage?.output_tokens
+      inputTokens: response.usage?.input_tokens as number | undefined,
+      outputTokens: response.usage?.output_tokens as number | undefined
     },
     openai: {
       response: {
-        serviceTier: response.service_tier
+        serviceTier: response.service_tier as string | undefined
       }
     }
   })
@@ -1266,14 +2224,14 @@ const annotateStreamResponse = (span: Span, part: Response.StreamPartEncoded) =>
     })
   }
   if (part.type === "finish") {
-    const serviceTier = part.metadata?.openai?.serviceTier as string | undefined
+    const serviceTier = (part.metadata as any)?.openai?.serviceTier as string | undefined
     addGenAIAnnotations(span, {
       response: {
         finishReasons: [part.reason]
       },
       usage: {
-        inputTokens: part.usage.inputTokens,
-        outputTokens: part.usage.outputTokens
+        inputTokens: part.usage.inputTokens.total,
+        outputTokens: part.usage.outputTokens.total
       },
       openai: {
         response: { serviceTier }
@@ -1283,15 +2241,23 @@ const annotateStreamResponse = (span: Span, part: Response.StreamPartEncoded) =>
 }
 
 // =============================================================================
-// Tool Calling
+// Tool Conversion
 // =============================================================================
 
-type OpenAiToolChoice = typeof Generated.CreateResponse.fields.tool_choice.from.Encoded
-
-const prepareTools: (options: LanguageModel.ProviderOptions) => Effect.Effect<{
+type OpenAiToolChoice = typeof Generated.CreateResponse.Encoded["tool_choice"]
+
+const prepareTools = Effect.fnUntraced(function*<Tools extends ReadonlyArray<Tool.Any>>({
+  config,
+  options,
+  toolNameMapper
+}: {
+  readonly config: typeof Config.Service
+  readonly options: LanguageModel.ProviderOptions
+  readonly toolNameMapper: Tool.NameMapper<Tools>
+}): Effect.fn.Return<{
   readonly tools: ReadonlyArray<typeof Generated.Tool.Encoded> | undefined
   readonly toolChoice: OpenAiToolChoice | undefined
-}, AiError.AiError> = Effect.fnUntraced(function*(options) {
+}, AiError.AiError> {
   // Return immediately if no tools are in the toolkit
   if (options.tools.length === 0) {
     return { tools: undefined, toolChoice: undefined }
@@ -1314,50 +2280,152 @@ const prepareTools: (options: LanguageModel.ProviderOptions) => Effect.Effect<{
   // 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 as any),
-        parameters: Tool.getJsonSchema(tool as any) as any,
-        strict: true
+        description: Tool.getDescription(tool) ?? null,
+        parameters: Tool.getJsonSchema(tool) as { readonly [x: string]: Schema.Json },
+        strict
       })
     }
 
     if (Tool.isProviderDefined(tool)) {
-      switch (tool.id) {
-        case "openai.code_interpreter": {
+      const openAiTool = tool as OpenAiTool.OpenAiTool
+      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({
-            ...tool.args,
+            ...args,
             type: "code_interpreter"
           })
           break
         }
-        case "openai.file_search": {
+        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({
-            ...tool.args,
+            ...args,
             type: "file_search"
           })
           break
         }
-        case "openai.web_search": {
+        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({
-            ...tool.args,
+            ...args,
             type: "web_search"
           })
           break
         }
-        case "openai.web_search_preview": {
+        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({
-            ...tool.args,
+            ...args,
             type: "web_search_preview"
           })
           break
         }
         default: {
-          return yield* new AiError.MalformedInput({
-            module: "AnthropicLanguageModel",
+          return yield* AiError.make({
+            module: "OpenAiLanguageModel",
             method: "prepareTools",
-            description: `Received request to call unknown provider-defined tool '${tool.name}'`
+            reason: new AiError.InvalidRequestError({
+              description: `Unknown provider-defined tool '${tool.name}'`
+            })
           })
         }
       }
@@ -1369,9 +2437,13 @@ const prepareTools: (options: LanguageModel.ProviderOptions) => Effect.Effect<{
   }
 
   if (typeof options.toolChoice === "object" && "tool" in options.toolChoice) {
-    toolChoice = Predicate.isUndefined(OpenAiTool.getProviderDefinedToolName(options.toolChoice.tool))
-      ? { type: "function", name: options.toolChoice.tool }
-      : { type: options.toolChoice.tool }
+    const toolName = toolNameMapper.getProviderName(options.toolChoice.tool)
+    const providerNames = toolNameMapper.providerNames
+    if (providerNames.includes(toolName)) {
+      toolChoice = { type: toolName as any }
+    } else {
+      toolChoice = { type: "function", name: options.toolChoice.tool }
+    }
   }
 
   return { tools, toolChoice }
@@ -1381,59 +2453,156 @@ const prepareTools: (options: LanguageModel.ProviderOptions) => Effect.Effect<{
 // Utilities
 // =============================================================================
 
-const isFileId = (data: string, config: Config.Service): boolean =>
-  Predicate.isNotUndefined(config.fileIdPrefixes) && config.fileIdPrefixes.some((prefix) => data.startsWith(prefix))
+const isFileId = (data: string, config: typeof Config.Service): boolean =>
+  config.fileIdPrefixes != null && config.fileIdPrefixes.some((prefix) => data.startsWith(prefix))
 
 const getItemId = (
+  part:
+    | Prompt.TextPart
+    | Prompt.ReasoningPart
+    | Prompt.ToolCallPart
+    | Prompt.ToolResultPart
+): string | null => part.options.openai?.itemId ?? null
+const getStatus = (
   part:
     | Prompt.TextPart
     | Prompt.ToolCallPart
-): string | undefined => part.options.openai?.itemId
+    | Prompt.ToolResultPart
+): typeof Generated.Message.Encoded["status"] | null => part.options.openai?.status ?? null
+const getEncryptedContent = (
+  part: Prompt.ReasoningPart
+): string | null => part.options.openai?.encryptedContent ?? null
+
+const getImageDetail = (part: Prompt.FilePart): ImageDetail => part.options.openai?.imageDetail ?? "auto"
 
-const getImageDetail = (part: Prompt.FilePart): typeof Generated.ImageDetail.Encoded =>
-  part.options.openai?.imageDetail ?? "auto"
+const makeItemIdMetadata = (itemId: string | undefined) => Predicate.isNotUndefined(itemId) ? { itemId } : undefined
 
-const prepareInclude = (
-  options: LanguageModel.ProviderOptions,
-  config: Config.Service
-): ReadonlyArray<typeof Generated.IncludeEnum.Encoded> => {
-  const include: Set<typeof Generated.IncludeEnum.Encoded> = new Set(config.include ?? [])
+const makeEncryptedContentMetadata = (encryptedContent: string | null | undefined) =>
+  Predicate.isNotNullish(encryptedContent) ? { encryptedContent } : undefined
+
+const prepareResponseFormat = ({ config, options }: {
+  readonly config: typeof Config.Service
+  readonly options: LanguageModel.ProviderOptions
+}): typeof Generated.TextResponseFormatConfiguration.Encoded => {
+  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) as any,
+      strict: config.strictJsonSchema ?? true
+    }
+  }
+  return { type: "text" }
+}
 
-  const codeInterpreterTool = options.tools.find((tool) =>
-    Tool.isProviderDefined(tool) &&
-    tool.id === "openai.code_interpreter"
-  ) as Tool.AnyProviderDefined | undefined
+interface ModelCapabilities {
+  readonly isReasoningModel: boolean
+  readonly systemMessageMode: "remove" | "system" | "developer"
+  readonly supportsFlexProcessing: boolean
+  readonly supportsPriorityProcessing: boolean
+  /**
+   * Allow temperature, topP, logProbs when reasoningEffort is none.
+   */
+  readonly supportsNonReasoningParameters: boolean
+}
 
-  if (Predicate.isNotUndefined(codeInterpreterTool)) {
-    include.add("code_interpreter_call.outputs")
+const getModelCapabilities = (modelId: string): ModelCapabilities => {
+  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: Prompt.Prompt): ReadonlyMap<string, string> => {
+  const mapping = new Map<string, string>()
+
+  for (const message of prompt.content) {
+    if (message.role !== "assistant") {
+      continue
+    }
 
-  const webSearchTool = options.tools.find((tool) =>
-    Tool.isProviderDefined(tool) &&
-    (tool.id === "openai.web_search" ||
-      tool.id === "openai.web_search_preview")
-  ) as Tool.AnyProviderDefined | undefined
+    for (const part of message.content) {
+      if (part.type !== "tool-call") {
+        continue
+      }
+
+      const approvalRequestId = part.options.openai?.approvalRequestId
 
-  if (Predicate.isNotUndefined(webSearchTool)) {
-    include.add("web_search_call.action.sources")
+      if (Predicate.isNotNullish(approvalRequestId)) {
+        mapping.set(approvalRequestId, part.id)
+      }
+    }
   }
 
-  return Array.from(include)
+  return mapping
 }
 
-const prepareResponseFormat = (
-  options: LanguageModel.ProviderOptions
-): typeof Generated.TextResponseFormatConfiguration.Encoded => {
-  if (options.responseFormat.type === "json") {
-    const name = options.responseFormat.objectName
-    const schema = options.responseFormat.schema
+const getUsage = (usage: Generated.ResponseUsage | null | undefined): Response.Usage => {
+  if (Predicate.isNullish(usage)) {
     return {
-      type: "json_schema",
-      name,
-      description: Tool.getDescriptionFromSchemaAst(schema.ast) ?? "Response with a JSON object",
-      schema: Tool.getJsonSchemaFromSchemaAst(schema.ast) as any,
-      strict: true
+      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
     }
   }
-  return { type: "text" }
 }