nuwaxcode 1.1.32 → 1.1.44

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

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

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

@@ -1,2 +0,0 @@
-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

@@ -1,100 +0,0 @@
-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

@@ -1,303 +0,0 @@
-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

@@ -1,22 +0,0 @@
-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

@@ -1,18 +0,0 @@
-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

@@ -1,22 +0,0 @@
-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

@@ -1,207 +0,0 @@
-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
-  }>
-}