@bloxystudios/bloxycode 1.0.1 → 1.0.4

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

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

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

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

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

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

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

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

@@ -1,104 +0,0 @@
-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(),
-  }),
-})