bincode-cli 1.0.1

package/src/provider/sdk/openai-compatible/src/responses/openai-responses-prepare-tools.ts

@@ -0,0 +1,177 @@
+import {
+  type LanguageModelV2CallOptions,
+  type LanguageModelV2CallWarning,
+  UnsupportedFunctionalityError,
+} from "@ai-sdk/provider"
+import { codeInterpreterArgsSchema } from "./tool/code-interpreter"
+import { fileSearchArgsSchema } from "./tool/file-search"
+import { webSearchArgsSchema } from "./tool/web-search"
+import { webSearchPreviewArgsSchema } from "./tool/web-search-preview"
+import { imageGenerationArgsSchema } from "./tool/image-generation"
+import type { OpenAIResponsesTool } from "./openai-responses-api-types"
+
+export function prepareResponsesTools({
+  tools,
+  toolChoice,
+  strictJsonSchema,
+}: {
+  tools: LanguageModelV2CallOptions["tools"]
+  toolChoice?: LanguageModelV2CallOptions["toolChoice"]
+  strictJsonSchema: boolean
+}): {
+  tools?: Array<OpenAIResponsesTool>
+  toolChoice?:
+    | "auto"
+    | "none"
+    | "required"
+    | { type: "file_search" }
+    | { type: "web_search_preview" }
+    | { type: "web_search" }
+    | { type: "function"; name: string }
+    | { type: "code_interpreter" }
+    | { type: "image_generation" }
+  toolWarnings: LanguageModelV2CallWarning[]
+} {
+  // when the tools array is empty, change it to undefined to prevent errors:
+  tools = tools?.length ? tools : undefined
+
+  const toolWarnings: LanguageModelV2CallWarning[] = []
+
+  if (tools == null) {
+    return { tools: undefined, toolChoice: undefined, toolWarnings }
+  }
+
+  const openaiTools: Array<OpenAIResponsesTool> = []
+
+  for (const tool of tools) {
+    switch (tool.type) {
+      case "function":
+        openaiTools.push({
+          type: "function",
+          name: tool.name,
+          description: tool.description,
+          parameters: tool.inputSchema,
+          strict: strictJsonSchema,
+        })
+        break
+      case "provider-defined": {
+        switch (tool.id) {
+          case "openai.file_search": {
+            const args = fileSearchArgsSchema.parse(tool.args)
+
+            openaiTools.push({
+              type: "file_search",
+              vector_store_ids: args.vectorStoreIds,
+              max_num_results: args.maxNumResults,
+              ranking_options: args.ranking
+                ? {
+                    ranker: args.ranking.ranker,
+                    score_threshold: args.ranking.scoreThreshold,
+                  }
+                : undefined,
+              filters: args.filters,
+            })
+
+            break
+          }
+          case "openai.local_shell": {
+            openaiTools.push({
+              type: "local_shell",
+            })
+            break
+          }
+          case "openai.web_search_preview": {
+            const args = webSearchPreviewArgsSchema.parse(tool.args)
+            openaiTools.push({
+              type: "web_search_preview",
+              search_context_size: args.searchContextSize,
+              user_location: args.userLocation,
+            })
+            break
+          }
+          case "openai.web_search": {
+            const args = webSearchArgsSchema.parse(tool.args)
+            openaiTools.push({
+              type: "web_search",
+              filters: args.filters != null ? { allowed_domains: args.filters.allowedDomains } : undefined,
+              search_context_size: args.searchContextSize,
+              user_location: args.userLocation,
+            })
+            break
+          }
+          case "openai.code_interpreter": {
+            const args = codeInterpreterArgsSchema.parse(tool.args)
+            openaiTools.push({
+              type: "code_interpreter",
+              container:
+                args.container == null
+                  ? { type: "auto", file_ids: undefined }
+                  : typeof args.container === "string"
+                    ? args.container
+                    : { type: "auto", file_ids: args.container.fileIds },
+            })
+            break
+          }
+          case "openai.image_generation": {
+            const args = imageGenerationArgsSchema.parse(tool.args)
+            openaiTools.push({
+              type: "image_generation",
+              background: args.background,
+              input_fidelity: args.inputFidelity,
+              input_image_mask: args.inputImageMask
+                ? {
+                    file_id: args.inputImageMask.fileId,
+                    image_url: args.inputImageMask.imageUrl,
+                  }
+                : undefined,
+              model: args.model,
+              moderation: args.moderation,
+              partial_images: args.partialImages,
+              quality: args.quality,
+              output_compression: args.outputCompression,
+              output_format: args.outputFormat,
+              size: args.size,
+            })
+            break
+          }
+        }
+        break
+      }
+      default:
+        toolWarnings.push({ type: "unsupported-tool", tool })
+        break
+    }
+  }
+
+  if (toolChoice == null) {
+    return { tools: openaiTools, toolChoice: undefined, toolWarnings }
+  }
+
+  const type = toolChoice.type
+
+  switch (type) {
+    case "auto":
+    case "none":
+    case "required":
+      return { tools: openaiTools, toolChoice: type, toolWarnings }
+    case "tool":
+      return {
+        tools: openaiTools,
+        toolChoice:
+          toolChoice.toolName === "code_interpreter" ||
+          toolChoice.toolName === "file_search" ||
+          toolChoice.toolName === "image_generation" ||
+          toolChoice.toolName === "web_search_preview" ||
+          toolChoice.toolName === "web_search"
+            ? { type: toolChoice.toolName }
+            : { type: "function", name: toolChoice.toolName },
+        toolWarnings,
+      }
+    default: {
+      const _exhaustiveCheck: never = type
+      throw new UnsupportedFunctionalityError({
+        functionality: `tool choice type: ${_exhaustiveCheck}`,
+      })
+    }
+  }
+}

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

