fix: address CodeRabbit review comments

- responses-text: remove unsafe `any` cast for call_id, fix overly
  restrictive item.id guard on function_call handling
- transcription: add ensureFileSupport() and decodeBase64() helpers
  for cross-environment safety (Node < 20, missing atob)
- schema-converter.test: rename misleading oneOf test name
- env.test: use unique generated keys for deterministic assertions

Author: AlemTuzlak

packages/typescript/ai-groq/tests/schema-converter.test.ts

@@ -29,7 +29,7 @@ describe('makeGroqStructuredOutputCompatible', () => {
     expect(objectVariant.required).toBeUndefined()
   })
 
-  it('should remove empty required arrays inside oneOf variants', () => {
+  it('should not have any empty required arrays in nested structures', () => {
     const schema = {
       type: 'object',
       properties: {

packages/typescript/ai-utils/tests/env.test.ts

@@ -12,7 +12,8 @@ describe('getApiKeyFromEnv', () => {
   })
 
   it('should throw if the env var is not set', () => {
-    expect(() => getApiKeyFromEnv('NONEXISTENT_KEY')).toThrow('NONEXISTENT_KEY')
+    const missingKey = `__AI_UTILS_TEST_MISSING_${Date.now()}__`
+    expect(() => getApiKeyFromEnv(missingKey)).toThrow(missingKey)
   })
 
   it('should throw if the env var is empty string', () => {
@@ -21,8 +22,7 @@ describe('getApiKeyFromEnv', () => {
   })
 
   it('should include the env var name in the error message', () => {
-    expect(() => getApiKeyFromEnv('MY_PROVIDER_API_KEY')).toThrow(
-      'MY_PROVIDER_API_KEY',
-    )
+    const providerKey = `__AI_UTILS_TEST_PROVIDER_${Date.now()}__`
+    expect(() => getApiKeyFromEnv(providerKey)).toThrow(providerKey)
   })
 })

packages/typescript/openai-base/src/adapters/responses-text.ts

@@ -556,12 +556,17 @@ export class OpenAICompatibleResponsesTextAdapter<
         // handle output_item.added to capture function call metadata (name)
         if (chunk.type === 'response.output_item.added') {
           const item = chunk.item
-          if (item.type === 'function_call' && item.id) {
-            // Use call_id for tool call correlation (required for function_call_output)
-            const callId = (item as any).call_id || item.id
+          if (item.type === 'function_call') {
+            // call_id is the required correlation ID for function_call_output.
+            // id is the internal item ID used by delta/done events (item_id).
+            // Use id when available (for the metadata map keyed by item_id),
+            // falling back to call_id for providers that omit id.
+            const itemId = item.id || item.call_id
+            const callId = item.call_id || item.id || ''
+
             // Store the function name for later use
-            if (!toolCallMetadata.has(item.id)) {
-              toolCallMetadata.set(item.id, {
+            if (!toolCallMetadata.has(itemId)) {
+              toolCallMetadata.set(itemId, {
                 index: chunk.output_index,
                 name: item.name || '',
                 callId,
@@ -577,7 +582,7 @@ export class OpenAICompatibleResponsesTextAdapter<
               timestamp,
               index: chunk.output_index,
             }
-            toolCallMetadata.get(item.id)!.started = true
+            toolCallMetadata.get(itemId)!.started = true
           }
         }
 

packages/typescript/openai-base/src/adapters/transcription.ts

@@ -110,54 +110,82 @@ export class OpenAICompatibleTranscriptionAdapter<
 
     // If Blob, convert to File
     if (typeof Blob !== 'undefined' && audio instanceof Blob) {
+      this.ensureFileSupport()
       return new File([audio], 'audio.mp3', {
         type: audio.type || 'audio/mpeg',
       })
     }
 
     // If ArrayBuffer, convert to File
     if (typeof ArrayBuffer !== 'undefined' && audio instanceof ArrayBuffer) {
+      this.ensureFileSupport()
       return new File([audio], 'audio.mp3', { type: 'audio/mpeg' })
     }
 
     // If base64 string, decode and convert to File
     if (typeof audio === 'string') {
+      this.ensureFileSupport()
+
       // Check if it's a data URL
       if (audio.startsWith('data:')) {
         const parts = audio.split(',')
         const header = parts[0]
         const base64Data = parts[1] || ''
         const mimeMatch = header?.match(/data:([^;]+)/)
         const mimeType = mimeMatch?.[1] || 'audio/mpeg'
-        if (typeof atob !== 'function') {
-          throw new Error(
-            'atob is not available in this environment. Use a File, Blob, or ArrayBuffer input instead.',
-          )
-        }
-        const binaryStr = atob(base64Data)
-        const bytes = new Uint8Array(binaryStr.length)
-        for (let i = 0; i < binaryStr.length; i++) {
-          bytes[i] = binaryStr.charCodeAt(i)
-        }
+        const bytes = this.decodeBase64(base64Data)
         const extension = mimeType.split('/')[1] || 'mp3'
         return new File([bytes], `audio.${extension}`, { type: mimeType })
       }
 
       // Assume raw base64
-      if (typeof atob !== 'function') {
-        throw new Error(
-          'atob is not available in this environment. Use a File, Blob, or ArrayBuffer input instead.',
-        )
-      }
-      const binaryStr = atob(audio)
+      const bytes = this.decodeBase64(audio)
+      return new File([bytes], 'audio.mp3', { type: 'audio/mpeg' })
+    }
+
+    throw new Error('Invalid audio input type')
+  }
+
+  /**
+   * Checks that the global `File` constructor is available.
+   * Throws a descriptive error in environments that lack it (e.g. Node < 20).
+   */
+  private ensureFileSupport(): void {
+    if (typeof File === 'undefined') {
+      throw new Error(
+        '`File` is not available in this environment. ' +
+          'Use Node.js 20 or newer, or pass a File object directly.',
+      )
+    }
+  }
+
+  /**
+   * Decodes a base64 string to an ArrayBuffer.
+   * Uses `atob` when available, falling back to `Buffer.from` in Node.js.
+   */
+  private decodeBase64(base64: string): ArrayBuffer {
+    if (typeof atob === 'function') {
+      const binaryStr = atob(base64)
       const bytes = new Uint8Array(binaryStr.length)
       for (let i = 0; i < binaryStr.length; i++) {
         bytes[i] = binaryStr.charCodeAt(i)
       }
-      return new File([bytes], 'audio.mp3', { type: 'audio/mpeg' })
+      return bytes.buffer as ArrayBuffer
     }
 
-    throw new Error('Invalid audio input type')
+    // Node.js fallback
+    if (typeof Buffer !== 'undefined') {
+      const buf = Buffer.from(base64, 'base64')
+      return buf.buffer.slice(
+        buf.byteOffset,
+        buf.byteOffset + buf.byteLength,
+      ) as ArrayBuffer
+    }
+
+    throw new Error(
+      'Neither `atob` nor `Buffer` is available in this environment. ' +
+        'Use a File, Blob, or ArrayBuffer input instead.',
+    )
   }
 
   /**