@depup/ai-sdk__openai 3.0.41-depup.0

package/src/tool/file-search.ts

@@ -0,0 +1,145 @@
+import {
+  createProviderToolFactoryWithOutputSchema,
+  lazySchema,
+  zodSchema,
+} from '@ai-sdk/provider-utils';
+import { z } from 'zod/v4';
+import {
+  OpenAIResponsesFileSearchToolComparisonFilter,
+  OpenAIResponsesFileSearchToolCompoundFilter,
+} from '../responses/openai-responses-api';
+
+const comparisonFilterSchema = z.object({
+  key: z.string(),
+  type: z.enum(['eq', 'ne', 'gt', 'gte', 'lt', 'lte', 'in', 'nin']),
+  value: z.union([z.string(), z.number(), z.boolean(), z.array(z.string())]),
+});
+
+const compoundFilterSchema: z.ZodType<any> = z.object({
+  type: z.enum(['and', 'or']),
+  filters: z.array(
+    z.union([comparisonFilterSchema, z.lazy(() => compoundFilterSchema)]),
+  ),
+});
+
+export const fileSearchArgsSchema = lazySchema(() =>
+  zodSchema(
+    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 = lazySchema(() =>
+  zodSchema(
+    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 = createProviderToolFactoryWithOutputSchema<
+  {},
+  {
+    /**
+     * 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',
+  inputSchema: z.object({}),
+  outputSchema: fileSearchOutputSchema,
+});

package/src/tool/image-generation.ts

@@ -0,0 +1,126 @@
+import {
+  createProviderToolFactoryWithOutputSchema,
+  lazySchema,
+  zodSchema,
+} from '@ai-sdk/provider-utils';
+import { z } from 'zod/v4';
+
+export const imageGenerationArgsSchema = lazySchema(() =>
+  zodSchema(
+    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(),
+  ),
+);
+
+const imageGenerationInputSchema = lazySchema(() => zodSchema(z.object({})));
+
+export const imageGenerationOutputSchema = lazySchema(() =>
+  zodSchema(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 = createProviderToolFactoryWithOutputSchema<
+  {},
+  {
+    /**
+     * The generated image encoded in base64.
+     */
+    result: string;
+  },
+  ImageGenerationArgs
+>({
+  id: 'openai.image_generation',
+  inputSchema: imageGenerationInputSchema,
+  outputSchema: imageGenerationOutputSchema,
+});
+
+export const imageGeneration = (
+  args: ImageGenerationArgs = {}, // default
+) => {
+  return imageGenerationToolFactory(args);
+};

package/src/tool/local-shell.ts

@@ -0,0 +1,72 @@
+import {
+  createProviderToolFactoryWithOutputSchema,
+  lazySchema,
+  zodSchema,
+} from '@ai-sdk/provider-utils';
+import { z } from 'zod/v4';
+
+export const localShellInputSchema = lazySchema(() =>
+  zodSchema(
+    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 = lazySchema(() =>
+  zodSchema(z.object({ output: z.string() })),
+);
+
+export const localShell = createProviderToolFactoryWithOutputSchema<
+  {
+    /**
+     * 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',
+  inputSchema: localShellInputSchema,
+  outputSchema: localShellOutputSchema,
+});

package/src/tool/mcp.ts

@@ -0,0 +1,125 @@
+import {
+  createProviderToolFactoryWithOutputSchema,
+  lazySchema,
+  zodSchema,
+} from '@ai-sdk/provider-utils';
+import { JSONValue } from '@ai-sdk/provider';
+import { z } from 'zod/v4';
+
+const jsonValueSchema: z.ZodType<JSONValue> = z.lazy(() =>
+  z.union([
+    z.string(),
+    z.number(),
+    z.boolean(),
+    z.null(),
+    z.array(jsonValueSchema),
+    z.record(z.string(), jsonValueSchema),
+  ]),
+);
+
+export const mcpArgsSchema = lazySchema(() =>
+  zodSchema(
+    z
+      .object({
+        serverLabel: z.string(),
+        allowedTools: z
+          .union([
+            z.array(z.string()),
+            z.object({
+              readOnly: z.boolean().optional(),
+              toolNames: z.array(z.string()).optional(),
+            }),
+          ])
+          .optional(),
+        authorization: z.string().optional(),
+        connectorId: z.string().optional(),
+        headers: z.record(z.string(), z.string()).optional(),
+
+        requireApproval: z
+          .union([
+            z.enum(['always', 'never']),
+            z.object({
+              never: z
+                .object({
+                  toolNames: z.array(z.string()).optional(),
+                })
+                .optional(),
+            }),
+          ])
+          .optional(),
+        serverDescription: z.string().optional(),
+        serverUrl: z.string().optional(),
+      })
+      .refine(
+        v => v.serverUrl != null || v.connectorId != null,
+        'One of serverUrl or connectorId must be provided.',
+      ),
+  ),
+);
+
+const mcpInputSchema = lazySchema(() => zodSchema(z.object({})));
+
+export const mcpOutputSchema = lazySchema(() =>
+  zodSchema(
+    z.object({
+      type: z.literal('call'),
+      serverLabel: z.string(),
+      name: z.string(),
+      arguments: z.string(),
+      output: z.string().nullish(),
+      error: z.union([z.string(), jsonValueSchema]).optional(),
+    }),
+  ),
+);
+
+type McpArgs = {
+  /** A label for this MCP server, used to identify it in tool calls. */
+  serverLabel: string;
+  /** List of allowed tool names or a filter object. */
+  allowedTools?:
+    | string[]
+    | {
+        readOnly?: boolean;
+        toolNames?: string[];
+      };
+  /** OAuth access token usable with the remote MCP server or connector. */
+  authorization?: string;
+  /** Identifier for a service connector. */
+  connectorId?: string;
+  /** Optional HTTP headers to send to the MCP server. */
+  headers?: Record<string, string>;
+  /**
+   * Which tools require approval before execution.
+   */
+  requireApproval?:
+    | 'always'
+    | 'never'
+    | {
+        never?: {
+          toolNames?: string[];
+        };
+      };
+  /** Optional description of the MCP server. */
+  serverDescription?: string;
+  /** URL for the MCP server. One of serverUrl or connectorId must be provided. */
+  serverUrl?: string;
+};
+
+export const mcpToolFactory = createProviderToolFactoryWithOutputSchema<
+  {},
+  {
+    type: 'call';
+    serverLabel: string;
+    name: string;
+    arguments: string;
+    output?: string | null;
+    error?: JSONValue;
+  },
+  McpArgs
+>({
+  id: 'openai.mcp',
+  inputSchema: mcpInputSchema,
+  outputSchema: mcpOutputSchema,
+});
+
+export const mcp = (args: McpArgs) => mcpToolFactory(args);

package/src/tool/shell.ts

@@ -0,0 +1,203 @@
+import {
+  createProviderToolFactoryWithOutputSchema,
+  lazySchema,
+  zodSchema,
+} from '@ai-sdk/provider-utils';
+import { z } from 'zod/v4';
+
+export const shellInputSchema = lazySchema(() =>
+  zodSchema(
+    z.object({
+      action: z.object({
+        commands: z.array(z.string()),
+        timeoutMs: z.number().optional(),
+        maxOutputLength: z.number().optional(),
+      }),
+    }),
+  ),
+);
+
+export const shellOutputSchema = lazySchema(() =>
+  zodSchema(
+    z.object({
+      output: z.array(
+        z.object({
+          stdout: z.string(),
+          stderr: z.string(),
+          outcome: z.discriminatedUnion('type', [
+            z.object({ type: z.literal('timeout') }),
+            z.object({ type: z.literal('exit'), exitCode: z.number() }),
+          ]),
+        }),
+      ),
+    }),
+  ),
+);
+
+const shellSkillsSchema = z
+  .array(
+    z.discriminatedUnion('type', [
+      z.object({
+        type: z.literal('skillReference'),
+        skillId: z.string(),
+        version: z.string().optional(),
+      }),
+      z.object({
+        type: z.literal('inline'),
+        name: z.string(),
+        description: z.string(),
+        source: z.object({
+          type: z.literal('base64'),
+          mediaType: z.literal('application/zip'),
+          data: z.string(),
+        }),
+      }),
+    ]),
+  )
+  .optional();
+
+export const shellArgsSchema = lazySchema(() =>
+  zodSchema(
+    z.object({
+      environment: z
+        .union([
+          z.object({
+            type: z.literal('containerAuto'),
+            fileIds: z.array(z.string()).optional(),
+            memoryLimit: z.enum(['1g', '4g', '16g', '64g']).optional(),
+            networkPolicy: z
+              .discriminatedUnion('type', [
+                z.object({ type: z.literal('disabled') }),
+                z.object({
+                  type: z.literal('allowlist'),
+                  allowedDomains: z.array(z.string()),
+                  domainSecrets: z
+                    .array(
+                      z.object({
+                        domain: z.string(),
+                        name: z.string(),
+                        value: z.string(),
+                      }),
+                    )
+                    .optional(),
+                }),
+              ])
+              .optional(),
+            skills: shellSkillsSchema,
+          }),
+          z.object({
+            type: z.literal('containerReference'),
+            containerId: z.string(),
+          }),
+          z.object({
+            type: z.literal('local').optional(),
+            skills: z
+              .array(
+                z.object({
+                  name: z.string(),
+                  description: z.string(),
+                  path: z.string(),
+                }),
+              )
+              .optional(),
+          }),
+        ])
+        .optional(),
+    }),
+  ),
+);
+
+type ShellArgs = {
+  environment?:
+    | {
+        type: 'containerAuto';
+        fileIds?: string[];
+        memoryLimit?: '1g' | '4g' | '16g' | '64g';
+        networkPolicy?:
+          | { type: 'disabled' }
+          | {
+              type: 'allowlist';
+              allowedDomains: string[];
+              domainSecrets?: Array<{
+                domain: string;
+                name: string;
+                value: string;
+              }>;
+            };
+        skills?: Array<
+          | { type: 'skillReference'; skillId: string; version?: string }
+          | {
+              type: 'inline';
+              name: string;
+              description: string;
+              source: {
+                type: 'base64';
+                mediaType: 'application/zip';
+                data: string;
+              };
+            }
+        >;
+      }
+    | {
+        type: 'containerReference';
+        containerId: string;
+      }
+    | {
+        type?: 'local';
+        skills?: Array<{
+          name: string;
+          description: string;
+          path: string;
+        }>;
+      };
+};
+
+export const shell = createProviderToolFactoryWithOutputSchema<
+  {
+    /**
+     * Shell tool action containing commands to execute.
+     */
+    action: {
+      /**
+       * A list of shell commands to execute.
+       */
+      commands: string[];
+
+      /**
+       * Optional timeout in milliseconds for the commands.
+       */
+      timeoutMs?: number;
+
+      /**
+       * Optional maximum number of characters to return from each command.
+       */
+      maxOutputLength?: number;
+    };
+  },
+  {
+    /**
+     * An array of shell call output contents.
+     */
+    output: Array<{
+      /**
+       * Standard output from the command.
+       */
+      stdout: string;
+
+      /**
+       * Standard error from the command.
+       */
+      stderr: string;
+
+      /**
+       * The outcome of the shell execution - either timeout or exit with code.
+       */
+      outcome: { type: 'timeout' } | { type: 'exit'; exitCode: number };
+    }>;
+  },
+  ShellArgs
+>({
+  id: 'openai.shell',
+  inputSchema: shellInputSchema,
+  outputSchema: shellOutputSchema,
+});