rird 1.0.200

package/src/provider/sdk/openai-compatible/src/README.md

@@ -0,0 +1,5 @@
+This is a temporary package used primarily for github copilot compatibility.
+
+Avoid making changes to these files unless you want to only affect Copilot provider.
+
+Also this should ONLY be used for Copilot provider.

package/src/provider/sdk/openai-compatible/src/index.ts

@@ -0,0 +1,2 @@
+export { createOpenaiCompatible, openaiCompatible } from "./openai-compatible-provider"
+export type { OpenaiCompatibleProvider, OpenaiCompatibleProviderSettings } from "./openai-compatible-provider"

package/src/provider/sdk/openai-compatible/src/openai-compatible-provider.ts

@@ -0,0 +1,100 @@
+import type { LanguageModelV2 } from "@ai-sdk/provider"
+import { OpenAICompatibleChatLanguageModel } from "@ai-sdk/openai-compatible"
+import { type FetchFunction, withoutTrailingSlash, withUserAgentSuffix } from "@ai-sdk/provider-utils"
+import { OpenAIResponsesLanguageModel } from "./responses/openai-responses-language-model"
+
+// Import the version or define it
+const VERSION = "0.1.0"
+
+export type OpenaiCompatibleModelId = string
+
+export interface OpenaiCompatibleProviderSettings {
+  /**
+   * API key for authenticating requests.
+   */
+  apiKey?: string
+
+  /**
+   * Base URL for the OpenAI Compatible API calls.
+   */
+  baseURL?: string
+
+  /**
+   * Name of the provider.
+   */
+  name?: string
+
+  /**
+   * Custom headers to include in the requests.
+   */
+  headers?: Record<string, string>
+
+  /**
+   * Custom fetch implementation.
+   */
+  fetch?: FetchFunction
+}
+
+export interface OpenaiCompatibleProvider {
+  (modelId: OpenaiCompatibleModelId): LanguageModelV2
+  chat(modelId: OpenaiCompatibleModelId): LanguageModelV2
+  responses(modelId: OpenaiCompatibleModelId): LanguageModelV2
+  languageModel(modelId: OpenaiCompatibleModelId): LanguageModelV2
+
+  // embeddingModel(modelId: any): EmbeddingModelV2
+
+  // imageModel(modelId: any): ImageModelV2
+}
+
+/**
+ * Create an OpenAI Compatible provider instance.
+ */
+export function createOpenaiCompatible(options: OpenaiCompatibleProviderSettings = {}): OpenaiCompatibleProvider {
+  const baseURL = withoutTrailingSlash(options.baseURL ?? "https://api.openai.com/v1")
+
+  if (!baseURL) {
+    throw new Error("baseURL is required")
+  }
+
+  // Merge headers: defaults first, then user overrides
+  const headers = {
+    // Default OpenAI Compatible headers (can be overridden by user)
+    ...(options.apiKey && { Authorization: `Bearer ${options.apiKey}` }),
+    ...options.headers,
+  }
+
+  const getHeaders = () => withUserAgentSuffix(headers, `ai-sdk/openai-compatible/${VERSION}`)
+
+  const createChatModel = (modelId: OpenaiCompatibleModelId) => {
+    return new OpenAICompatibleChatLanguageModel(modelId, {
+      provider: `${options.name ?? "openai-compatible"}.chat`,
+      headers: getHeaders,
+      url: ({ path }) => `${baseURL}${path}`,
+      fetch: options.fetch,
+    })
+  }
+
+  const createResponsesModel = (modelId: OpenaiCompatibleModelId) => {
+    return new OpenAIResponsesLanguageModel(modelId, {
+      provider: `${options.name ?? "openai-compatible"}.responses`,
+      headers: getHeaders,
+      url: ({ path }) => `${baseURL}${path}`,
+      fetch: options.fetch,
+    })
+  }
+
+  const createLanguageModel = (modelId: OpenaiCompatibleModelId) => createChatModel(modelId)
+
+  const provider = function (modelId: OpenaiCompatibleModelId) {
+    return createChatModel(modelId)
+  }
+
+  provider.languageModel = createLanguageModel
+  provider.chat = createChatModel
+  provider.responses = createResponsesModel
+
+  return provider as OpenaiCompatibleProvider
+}
+
+// Default OpenAI Compatible provider instance
+export const openaiCompatible = createOpenaiCompatible()

package/src/provider/sdk/openai-compatible/src/responses/convert-to-openai-responses-input.ts

