improve shape of turn context

Author: mattapperson

src/index.ts

@@ -24,7 +24,6 @@ export type {
   StopCondition,
   StopWhen,
   Tool,
-  ToolCallInfo,
   ToolPreliminaryResultEvent,
   ToolStreamEvent,
   ToolWithExecute,

src/lib/model-result.ts

@@ -157,9 +157,6 @@ export class ModelResult {
       // Build initial turn context (turn 0 for initial request)
       const initialContext: TurnContext = {
         numberOfTurns: 0,
-        input: [],
-        model: undefined,
-        models: undefined,
       };
 
       // Resolve any async functions first
@@ -248,8 +245,6 @@ export class ModelResult {
 
       let currentResponse = initialResponse;
       let currentRound = 0;
-      let currentInput: models.OpenResponsesInput =
-        (this.options.request as models.OpenResponsesRequest).input || [];
 
       while (true) {
         const currentToolCalls = extractToolCallsFromResponse(currentResponse);
@@ -274,17 +269,9 @@ export class ModelResult {
           response: currentResponse,
         });
 
-        // Build turn context for this round
-        const resolvedRequest = this.options.request as models.OpenResponsesRequest;
+        // Build turn context for this round (for async parameter resolution only)
         const turnContext: TurnContext = {
           numberOfTurns: currentRound + 1, // 1-indexed
-          input: currentInput,
-          ...(resolvedRequest.model && {
-            model: resolvedRequest.model,
-          }),
-          ...(resolvedRequest.models && {
-            models: resolvedRequest.models,
-          }),
         };
 
         // Resolve async functions for this turn
@@ -353,9 +340,6 @@ export class ModelResult {
           ...toolResults,
         ];
 
-        // Update current input for next iteration
-        currentInput = newInput;
-
         // Make new request with tool results
         const newRequest: models.OpenResponsesRequest = {
           ...(this.options.request as models.OpenResponsesRequest),

src/lib/tool-orchestrator.ts

@@ -104,12 +104,31 @@ export async function executeToolLoop(
         return null;
       }
 
-      // Build turn context
+      // Find the raw tool call from the response output
+      const rawToolCall = currentResponse.output.find(
+        (item): item is models.ResponsesOutputItemFunctionCall =>
+          'type' in item && item.type === 'function_call' && item.callId === toolCall.id
+      );
+
+      if (!rawToolCall) {
+        throw new Error(`Could not find raw tool call for ${toolCall.id}`);
+      }
+
+      // Convert to OpenResponsesFunctionToolCall format
+      const openResponsesToolCall: models.OpenResponsesFunctionToolCall = {
+        type: 'function_call' as const,
+        callId: rawToolCall.callId,
+        name: rawToolCall.name,
+        arguments: rawToolCall.arguments,
+        id: rawToolCall.callId,
+        status: rawToolCall.status,
+      };
+
+      // Build turn context with full information
       const turnContext = buildTurnContext({
         numberOfTurns: currentRound,
-        messageHistory: conversationInput,
-        model: currentRequest.model,
-        models: currentRequest.models,
+        toolCall: openResponsesToolCall,
+        turnRequest: currentRequest,
       });
 
       // Execute the tool

src/lib/tool-types.ts

@@ -11,14 +11,16 @@ export enum ToolType {
 }
 
 /**
- * Turn context passed to tool execute functions
+ * Turn context passed to tool execute functions and async parameter resolution
  * Contains information about the current conversation state
  */
 export interface TurnContext {
-  toolCall: models.OpenResponsesFunctionToolCall;
-  /** Number of tool execution turns so far (1-indexed: first turn = 1) */
+  /** The specific tool call being executed (only available during tool execution) */
+  toolCall?: models.OpenResponsesFunctionToolCall;
+  /** Number of tool execution turns so far (1-indexed: first turn = 1, 0 = initial request) */
   numberOfTurns: number;
-  turnRequest: models.OpenResponsesRequest;
+  /** The full request being sent to the API (only available during tool execution) */
+  turnRequest?: models.OpenResponsesRequest;
 }
 
 /**
@@ -56,16 +58,6 @@ export type NextTurnParamsFunctions<TInput> = {
   ) => NextTurnParamsContext[K] | Promise<NextTurnParamsContext[K]>;
 };
 
-/**
- * Information about a tool call needed for nextTurnParams execution
- */
-export interface ToolCallInfo {
-  id: string;
-  name: string;
-  arguments: unknown;
-  tool: Tool;
-}
-
 /**
  * Base tool function interface with inputSchema
  */

src/lib/turn-context.ts

@@ -5,38 +5,49 @@ import type { TurnContext } from './tool-types.js';
  * Options for building a turn context
  */
 export interface BuildTurnContextOptions {
-  /** Number of turns so far (1-indexed) */
+  /** Number of turns so far (1-indexed for tool execution, 0 for initial request) */
   numberOfTurns: number;
-  /** Current message history */
-  messageHistory: models.OpenResponsesInput;
-  /** Current model (if set) */
-  model?: string | undefined;
-  /** Current models array (if set) */
-  models?: string[] | undefined;
+  /** The specific tool call being executed (optional for initial/async resolution contexts) */
+  toolCall?: models.OpenResponsesFunctionToolCall;
+  /** The full request being sent to the API (optional for initial/async resolution contexts) */
+  turnRequest?: models.OpenResponsesRequest;
 }
 
 /**
- * Build a turn context for tool execution
+ * Build a turn context for tool execution or async parameter resolution
  *
  * @param options - Options for building the context
  * @returns A TurnContext object
  *
  * @example
  * ```typescript
+ * // For tool execution with full context
  * const context = buildTurnContext({
  *   numberOfTurns: 1,
- *   messageHistory: input,
- *   model: 'anthropic/claude-3-sonnet',
+ *   toolCall: rawToolCall,
+ *   turnRequest: currentRequest,
+ * });
+ *
+ * // For async parameter resolution (partial context)
+ * const context = buildTurnContext({
+ *   numberOfTurns: 0,
  * });
  * ```
  */
 export function buildTurnContext(options: BuildTurnContextOptions): TurnContext {
-  return {
+  const context: TurnContext = {
     numberOfTurns: options.numberOfTurns,
-    input: options.messageHistory,
-    model: options.model,
-    models: options.models,
   };
+
+  if (options.toolCall !== undefined) {
+    context.toolCall = options.toolCall;
+  }
+
+  if (options.turnRequest !== undefined) {
+    context.turnRequest = options.turnRequest;
+  }
+
+  return context;
 }
 
 /**