@@ -0,0 +1 @@
+export type OpenAIResponsesModelId = string

package/src/provider/sdk/openai-compatible/src/responses/tool/code-interpreter.ts

@@ -0,0 +1,88 @@
+import { createProviderDefinedToolFactoryWithOutputSchema } from "@ai-sdk/provider-utils"
+import { z } from "zod/v4"
+
+export const codeInterpreterInputSchema = z.object({
+  code: z.string().nullish(),
+  containerId: z.string(),
+})
+
+export const codeInterpreterOutputSchema = z.object({
+  outputs: z
+    .array(
+      z.discriminatedUnion("type", [
+        z.object({ type: z.literal("logs"), logs: z.string() }),
+        z.object({ type: z.literal("image"), url: z.string() }),
+      ]),
+    )
+    .nullish(),
+})
+
+export const codeInterpreterArgsSchema = z.object({
+  container: z
+    .union([
+      z.string(),
+      z.object({
+        fileIds: z.array(z.string()).optional(),
+      }),
+    ])
+    .optional(),
+})
+
+type CodeInterpreterArgs = {
+  /**
+   * The code interpreter container.
+   * Can be a container ID
+   * or an object that specifies uploaded file IDs to make available to your code.
+   */
+  container?: string | { fileIds?: string[] }
+}
+
+export const codeInterpreterToolFactory = createProviderDefinedToolFactoryWithOutputSchema<
+  {
+    /**
+     * The code to run, or null if not available.
+     */
+    code?: string | null
+
+    /**
+     * The ID of the container used to run the code.
+     */
+    containerId: string
+  },
+  {
+    /**
+     * The outputs generated by the code interpreter, such as logs or images.
+     * Can be null if no outputs are available.
+     */
+    outputs?: Array<
+      | {
+          type: "logs"
+
+          /**
+           * The logs output from the code interpreter.
+           */
+          logs: string
+        }
+      | {
+          type: "image"
+
+          /**
+           * The URL of the image output from the code interpreter.
+           */
+          url: string
+        }
+    > | null
+  },
+  CodeInterpreterArgs
+>({
+  id: "openai.code_interpreter",
+  name: "code_interpreter",
+  inputSchema: codeInterpreterInputSchema,
+  outputSchema: codeInterpreterOutputSchema,
+})
+
+export const codeInterpreter = (
+  args: CodeInterpreterArgs = {}, // default
+) => {
+  return codeInterpreterToolFactory(args)
+}