@@ -0,0 +1,303 @@
+import {
+  type LanguageModelV2CallWarning,
+  type LanguageModelV2Prompt,
+  type LanguageModelV2ToolCallPart,
+  UnsupportedFunctionalityError,
+} from "@ai-sdk/provider"
+import { convertToBase64, parseProviderOptions } from "@ai-sdk/provider-utils"
+import { z } from "zod/v4"
+import type { OpenAIResponsesInput, OpenAIResponsesReasoning } from "./openai-responses-api-types"
+import { localShellInputSchema, localShellOutputSchema } from "./tool/local-shell"
+
+/**
+ * Check if a string is a file ID based on the given prefixes
+ * Returns false if prefixes is undefined (disables file ID detection)
+ */
+function isFileId(data: string, prefixes?: readonly string[]): boolean {
+  if (!prefixes) return false
+  return prefixes.some((prefix) => data.startsWith(prefix))
+}
+
+export async function convertToOpenAIResponsesInput({
+  prompt,
+  systemMessageMode,
+  fileIdPrefixes,
+  store,
+  hasLocalShellTool = false,
+}: {
+  prompt: LanguageModelV2Prompt
+  systemMessageMode: "system" | "developer" | "remove"
+  fileIdPrefixes?: readonly string[]
+  store: boolean
+  hasLocalShellTool?: boolean
+}): Promise<{
+  input: OpenAIResponsesInput
+  warnings: Array<LanguageModelV2CallWarning>
+}> {
+  const input: OpenAIResponsesInput = []
+  const warnings: Array<LanguageModelV2CallWarning> = []
+
+  for (const { role, content } of prompt) {
+    switch (role) {
+      case "system": {
+        switch (systemMessageMode) {
+          case "system": {
+            input.push({ role: "system", content })
+            break
+          }
+          case "developer": {
+            input.push({ role: "developer", content })
+            break
+          }
+          case "remove": {
+            warnings.push({
+              type: "other",
+              message: "system messages are removed for this model",
+            })
+            break
+          }
+          default: {
+            const _exhaustiveCheck: never = systemMessageMode
+            throw new Error(`Unsupported system message mode: ${_exhaustiveCheck}`)
+          }
+        }
+        break
+      }
+
+      case "user": {
+        input.push({
+          role: "user",
+          content: content.map((part, index) => {
+            switch (part.type) {
+              case "text": {
+                return { type: "input_text", text: part.text }
+              }
+              case "file": {
+                if (part.mediaType.startsWith("image/")) {
+                  const mediaType = part.mediaType === "image/*" ? "image/jpeg" : part.mediaType
+
+                  return {
+                    type: "input_image",
+                    ...(part.data instanceof URL
+                      ? { image_url: part.data.toString() }
+                      : typeof part.data === "string" && isFileId(part.data, fileIdPrefixes)
+                        ? { file_id: part.data }
+                        : {
+                            image_url: `data:${mediaType};base64,${convertToBase64(part.data)}`,
+                          }),
+                    detail: part.providerOptions?.openai?.imageDetail,
+                  }
+                } else if (part.mediaType === "application/pdf") {
+                  if (part.data instanceof URL) {
+                    return {
+                      type: "input_file",
+                      file_url: part.data.toString(),
+                    }
+                  }
+                  return {
+                    type: "input_file",
+                    ...(typeof part.data === "string" && isFileId(part.data, fileIdPrefixes)
+                      ? { file_id: part.data }
+                      : {
+                          filename: part.filename ?? `part-${index}.pdf`,
+                          file_data: `data:application/pdf;base64,${convertToBase64(part.data)}`,
+                        }),
+                  }
+                } else {
+                  throw new UnsupportedFunctionalityError({
+                    functionality: `file part media type ${part.mediaType}`,
+                  })
+                }
+              }
+            }
+          }),
+        })
+
+        break
+      }
+
+      case "assistant": {
+        const reasoningMessages: Record<string, OpenAIResponsesReasoning> = {}
+        const toolCallParts: Record<string, LanguageModelV2ToolCallPart> = {}
+
+        for (const part of content) {
+          switch (part.type) {
+            case "text": {
+              input.push({
+                role: "assistant",
+                content: [{ type: "output_text", text: part.text }],
+                id: (part.providerOptions?.openai?.itemId as string) ?? undefined,
+              })
+              break
+            }
+            case "tool-call": {
+              toolCallParts[part.toolCallId] = part
+
+              if (part.providerExecuted) {
+                break
+              }
+
+              if (hasLocalShellTool && part.toolName === "local_shell") {
+                const parsedInput = localShellInputSchema.parse(part.input)
+                input.push({
+                  type: "local_shell_call",
+                  call_id: part.toolCallId,
+                  id: (part.providerOptions?.openai?.itemId as string) ?? undefined,
+                  action: {
+                    type: "exec",
+                    command: parsedInput.action.command,
+                    timeout_ms: parsedInput.action.timeoutMs,
+                    user: parsedInput.action.user,
+                    working_directory: parsedInput.action.workingDirectory,
+                    env: parsedInput.action.env,
+                  },
+                })
+
+                break
+              }
+
+              input.push({
+                type: "function_call",
+                call_id: part.toolCallId,
+                name: part.toolName,
+                arguments: JSON.stringify(part.input),
+                id: (part.providerOptions?.openai?.itemId as string) ?? undefined,
+              })
+              break
+            }
+
+            // assistant tool result parts are from provider-executed tools:
+            case "tool-result": {
+              if (store) {
+                // use item references to refer to tool results from built-in tools
+                input.push({ type: "item_reference", id: part.toolCallId })
+              } else {
+                warnings.push({
+                  type: "other",
+                  message: `Results for OpenAI tool ${part.toolName} are not sent to the API when store is false`,
+                })
+              }
+
+              break
+            }
+
+            case "reasoning": {
+              const providerOptions = await parseProviderOptions({
+                provider: "openai",
+                providerOptions: part.providerOptions,
+                schema: openaiResponsesReasoningProviderOptionsSchema,
+              })
+
+              const reasoningId = providerOptions?.itemId
+
+              if (reasoningId != null) {
+                const reasoningMessage = reasoningMessages[reasoningId]
+
+                if (store) {
+                  if (reasoningMessage === undefined) {
+                    // use item references to refer to reasoning (single reference)
+                    input.push({ type: "item_reference", id: reasoningId })
+
+                    // store unused reasoning message to mark id as used
+                    reasoningMessages[reasoningId] = {
+                      type: "reasoning",
+                      id: reasoningId,
+                      summary: [],
+                    }
+                  }
+                } else {
+                  const summaryParts: Array<{
+                    type: "summary_text"
+                    text: string
+                  }> = []
+
+                  if (part.text.length > 0) {
+                    summaryParts.push({
+                      type: "summary_text",
+                      text: part.text,
+                    })
+                  } else if (reasoningMessage !== undefined) {
+                    warnings.push({
+                      type: "other",
+                      message: `Cannot append empty reasoning part to existing reasoning sequence. Skipping reasoning part: ${JSON.stringify(part)}.`,
+                    })
+                  }
+
+                  if (reasoningMessage === undefined) {
+                    reasoningMessages[reasoningId] = {
+                      type: "reasoning",
+                      id: reasoningId,
+                      encrypted_content: providerOptions?.reasoningEncryptedContent,
+                      summary: summaryParts,
+                    }
+                    input.push(reasoningMessages[reasoningId])
+                  } else {
+                    reasoningMessage.summary.push(...summaryParts)
+                  }
+                }
+              } else {
+                warnings.push({
+                  type: "other",
+                  message: `Non-OpenAI reasoning parts are not supported. Skipping reasoning part: ${JSON.stringify(part)}.`,
+                })
+              }
+              break
+            }
+          }
+        }
+
+        break
+      }
+
+      case "tool": {
+        for (const part of content) {
+          const output = part.output
+
+          if (hasLocalShellTool && part.toolName === "local_shell" && output.type === "json") {
+            input.push({
+              type: "local_shell_call_output",
+              call_id: part.toolCallId,
+              output: localShellOutputSchema.parse(output.value).output,
+            })
+            break
+          }
+
+          let contentValue: string
+          switch (output.type) {
+            case "text":
+            case "error-text":
+              contentValue = output.value
+              break
+            case "content":
+            case "json":
+            case "error-json":
+              contentValue = JSON.stringify(output.value)
+              break
+          }
+
+          input.push({
+            type: "function_call_output",
+            call_id: part.toolCallId,
+            output: contentValue,
+          })
+        }
+
+        break
+      }
+
+      default: {
+        const _exhaustiveCheck: never = role
+        throw new Error(`Unsupported role: ${_exhaustiveCheck}`)
+      }
+    }
+  }
+
+  return { input, warnings }
+}
+
+const openaiResponsesReasoningProviderOptionsSchema = z.object({
+  itemId: z.string().nullish(),
+  reasoningEncryptedContent: z.string().nullish(),
+})
+
+export type OpenAIResponsesReasoningProviderOptions = z.infer<typeof openaiResponsesReasoningProviderOptionsSchema>

