@ai-sdk/openai 3.0.28 → 3.0.30

package/src/responses/openai-responses-prepare-tools.ts

@@ -8,6 +8,7 @@ import { codeInterpreterArgsSchema } from '../tool/code-interpreter';
 import { fileSearchArgsSchema } from '../tool/file-search';
 import { imageGenerationArgsSchema } from '../tool/image-generation';
 import { mcpArgsSchema } from '../tool/mcp';
+import { shellArgsSchema } from '../tool/shell';
 import { webSearchArgsSchema } from '../tool/web-search';
 import { webSearchPreviewArgsSchema } from '../tool/web-search-preview';
 import { OpenAIResponsesTool } from './openai-responses-api';
@@ -86,8 +87,16 @@ export async function prepareResponsesTools({
             break;
           }
           case 'openai.shell': {
+            const args = await validateTypes({
+              value: tool.args,
+              schema: shellArgsSchema,
+            });
+
             openaiTools.push({
               type: 'shell',
+              ...(args.environment && {
+                environment: mapShellEnvironment(args.environment),
+              }),
             });
             break;
           }
@@ -262,3 +271,108 @@ export async function prepareResponsesTools({
     }
   }
 }
+
+function mapShellEnvironment(environment: {
+  type?: string;
+  [key: string]: unknown;
+}): NonNullable<
+  Extract<OpenAIResponsesTool, { type: 'shell' }>['environment']
+> {
+  if (environment.type === 'containerReference') {
+    const env = environment as {
+      type: 'containerReference';
+      containerId: string;
+    };
+    return {
+      type: 'container_reference',
+      container_id: env.containerId,
+    };
+  }
+
+  if (environment.type === 'containerAuto') {
+    const env = environment as {
+      type: 'containerAuto';
+      fileIds?: string[];
+      memoryLimit?: '1g' | '4g' | '16g' | '64g';
+      networkPolicy?: {
+        type: string;
+        allowedDomains?: string[];
+        domainSecrets?: Array<{
+          domain: string;
+          name: string;
+          value: string;
+        }>;
+      };
+      skills?: Array<{
+        type: string;
+        skillId?: string;
+        version?: string;
+        name?: string;
+        description?: string;
+        source?: { type: string; mediaType: string; data: string };
+      }>;
+    };
+
+    return {
+      type: 'container_auto',
+      file_ids: env.fileIds,
+      memory_limit: env.memoryLimit,
+      network_policy:
+        env.networkPolicy == null
+          ? undefined
+          : env.networkPolicy.type === 'disabled'
+            ? { type: 'disabled' as const }
+            : {
+                type: 'allowlist' as const,
+                allowed_domains: env.networkPolicy.allowedDomains!,
+                domain_secrets: env.networkPolicy.domainSecrets,
+              },
+      skills: mapShellSkills(env.skills),
+    };
+  }
+
+  const env = environment as {
+    type?: 'local';
+    skills?: Array<{
+      name: string;
+      description: string;
+      path: string;
+    }>;
+  };
+  return {
+    type: 'local',
+    skills: env.skills,
+  };
+}
+
+function mapShellSkills(
+  skills:
+    | Array<{
+        type: string;
+        skillId?: string;
+        version?: string;
+        name?: string;
+        description?: string;
+        source?: { type: string; mediaType: string; data: string };
+      }>
+    | undefined,
+) {
+  return skills?.map(skill =>
+    skill.type === 'skillReference'
+      ? {
+          type: 'skill_reference' as const,
+          skill_id: skill.skillId!,
+          version: skill.version,
+        }
+      : {
+          type: 'inline' as const,
+          name: skill.name!,
+          description: skill.description!,
+          source: {
+            type: 'base64' as const,
+            media_type: skill.source!.mediaType as 'application/zip',
+            data: skill.source!.data,
+          },
+        },
+  );
+}

package/src/tool/shell.ts

@@ -34,6 +34,124 @@ export const shellOutputSchema = lazySchema(() =>
   ),
 );
 
+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<
   {
     /**
@@ -77,7 +195,7 @@ export const shell = createProviderToolFactoryWithOutputSchema<
       outcome: { type: 'timeout' } | { type: 'exit'; exitCode: number };
     }>;
   },
-  {}
+  ShellArgs
 >({
   id: 'openai.shell',
   inputSchema: shellInputSchema,