package/src/provider/sdk/openai-compatible/src/responses/tool/file-search.ts

@@ -0,0 +1,128 @@
+import { createProviderDefinedToolFactoryWithOutputSchema } from "@ai-sdk/provider-utils"
+import type {
+  OpenAIResponsesFileSearchToolComparisonFilter,
+  OpenAIResponsesFileSearchToolCompoundFilter,
+} from "../openai-responses-api-types"
+import { z } from "zod/v4"
+
+const comparisonFilterSchema = z.object({
+  key: z.string(),
+  type: z.enum(["eq", "ne", "gt", "gte", "lt", "lte"]),
+  value: z.union([z.string(), z.number(), z.boolean()]),
+})
+
+const compoundFilterSchema: z.ZodType<any> = z.object({
+  type: z.enum(["and", "or"]),
+  filters: z.array(z.union([comparisonFilterSchema, z.lazy(() => compoundFilterSchema)])),
+})
+
+export const fileSearchArgsSchema = z.object({
+  vectorStoreIds: z.array(z.string()),
+  maxNumResults: z.number().optional(),
+  ranking: z
+    .object({
+      ranker: z.string().optional(),
+      scoreThreshold: z.number().optional(),
+    })
+    .optional(),
+  filters: z.union([comparisonFilterSchema, compoundFilterSchema]).optional(),
+})
+
+export const fileSearchOutputSchema = z.object({
+  queries: z.array(z.string()),
+  results: z
+    .array(
+      z.object({
+        attributes: z.record(z.string(), z.unknown()),
+        fileId: z.string(),
+        filename: z.string(),
+        score: z.number(),
+        text: z.string(),
+      }),
+    )
+    .nullable(),
+})
+
+export const fileSearch = createProviderDefinedToolFactoryWithOutputSchema<
+  {},
+  {
+    /**
+     * The search query to execute.
+     */
+    queries: string[]
+
+    /**
+     * The results of the file search tool call.
+     */
+    results:
+      | null
+      | {
+          /**
+           * Set of 16 key-value pairs that can be attached to an object.
+           * This can be useful for storing additional information about the object
+           * in a structured format, and querying for objects via API or the dashboard.
+           * Keys are strings with a maximum length of 64 characters.
+           * Values are strings with a maximum length of 512 characters, booleans, or numbers.
+           */
+          attributes: Record<string, unknown>
+
+          /**
+           * The unique ID of the file.
+           */
+          fileId: string
+
+          /**
+           * The name of the file.
+           */
+          filename: string
+
+          /**
+           * The relevance score of the file - a value between 0 and 1.
+           */
+          score: number
+
+          /**
+           * The text that was retrieved from the file.
+           */
+          text: string
+        }[]
+  },
+  {
+    /**
+     * List of vector store IDs to search through.
+     */
+    vectorStoreIds: string[]
+
+    /**
+     * Maximum number of search results to return. Defaults to 10.
+     */
+    maxNumResults?: number
+
+    /**
+     * Ranking options for the search.
+     */
+    ranking?: {
+      /**
+       * The ranker to use for the file search.
+       */
+      ranker?: string
+
+      /**
+       * The score threshold for the file search, a number between 0 and 1.
+       * Numbers closer to 1 will attempt to return only the most relevant results,
+       * but may return fewer results.
+       */
+      scoreThreshold?: number
+    }
+
+    /**
+     * A filter to apply.
+     */
+    filters?: OpenAIResponsesFileSearchToolComparisonFilter | OpenAIResponsesFileSearchToolCompoundFilter
+  }
+>({
+  id: "openai.file_search",
+  name: "file_search",
+  inputSchema: z.object({}),
+  outputSchema: fileSearchOutputSchema,
+})

