@opencode/core 0.0.0-beta-19275

package/dist/chunks/worktree-n679sgpe.js

@@ -0,0 +1,1419 @@
+import {
+  openaiFailedResponseHandler2
+} from "./worktree-550bvhaj.js";
+import {
+  convertToOpenAIResponsesInput2
+} from "./worktree-j5zkgpj8.js";
+import {
+  mapOpenAIResponseFinishReason2
+} from "./worktree-3asan66x.js";
+import {
+  prepareResponsesTools2
+} from "./worktree-b29mbqx6.js";
+
+// src/github-copilot/responses/openai-responses-language-model.ts
+import {
+  APICallError
+} from "@ai-sdk/provider";
+import {
+  combineHeaders,
+  createEventSourceResponseHandler,
+  createJsonResponseHandler,
+  generateId,
+  parseProviderOptions,
+  postJsonToApi
+} from "@ai-sdk/provider-utils";
+import { z } from "zod/v4";
+var 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()
+});
+var 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()
+});
+var 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()
+});
+var imageGenerationCallItem = z.object({
+  type: z.literal("image_generation_call"),
+  id: z.string(),
+  result: z.string()
+});
+var TOP_LOGPROBS_MAX = 20;
+var LOGPROBS_SCHEMA = z.array(z.object({
+  token: z.string(),
+  logprob: z.number(),
+  top_logprobs: z.array(z.object({
+    token: z.string(),
+    logprob: z.number()
+  }))
+}));
+
+class OpenAIResponsesLanguageModel2 {
+  specificationVersion = "v3";
+  modelId;
+  config;
+  constructor(modelId, config) {
+    this.modelId = modelId;
+    this.config = config;
+  }
+  supportedUrls = {
+    "image/*": [/^https?:\/\/.*$/],
+    "application/pdf": [/^https?:\/\/.*$/]
+  };
+  get provider() {
+    return this.config.provider;
+  }
+  async getArgs({
+    maxOutputTokens,
+    temperature,
+    stopSequences,
+    topP,
+    topK,
+    presencePenalty,
+    frequencyPenalty,
+    seed,
+    prompt,
+    providerOptions,
+    tools,
+    toolChoice,
+    responseFormat
+  }) {
+    const warnings = [];
+    const modelConfig = getResponsesModelConfig(this.modelId);
+    if (topK != null) {
+      warnings.push({ type: "unsupported", feature: "topK" });
+    }
+    if (seed != null) {
+      warnings.push({ type: "unsupported", feature: "seed" });
+    }
+    if (presencePenalty != null) {
+      warnings.push({
+        type: "unsupported",
+        feature: "presencePenalty"
+      });
+    }
+    if (frequencyPenalty != null) {
+      warnings.push({
+        type: "unsupported",
+        feature: "frequencyPenalty"
+      });
+    }
+    if (stopSequences != null) {
+      warnings.push({ type: "unsupported", feature: "stopSequences" });
+    }
+    const openaiOptions = await parseProviderOptions({
+      provider: "copilot",
+      providerOptions,
+      schema: openaiResponsesProviderOptionsSchema
+    });
+    const store = openaiOptions?.store ?? false;
+    const { input, warnings: inputWarnings } = await convertToOpenAIResponsesInput2({
+      prompt,
+      systemMessageMode: modelConfig.systemMessageMode,
+      fileIdPrefixes: this.config.fileIdPrefixes,
+      store
+    });
+    warnings.push(...inputWarnings);
+    const strictJsonSchema = openaiOptions?.strictJsonSchema ?? false;
+    let include = openaiOptions?.include;
+    function addInclude(key) {
+      if (include?.includes(key))
+        return;
+      include = include != null ? [...include, key] : [key];
+    }
+    addInclude("reasoning.encrypted_content");
+    function hasOpenAITool(id) {
+      return tools?.find((tool) => tool.type === "provider" && tool.id === id) != null;
+    }
+    const topLogprobs = typeof openaiOptions?.logprobs === "number" ? openaiOptions?.logprobs : openaiOptions?.logprobs === true ? TOP_LOGPROBS_MAX : undefined;
+    if (topLogprobs) {
+      addInclude("message.output_text.logprobs");
+    }
+    const {
+      tools: openaiTools,
+      toolChoice: openaiToolChoice,
+      hostedTools,
+      selectedHostedTool,
+      toolWarnings
+    } = prepareResponsesTools2({
+      tools,
+      toolChoice,
+      strictJsonSchema
+    });
+    const getHostedToolName = (responseType) => {
+      if (selectedHostedTool?.responseType === responseType)
+        return selectedHostedTool.name;
+      return hostedTools.find((tool) => tool.responseType === responseType)?.name ?? responseType;
+    };
+    if (hostedTools.some((tool) => tool.responseType === "web_search")) {
+      addInclude("web_search_call.action.sources");
+    }
+    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
+          }
+        }
+      },
+      max_tool_calls: openaiOptions?.maxToolCalls,
+      metadata: openaiOptions?.metadata,
+      parallel_tool_calls: openaiOptions?.parallelToolCalls,
+      previous_response_id: openaiOptions?.previousResponseId,
+      store,
+      user: openaiOptions?.user,
+      instructions: openaiOptions?.instructions,
+      service_tier: openaiOptions?.serviceTier,
+      include,
+      prompt_cache_key: openaiOptions?.promptCacheKey,
+      safety_identifier: openaiOptions?.safetyIdentifier,
+      top_logprobs: topLogprobs,
+      ...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) {
+      if (baseArgs.temperature != null) {
+        baseArgs.temperature = undefined;
+        warnings.push({
+          type: "unsupported",
+          feature: "temperature",
+          details: "temperature is not supported for reasoning models"
+        });
+      }
+      if (baseArgs.top_p != null) {
+        baseArgs.top_p = undefined;
+        warnings.push({
+          type: "unsupported",
+          feature: "topP",
+          details: "topP is not supported for reasoning models"
+        });
+      }
+    } else {
+      if (openaiOptions?.reasoningEffort != null) {
+        warnings.push({
+          type: "unsupported",
+          feature: "reasoningEffort",
+          details: "reasoningEffort is not supported for non-reasoning models"
+        });
+      }
+      if (openaiOptions?.reasoningSummary != null) {
+        warnings.push({
+          type: "unsupported",
+          feature: "reasoningSummary",
+          details: "reasoningSummary is not supported for non-reasoning models"
+        });
+      }
+    }
+    if (openaiOptions?.serviceTier === "flex" && !modelConfig.supportsFlexProcessing) {
+      warnings.push({
+        type: "unsupported",
+        feature: "serviceTier",
+        details: "flex processing is only available for o3, o4-mini, and gpt-5 models"
+      });
+      baseArgs.service_tier = undefined;
+    }
+    if (openaiOptions?.serviceTier === "priority" && !modelConfig.supportsPriorityProcessing) {
+      warnings.push({
+        type: "unsupported",
+        feature: "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"
+      });
+      baseArgs.service_tier = undefined;
+    }
+    return {
+      getHostedToolName,
+      args: {
+        ...baseArgs,
+        tools: openaiTools,
+        tool_choice: openaiToolChoice
+      },
+      warnings: [...warnings, ...toolWarnings]
+    };
+  }
+  async doGenerate(options) {
+    const { args: body, warnings, getHostedToolName } = 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: openaiFailedResponseHandler2,
+      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,
+          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,
+        isRetryable: false
+      });
+    }
+    const content = [];
+    const logprobs = [];
+    let hasFunctionCall = false;
+    for (const part of response.output) {
+      switch (part.type) {
+        case "reasoning": {
+          if (part.summary.length === 0) {
+            part.summary.push({ type: "summary_text", text: "" });
+          }
+          for (const summary of part.summary) {
+            content.push({
+              type: "reasoning",
+              text: summary.text,
+              providerMetadata: {
+                copilot: {
+                  itemId: part.id,
+                  reasoningEncryptedContent: part.encrypted_content ?? null
+                }
+              }
+            });
+          }
+          break;
+        }
+        case "image_generation_call": {
+          content.push({
+            type: "tool-call",
+            toolCallId: part.id,
+            toolName: getHostedToolName("image_generation"),
+            input: "{}",
+            providerExecuted: true
+          });
+          content.push({
+            type: "tool-result",
+            toolCallId: part.id,
+            toolName: getHostedToolName("image_generation"),
+            result: {
+              result: part.result
+            }
+          });
+          break;
+        }
+        case "message": {
+          for (const contentPart of part.content) {
+            if (options.providerOptions?.copilot?.logprobs && contentPart.logprobs) {
+              logprobs.push(contentPart.logprobs);
+            }
+            content.push({
+              type: "text",
+              text: contentPart.text,
+              providerMetadata: {
+                copilot: {
+                  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: {
+              copilot: {
+                itemId: part.id
+              }
+            }
+          });
+          break;
+        }
+        case "web_search_call": {
+          content.push({
+            type: "tool-call",
+            toolCallId: part.id,
+            toolName: getHostedToolName("web_search"),
+            input: JSON.stringify({ action: part.action }),
+            providerExecuted: true
+          });
+          content.push({
+            type: "tool-result",
+            toolCallId: part.id,
+            toolName: getHostedToolName("web_search"),
+            result: { status: part.status }
+          });
+          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"
+            }
+          });
+          break;
+        }
+        case "file_search_call": {
+          content.push({
+            type: "tool-call",
+            toolCallId: part.id,
+            toolName: getHostedToolName("file_search"),
+            input: "{}",
+            providerExecuted: true
+          });
+          content.push({
+            type: "tool-result",
+            toolCallId: part.id,
+            toolName: getHostedToolName("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
+            }
+          });
+          break;
+        }
+        case "code_interpreter_call": {
+          content.push({
+            type: "tool-call",
+            toolCallId: part.id,
+            toolName: getHostedToolName("code_interpreter"),
+            input: JSON.stringify({
+              code: part.code,
+              containerId: part.container_id
+            }),
+            providerExecuted: true
+          });
+          content.push({
+            type: "tool-result",
+            toolCallId: part.id,
+            toolName: getHostedToolName("code_interpreter"),
+            result: {
+              outputs: part.outputs
+            }
+          });
+          break;
+        }
+      }
+    }
+    const providerMetadata = {
+      copilot: { responseId: response.id }
+    };
+    if (logprobs.length > 0) {
+      providerMetadata.copilot.logprobs = logprobs;
+    }
+    if (typeof response.service_tier === "string") {
+      providerMetadata.copilot.serviceTier = response.service_tier;
+    }
+    return {
+      content,
+      finishReason: {
+        unified: mapOpenAIResponseFinishReason2({
+          finishReason: response.incomplete_details?.reason,
+          hasFunctionCall
+        }),
+        raw: response.incomplete_details?.reason
+      },
+      usage: {
+        inputTokens: {
+          total: response.usage.input_tokens,
+          noCache: response.usage.input_tokens_details?.cached_tokens != null ? response.usage.input_tokens - response.usage.input_tokens_details.cached_tokens : undefined,
+          cacheRead: response.usage.input_tokens_details?.cached_tokens ?? undefined,
+          cacheWrite: undefined
+        },
+        outputTokens: {
+          total: response.usage.output_tokens,
+          text: undefined,
+          reasoning: response.usage.output_tokens_details?.reasoning_tokens ?? undefined
+        },
+        raw: response.usage
+      },
+      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) {
+    const { args: body, warnings, getHostedToolName } = 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: openaiFailedResponseHandler2,
+      successfulResponseHandler: createEventSourceResponseHandler(openaiResponsesChunkSchema),
+      abortSignal: options.abortSignal,
+      fetch: this.config.fetch
+    });
+    const self = this;
+    let finishReason = {
+      unified: "other",
+      raw: undefined
+    };
+    const usage = {
+      inputTokens: undefined,
+      outputTokens: undefined,
+      totalTokens: undefined,
+      reasoningTokens: undefined,
+      cachedInputTokens: undefined
+    };
+    const logprobs = [];
+    let responseId = null;
+    const ongoingToolCalls = {};
+    let hasFunctionCall = false;
+    const activeReasoning = {};
+    let currentReasoningOutputIndex = null;
+    let currentTextId = null;
+    let serviceTier;
+    return {
+      stream: response.pipeThrough(new TransformStream({
+        start(controller) {
+          controller.enqueue({ type: "stream-start", warnings });
+        },
+        transform(chunk, controller) {
+          if (options.includeRawChunks) {
+            controller.enqueue({ type: "raw", rawValue: chunk.rawValue });
+          }
+          if (!chunk.success) {
+            finishReason = {
+              unified: "error",
+              raw: undefined
+            };
+            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] = {
+                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] = {
+                toolCallId: value.item.id
+              };
+              controller.enqueue({
+                type: "tool-input-start",
+                id: value.item.id,
+                toolName: getHostedToolName("web_search")
+              });
+            } else if (value.item.type === "computer_call") {
+              ongoingToolCalls[value.output_index] = {
+                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] = {
+                toolCallId: value.item.id,
+                codeInterpreter: {
+                  containerId: value.item.container_id
+                }
+              };
+              controller.enqueue({
+                type: "tool-input-start",
+                id: value.item.id,
+                toolName: getHostedToolName("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: getHostedToolName("file_search"),
+                input: "{}",
+                providerExecuted: true
+              });
+            } else if (value.item.type === "image_generation_call") {
+              controller.enqueue({
+                type: "tool-call",
+                toolCallId: value.item.id,
+                toolName: getHostedToolName("image_generation"),
+                input: "{}",
+                providerExecuted: true
+              });
+            } else if (value.item.type === "message") {
+              currentTextId = value.item.id;
+              controller.enqueue({
+                type: "text-start",
+                id: value.item.id,
+                providerMetadata: {
+                  copilot: {
+                    itemId: value.item.id
+                  }
+                }
+              });
+            } else if (isResponseOutputItemAddedReasoningChunk(value)) {
+              if (activeReasoning[value.output_index]) {
+                currentReasoningOutputIndex = value.output_index;
+                return;
+              }
+              activeReasoning[value.output_index] = {
+                canonicalId: value.item.id,
+                encryptedContent: value.item.encrypted_content,
+                summaryParts: { 0: "active" }
+              };
+              currentReasoningOutputIndex = value.output_index;
+              controller.enqueue({
+                type: "reasoning-start",
+                id: `${value.item.id}:0`,
+                providerMetadata: {
+                  copilot: {
+                    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: {
+                  copilot: {
+                    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: getHostedToolName("web_search"),
+                input: JSON.stringify({ action: value.item.action }),
+                providerExecuted: true
+              });
+              controller.enqueue({
+                type: "tool-result",
+                toolCallId: value.item.id,
+                toolName: getHostedToolName("web_search"),
+                result: { status: value.item.status }
+              });
+            } 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"
+                }
+              });
+            } else if (value.item.type === "file_search_call") {
+              ongoingToolCalls[value.output_index] = undefined;
+              controller.enqueue({
+                type: "tool-result",
+                toolCallId: value.item.id,
+                toolName: getHostedToolName("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
+                }
+              });
+            } else if (value.item.type === "code_interpreter_call") {
+              ongoingToolCalls[value.output_index] = undefined;
+              controller.enqueue({
+                type: "tool-result",
+                toolCallId: value.item.id,
+                toolName: getHostedToolName("code_interpreter"),
+                result: {
+                  outputs: value.item.outputs
+                }
+              });
+            } else if (value.item.type === "image_generation_call") {
+              controller.enqueue({
+                type: "tool-result",
+                toolCallId: value.item.id,
+                toolName: getHostedToolName("image_generation"),
+                result: {
+                  result: value.item.result
+                }
+              });
+            } 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.output_index];
+              if (activeReasoningPart) {
+                for (const [summaryIndex, status] of Object.entries(activeReasoningPart.summaryParts)) {
+                  if (status === "concluded")
+                    continue;
+                  controller.enqueue({
+                    type: "reasoning-end",
+                    id: `${activeReasoningPart.canonicalId}:${summaryIndex}`,
+                    providerMetadata: {
+                      copilot: {
+                        itemId: value.item.id,
+                        reasoningEncryptedContent: value.item.encrypted_content ?? null
+                      }
+                    }
+                  });
+                }
+                delete activeReasoning[value.output_index];
+                if (currentReasoningOutputIndex === value.output_index) {
+                  currentReasoningOutputIndex = null;
+                }
+              }
+            }
+          } 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: getHostedToolName("image_generation"),
+              result: {
+                result: value.partial_image_b64
+              }
+            });
+          } else if (isResponseCodeInterpreterCallCodeDeltaChunk(value)) {
+            const toolCall = ongoingToolCalls[value.output_index];
+            if (toolCall != null) {
+              controller.enqueue({
+                type: "tool-input-delta",
+                id: toolCall.toolCallId,
+                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
+              });
+              controller.enqueue({
+                type: "tool-call",
+                toolCallId: toolCall.toolCallId,
+                toolName: getHostedToolName("code_interpreter"),
+                input: JSON.stringify({
+                  code: value.code,
+                  containerId: toolCall.codeInterpreter.containerId
+                }),
+                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)) {
+            if (!currentTextId) {
+              currentTextId = value.item_id;
+              controller.enqueue({
+                type: "text-start",
+                id: currentTextId,
+                providerMetadata: {
+                  copilot: { itemId: value.item_id }
+                }
+              });
+            }
+            controller.enqueue({
+              type: "text-delta",
+              id: currentTextId,
+              delta: value.delta
+            });
+            if (options.providerOptions?.copilot?.logprobs && value.logprobs) {
+              logprobs.push(value.logprobs);
+            }
+          } else if (isResponseReasoningSummaryPartAddedChunk(value)) {
+            const activeItem = currentReasoningOutputIndex !== null ? activeReasoning[currentReasoningOutputIndex] : null;
+            if (activeItem && value.summary_index > 0 && activeItem.summaryParts[value.summary_index] === undefined) {
+              for (const [summaryIndex, status] of Object.entries(activeItem.summaryParts)) {
+                if (status !== "can-conclude")
+                  continue;
+                controller.enqueue({
+                  type: "reasoning-end",
+                  id: `${activeItem.canonicalId}:${summaryIndex}`,
+                  providerMetadata: {
+                    copilot: { itemId: activeItem.canonicalId }
+                  }
+                });
+                activeItem.summaryParts[Number(summaryIndex)] = "concluded";
+              }
+              activeItem.summaryParts[value.summary_index] = "active";
+              controller.enqueue({
+                type: "reasoning-start",
+                id: `${activeItem.canonicalId}:${value.summary_index}`,
+                providerMetadata: {
+                  copilot: {
+                    itemId: activeItem.canonicalId,
+                    reasoningEncryptedContent: activeItem.encryptedContent ?? null
+                  }
+                }
+              });
+            }
+          } else if (isResponseReasoningSummaryPartDoneChunk(value)) {
+            const activeItem = currentReasoningOutputIndex !== null ? activeReasoning[currentReasoningOutputIndex] : null;
+            if (!activeItem || activeItem.summaryParts[value.summary_index] !== "active")
+              return;
+            if (body.store === false) {
+              activeItem.summaryParts[value.summary_index] = "can-conclude";
+              return;
+            }
+            controller.enqueue({
+              type: "reasoning-end",
+              id: `${activeItem.canonicalId}:${value.summary_index}`,
+              providerMetadata: {
+                copilot: { itemId: activeItem.canonicalId }
+              }
+            });
+            activeItem.summaryParts[value.summary_index] = "concluded";
+          } else if (isResponseReasoningSummaryTextDeltaChunk(value)) {
+            const activeItem = currentReasoningOutputIndex !== null ? activeReasoning[currentReasoningOutputIndex] : null;
+            if (activeItem) {
+              controller.enqueue({
+                type: "reasoning-delta",
+                id: `${activeItem.canonicalId}:${value.summary_index}`,
+                delta: value.delta,
+                providerMetadata: {
+                  copilot: {
+                    itemId: activeItem.canonicalId
+                  }
+                }
+              });
+            }
+          } else if (isResponseFinishedChunk(value)) {
+            finishReason = {
+              unified: mapOpenAIResponseFinishReason2({
+                finishReason: value.response.incomplete_details?.reason,
+                hasFunctionCall
+              }),
+              raw: value.response.incomplete_details?.reason ?? undefined
+            };
+            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) {
+          if (currentTextId) {
+            controller.enqueue({ type: "text-end", id: currentTextId });
+            currentTextId = null;
+          }
+          for (const activeItem of Object.values(activeReasoning)) {
+            for (const [summaryIndex, status] of Object.entries(activeItem.summaryParts)) {
+              if (status === "concluded")
+                continue;
+              controller.enqueue({
+                type: "reasoning-end",
+                id: `${activeItem.canonicalId}:${summaryIndex}`,
+                providerMetadata: { copilot: { itemId: activeItem.canonicalId } }
+              });
+            }
+          }
+          const providerMetadata = {
+            copilot: {
+              responseId
+            }
+          };
+          if (logprobs.length > 0) {
+            providerMetadata.copilot.logprobs = logprobs;
+          }
+          if (serviceTier !== undefined) {
+            providerMetadata.copilot.serviceTier = serviceTier;
+          }
+          controller.enqueue({
+            type: "finish",
+            finishReason,
+            usage: {
+              inputTokens: {
+                total: usage.inputTokens,
+                noCache: usage.inputTokens != null && usage.cachedInputTokens != null ? usage.inputTokens - usage.cachedInputTokens : undefined,
+                cacheRead: usage.cachedInputTokens,
+                cacheWrite: undefined
+              },
+              outputTokens: {
+                total: usage.outputTokens,
+                text: undefined,
+                reasoning: usage.reasoningTokens
+              },
+              raw: {
+                input_tokens: usage.inputTokens,
+                output_tokens: usage.outputTokens,
+                total_tokens: usage.totalTokens
+              }
+            },
+            providerMetadata
+          });
+        }
+      })),
+      request: { body },
+      response: { headers: responseHeaders }
+    };
+  }
+}
+var 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()
+});
+var textDeltaChunkSchema = z.object({
+  type: z.literal("response.output_text.delta"),
+  item_id: z.string(),
+  delta: z.string(),
+  logprobs: LOGPROBS_SCHEMA.nullish()
+});
+var errorChunkSchema = z.object({
+  type: z.literal("error"),
+  code: z.string(),
+  message: z.string(),
+  param: z.string().nullish(),
+  sequence_number: z.number()
+});
+var 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()
+  })
+});
+var 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()
+  })
+});
+var 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()
+    })
+  ])
+});
+var 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,
+    z.object({
+      type: z.literal("computer_call"),
+      id: z.string(),
+      status: z.literal("completed")
+    })
+  ])
+});
+var responseFunctionCallArgumentsDeltaSchema = z.object({
+  type: z.literal("response.function_call_arguments.delta"),
+  item_id: z.string(),
+  output_index: z.number(),
+  delta: z.string()
+});
+var 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()
+});
+var responseCodeInterpreterCallCodeDeltaSchema = z.object({
+  type: z.literal("response.code_interpreter_call_code.delta"),
+  item_id: z.string(),
+  output_index: z.number(),
+  delta: z.string()
+});
+var responseCodeInterpreterCallCodeDoneSchema = z.object({
+  type: z.literal("response.code_interpreter_call_code.done"),
+  item_id: z.string(),
+  output_index: z.number(),
+  code: z.string()
+});
+var 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()
+    })
+  ])
+});
+var responseReasoningSummaryPartAddedSchema = z.object({
+  type: z.literal("response.reasoning_summary_part.added"),
+  item_id: z.string(),
+  summary_index: z.number()
+});
+var responseReasoningSummaryTextDeltaSchema = z.object({
+  type: z.literal("response.reasoning_summary_text.delta"),
+  item_id: z.string(),
+  summary_index: z.number(),
+  delta: z.string()
+});
+var responseReasoningSummaryPartDoneSchema = z.object({
+  type: z.literal("response.reasoning_summary_part.done"),
+  item_id: z.string(),
+  summary_index: z.number()
+});
+var openaiResponsesChunkSchema = z.union([
+  textDeltaChunkSchema,
+  responseFinishedChunkSchema,
+  responseCreatedChunkSchema,
+  responseOutputItemAddedSchema,
+  responseOutputItemDoneSchema,
+  responseFunctionCallArgumentsDeltaSchema,
+  responseImageGenerationCallPartialImageSchema,
+  responseCodeInterpreterCallCodeDeltaSchema,
+  responseCodeInterpreterCallCodeDoneSchema,
+  responseAnnotationAddedSchema,
+  responseReasoningSummaryPartAddedSchema,
+  responseReasoningSummaryPartDoneSchema,
+  responseReasoningSummaryTextDeltaSchema,
+  errorChunkSchema,
+  z.object({ type: z.string() }).loose()
+]);
+function isTextDeltaChunk(chunk) {
+  return chunk.type === "response.output_text.delta";
+}
+function isResponseOutputItemDoneChunk(chunk) {
+  return chunk.type === "response.output_item.done";
+}
+function isResponseOutputItemDoneReasoningChunk(chunk) {
+  return isResponseOutputItemDoneChunk(chunk) && chunk.item.type === "reasoning";
+}
+function isResponseFinishedChunk(chunk) {
+  return chunk.type === "response.completed" || chunk.type === "response.incomplete";
+}
+function isResponseCreatedChunk(chunk) {
+  return chunk.type === "response.created";
+}
+function isResponseFunctionCallArgumentsDeltaChunk(chunk) {
+  return chunk.type === "response.function_call_arguments.delta";
+}
+function isResponseImageGenerationCallPartialImageChunk(chunk) {
+  return chunk.type === "response.image_generation_call.partial_image";
+}
+function isResponseCodeInterpreterCallCodeDeltaChunk(chunk) {
+  return chunk.type === "response.code_interpreter_call_code.delta";
+}
+function isResponseCodeInterpreterCallCodeDoneChunk(chunk) {
+  return chunk.type === "response.code_interpreter_call_code.done";
+}
+function isResponseOutputItemAddedChunk(chunk) {
+  return chunk.type === "response.output_item.added";
+}
+function isResponseOutputItemAddedReasoningChunk(chunk) {
+  return isResponseOutputItemAddedChunk(chunk) && chunk.item.type === "reasoning";
+}
+function isResponseAnnotationAddedChunk(chunk) {
+  return chunk.type === "response.output_text.annotation.added";
+}
+function isResponseReasoningSummaryPartAddedChunk(chunk) {
+  return chunk.type === "response.reasoning_summary_part.added";
+}
+function isResponseReasoningSummaryPartDoneChunk(chunk) {
+  return chunk.type === "response.reasoning_summary_part.done";
+}
+function isResponseReasoningSummaryTextDeltaChunk(chunk) {
+  return chunk.type === "response.reasoning_summary_text.delta";
+}
+function isErrorChunk(chunk) {
+  return chunk.type === "error";
+}
+function getResponsesModelConfig(modelId) {
+  const supportsFlexProcessing = modelId.startsWith("o3") || modelId.startsWith("o4-mini") || modelId.startsWith("gpt-5") && !modelId.startsWith("gpt-5-chat");
+  const supportsPriorityProcessing = modelId.startsWith("gpt-4") || modelId.startsWith("gpt-5-mini") || modelId.startsWith("gpt-5") && !modelId.startsWith("gpt-5-nano") && !modelId.startsWith("gpt-5-chat") || modelId.startsWith("o3") || modelId.startsWith("o4-mini");
+  const defaults = {
+    requiredAutoTruncation: false,
+    systemMessageMode: "system",
+    supportsFlexProcessing,
+    supportsPriorityProcessing
+  };
+  if (modelId.startsWith("gpt-5-chat")) {
+    return {
+      ...defaults,
+      isReasoningModel: false
+    };
+  }
+  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"
+    };
+  }
+  return {
+    ...defaults,
+    isReasoningModel: false
+  };
+}
+var openaiResponsesProviderOptionsSchema = z.object({
+  include: z.array(z.enum(["reasoning.encrypted_content", "file_search_call.results", "message.output_text.logprobs"])).nullish(),
+  instructions: z.string().nullish(),
+  logprobs: z.union([z.boolean(), z.number().min(1).max(TOP_LOGPROBS_MAX)]).optional(),
+  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 { OpenAIResponsesLanguageModel2 };