bincode-cli 1.0.1

package/src/provider/sdk/openai-compatible/src/responses/openai-responses-language-model.ts

@@ -0,0 +1,1713 @@
+import {
+  APICallError,
+  type LanguageModelV2,
+  type LanguageModelV2CallWarning,
+  type LanguageModelV2Content,
+  type LanguageModelV2FinishReason,
+  type LanguageModelV2ProviderDefinedTool,
+  type LanguageModelV2StreamPart,
+  type LanguageModelV2Usage,
+  type SharedV2ProviderMetadata,
+} from "@ai-sdk/provider"
+import {
+  combineHeaders,
+  createEventSourceResponseHandler,
+  createJsonResponseHandler,
+  generateId,
+  parseProviderOptions,
+  type ParseResult,
+  postJsonToApi,
+} from "@ai-sdk/provider-utils"
+import { z } from "zod/v4"
+import type { OpenAIConfig } from "./openai-config"
+import { openaiFailedResponseHandler } from "./openai-error"
+import { codeInterpreterInputSchema, codeInterpreterOutputSchema } from "./tool/code-interpreter"
+import { fileSearchOutputSchema } from "./tool/file-search"
+import { imageGenerationOutputSchema } from "./tool/image-generation"
+import { convertToOpenAIResponsesInput } from "./convert-to-openai-responses-input"
+import { mapOpenAIResponseFinishReason } from "./map-openai-responses-finish-reason"
+import type { OpenAIResponsesIncludeOptions, OpenAIResponsesIncludeValue } from "./openai-responses-api-types"
+import { prepareResponsesTools } from "./openai-responses-prepare-tools"
+import type { OpenAIResponsesModelId } from "./openai-responses-settings"
+import { localShellInputSchema } from "./tool/local-shell"
+
+const webSearchCallItem = z.object({
+  type: z.literal("web_search_call"),
+  id: z.string(),
+  status: z.string(),
+  action: z
+    .discriminatedUnion("type", [
+      z.object({
+        type: z.literal("search"),
+        query: z.string().nullish(),
+      }),
+      z.object({
+        type: z.literal("open_page"),
+        url: z.string(),
+      }),
+      z.object({
+        type: z.literal("find"),
+        url: z.string(),
+        pattern: z.string(),
+      }),
+    ])
+    .nullish(),
+})
+
+const fileSearchCallItem = z.object({
+  type: z.literal("file_search_call"),
+  id: z.string(),
+  queries: z.array(z.string()),
+  results: z
+    .array(
+      z.object({
+        attributes: z.record(z.string(), z.unknown()),
+        file_id: z.string(),
+        filename: z.string(),
+        score: z.number(),
+        text: z.string(),
+      }),
+    )
+    .nullish(),
+})
+
+const codeInterpreterCallItem = z.object({
+  type: z.literal("code_interpreter_call"),
+  id: z.string(),
+  code: z.string().nullable(),
+  container_id: z.string(),
+  outputs: z
+    .array(
+      z.discriminatedUnion("type", [
+        z.object({ type: z.literal("logs"), logs: z.string() }),
+        z.object({ type: z.literal("image"), url: z.string() }),
+      ]),
+    )
+    .nullable(),
+})
+
+const localShellCallItem = z.object({
+  type: z.literal("local_shell_call"),
+  id: z.string(),
+  call_id: z.string(),
+  action: z.object({
+    type: z.literal("exec"),
+    command: z.array(z.string()),
+    timeout_ms: z.number().optional(),
+    user: z.string().optional(),
+    working_directory: z.string().optional(),
+    env: z.record(z.string(), z.string()).optional(),
+  }),
+})
+
+const imageGenerationCallItem = z.object({
+  type: z.literal("image_generation_call"),
+  id: z.string(),
+  result: z.string(),
+})
+
+/**
+ * `top_logprobs` request body argument can be set to an integer between
+ * 0 and 20 specifying the number of most likely tokens to return at each
+ * token position, each with an associated log probability.
+ *
+ * @see https://platform.openai.com/docs/api-reference/responses/create#responses_create-top_logprobs
+ */
+const TOP_LOGPROBS_MAX = 20
+
+const LOGPROBS_SCHEMA = z.array(
+  z.object({
+    token: z.string(),
+    logprob: z.number(),
+    top_logprobs: z.array(
+      z.object({
+        token: z.string(),
+        logprob: z.number(),
+      }),
+    ),
+  }),
+)
+
+export class OpenAIResponsesLanguageModel implements LanguageModelV2 {
+  readonly specificationVersion = "v2"
+
+  readonly modelId: OpenAIResponsesModelId
+
+  private readonly config: OpenAIConfig
+
+  constructor(modelId: OpenAIResponsesModelId, config: OpenAIConfig) {
+    this.modelId = modelId
+    this.config = config
+  }
+
+  readonly supportedUrls: Record<string, RegExp[]> = {
+    "image/*": [/^https?:\/\/.*$/],
+    "application/pdf": [/^https?:\/\/.*$/],
+  }
+
+  get provider(): string {
+    return this.config.provider
+  }
+
+  private async getArgs({
+    maxOutputTokens,
+    temperature,
+    stopSequences,
+    topP,
+    topK,
+    presencePenalty,
+    frequencyPenalty,
+    seed,
+    prompt,
+    providerOptions,
+    tools,
+    toolChoice,
+    responseFormat,
+  }: Parameters<LanguageModelV2["doGenerate"]>[0]) {
+    const warnings: LanguageModelV2CallWarning[] = []
+    const modelConfig = getResponsesModelConfig(this.modelId)
+
+    if (topK != null) {
+      warnings.push({ type: "unsupported-setting", setting: "topK" })
+    }
+
+    if (seed != null) {
+      warnings.push({ type: "unsupported-setting", setting: "seed" })
+    }
+
+    if (presencePenalty != null) {
+      warnings.push({
+        type: "unsupported-setting",
+        setting: "presencePenalty",
+      })
+    }
+
+    if (frequencyPenalty != null) {
+      warnings.push({
+        type: "unsupported-setting",
+        setting: "frequencyPenalty",
+      })
+    }
+
+    if (stopSequences != null) {
+      warnings.push({ type: "unsupported-setting", setting: "stopSequences" })
+    }
+
+    const openaiOptions = await parseProviderOptions({
+      provider: "openai",
+      providerOptions,
+      schema: openaiResponsesProviderOptionsSchema,
+    })
+
+    const { input, warnings: inputWarnings } = await convertToOpenAIResponsesInput({
+      prompt,
+      systemMessageMode: modelConfig.systemMessageMode,
+      fileIdPrefixes: this.config.fileIdPrefixes,
+      store: openaiOptions?.store ?? true,
+      hasLocalShellTool: hasOpenAITool("openai.local_shell"),
+    })
+
+    warnings.push(...inputWarnings)
+
+    const strictJsonSchema = openaiOptions?.strictJsonSchema ?? false
+
+    let include: OpenAIResponsesIncludeOptions = openaiOptions?.include
+
+    function addInclude(key: OpenAIResponsesIncludeValue) {
+      include = include != null ? [...include, key] : [key]
+    }
+
+    function hasOpenAITool(id: string) {
+      return tools?.find((tool) => tool.type === "provider-defined" && tool.id === id) != null
+    }
+
+    // when logprobs are requested, automatically include them:
+    const topLogprobs =
+      typeof openaiOptions?.logprobs === "number"
+        ? openaiOptions?.logprobs
+        : openaiOptions?.logprobs === true
+          ? TOP_LOGPROBS_MAX
+          : undefined
+
+    if (topLogprobs) {
+      addInclude("message.output_text.logprobs")
+    }
+
+    // when a web search tool is present, automatically include the sources:
+    const webSearchToolName = (
+      tools?.find(
+        (tool) =>
+          tool.type === "provider-defined" &&
+          (tool.id === "openai.web_search" || tool.id === "openai.web_search_preview"),
+      ) as LanguageModelV2ProviderDefinedTool | undefined
+    )?.name
+
+    if (webSearchToolName) {
+      addInclude("web_search_call.action.sources")
+    }
+
+    // when a code interpreter tool is present, automatically include the outputs:
+    if (hasOpenAITool("openai.code_interpreter")) {
+      addInclude("code_interpreter_call.outputs")
+    }
+
+    const baseArgs = {
+      model: this.modelId,
+      input,
+      temperature,
+      top_p: topP,
+      max_output_tokens: maxOutputTokens,
+
+      ...((responseFormat?.type === "json" || openaiOptions?.textVerbosity) && {
+        text: {
+          ...(responseFormat?.type === "json" && {
+            format:
+              responseFormat.schema != null
+                ? {
+                    type: "json_schema",
+                    strict: strictJsonSchema,
+                    name: responseFormat.name ?? "response",
+                    description: responseFormat.description,
+                    schema: responseFormat.schema,
+                  }
+                : { type: "json_object" },
+          }),
+          ...(openaiOptions?.textVerbosity && {
+            verbosity: openaiOptions.textVerbosity,
+          }),
+        },
+      }),
+
+      // provider options:
+      max_tool_calls: openaiOptions?.maxToolCalls,
+      metadata: openaiOptions?.metadata,
+      parallel_tool_calls: openaiOptions?.parallelToolCalls,
+      previous_response_id: openaiOptions?.previousResponseId,
+      store: openaiOptions?.store,
+      user: openaiOptions?.user,
+      instructions: openaiOptions?.instructions,
+      service_tier: openaiOptions?.serviceTier,
+      include,
+      prompt_cache_key: openaiOptions?.promptCacheKey,
+      safety_identifier: openaiOptions?.safetyIdentifier,
+      top_logprobs: topLogprobs,
+
+      // model-specific settings:
+      ...(modelConfig.isReasoningModel &&
+        (openaiOptions?.reasoningEffort != null || openaiOptions?.reasoningSummary != null) && {
+          reasoning: {
+            ...(openaiOptions?.reasoningEffort != null && {
+              effort: openaiOptions.reasoningEffort,
+            }),
+            ...(openaiOptions?.reasoningSummary != null && {
+              summary: openaiOptions.reasoningSummary,
+            }),
+          },
+        }),
+      ...(modelConfig.requiredAutoTruncation && {
+        truncation: "auto",
+      }),
+    }
+
+    if (modelConfig.isReasoningModel) {
+      // remove unsupported settings for reasoning models
+      // see https://platform.openai.com/docs/guides/reasoning#limitations
+      if (baseArgs.temperature != null) {
+        baseArgs.temperature = undefined
+        warnings.push({
+          type: "unsupported-setting",
+          setting: "temperature",
+          details: "temperature is not supported for reasoning models",
+        })
+      }
+
+      if (baseArgs.top_p != null) {
+        baseArgs.top_p = undefined
+        warnings.push({
+          type: "unsupported-setting",
+          setting: "topP",
+          details: "topP is not supported for reasoning models",
+        })
+      }
+    } else {
+      if (openaiOptions?.reasoningEffort != null) {
+        warnings.push({
+          type: "unsupported-setting",
+          setting: "reasoningEffort",
+          details: "reasoningEffort is not supported for non-reasoning models",
+        })
+      }
+
+      if (openaiOptions?.reasoningSummary != null) {
+        warnings.push({
+          type: "unsupported-setting",
+          setting: "reasoningSummary",
+          details: "reasoningSummary is not supported for non-reasoning models",
+        })
+      }
+    }
+
+    // Validate flex processing support
+    if (openaiOptions?.serviceTier === "flex" && !modelConfig.supportsFlexProcessing) {
+      warnings.push({
+        type: "unsupported-setting",
+        setting: "serviceTier",
+        details: "flex processing is only available for o3, o4-mini, and gpt-5 models",
+      })
+      // Remove from args if not supported
+      delete (baseArgs as any).service_tier
+    }
+
+    // Validate priority processing support
+    if (openaiOptions?.serviceTier === "priority" && !modelConfig.supportsPriorityProcessing) {
+      warnings.push({
+        type: "unsupported-setting",
+        setting: "serviceTier",
+        details:
+          "priority processing is only available for supported models (gpt-4, gpt-5, gpt-5-mini, o3, o4-mini) and requires Enterprise access. gpt-5-nano is not supported",
+      })
+      // Remove from args if not supported
+      delete (baseArgs as any).service_tier
+    }
+
+    const {
+      tools: openaiTools,
+      toolChoice: openaiToolChoice,
+      toolWarnings,
+    } = prepareResponsesTools({
+      tools,
+      toolChoice,
+      strictJsonSchema,
+    })
+
+    return {
+      webSearchToolName,
+      args: {
+        ...baseArgs,
+        tools: openaiTools,
+        tool_choice: openaiToolChoice,
+      },
+      warnings: [...warnings, ...toolWarnings],
+    }
+  }
+
+  async doGenerate(
+    options: Parameters<LanguageModelV2["doGenerate"]>[0],
+  ): Promise<Awaited<ReturnType<LanguageModelV2["doGenerate"]>>> {
+    const { args: body, warnings, webSearchToolName } = await this.getArgs(options)
+    const url = this.config.url({
+      path: "/responses",
+      modelId: this.modelId,
+    })
+
+    const {
+      responseHeaders,
+      value: response,
+      rawValue: rawResponse,
+    } = await postJsonToApi({
+      url,
+      headers: combineHeaders(this.config.headers(), options.headers),
+      body,
+      failedResponseHandler: openaiFailedResponseHandler,
+      successfulResponseHandler: createJsonResponseHandler(
+        z.object({
+          id: z.string(),
+          created_at: z.number(),
+          error: z
+            .object({
+              code: z.string(),
+              message: z.string(),
+            })
+            .nullish(),
+          model: z.string(),
+          output: z.array(
+            z.discriminatedUnion("type", [
+              z.object({
+                type: z.literal("message"),
+                role: z.literal("assistant"),
+                id: z.string(),
+                content: z.array(
+                  z.object({
+                    type: z.literal("output_text"),
+                    text: z.string(),
+                    logprobs: LOGPROBS_SCHEMA.nullish(),
+                    annotations: z.array(
+                      z.discriminatedUnion("type", [
+                        z.object({
+                          type: z.literal("url_citation"),
+                          start_index: z.number(),
+                          end_index: z.number(),
+                          url: z.string(),
+                          title: z.string(),
+                        }),
+                        z.object({
+                          type: z.literal("file_citation"),
+                          file_id: z.string(),
+                          filename: z.string().nullish(),
+                          index: z.number().nullish(),
+                          start_index: z.number().nullish(),
+                          end_index: z.number().nullish(),
+                          quote: z.string().nullish(),
+                        }),
+                        z.object({
+                          type: z.literal("container_file_citation"),
+                        }),
+                      ]),
+                    ),
+                  }),
+                ),
+              }),
+              webSearchCallItem,
+              fileSearchCallItem,
+              codeInterpreterCallItem,
+              imageGenerationCallItem,
+              localShellCallItem,
+              z.object({
+                type: z.literal("function_call"),
+                call_id: z.string(),
+                name: z.string(),
+                arguments: z.string(),
+                id: z.string(),
+              }),
+              z.object({
+                type: z.literal("computer_call"),
+                id: z.string(),
+                status: z.string().optional(),
+              }),
+              z.object({
+                type: z.literal("reasoning"),
+                id: z.string(),
+                encrypted_content: z.string().nullish(),
+                summary: z.array(
+                  z.object({
+                    type: z.literal("summary_text"),
+                    text: z.string(),
+                  }),
+                ),
+              }),
+            ]),
+          ),
+          service_tier: z.string().nullish(),
+          incomplete_details: z.object({ reason: z.string() }).nullish(),
+          usage: usageSchema,
+        }),
+      ),
+      abortSignal: options.abortSignal,
+      fetch: this.config.fetch,
+    })
+
+    if (response.error) {
+      throw new APICallError({
+        message: response.error.message,
+        url,
+        requestBodyValues: body,
+        statusCode: 400,
+        responseHeaders,
+        responseBody: rawResponse as string,
+        isRetryable: false,
+      })
+    }
+
+    const content: Array<LanguageModelV2Content> = []
+    const logprobs: Array<z.infer<typeof LOGPROBS_SCHEMA>> = []
+
+    // flag that checks if there have been client-side tool calls (not executed by openai)
+    let hasFunctionCall = false
+
+    // map response content to content array
+    for (const part of response.output) {
+      switch (part.type) {
+        case "reasoning": {
+          // when there are no summary parts, we need to add an empty reasoning part:
+          if (part.summary.length === 0) {
+            part.summary.push({ type: "summary_text", text: "" })
+          }
+
+          for (const summary of part.summary) {
+            content.push({
+              type: "reasoning" as const,
+              text: summary.text,
+              providerMetadata: {
+                openai: {
+                  itemId: part.id,
+                  reasoningEncryptedContent: part.encrypted_content ?? null,
+                },
+              },
+            })
+          }
+          break
+        }
+
+        case "image_generation_call": {
+          content.push({
+            type: "tool-call",
+            toolCallId: part.id,
+            toolName: "image_generation",
+            input: "{}",
+            providerExecuted: true,
+          })
+
+          content.push({
+            type: "tool-result",
+            toolCallId: part.id,
+            toolName: "image_generation",
+            result: {
+              result: part.result,
+            } satisfies z.infer<typeof imageGenerationOutputSchema>,
+            providerExecuted: true,
+          })
+
+          break
+        }
+
+        case "local_shell_call": {
+          content.push({
+            type: "tool-call",
+            toolCallId: part.call_id,
+            toolName: "local_shell",
+            input: JSON.stringify({ action: part.action } satisfies z.infer<typeof localShellInputSchema>),
+            providerMetadata: {
+              openai: {
+                itemId: part.id,
+              },
+            },
+          })
+
+          break
+        }
+
+        case "message": {
+          for (const contentPart of part.content) {
+            if (options.providerOptions?.openai?.logprobs && contentPart.logprobs) {
+              logprobs.push(contentPart.logprobs)
+            }
+
+            content.push({
+              type: "text",
+              text: contentPart.text,
+              providerMetadata: {
+                openai: {
+                  itemId: part.id,
+                },
+              },
+            })
+
+            for (const annotation of contentPart.annotations) {
+              if (annotation.type === "url_citation") {
+                content.push({
+                  type: "source",
+                  sourceType: "url",
+                  id: this.config.generateId?.() ?? generateId(),
+                  url: annotation.url,
+                  title: annotation.title,
+                })
+              } else if (annotation.type === "file_citation") {
+                content.push({
+                  type: "source",
+                  sourceType: "document",
+                  id: this.config.generateId?.() ?? generateId(),
+                  mediaType: "text/plain",
+                  title: annotation.quote ?? annotation.filename ?? "Document",
+                  filename: annotation.filename ?? annotation.file_id,
+                })
+              }
+            }
+          }
+
+          break
+        }
+
+        case "function_call": {
+          hasFunctionCall = true
+
+          content.push({
+            type: "tool-call",
+            toolCallId: part.call_id,
+            toolName: part.name,
+            input: part.arguments,
+            providerMetadata: {
+              openai: {
+                itemId: part.id,
+              },
+            },
+          })
+          break
+        }
+
+        case "web_search_call": {
+          content.push({
+            type: "tool-call",
+            toolCallId: part.id,
+            toolName: webSearchToolName ?? "web_search",
+            input: JSON.stringify({ action: part.action }),
+            providerExecuted: true,
+          })
+
+          content.push({
+            type: "tool-result",
+            toolCallId: part.id,
+            toolName: webSearchToolName ?? "web_search",
+            result: { status: part.status },
+            providerExecuted: true,
+          })
+
+          break
+        }
+
+        case "computer_call": {
+          content.push({
+            type: "tool-call",
+            toolCallId: part.id,
+            toolName: "computer_use",
+            input: "",
+            providerExecuted: true,
+          })
+
+          content.push({
+            type: "tool-result",
+            toolCallId: part.id,
+            toolName: "computer_use",
+            result: {
+              type: "computer_use_tool_result",
+              status: part.status || "completed",
+            },
+            providerExecuted: true,
+          })
+          break
+        }
+
+        case "file_search_call": {
+          content.push({
+            type: "tool-call",
+            toolCallId: part.id,
+            toolName: "file_search",
+            input: "{}",
+            providerExecuted: true,
+          })
+
+          content.push({
+            type: "tool-result",
+            toolCallId: part.id,
+            toolName: "file_search",
+            result: {
+              queries: part.queries,
+              results:
+                part.results?.map((result) => ({
+                  attributes: result.attributes,
+                  fileId: result.file_id,
+                  filename: result.filename,
+                  score: result.score,
+                  text: result.text,
+                })) ?? null,
+            } satisfies z.infer<typeof fileSearchOutputSchema>,
+            providerExecuted: true,
+          })
+          break
+        }
+
+        case "code_interpreter_call": {
+          content.push({
+            type: "tool-call",
+            toolCallId: part.id,
+            toolName: "code_interpreter",
+            input: JSON.stringify({
+              code: part.code,
+              containerId: part.container_id,
+            } satisfies z.infer<typeof codeInterpreterInputSchema>),
+            providerExecuted: true,
+          })
+
+          content.push({
+            type: "tool-result",
+            toolCallId: part.id,
+            toolName: "code_interpreter",
+            result: {
+              outputs: part.outputs,
+            } satisfies z.infer<typeof codeInterpreterOutputSchema>,
+            providerExecuted: true,
+          })
+          break
+        }
+      }
+    }
+
+    const providerMetadata: SharedV2ProviderMetadata = {
+      openai: { responseId: response.id },
+    }
+
+    if (logprobs.length > 0) {
+      providerMetadata.openai.logprobs = logprobs
+    }
+
+    if (typeof response.service_tier === "string") {
+      providerMetadata.openai.serviceTier = response.service_tier
+    }
+
+    return {
+      content,
+      finishReason: mapOpenAIResponseFinishReason({
+        finishReason: response.incomplete_details?.reason,
+        hasFunctionCall,
+      }),
+      usage: {
+        inputTokens: response.usage.input_tokens,
+        outputTokens: response.usage.output_tokens,
+        totalTokens: response.usage.input_tokens + response.usage.output_tokens,
+        reasoningTokens: response.usage.output_tokens_details?.reasoning_tokens ?? undefined,
+        cachedInputTokens: response.usage.input_tokens_details?.cached_tokens ?? undefined,
+      },
+      request: { body },
+      response: {
+        id: response.id,
+        timestamp: new Date(response.created_at * 1000),
+        modelId: response.model,
+        headers: responseHeaders,
+        body: rawResponse,
+      },
+      providerMetadata,
+      warnings,
+    }
+  }
+
+  async doStream(
+    options: Parameters<LanguageModelV2["doStream"]>[0],
+  ): Promise<Awaited<ReturnType<LanguageModelV2["doStream"]>>> {
+    const { args: body, warnings, webSearchToolName } = await this.getArgs(options)
+
+    const { responseHeaders, value: response } = await postJsonToApi({
+      url: this.config.url({
+        path: "/responses",
+        modelId: this.modelId,
+      }),
+      headers: combineHeaders(this.config.headers(), options.headers),
+      body: {
+        ...body,
+        stream: true,
+      },
+      failedResponseHandler: openaiFailedResponseHandler,
+      successfulResponseHandler: createEventSourceResponseHandler(openaiResponsesChunkSchema),
+      abortSignal: options.abortSignal,
+      fetch: this.config.fetch,
+    })
+
+    const self = this
+
+    let finishReason: LanguageModelV2FinishReason = "unknown"
+    const usage: LanguageModelV2Usage = {
+      inputTokens: undefined,
+      outputTokens: undefined,
+      totalTokens: undefined,
+    }
+    const logprobs: Array<z.infer<typeof LOGPROBS_SCHEMA>> = []
+    let responseId: string | null = null
+    const ongoingToolCalls: Record<
+      number,
+      | {
+          toolName: string
+          toolCallId: string
+          codeInterpreter?: {
+            containerId: string
+          }
+        }
+      | undefined
+    > = {}
+
+    // flag that checks if there have been client-side tool calls (not executed by openai)
+    let hasFunctionCall = false
+
+    const activeReasoning: Record<
+      string,
+      {
+        encryptedContent?: string | null
+        summaryParts: number[]
+      }
+    > = {}
+
+    // Track a stable text part id for the current assistant message.
+    // Copilot may change item_id across text deltas; normalize to one id.
+    let currentTextId: string | null = null
+
+    let serviceTier: string | undefined
+
+    return {
+      stream: response.pipeThrough(
+        new TransformStream<ParseResult<z.infer<typeof openaiResponsesChunkSchema>>, LanguageModelV2StreamPart>({
+          start(controller) {
+            controller.enqueue({ type: "stream-start", warnings })
+          },
+
+          transform(chunk, controller) {
+            if (options.includeRawChunks) {
+              controller.enqueue({ type: "raw", rawValue: chunk.rawValue })
+            }
+
+            // handle failed chunk parsing / validation:
+            if (!chunk.success) {
+              finishReason = "error"
+              controller.enqueue({ type: "error", error: chunk.error })
+              return
+            }
+
+            const value = chunk.value
+
+            if (isResponseOutputItemAddedChunk(value)) {
+              if (value.item.type === "function_call") {
+                ongoingToolCalls[value.output_index] = {
+                  toolName: value.item.name,
+                  toolCallId: value.item.call_id,
+                }
+
+                controller.enqueue({
+                  type: "tool-input-start",
+                  id: value.item.call_id,
+                  toolName: value.item.name,
+                })
+              } else if (value.item.type === "web_search_call") {
+                ongoingToolCalls[value.output_index] = {
+                  toolName: webSearchToolName ?? "web_search",
+                  toolCallId: value.item.id,
+                }
+
+                controller.enqueue({
+                  type: "tool-input-start",
+                  id: value.item.id,
+                  toolName: webSearchToolName ?? "web_search",
+                })
+              } else if (value.item.type === "computer_call") {
+                ongoingToolCalls[value.output_index] = {
+                  toolName: "computer_use",
+                  toolCallId: value.item.id,
+                }
+
+                controller.enqueue({
+                  type: "tool-input-start",
+                  id: value.item.id,
+                  toolName: "computer_use",
+                })
+              } else if (value.item.type === "code_interpreter_call") {
+                ongoingToolCalls[value.output_index] = {
+                  toolName: "code_interpreter",
+                  toolCallId: value.item.id,
+                  codeInterpreter: {
+                    containerId: value.item.container_id,
+                  },
+                }
+
+                controller.enqueue({
+                  type: "tool-input-start",
+                  id: value.item.id,
+                  toolName: "code_interpreter",
+                })
+
+                controller.enqueue({
+                  type: "tool-input-delta",
+                  id: value.item.id,
+                  delta: `{"containerId":"${value.item.container_id}","code":"`,
+                })
+              } else if (value.item.type === "file_search_call") {
+                controller.enqueue({
+                  type: "tool-call",
+                  toolCallId: value.item.id,
+                  toolName: "file_search",
+                  input: "{}",
+                  providerExecuted: true,
+                })
+              } else if (value.item.type === "image_generation_call") {
+                controller.enqueue({
+                  type: "tool-call",
+                  toolCallId: value.item.id,
+                  toolName: "image_generation",
+                  input: "{}",
+                  providerExecuted: true,
+                })
+              } else if (value.item.type === "message") {
+                // Start a stable text part for this assistant message
+                currentTextId = value.item.id
+                controller.enqueue({
+                  type: "text-start",
+                  id: value.item.id,
+                  providerMetadata: {
+                    openai: {
+                      itemId: value.item.id,
+                    },
+                  },
+                })
+              } else if (isResponseOutputItemAddedReasoningChunk(value)) {
+                activeReasoning[value.item.id] = {
+                  encryptedContent: value.item.encrypted_content,
+                  summaryParts: [0],
+                }
+
+                controller.enqueue({
+                  type: "reasoning-start",
+                  id: `${value.item.id}:0`,
+                  providerMetadata: {
+                    openai: {
+                      itemId: value.item.id,
+                      reasoningEncryptedContent: value.item.encrypted_content ?? null,
+                    },
+                  },
+                })
+              }
+            } else if (isResponseOutputItemDoneChunk(value)) {
+              if (value.item.type === "function_call") {
+                ongoingToolCalls[value.output_index] = undefined
+                hasFunctionCall = true
+
+                controller.enqueue({
+                  type: "tool-input-end",
+                  id: value.item.call_id,
+                })
+
+                controller.enqueue({
+                  type: "tool-call",
+                  toolCallId: value.item.call_id,
+                  toolName: value.item.name,
+                  input: value.item.arguments,
+                  providerMetadata: {
+                    openai: {
+                      itemId: value.item.id,
+                    },
+                  },
+                })
+              } else if (value.item.type === "web_search_call") {
+                ongoingToolCalls[value.output_index] = undefined
+
+                controller.enqueue({
+                  type: "tool-input-end",
+                  id: value.item.id,
+                })
+
+                controller.enqueue({
+                  type: "tool-call",
+                  toolCallId: value.item.id,
+                  toolName: "web_search",
+                  input: JSON.stringify({ action: value.item.action }),
+                  providerExecuted: true,
+                })
+
+                controller.enqueue({
+                  type: "tool-result",
+                  toolCallId: value.item.id,
+                  toolName: "web_search",
+                  result: { status: value.item.status },
+                  providerExecuted: true,
+                })
+              } else if (value.item.type === "computer_call") {
+                ongoingToolCalls[value.output_index] = undefined
+
+                controller.enqueue({
+                  type: "tool-input-end",
+                  id: value.item.id,
+                })
+
+                controller.enqueue({
+                  type: "tool-call",
+                  toolCallId: value.item.id,
+                  toolName: "computer_use",
+                  input: "",
+                  providerExecuted: true,
+                })
+
+                controller.enqueue({
+                  type: "tool-result",
+                  toolCallId: value.item.id,
+                  toolName: "computer_use",
+                  result: {
+                    type: "computer_use_tool_result",
+                    status: value.item.status || "completed",
+                  },
+                  providerExecuted: true,
+                })
+              } else if (value.item.type === "file_search_call") {
+                ongoingToolCalls[value.output_index] = undefined
+
+                controller.enqueue({
+                  type: "tool-result",
+                  toolCallId: value.item.id,
+                  toolName: "file_search",
+                  result: {
+                    queries: value.item.queries,
+                    results:
+                      value.item.results?.map((result) => ({
+                        attributes: result.attributes,
+                        fileId: result.file_id,
+                        filename: result.filename,
+                        score: result.score,
+                        text: result.text,
+                      })) ?? null,
+                  } satisfies z.infer<typeof fileSearchOutputSchema>,
+                  providerExecuted: true,
+                })
+              } else if (value.item.type === "code_interpreter_call") {
+                ongoingToolCalls[value.output_index] = undefined
+
+                controller.enqueue({
+                  type: "tool-result",
+                  toolCallId: value.item.id,
+                  toolName: "code_interpreter",
+                  result: {
+                    outputs: value.item.outputs,
+                  } satisfies z.infer<typeof codeInterpreterOutputSchema>,
+                  providerExecuted: true,
+                })
+              } else if (value.item.type === "image_generation_call") {
+                controller.enqueue({
+                  type: "tool-result",
+                  toolCallId: value.item.id,
+                  toolName: "image_generation",
+                  result: {
+                    result: value.item.result,
+                  } satisfies z.infer<typeof imageGenerationOutputSchema>,
+                  providerExecuted: true,
+                })
+              } else if (value.item.type === "local_shell_call") {
+                ongoingToolCalls[value.output_index] = undefined
+
+                controller.enqueue({
+                  type: "tool-call",
+                  toolCallId: value.item.call_id,
+                  toolName: "local_shell",
+                  input: JSON.stringify({
+                    action: {
+                      type: "exec",
+                      command: value.item.action.command,
+                      timeoutMs: value.item.action.timeout_ms,
+                      user: value.item.action.user,
+                      workingDirectory: value.item.action.working_directory,
+                      env: value.item.action.env,
+                    },
+                  } satisfies z.infer<typeof localShellInputSchema>),
+                  providerMetadata: {
+                    openai: { itemId: value.item.id },
+                  },
+                })
+              } else if (value.item.type === "message") {
+                if (currentTextId) {
+                  controller.enqueue({
+                    type: "text-end",
+                    id: currentTextId,
+                  })
+                  currentTextId = null
+                }
+              } else if (isResponseOutputItemDoneReasoningChunk(value)) {
+                const activeReasoningPart = activeReasoning[value.item.id]
+                if (activeReasoningPart) {
+                  for (const summaryIndex of activeReasoningPart.summaryParts) {
+                    controller.enqueue({
+                      type: "reasoning-end",
+                      id: `${value.item.id}:${summaryIndex}`,
+                      providerMetadata: {
+                        openai: {
+                          itemId: value.item.id,
+                          reasoningEncryptedContent: value.item.encrypted_content ?? null,
+                        },
+                      },
+                    })
+                  }
+                }
+                delete activeReasoning[value.item.id]
+              }
+            } else if (isResponseFunctionCallArgumentsDeltaChunk(value)) {
+              const toolCall = ongoingToolCalls[value.output_index]
+
+              if (toolCall != null) {
+                controller.enqueue({
+                  type: "tool-input-delta",
+                  id: toolCall.toolCallId,
+                  delta: value.delta,
+                })
+              }
+            } else if (isResponseImageGenerationCallPartialImageChunk(value)) {
+              controller.enqueue({
+                type: "tool-result",
+                toolCallId: value.item_id,
+                toolName: "image_generation",
+                result: {
+                  result: value.partial_image_b64,
+                } satisfies z.infer<typeof imageGenerationOutputSchema>,
+                providerExecuted: true,
+              })
+            } else if (isResponseCodeInterpreterCallCodeDeltaChunk(value)) {
+              const toolCall = ongoingToolCalls[value.output_index]
+
+              if (toolCall != null) {
+                controller.enqueue({
+                  type: "tool-input-delta",
+                  id: toolCall.toolCallId,
+                  // The delta is code, which is embedding in a JSON string.
+                  // To escape it, we use JSON.stringify and slice to remove the outer quotes.
+                  delta: JSON.stringify(value.delta).slice(1, -1),
+                })
+              }
+            } else if (isResponseCodeInterpreterCallCodeDoneChunk(value)) {
+              const toolCall = ongoingToolCalls[value.output_index]
+
+              if (toolCall != null) {
+                controller.enqueue({
+                  type: "tool-input-delta",
+                  id: toolCall.toolCallId,
+                  delta: '"}',
+                })
+
+                controller.enqueue({
+                  type: "tool-input-end",
+                  id: toolCall.toolCallId,
+                })
+
+                // immediately send the tool call after the input end:
+                controller.enqueue({
+                  type: "tool-call",
+                  toolCallId: toolCall.toolCallId,
+                  toolName: "code_interpreter",
+                  input: JSON.stringify({
+                    code: value.code,
+                    containerId: toolCall.codeInterpreter!.containerId,
+                  } satisfies z.infer<typeof codeInterpreterInputSchema>),
+                  providerExecuted: true,
+                })
+              }
+            } else if (isResponseCreatedChunk(value)) {
+              responseId = value.response.id
+              controller.enqueue({
+                type: "response-metadata",
+                id: value.response.id,
+                timestamp: new Date(value.response.created_at * 1000),
+                modelId: value.response.model,
+              })
+            } else if (isTextDeltaChunk(value)) {
+              // Ensure a text-start exists, and normalize deltas to a stable id
+              if (!currentTextId) {
+                currentTextId = value.item_id
+                controller.enqueue({
+                  type: "text-start",
+                  id: currentTextId,
+                  providerMetadata: {
+                    openai: { itemId: value.item_id },
+                  },
+                })
+              }
+
+              controller.enqueue({
+                type: "text-delta",
+                id: currentTextId,
+                delta: value.delta,
+              })
+
+              if (options.providerOptions?.openai?.logprobs && value.logprobs) {
+                logprobs.push(value.logprobs)
+              }
+            } else if (isResponseReasoningSummaryPartAddedChunk(value)) {
+              // the first reasoning start is pushed in isResponseOutputItemAddedReasoningChunk.
+              if (value.summary_index > 0) {
+                activeReasoning[value.item_id]?.summaryParts.push(value.summary_index)
+
+                controller.enqueue({
+                  type: "reasoning-start",
+                  id: `${value.item_id}:${value.summary_index}`,
+                  providerMetadata: {
+                    openai: {
+                      itemId: value.item_id,
+                      reasoningEncryptedContent: activeReasoning[value.item_id]?.encryptedContent ?? null,
+                    },
+                  },
+                })
+              }
+            } else if (isResponseReasoningSummaryTextDeltaChunk(value)) {
+              controller.enqueue({
+                type: "reasoning-delta",
+                id: `${value.item_id}:${value.summary_index}`,
+                delta: value.delta,
+                providerMetadata: {
+                  openai: {
+                    itemId: value.item_id,
+                  },
+                },
+              })
+            } else if (isResponseFinishedChunk(value)) {
+              finishReason = mapOpenAIResponseFinishReason({
+                finishReason: value.response.incomplete_details?.reason,
+                hasFunctionCall,
+              })
+              usage.inputTokens = value.response.usage.input_tokens
+              usage.outputTokens = value.response.usage.output_tokens
+              usage.totalTokens = value.response.usage.input_tokens + value.response.usage.output_tokens
+              usage.reasoningTokens = value.response.usage.output_tokens_details?.reasoning_tokens ?? undefined
+              usage.cachedInputTokens = value.response.usage.input_tokens_details?.cached_tokens ?? undefined
+              if (typeof value.response.service_tier === "string") {
+                serviceTier = value.response.service_tier
+              }
+            } else if (isResponseAnnotationAddedChunk(value)) {
+              if (value.annotation.type === "url_citation") {
+                controller.enqueue({
+                  type: "source",
+                  sourceType: "url",
+                  id: self.config.generateId?.() ?? generateId(),
+                  url: value.annotation.url,
+                  title: value.annotation.title,
+                })
+              } else if (value.annotation.type === "file_citation") {
+                controller.enqueue({
+                  type: "source",
+                  sourceType: "document",
+                  id: self.config.generateId?.() ?? generateId(),
+                  mediaType: "text/plain",
+                  title: value.annotation.quote ?? value.annotation.filename ?? "Document",
+                  filename: value.annotation.filename ?? value.annotation.file_id,
+                })
+              }
+            } else if (isErrorChunk(value)) {
+              controller.enqueue({ type: "error", error: value })
+            }
+          },
+
+          flush(controller) {
+            // Close any dangling text part
+            if (currentTextId) {
+              controller.enqueue({ type: "text-end", id: currentTextId })
+              currentTextId = null
+            }
+
+            const providerMetadata: SharedV2ProviderMetadata = {
+              openai: {
+                responseId,
+              },
+            }
+
+            if (logprobs.length > 0) {
+              providerMetadata.openai.logprobs = logprobs
+            }
+
+            if (serviceTier !== undefined) {
+              providerMetadata.openai.serviceTier = serviceTier
+            }
+
+            controller.enqueue({
+              type: "finish",
+              finishReason,
+              usage,
+              providerMetadata,
+            })
+          },
+        }),
+      ),
+      request: { body },
+      response: { headers: responseHeaders },
+    }
+  }
+}
+
+const usageSchema = z.object({
+  input_tokens: z.number(),
+  input_tokens_details: z.object({ cached_tokens: z.number().nullish() }).nullish(),
+  output_tokens: z.number(),
+  output_tokens_details: z.object({ reasoning_tokens: z.number().nullish() }).nullish(),
+})
+
+const textDeltaChunkSchema = z.object({
+  type: z.literal("response.output_text.delta"),
+  item_id: z.string(),
+  delta: z.string(),
+  logprobs: LOGPROBS_SCHEMA.nullish(),
+})
+
+const errorChunkSchema = z.object({
+  type: z.literal("error"),
+  code: z.string(),
+  message: z.string(),
+  param: z.string().nullish(),
+  sequence_number: z.number(),
+})
+
+const responseFinishedChunkSchema = z.object({
+  type: z.enum(["response.completed", "response.incomplete"]),
+  response: z.object({
+    incomplete_details: z.object({ reason: z.string() }).nullish(),
+    usage: usageSchema,
+    service_tier: z.string().nullish(),
+  }),
+})
+
+const responseCreatedChunkSchema = z.object({
+  type: z.literal("response.created"),
+  response: z.object({
+    id: z.string(),
+    created_at: z.number(),
+    model: z.string(),
+    service_tier: z.string().nullish(),
+  }),
+})
+
+const responseOutputItemAddedSchema = z.object({
+  type: z.literal("response.output_item.added"),
+  output_index: z.number(),
+  item: z.discriminatedUnion("type", [
+    z.object({
+      type: z.literal("message"),
+      id: z.string(),
+    }),
+    z.object({
+      type: z.literal("reasoning"),
+      id: z.string(),
+      encrypted_content: z.string().nullish(),
+    }),
+    z.object({
+      type: z.literal("function_call"),
+      id: z.string(),
+      call_id: z.string(),
+      name: z.string(),
+      arguments: z.string(),
+    }),
+    z.object({
+      type: z.literal("web_search_call"),
+      id: z.string(),
+      status: z.string(),
+      action: z
+        .object({
+          type: z.literal("search"),
+          query: z.string().optional(),
+        })
+        .nullish(),
+    }),
+    z.object({
+      type: z.literal("computer_call"),
+      id: z.string(),
+      status: z.string(),
+    }),
+    z.object({
+      type: z.literal("file_search_call"),
+      id: z.string(),
+    }),
+    z.object({
+      type: z.literal("image_generation_call"),
+      id: z.string(),
+    }),
+    z.object({
+      type: z.literal("code_interpreter_call"),
+      id: z.string(),
+      container_id: z.string(),
+      code: z.string().nullable(),
+      outputs: z
+        .array(
+          z.discriminatedUnion("type", [
+            z.object({ type: z.literal("logs"), logs: z.string() }),
+            z.object({ type: z.literal("image"), url: z.string() }),
+          ]),
+        )
+        .nullable(),
+      status: z.string(),
+    }),
+  ]),
+})
+
+const responseOutputItemDoneSchema = z.object({
+  type: z.literal("response.output_item.done"),
+  output_index: z.number(),
+  item: z.discriminatedUnion("type", [
+    z.object({
+      type: z.literal("message"),
+      id: z.string(),
+    }),
+    z.object({
+      type: z.literal("reasoning"),
+      id: z.string(),
+      encrypted_content: z.string().nullish(),
+    }),
+    z.object({
+      type: z.literal("function_call"),
+      id: z.string(),
+      call_id: z.string(),
+      name: z.string(),
+      arguments: z.string(),
+      status: z.literal("completed"),
+    }),
+    codeInterpreterCallItem,
+    imageGenerationCallItem,
+    webSearchCallItem,
+    fileSearchCallItem,
+    localShellCallItem,
+    z.object({
+      type: z.literal("computer_call"),
+      id: z.string(),
+      status: z.literal("completed"),
+    }),
+  ]),
+})
+
+const responseFunctionCallArgumentsDeltaSchema = z.object({
+  type: z.literal("response.function_call_arguments.delta"),
+  item_id: z.string(),
+  output_index: z.number(),
+  delta: z.string(),
+})
+
+const responseImageGenerationCallPartialImageSchema = z.object({
+  type: z.literal("response.image_generation_call.partial_image"),
+  item_id: z.string(),
+  output_index: z.number(),
+  partial_image_b64: z.string(),
+})
+
+const responseCodeInterpreterCallCodeDeltaSchema = z.object({
+  type: z.literal("response.code_interpreter_call_code.delta"),
+  item_id: z.string(),
+  output_index: z.number(),
+  delta: z.string(),
+})
+
+const responseCodeInterpreterCallCodeDoneSchema = z.object({
+  type: z.literal("response.code_interpreter_call_code.done"),
+  item_id: z.string(),
+  output_index: z.number(),
+  code: z.string(),
+})
+
+const responseAnnotationAddedSchema = z.object({
+  type: z.literal("response.output_text.annotation.added"),
+  annotation: z.discriminatedUnion("type", [
+    z.object({
+      type: z.literal("url_citation"),
+      url: z.string(),
+      title: z.string(),
+    }),
+    z.object({
+      type: z.literal("file_citation"),
+      file_id: z.string(),
+      filename: z.string().nullish(),
+      index: z.number().nullish(),
+      start_index: z.number().nullish(),
+      end_index: z.number().nullish(),
+      quote: z.string().nullish(),
+    }),
+  ]),
+})
+
+const responseReasoningSummaryPartAddedSchema = z.object({
+  type: z.literal("response.reasoning_summary_part.added"),
+  item_id: z.string(),
+  summary_index: z.number(),
+})
+
+const responseReasoningSummaryTextDeltaSchema = z.object({
+  type: z.literal("response.reasoning_summary_text.delta"),
+  item_id: z.string(),
+  summary_index: z.number(),
+  delta: z.string(),
+})
+
+const openaiResponsesChunkSchema = z.union([
+  textDeltaChunkSchema,
+  responseFinishedChunkSchema,
+  responseCreatedChunkSchema,
+  responseOutputItemAddedSchema,
+  responseOutputItemDoneSchema,
+  responseFunctionCallArgumentsDeltaSchema,
+  responseImageGenerationCallPartialImageSchema,
+  responseCodeInterpreterCallCodeDeltaSchema,
+  responseCodeInterpreterCallCodeDoneSchema,
+  responseAnnotationAddedSchema,
+  responseReasoningSummaryPartAddedSchema,
+  responseReasoningSummaryTextDeltaSchema,
+  errorChunkSchema,
+  z.object({ type: z.string() }).loose(), // fallback for unknown chunks
+])
+
+type ExtractByType<T, K extends T extends { type: infer U } ? U : never> = T extends { type: K } ? T : never
+
+function isTextDeltaChunk(
+  chunk: z.infer<typeof openaiResponsesChunkSchema>,
+): chunk is z.infer<typeof textDeltaChunkSchema> {
+  return chunk.type === "response.output_text.delta"
+}
+
+function isResponseOutputItemDoneChunk(
+  chunk: z.infer<typeof openaiResponsesChunkSchema>,
+): chunk is z.infer<typeof responseOutputItemDoneSchema> {
+  return chunk.type === "response.output_item.done"
+}
+
+function isResponseOutputItemDoneReasoningChunk(chunk: z.infer<typeof openaiResponsesChunkSchema>): chunk is z.infer<
+  typeof responseOutputItemDoneSchema
+> & {
+  item: ExtractByType<z.infer<typeof responseOutputItemDoneSchema>["item"], "reasoning">
+} {
+  return isResponseOutputItemDoneChunk(chunk) && chunk.item.type === "reasoning"
+}
+
+function isResponseFinishedChunk(
+  chunk: z.infer<typeof openaiResponsesChunkSchema>,
+): chunk is z.infer<typeof responseFinishedChunkSchema> {
+  return chunk.type === "response.completed" || chunk.type === "response.incomplete"
+}
+
+function isResponseCreatedChunk(
+  chunk: z.infer<typeof openaiResponsesChunkSchema>,
+): chunk is z.infer<typeof responseCreatedChunkSchema> {
+  return chunk.type === "response.created"
+}
+
+function isResponseFunctionCallArgumentsDeltaChunk(
+  chunk: z.infer<typeof openaiResponsesChunkSchema>,
+): chunk is z.infer<typeof responseFunctionCallArgumentsDeltaSchema> {
+  return chunk.type === "response.function_call_arguments.delta"
+}
+function isResponseImageGenerationCallPartialImageChunk(
+  chunk: z.infer<typeof openaiResponsesChunkSchema>,
+): chunk is z.infer<typeof responseImageGenerationCallPartialImageSchema> {
+  return chunk.type === "response.image_generation_call.partial_image"
+}
+
+function isResponseCodeInterpreterCallCodeDeltaChunk(
+  chunk: z.infer<typeof openaiResponsesChunkSchema>,
+): chunk is z.infer<typeof responseCodeInterpreterCallCodeDeltaSchema> {
+  return chunk.type === "response.code_interpreter_call_code.delta"
+}
+
+function isResponseCodeInterpreterCallCodeDoneChunk(
+  chunk: z.infer<typeof openaiResponsesChunkSchema>,
+): chunk is z.infer<typeof responseCodeInterpreterCallCodeDoneSchema> {
+  return chunk.type === "response.code_interpreter_call_code.done"
+}
+
+function isResponseOutputItemAddedChunk(
+  chunk: z.infer<typeof openaiResponsesChunkSchema>,
+): chunk is z.infer<typeof responseOutputItemAddedSchema> {
+  return chunk.type === "response.output_item.added"
+}
+
+function isResponseOutputItemAddedReasoningChunk(chunk: z.infer<typeof openaiResponsesChunkSchema>): chunk is z.infer<
+  typeof responseOutputItemAddedSchema
+> & {
+  item: ExtractByType<z.infer<typeof responseOutputItemAddedSchema>["item"], "reasoning">
+} {
+  return isResponseOutputItemAddedChunk(chunk) && chunk.item.type === "reasoning"
+}
+
+function isResponseAnnotationAddedChunk(
+  chunk: z.infer<typeof openaiResponsesChunkSchema>,
+): chunk is z.infer<typeof responseAnnotationAddedSchema> {
+  return chunk.type === "response.output_text.annotation.added"
+}
+
+function isResponseReasoningSummaryPartAddedChunk(
+  chunk: z.infer<typeof openaiResponsesChunkSchema>,
+): chunk is z.infer<typeof responseReasoningSummaryPartAddedSchema> {
+  return chunk.type === "response.reasoning_summary_part.added"
+}
+
+function isResponseReasoningSummaryTextDeltaChunk(
+  chunk: z.infer<typeof openaiResponsesChunkSchema>,
+): chunk is z.infer<typeof responseReasoningSummaryTextDeltaSchema> {
+  return chunk.type === "response.reasoning_summary_text.delta"
+}
+
+function isErrorChunk(chunk: z.infer<typeof openaiResponsesChunkSchema>): chunk is z.infer<typeof errorChunkSchema> {
+  return chunk.type === "error"
+}
+
+type ResponsesModelConfig = {
+  isReasoningModel: boolean
+  systemMessageMode: "remove" | "system" | "developer"
+  requiredAutoTruncation: boolean
+  supportsFlexProcessing: boolean
+  supportsPriorityProcessing: boolean
+}
+
+function getResponsesModelConfig(modelId: string): ResponsesModelConfig {
+  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")
+  const defaults = {
+    requiredAutoTruncation: false,
+    systemMessageMode: "system" as const,
+    supportsFlexProcessing,
+    supportsPriorityProcessing,
+  }
+
+  // gpt-5-chat models are non-reasoning
+  if (modelId.startsWith("gpt-5-chat")) {
+    return {
+      ...defaults,
+      isReasoningModel: false,
+    }
+  }
+
+  // o series reasoning models:
+  if (
+    modelId.startsWith("o") ||
+    modelId.startsWith("gpt-5") ||
+    modelId.startsWith("codex-") ||
+    modelId.startsWith("computer-use")
+  ) {
+    if (modelId.startsWith("o1-mini") || modelId.startsWith("o1-preview")) {
+      return {
+        ...defaults,
+        isReasoningModel: true,
+        systemMessageMode: "remove",
+      }
+    }
+
+    return {
+      ...defaults,
+      isReasoningModel: true,
+      systemMessageMode: "developer",
+    }
+  }
+
+  // gpt models:
+  return {
+    ...defaults,
+    isReasoningModel: false,
+  }
+}
+
+// TODO AI SDK 6: use optional here instead of nullish
+const openaiResponsesProviderOptionsSchema = z.object({
+  include: z
+    .array(z.enum(["reasoning.encrypted_content", "file_search_call.results", "message.output_text.logprobs"]))
+    .nullish(),
+  instructions: z.string().nullish(),
+
+  /**
+   * Return the log probabilities of the tokens.
+   *
+   * Setting to true will return the log probabilities of the tokens that
+   * were generated.
+   *
+   * Setting to a number will return the log probabilities of the top n
+   * tokens that were generated.
+   *
+   * @see https://platform.openai.com/docs/api-reference/responses/create
+   * @see https://cookbook.openai.com/examples/using_logprobs
+   */
+  logprobs: z.union([z.boolean(), z.number().min(1).max(TOP_LOGPROBS_MAX)]).optional(),
+
+  /**
+   * The maximum number of total calls to built-in tools that can be processed in a response.
+   * This maximum number applies across all built-in tool calls, not per individual tool.
+   * Any further attempts to call a tool by the model will be ignored.
+   */
+  maxToolCalls: z.number().nullish(),
+
+  metadata: z.any().nullish(),
+  parallelToolCalls: z.boolean().nullish(),
+  previousResponseId: z.string().nullish(),
+  promptCacheKey: z.string().nullish(),
+  reasoningEffort: z.string().nullish(),
+  reasoningSummary: z.string().nullish(),
+  safetyIdentifier: z.string().nullish(),
+  serviceTier: z.enum(["auto", "flex", "priority"]).nullish(),
+  store: z.boolean().nullish(),
+  strictJsonSchema: z.boolean().nullish(),
+  textVerbosity: z.enum(["low", "medium", "high"]).nullish(),
+  user: z.string().nullish(),
+})
+
+export type OpenAIResponsesProviderOptions = z.infer<typeof openaiResponsesProviderOptionsSchema>