fix(build): rename LoopToolCallRequest/Result to avoid barrel collision, fix Buffer→Uint8Array in speech providers

Author: jddunn

src/orchestration/__tests__/loop-controller.test.ts

@@ -18,8 +18,8 @@ import type {
   LoopContext,
   LoopChunk,
   LoopOutput,
-  ToolCallRequest,
-  ToolCallResult,
+  LoopToolCallRequest,
+  LoopToolCallResult,
 } from '../runtime/LoopController.js';
 
 // ---------------------------------------------------------------------------
@@ -67,15 +67,15 @@ function createMockContext(
   toolCallsPerIteration = 1,
 ) {
   let calls = 0;
-  const addedResults: ToolCallResult[][] = [];
+  const addedResults: LoopToolCallResult[][] = [];
 
   const context: LoopContext = {
     generateStream: async function* () {
       calls++;
 
       if (calls <= toolCallIterations) {
         // Build N tool calls for this iteration.
-        const tc: ToolCallRequest[] = Array.from(
+        const tc: LoopToolCallRequest[] = Array.from(
           { length: toolCallsPerIteration },
           (_, j) => ({
             id: `tc-${calls}-${j}`,
@@ -100,7 +100,7 @@ function createMockContext(
       } satisfies LoopOutput;
     },
 
-    executeTool: vi.fn<[ToolCallRequest], Promise<ToolCallResult>>().mockImplementation(
+    executeTool: vi.fn<[LoopToolCallRequest], Promise<LoopToolCallResult>>().mockImplementation(
       async (tc) => ({
         id: tc.id,
         name: tc.name,
@@ -109,7 +109,7 @@ function createMockContext(
       }),
     ),
 
-    addToolResults: vi.fn((results: ToolCallResult[]) => {
+    addToolResults: vi.fn((results: LoopToolCallResult[]) => {
       addedResults.push(results);
     }),
   };
@@ -198,7 +198,7 @@ describe('LoopController', () => {
       name: 'test_tool',
       success: false,
       error: 'something went wrong',
-    } satisfies ToolCallResult);
+    } satisfies LoopToolCallResult);
 
     const controller = new LoopController();
     const config = baseConfig({ failureMode: 'fail_closed' });
@@ -221,7 +221,7 @@ describe('LoopController', () => {
       name: 'test_tool',
       success: false,
       error: 'transient error',
-    } satisfies ToolCallResult);
+    } satisfies LoopToolCallResult);
 
     const events = await collectEvents(baseConfig({ failureMode: 'fail_open' }), context);
 
@@ -246,7 +246,7 @@ describe('LoopController', () => {
 
     // Override executeTool to track concurrent invocations
     (context.executeTool as ReturnType<typeof vi.fn>).mockImplementation(
-      async (tc: ToolCallRequest): Promise<ToolCallResult> => {
+      async (tc: LoopToolCallRequest): Promise<LoopToolCallResult> => {
         const idx = dispatchOrder.length;
         dispatchOrder.push(idx);
 

src/orchestration/runtime/LoopController.ts

@@ -68,13 +68,13 @@ export interface LoopContext {
    * Implementations should never throw — instead return a result with
    * `success: false` and a populated `error` field.
    */
-  executeTool: (toolCall: ToolCallRequest) => Promise<ToolCallResult>;
+  executeTool: (toolCall: LoopToolCallRequest) => Promise<LoopToolCallResult>;
 
   /**
    * Feed tool results back into the conversation so the next `generateStream`
    * call has access to them. Typically appends tool messages to the message list.
    */
-  addToolResults: (results: ToolCallResult[]) => void;
+  addToolResults: (results: LoopToolCallResult[]) => void;
 }
 
 // ---------------------------------------------------------------------------
@@ -84,7 +84,7 @@ export interface LoopContext {
 /**
  * A single tool invocation requested by the LLM.
  */
-export interface ToolCallRequest {
+export interface LoopToolCallRequest {
   /** Unique identifier for this tool call within a response (matches the tool result). */
   id: string;
 
@@ -96,10 +96,10 @@ export interface ToolCallRequest {
 }
 
 /**
- * The outcome of executing a {@link ToolCallRequest}.
+ * The outcome of executing a {@link LoopToolCallRequest}.
  */
-export interface ToolCallResult {
-  /** Matches the originating {@link ToolCallRequest.id}. */
+export interface LoopToolCallResult {
+  /** Matches the originating {@link LoopToolCallRequest.id}. */
   id: string;
 
   /** Name of the tool that was called. */
@@ -134,7 +134,7 @@ export interface LoopChunk {
   content?: string;
 
   /** Present when `type === 'tool_call_request'`. */
-  toolCalls?: ToolCallRequest[];
+  toolCalls?: LoopToolCallRequest[];
 }
 
 /**
@@ -149,7 +149,7 @@ export interface LoopOutput {
    * All tool calls requested in this iteration. An empty array signals that
    * the LLM is done and the loop should terminate.
    */
-  toolCalls: ToolCallRequest[];
+  toolCalls: LoopToolCallRequest[];
 
   /**
    * The LLM finish reason (e.g. `'stop'`, `'tool_calls'`, `'length'`).
@@ -168,8 +168,8 @@ export interface LoopOutput {
  */
 export type LoopEvent =
   | { type: 'text_delta'; content: string }
-  | { type: 'tool_call_request'; toolCalls: ToolCallRequest[] }
-  | { type: 'tool_result'; toolName: string; result: ToolCallResult }
+  | { type: 'tool_call_request'; toolCalls: LoopToolCallRequest[] }
+  | { type: 'tool_result'; toolName: string; result: LoopToolCallResult }
   | { type: 'tool_error'; toolName: string; error: string }
   | { type: 'max_iterations_reached'; iteration: number }
   | { type: 'loop_complete'; totalIterations: number };
@@ -249,7 +249,7 @@ export class LoopController {
       // Act phase: execute tool calls (parallel or sequential).
       // ------------------------------------------------------------------
       const toolCalls = gmiOutput.toolCalls;
-      let results: ToolCallResult[];
+      let results: LoopToolCallResult[];
 
       if (config.parallelTools) {
         // Dispatch all tool calls simultaneously; collect all outcomes even
@@ -261,7 +261,7 @@ export class LoopController {
         results = settled.map((s, i) => {
           if (s.status === 'fulfilled') return s.value;
 
-          // Convert a rejected promise into a failed ToolCallResult so
+          // Convert a rejected promise into a failed LoopToolCallResult so
           // downstream handling is uniform.
           return {
             id: toolCalls[i].id,

src/orchestration/runtime/index.ts

@@ -13,8 +13,8 @@ export type {
   LoopConfig,
   LoopContext,
   LoopEvent,
-  ToolCallRequest,
-  ToolCallResult,
+  LoopToolCallRequest,
+  LoopToolCallResult,
 } from './LoopController.js';
 export { NodeExecutor } from './NodeExecutor.js';
 export type { NodeExecutionResult } from './NodeExecutor.js';

src/speech/providers/AssemblyAISTTProvider.ts

@@ -125,7 +125,7 @@ export class AssemblyAISTTProvider implements SpeechToTextProvider {
         Authorization: this.config.apiKey,
         'Content-Type': audio.mimeType ?? 'audio/wav',
       },
-      body: audio.data,
+      body: audio.data instanceof Buffer ? new Uint8Array(audio.data) : audio.data,
       signal,
     });
 

src/speech/providers/AzureSpeechSTTProvider.ts

@@ -93,7 +93,7 @@ export class AzureSpeechSTTProvider implements SpeechToTextProvider {
         'Ocp-Apim-Subscription-Key': key,
         'Content-Type': 'audio/wav',
       },
-      body: audio.data,
+      body: audio.data instanceof Buffer ? new Uint8Array(audio.data) : audio.data,
     });
 
     if (!response.ok) {

src/speech/providers/DeepgramBatchSTTProvider.ts

@@ -138,7 +138,7 @@ export class DeepgramBatchSTTProvider implements SpeechToTextProvider {
         Authorization: `Token ${this.config.apiKey}`,
         'Content-Type': contentType,
       },
-      body: audio.data,
+      body: audio.data instanceof Buffer ? new Uint8Array(audio.data) : audio.data,
     });
 
     if (!response.ok) {