package/src/provider/sdk/openai-compatible/src/responses/tool/image-generation.ts

@@ -0,0 +1,115 @@
+import { createProviderDefinedToolFactoryWithOutputSchema } from "@ai-sdk/provider-utils"
+import { z } from "zod/v4"
+
+export const imageGenerationArgsSchema = z
+  .object({
+    background: z.enum(["auto", "opaque", "transparent"]).optional(),
+    inputFidelity: z.enum(["low", "high"]).optional(),
+    inputImageMask: z
+      .object({
+        fileId: z.string().optional(),
+        imageUrl: z.string().optional(),
+      })
+      .optional(),
+    model: z.string().optional(),
+    moderation: z.enum(["auto"]).optional(),
+    outputCompression: z.number().int().min(0).max(100).optional(),
+    outputFormat: z.enum(["png", "jpeg", "webp"]).optional(),
+    partialImages: z.number().int().min(0).max(3).optional(),
+    quality: z.enum(["auto", "low", "medium", "high"]).optional(),
+    size: z.enum(["1024x1024", "1024x1536", "1536x1024", "auto"]).optional(),
+  })
+  .strict()
+
+export const imageGenerationOutputSchema = z.object({
+  result: z.string(),
+})
+
+type ImageGenerationArgs = {
+  /**
+   * Background type for the generated image. Default is 'auto'.
+   */
+  background?: "auto" | "opaque" | "transparent"
+
+  /**
+   * Input fidelity for the generated image. Default is 'low'.
+   */
+  inputFidelity?: "low" | "high"
+
+  /**
+   * Optional mask for inpainting.
+   * Contains image_url (string, optional) and file_id (string, optional).
+   */
+  inputImageMask?: {
+    /**
+     * File ID for the mask image.
+     */
+    fileId?: string
+
+    /**
+     * Base64-encoded mask image.
+     */
+    imageUrl?: string
+  }
+
+  /**
+   * The image generation model to use. Default: gpt-image-1.
+   */
+  model?: string
+
+  /**
+   * Moderation level for the generated image. Default: auto.
+   */
+  moderation?: "auto"
+
+  /**
+   * Compression level for the output image. Default: 100.
+   */
+  outputCompression?: number
+
+  /**
+   * The output format of the generated image. One of png, webp, or jpeg.
+   * Default: png
+   */
+  outputFormat?: "png" | "jpeg" | "webp"
+
+  /**
+   * Number of partial images to generate in streaming mode, from 0 (default value) to 3.
+   */
+  partialImages?: number
+
+  /**
+   * The quality of the generated image.
+   * One of low, medium, high, or auto. Default: auto.
+   */
+  quality?: "auto" | "low" | "medium" | "high"
+
+  /**
+   * The size of the generated image.
+   * One of 1024x1024, 1024x1536, 1536x1024, or auto.
+   * Default: auto.
+   */
+  size?: "auto" | "1024x1024" | "1024x1536" | "1536x1024"
+}
+
+const imageGenerationToolFactory = createProviderDefinedToolFactoryWithOutputSchema<
+  {},
+  {
+    /**
+     * The generated image encoded in base64.
+     */
+    result: string
+  },
+  ImageGenerationArgs
+>({
+  id: "openai.image_generation",
+  name: "image_generation",
+  inputSchema: z.object({}),
+  outputSchema: imageGenerationOutputSchema,
+})
+
+export const imageGeneration = (
+  args: ImageGenerationArgs = {}, // default
+) => {
+  return imageGenerationToolFactory(args)
+}

package/src/provider/sdk/openai-compatible/src/responses/tool/local-shell.ts