package/src/provider/sdk/openai-compatible/src/responses/map-openai-responses-finish-reason.ts

@@ -0,0 +1,22 @@
+import type { LanguageModelV2FinishReason } from "@ai-sdk/provider"
+
+export function mapOpenAIResponseFinishReason({
+  finishReason,
+  hasFunctionCall,
+}: {
+  finishReason: string | null | undefined
+  // flag that checks if there have been client-side tool calls (not executed by openai)
+  hasFunctionCall: boolean
+}): LanguageModelV2FinishReason {
+  switch (finishReason) {
+    case undefined:
+    case null:
+      return hasFunctionCall ? "tool-calls" : "stop"
+    case "max_output_tokens":
+      return "length"
+    case "content_filter":
+      return "content-filter"
+    default:
+      return hasFunctionCall ? "tool-calls" : "unknown"
+  }
+}

package/src/provider/sdk/openai-compatible/src/responses/openai-config.ts

@@ -0,0 +1,18 @@
+import type { FetchFunction } from "@ai-sdk/provider-utils"
+
+export type OpenAIConfig = {
+  provider: string
+  url: (options: { modelId: string; path: string }) => string
+  headers: () => Record<string, string | undefined>
+  fetch?: FetchFunction
+  generateId?: () => string
+  /**
+   * File ID prefixes used to identify file IDs in Responses API.
+   * When undefined, all file data is treated as base64 content.
+   *
+   * Examples:
+   * - OpenAI: ['file-'] for IDs like 'file-abc123'
+   * - Azure OpenAI: ['assistant-'] for IDs like 'assistant-abc123'
+   */
+  fileIdPrefixes?: readonly string[]
+}

package/src/provider/sdk/openai-compatible/src/responses/openai-error.ts

@@ -0,0 +1,22 @@
+import { z } from "zod/v4"
+import { createJsonErrorResponseHandler } from "@ai-sdk/provider-utils"
+
+export const openaiErrorDataSchema = z.object({
+  error: z.object({
+    message: z.string(),
+
+    // The additional information below is handled loosely to support
+    // OpenAI-compatible providers that have slightly different error
+    // responses:
+    type: z.string().nullish(),
+    param: z.any().nullish(),
+    code: z.union([z.string(), z.number()]).nullish(),
+  }),
+})
+
+export type OpenAIErrorData = z.infer<typeof openaiErrorDataSchema>
+
+export const openaiFailedResponseHandler: any = createJsonErrorResponseHandler({
+  errorSchema: openaiErrorDataSchema,
+  errorToMessage: (data) => data.error.message,
+})

package/src/provider/sdk/openai-compatible/src/responses/openai-responses-api-types.ts

@@ -0,0 +1,207 @@
+import type { JSONSchema7 } from "@ai-sdk/provider"
+
+export type OpenAIResponsesInput = Array<OpenAIResponsesInputItem>
+
+export type OpenAIResponsesInputItem =
+  | OpenAIResponsesSystemMessage
+  | OpenAIResponsesUserMessage
+  | OpenAIResponsesAssistantMessage
+  | OpenAIResponsesFunctionCall
+  | OpenAIResponsesFunctionCallOutput
+  | OpenAIResponsesComputerCall
+  | OpenAIResponsesLocalShellCall
+  | OpenAIResponsesLocalShellCallOutput
+  | OpenAIResponsesReasoning
+  | OpenAIResponsesItemReference
+
+export type OpenAIResponsesIncludeValue =
+  | "web_search_call.action.sources"
+  | "code_interpreter_call.outputs"
+  | "computer_call_output.output.image_url"
+  | "file_search_call.results"
+  | "message.input_image.image_url"
+  | "message.output_text.logprobs"
+  | "reasoning.encrypted_content"
+
+export type OpenAIResponsesIncludeOptions = Array<OpenAIResponsesIncludeValue> | undefined | null
+
+export type OpenAIResponsesSystemMessage = {
+  role: "system" | "developer"
+  content: string
+}
+
+export type OpenAIResponsesUserMessage = {
+  role: "user"
+  content: Array<
+    | { type: "input_text"; text: string }
+    | { type: "input_image"; image_url: string }
+    | { type: "input_image"; file_id: string }
+    | { type: "input_file"; file_url: string }
+    | { type: "input_file"; filename: string; file_data: string }
+    | { type: "input_file"; file_id: string }
+  >
+}
+
+export type OpenAIResponsesAssistantMessage = {
+  role: "assistant"
+  content: Array<{ type: "output_text"; text: string }>
+  id?: string
+}
+
+export type OpenAIResponsesFunctionCall = {
+  type: "function_call"
+  call_id: string
+  name: string
+  arguments: string
+  id?: string
+}
+
+export type OpenAIResponsesFunctionCallOutput = {
+  type: "function_call_output"
+  call_id: string
+  output: string
+}
+
+export type OpenAIResponsesComputerCall = {
+  type: "computer_call"
+  id: string
+  status?: string
+}
+
+export type OpenAIResponsesLocalShellCall = {
+  type: "local_shell_call"
+  id: string
+  call_id: string
+  action: {
+    type: "exec"
+    command: string[]
+    timeout_ms?: number
+    user?: string
+    working_directory?: string
+    env?: Record<string, string>
+  }
+}
+
+export type OpenAIResponsesLocalShellCallOutput = {
+  type: "local_shell_call_output"
+  call_id: string
+  output: string
+}
+
+export type OpenAIResponsesItemReference = {
+  type: "item_reference"
+  id: string
+}
+
+/**
+ * A filter used to compare a specified attribute key to a given value using a defined comparison operation.
+ */
+export type OpenAIResponsesFileSearchToolComparisonFilter = {
+  /**
+   * The key to compare against the value.
+   */
+  key: string
+
+  /**
+   * Specifies the comparison operator: eq, ne, gt, gte, lt, lte.
+   */
+  type: "eq" | "ne" | "gt" | "gte" | "lt" | "lte"
+
+  /**
+   * The value to compare against the attribute key; supports string, number, or boolean types.
+   */
+  value: string | number | boolean
+}
+
+/**
+ * Combine multiple filters using and or or.
+ */
+export type OpenAIResponsesFileSearchToolCompoundFilter = {
+  /**
+   * Type of operation: and or or.
+   */
+  type: "and" | "or"
+
+  /**
+   * Array of filters to combine. Items can be ComparisonFilter or CompoundFilter.
+   */
+  filters: Array<OpenAIResponsesFileSearchToolComparisonFilter | OpenAIResponsesFileSearchToolCompoundFilter>
+}
+
+export type OpenAIResponsesTool =
+  | {
+      type: "function"
+      name: string
+      description: string | undefined
+      parameters: JSONSchema7
+      strict: boolean | undefined
+    }
+  | {
+      type: "web_search"
+      filters: { allowed_domains: string[] | undefined } | undefined
+      search_context_size: "low" | "medium" | "high" | undefined
+      user_location:
+        | {
+            type: "approximate"
+            city?: string
+            country?: string
+            region?: string
+            timezone?: string
+          }
+        | undefined
+    }
+  | {
+      type: "web_search_preview"
+      search_context_size: "low" | "medium" | "high" | undefined
+      user_location:
+        | {
+            type: "approximate"
+            city?: string
+            country?: string
+            region?: string
+            timezone?: string
+          }
+        | undefined
+    }
+  | {
+      type: "code_interpreter"
+      container: string | { type: "auto"; file_ids: string[] | undefined }
+    }
+  | {
+      type: "file_search"
+      vector_store_ids: string[]
+      max_num_results: number | undefined
+      ranking_options: { ranker?: string; score_threshold?: number } | undefined
+      filters: OpenAIResponsesFileSearchToolComparisonFilter | OpenAIResponsesFileSearchToolCompoundFilter | undefined
+    }
+  | {
+      type: "image_generation"
+      background: "auto" | "opaque" | "transparent" | undefined
+      input_fidelity: "low" | "high" | undefined
+      input_image_mask:
+        | {
+            file_id: string | undefined
+            image_url: string | undefined
+          }
+        | undefined
+      model: string | undefined
+      moderation: "auto" | undefined
+      output_compression: number | undefined
+      output_format: "png" | "jpeg" | "webp" | undefined
+      partial_images: number | undefined
+      quality: "auto" | "low" | "medium" | "high" | undefined
+      size: "auto" | "1024x1024" | "1024x1536" | "1536x1024" | undefined
+    }
+  | {
+      type: "local_shell"
+    }
+
+export type OpenAIResponsesReasoning = {
+  type: "reasoning"
+  id: string
+  encrypted_content?: string | null
+  summary: Array<{
+    type: "summary_text"
+    text: string
+  }>
+}