@@ -0,0 +1,65 @@
+import { createProviderDefinedToolFactoryWithOutputSchema } from "@ai-sdk/provider-utils"
+import { z } from "zod/v4"
+
+export const localShellInputSchema = z.object({
+  action: z.object({
+    type: z.literal("exec"),
+    command: z.array(z.string()),
+    timeoutMs: z.number().optional(),
+    user: z.string().optional(),
+    workingDirectory: z.string().optional(),
+    env: z.record(z.string(), z.string()).optional(),
+  }),
+})
+
+export const localShellOutputSchema = z.object({
+  output: z.string(),
+})
+
+export const localShell = createProviderDefinedToolFactoryWithOutputSchema<
+  {
+    /**
+     * Execute a shell command on the server.
+     */
+    action: {
+      type: "exec"
+
+      /**
+       * The command to run.
+       */
+      command: string[]
+
+      /**
+       * Optional timeout in milliseconds for the command.
+       */
+      timeoutMs?: number
+
+      /**
+       * Optional user to run the command as.
+       */
+      user?: string
+
+      /**
+       * Optional working directory to run the command in.
+       */
+      workingDirectory?: string
+
+      /**
+       * Environment variables to set for the command.
+       */
+      env?: Record<string, string>
+    }
+  },
+  {
+    /**
+     * The output of local shell tool call.
+     */
+    output: string
+  },
+  {}
+>({
+  id: "openai.local_shell",
+  name: "local_shell",
+  inputSchema: localShellInputSchema,
+  outputSchema: localShellOutputSchema,
+})

package/src/provider/sdk/openai-compatible/src/responses/tool/web-search-preview.ts

@@ -0,0 +1,104 @@
+import { createProviderDefinedToolFactory } from "@ai-sdk/provider-utils"
+import { z } from "zod/v4"
+
+// Args validation schema
+export const webSearchPreviewArgsSchema = z.object({
+  /**
+   * Search context size to use for the web search.
+   * - high: Most comprehensive context, highest cost, slower response
+   * - medium: Balanced context, cost, and latency (default)
+   * - low: Least context, lowest cost, fastest response
+   */
+  searchContextSize: z.enum(["low", "medium", "high"]).optional(),
+
+  /**
+   * User location information to provide geographically relevant search results.
+   */
+  userLocation: z
+    .object({
+      /**
+       * Type of location (always 'approximate')
+       */
+      type: z.literal("approximate"),
+      /**
+       * Two-letter ISO country code (e.g., 'US', 'GB')
+       */
+      country: z.string().optional(),
+      /**
+       * City name (free text, e.g., 'Minneapolis')
+       */
+      city: z.string().optional(),
+      /**
+       * Region name (free text, e.g., 'Minnesota')
+       */
+      region: z.string().optional(),
+      /**
+       * IANA timezone (e.g., 'America/Chicago')
+       */
+      timezone: z.string().optional(),
+    })
+    .optional(),
+})
+
+export const webSearchPreview = createProviderDefinedToolFactory<
+  {
+    // Web search doesn't take input parameters - it's controlled by the prompt
+  },
+  {
+    /**
+     * Search context size to use for the web search.
+     * - high: Most comprehensive context, highest cost, slower response
+     * - medium: Balanced context, cost, and latency (default)
+     * - low: Least context, lowest cost, fastest response
+     */
+    searchContextSize?: "low" | "medium" | "high"
+
+    /**
+     * User location information to provide geographically relevant search results.
+     */
+    userLocation?: {
+      /**
+       * Type of location (always 'approximate')
+       */
+      type: "approximate"
+      /**
+       * Two-letter ISO country code (e.g., 'US', 'GB')
+       */
+      country?: string
+      /**
+       * City name (free text, e.g., 'Minneapolis')
+       */
+      city?: string
+      /**
+       * Region name (free text, e.g., 'Minnesota')
+       */
+      region?: string
+      /**
+       * IANA timezone (e.g., 'America/Chicago')
+       */
+      timezone?: string
+    }
+  }
+>({
+  id: "openai.web_search_preview",
+  name: "web_search_preview",
+  inputSchema: z.object({
+    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(),
+  }),
+})