@openrouter/sdk 0.3.2 → 0.3.10

package/esm/lib/{response-wrapper.d.ts → model-result.d.ts}

@@ -1,31 +1,37 @@
 import type { OpenRouterCore } from '../core.js';
 import type * as models from '../models/index.js';
+import type { CallModelInput } from './async-params.js';
 import type { RequestOptions } from './sdks.js';
-import type { ChatStreamEvent, EnhancedResponseStreamEvent, Tool, MaxToolRounds, ParsedToolCall, ToolStreamEvent } from './tool-types.js';
-export interface GetResponseOptions {
-    request: models.OpenResponsesRequest;
+import type { ResponseStreamEvent, InferToolEventsUnion, ParsedToolCall, StopWhen, Tool, ToolStreamEvent } from './tool-types.js';
+export interface GetResponseOptions<TTools extends readonly Tool[]> {
+    request: CallModelInput<TTools>;
     client: OpenRouterCore;
     options?: RequestOptions;
-    tools?: Tool[];
-    maxToolRounds?: MaxToolRounds;
+    tools?: TTools;
+    stopWhen?: StopWhen<TTools>;
 }
 /**
  * A wrapper around a streaming response that provides multiple consumption patterns.
  *
  * Allows consuming the response in multiple ways:
- * - `await response.getMessage()` - Get the completed message
- * - `await response.getText()` - Get just the text
- * - `for await (const delta of response.getTextStream())` - Stream text deltas
- * - `for await (const msg of response.getNewMessagesStream())` - Stream incremental message updates
- * - `for await (const event of response.getFullResponsesStream())` - Stream all response events
+ * - `await result.getText()` - Get just the text
+ * - `await result.getResponse()` - Get the full response object
+ * - `for await (const delta of result.getTextStream())` - Stream text deltas
+ * - `for await (const msg of result.getNewMessagesStream())` - Stream incremental message updates
+ * - `for await (const event of result.getFullResponsesStream())` - Stream all response events
+ *
+ * For message format conversion, use the helper functions:
+ * - `toChatMessage(response)` for OpenAI chat format
+ * - `toClaudeMessage(response)` for Anthropic Claude format
  *
  * All consumption patterns can be used concurrently thanks to the underlying
  * ReusableReadableStream implementation.
+ *
+ * @template TTools - The tools array type to enable typed tool calls and results
  */
-export declare class ResponseWrapper {
+export declare class ModelResult<TTools extends readonly Tool[]> {
     private reusableStream;
     private streamPromise;
-    private messagePromise;
     private textPromise;
     private options;
     private initPromise;
@@ -33,7 +39,8 @@ export declare class ResponseWrapper {
     private finalResponse;
     private preliminaryResults;
     private allToolExecutionRounds;
-    constructor(options: GetResponseOptions);
+    private resolvedRequest;
+    constructor(options: GetResponseOptions<TTools>);
     /**
      * Type guard to check if a value is a non-streaming response
      */
@@ -48,20 +55,10 @@ export declare class ResponseWrapper {
      * This is idempotent - multiple calls will return the same promise
      */
     private executeToolsIfNeeded;
-    /**
-     * Internal helper to get the message after tool execution
-     */
-    private getMessageInternal;
     /**
      * Internal helper to get the text after tool execution
      */
     private getTextInternal;
-    /**
-     * Get the completed message from the response.
-     * This will consume the stream until completion, execute any tools, and extract the first message.
-     * Returns an AssistantMessage in chat format.
-     */
-    getMessage(): Promise<models.AssistantMessage>;
     /**
      * Get just the text content from the response.
      * This will consume the stream until completion, execute any tools, and extract the text.
@@ -78,19 +75,19 @@ export declare class ResponseWrapper {
      * Multiple consumers can iterate over this stream concurrently.
      * Includes preliminary tool result events after tool execution.
      */
-    getFullResponsesStream(): AsyncIterableIterator<EnhancedResponseStreamEvent>;
+    getFullResponsesStream(): AsyncIterableIterator<ResponseStreamEvent<InferToolEventsUnion<TTools>>>;
     /**
      * Stream only text deltas as they arrive.
      * This filters the full event stream to only yield text content.
      */
     getTextStream(): AsyncIterableIterator<string>;
     /**
-     * Stream incremental message updates as content is added.
+     * Stream incremental message updates as content is added in responses format.
      * Each iteration yields an updated version of the message with new content.
-     * Also yields ToolResponseMessages after tool execution completes.
-     * Returns AssistantMessage or ToolResponseMessage in chat format.
+     * Also yields OpenResponsesFunctionCallOutput after tool execution completes.
+     * Returns ResponsesOutputMessage or OpenResponsesFunctionCallOutput compatible with OpenAI Responses API format.
      */
-    getNewMessagesStream(): AsyncIterableIterator<models.AssistantMessage | models.ToolResponseMessage>;
+    getNewMessagesStream(): AsyncIterableIterator<models.ResponsesOutputMessage | models.OpenResponsesFunctionCallOutput>;
     /**
      * Stream only reasoning deltas as they arrive.
      * This filters the full event stream to only yield reasoning content.
@@ -102,33 +99,22 @@ export declare class ResponseWrapper {
      * - Tool call argument deltas as { type: "delta", content: string }
      * - Preliminary results as { type: "preliminary_result", toolCallId, result }
      */
-    getToolStream(): AsyncIterableIterator<ToolStreamEvent>;
-    /**
-     * Stream events in chat format (compatibility layer).
-     * Note: This transforms responses API events into a chat-like format.
-     * Includes preliminary tool result events after tool execution.
-     *
-     * @remarks
-     * This is a compatibility method that attempts to transform the responses API
-     * stream into a format similar to the chat API. Due to differences in the APIs,
-     * this may not be a perfect mapping.
-     */
-    getFullChatStream(): AsyncIterableIterator<ChatStreamEvent>;
+    getToolStream(): AsyncIterableIterator<ToolStreamEvent<InferToolEventsUnion<TTools>>>;
     /**
      * Get all tool calls from the completed response (before auto-execution).
      * Note: If tools have execute functions, they will be automatically executed
      * and this will return the tool calls from the initial response.
      * Returns structured tool calls with parsed arguments.
      */
-    getToolCalls(): Promise<ParsedToolCall[]>;
+    getToolCalls(): Promise<ParsedToolCall<TTools[number]>[]>;
     /**
      * Stream structured tool call objects as they're completed.
      * Each iteration yields a complete tool call with parsed arguments.
      */
-    getToolCallsStream(): AsyncIterableIterator<ParsedToolCall>;
+    getToolCallsStream(): AsyncIterableIterator<ParsedToolCall<TTools[number]>>;
     /**
      * Cancel the underlying stream and all consumers
      */
     cancel(): Promise<void>;
 }
-//# sourceMappingURL=response-wrapper.d.ts.map
+//# sourceMappingURL=model-result.d.ts.map

package/esm/lib/{response-wrapper.js → model-result.js}

@@ -1,32 +1,60 @@
 import { betaResponsesSend } from '../funcs/betaResponsesSend.js';
+import { hasAsyncFunctions, resolveAsyncFunctions, } from './async-params.js';
 import { ReusableReadableStream } from './reusable-stream.js';
-import { buildMessageStream, buildToolCallStream, consumeStreamForCompletion, extractMessageFromResponse, extractReasoningDeltas, extractTextDeltas, extractTextFromResponse, extractToolCallsFromResponse, extractToolDeltas, } from './stream-transformers.js';
+import { buildResponsesMessageStream, buildToolCallStream, consumeStreamForCompletion, extractReasoningDeltas, extractResponsesMessageFromResponse, extractTextDeltas, extractTextFromResponse, extractToolCallsFromResponse, extractToolDeltas, } from './stream-transformers.js';
 import { executeTool } from './tool-executor.js';
+import { executeNextTurnParamsFunctions, applyNextTurnParamsToRequest } from './next-turn-params.js';
 import { hasExecuteFunction } from './tool-types.js';
+import { isStopConditionMet } from './stop-conditions.js';
+/**
+ * Type guard for stream event with toReadableStream method
+ */
+function isEventStream(value) {
+    return (value !== null &&
+        typeof value === 'object' &&
+        'toReadableStream' in value &&
+        typeof value.toReadableStream === 'function');
+}
+/**
+ * Type guard for output items with a type property
+ */
+function hasTypeProperty(item) {
+    return (typeof item === 'object' &&
+        item !== null &&
+        'type' in item &&
+        typeof item.type === 'string');
+}
 /**
  * A wrapper around a streaming response that provides multiple consumption patterns.
  *
  * Allows consuming the response in multiple ways:
- * - `await response.getMessage()` - Get the completed message
- * - `await response.getText()` - Get just the text
- * - `for await (const delta of response.getTextStream())` - Stream text deltas
- * - `for await (const msg of response.getNewMessagesStream())` - Stream incremental message updates
- * - `for await (const event of response.getFullResponsesStream())` - Stream all response events
+ * - `await result.getText()` - Get just the text
+ * - `await result.getResponse()` - Get the full response object
+ * - `for await (const delta of result.getTextStream())` - Stream text deltas
+ * - `for await (const msg of result.getNewMessagesStream())` - Stream incremental message updates
+ * - `for await (const event of result.getFullResponsesStream())` - Stream all response events
+ *
+ * For message format conversion, use the helper functions:
+ * - `toChatMessage(response)` for OpenAI chat format
+ * - `toClaudeMessage(response)` for Anthropic Claude format
  *
  * All consumption patterns can be used concurrently thanks to the underlying
  * ReusableReadableStream implementation.
+ *
+ * @template TTools - The tools array type to enable typed tool calls and results
  */
-export class ResponseWrapper {
+export class ModelResult {
     constructor(options) {
         this.reusableStream = null;
         this.streamPromise = null;
-        this.messagePromise = null;
         this.textPromise = null;
         this.initPromise = null;
         this.toolExecutionPromise = null;
         this.finalResponse = null;
         this.preliminaryResults = new Map();
         this.allToolExecutionRounds = [];
+        // Track resolved request after async function resolution
+        this.resolvedRequest = null;
         this.options = options;
     }
     /**
@@ -34,11 +62,11 @@ export class ResponseWrapper {
      */
     isNonStreamingResponse(value) {
         return (value !== null &&
-            typeof value === "object" &&
-            "id" in value &&
-            "object" in value &&
-            "output" in value &&
-            !("toReadableStream" in value));
+            typeof value === 'object' &&
+            'id' in value &&
+            'object' in value &&
+            'output' in value &&
+            !('toReadableStream' in value));
     }
     /**
      * Initialize the stream if not already started
@@ -49,16 +77,40 @@ export class ResponseWrapper {
             return this.initPromise;
         }
         this.initPromise = (async () => {
-            // Force stream mode
-            const request = {
-                ...this.options.request,
+            // Resolve async functions before initial request
+            // Build initial turn context (turn 0 for initial request)
+            const initialContext = {
+                numberOfTurns: 0,
+            };
+            // Resolve any async functions first
+            let baseRequest;
+            if (hasAsyncFunctions(this.options.request)) {
+                baseRequest = await resolveAsyncFunctions(this.options.request, initialContext);
+            }
+            else {
+                // Already resolved, extract non-function fields
+                // Since request is CallModelInput, we need to filter out stopWhen
+                // Note: tools are already in API format at this point (converted in callModel())
+                // eslint-disable-next-line @typescript-eslint/no-unused-vars
+                const { stopWhen, ...rest } = this.options.request;
+                // Cast to ResolvedCallModelInput - we know it's resolved if hasAsyncFunctions returned false
+                baseRequest = rest;
+            }
+            // Store resolved request with stream mode
+            this.resolvedRequest = {
+                ...baseRequest,
                 stream: true,
             };
+            // Force stream mode for initial request
+            const request = this.resolvedRequest;
             // Create the stream promise
             this.streamPromise = betaResponsesSend(this.options.client, request, this.options.options).then((result) => {
                 if (!result.ok) {
                     throw result.error;
                 }
+                // When stream: true, the API returns EventStream
+                // TypeScript can't narrow the union type based on runtime parameter values,
+                // so we assert the type here based on our knowledge that stream=true
                 return result.value;
             });
             // Wait for the stream and create the reusable stream
@@ -80,12 +132,13 @@ export class ResponseWrapper {
             if (!this.reusableStream) {
                 throw new Error('Stream not initialized');
             }
+            // Note: Async functions already resolved in initStream()
             // Get the initial response
             const initialResponse = await consumeStreamForCompletion(this.reusableStream);
             // Check if we have tools and if auto-execution is enabled
             const shouldAutoExecute = this.options.tools &&
                 this.options.tools.length > 0 &&
-                initialResponse.output.some((item) => 'type' in item && item.type === 'function_call');
+                initialResponse.output.some((item) => hasTypeProperty(item) && item.type === 'function_call');
             if (!shouldAutoExecute) {
                 // No tools to execute, use initial response
                 this.finalResponse = initialResponse;
@@ -103,12 +156,34 @@ export class ResponseWrapper {
                 this.finalResponse = initialResponse;
                 return;
             }
-            // Get maxToolRounds configuration
-            const maxToolRounds = this.options.maxToolRounds ?? 5;
             let currentResponse = initialResponse;
             let currentRound = 0;
-            let currentInput = this.options.request.input || [];
             while (true) {
+                // Check stopWhen conditions
+                if (this.options.stopWhen) {
+                    const stopConditions = Array.isArray(this.options.stopWhen)
+                        ? this.options.stopWhen
+                        : [this.options.stopWhen];
+                    const shouldStop = await isStopConditionMet({
+                        stopConditions,
+                        steps: this.allToolExecutionRounds.map((round) => ({
+                            stepType: 'continue',
+                            text: extractTextFromResponse(round.response),
+                            toolCalls: round.toolCalls,
+                            toolResults: round.toolResults.map((tr) => ({
+                                toolCallId: tr.callId,
+                                toolName: round.toolCalls.find((tc) => tc.id === tr.callId)?.name ?? '',
+                                result: JSON.parse(tr.output),
+                            })),
+                            response: round.response,
+                            usage: round.response.usage,
+                            finishReason: undefined, // OpenResponsesNonStreamingResponse doesn't have finishReason
+                        })),
+                    });
+                    if (shouldStop) {
+                        break;
+                    }
+                }
                 const currentToolCalls = extractToolCallsFromResponse(currentResponse);
                 if (currentToolCalls.length === 0) {
                     break;
@@ -120,46 +195,19 @@ export class ResponseWrapper {
                 if (!hasExecutable) {
                     break;
                 }
-                // Check if we should continue based on maxToolRounds
-                if (typeof maxToolRounds === 'number') {
-                    if (currentRound >= maxToolRounds) {
-                        break;
-                    }
-                }
-                else if (typeof maxToolRounds === 'function') {
-                    // Function signature: (context: TurnContext) => boolean
-                    const turnContext = {
-                        numberOfTurns: currentRound + 1,
-                        messageHistory: currentInput,
-                        ...(this.options.request.model && {
-                            model: this.options.request.model,
-                        }),
-                        ...(this.options.request.models && {
-                            models: this.options.request.models,
-                        }),
-                    };
-                    const shouldContinue = maxToolRounds(turnContext);
-                    if (!shouldContinue) {
-                        break;
-                    }
-                }
-                // Store execution round info
-                this.allToolExecutionRounds.push({
-                    round: currentRound,
-                    toolCalls: currentToolCalls,
-                    response: currentResponse,
-                });
-                // Build turn context for tool execution
+                // Build turn context for this round (for async parameter resolution only)
                 const turnContext = {
                     numberOfTurns: currentRound + 1, // 1-indexed
-                    messageHistory: currentInput,
-                    ...(this.options.request.model && {
-                        model: this.options.request.model,
-                    }),
-                    ...(this.options.request.models && {
-                        models: this.options.request.models,
-                    }),
                 };
+                // Resolve async functions for this turn
+                if (hasAsyncFunctions(this.options.request)) {
+                    const resolved = await resolveAsyncFunctions(this.options.request, turnContext);
+                    // Update resolved request with new values
+                    this.resolvedRequest = {
+                        ...resolved,
+                        stream: false, // Tool execution turns don't need streaming
+                    };
+                }
                 // Execute all tool calls
                 const toolResults = [];
                 for (const toolCall of currentToolCalls) {
@@ -183,6 +231,24 @@ export class ResponseWrapper {
                             : JSON.stringify(result.result),
                     });
                 }
+                // Store execution round info including tool results
+                this.allToolExecutionRounds.push({
+                    round: currentRound,
+                    toolCalls: currentToolCalls,
+                    response: currentResponse,
+                    toolResults,
+                });
+                // Execute nextTurnParams functions for tools that were called
+                if (this.options.tools && currentToolCalls.length > 0) {
+                    if (!this.resolvedRequest) {
+                        throw new Error('Request not initialized');
+                    }
+                    const computedParams = await executeNextTurnParamsFunctions(currentToolCalls, this.options.tools, this.resolvedRequest);
+                    // Apply computed parameters to the resolved request for next turn
+                    if (Object.keys(computedParams).length > 0) {
+                        this.resolvedRequest = applyNextTurnParamsToRequest(this.resolvedRequest, computedParams);
+                    }
+                }
                 // Build new input with tool results
                 // For the Responses API, we need to include the tool results in the input
                 const newInput = [
@@ -193,11 +259,12 @@ export class ResponseWrapper {
                         ]),
                     ...toolResults,
                 ];
-                // Update current input for next iteration
-                currentInput = newInput;
                 // Make new request with tool results
+                if (!this.resolvedRequest) {
+                    throw new Error('Request not initialized');
+                }
                 const newRequest = {
-                    ...this.options.request,
+                    ...this.resolvedRequest,
                     input: newInput,
                     stream: false,
                 };
@@ -207,7 +274,7 @@ export class ResponseWrapper {
                 }
                 // Handle the result - it might be a stream or a response
                 const value = newResult.value;
-                if (value && typeof value === 'object' && 'toReadableStream' in value) {
+                if (isEventStream(value)) {
                     // It's a stream, consume it
                     const stream = new ReusableReadableStream(value);
                     currentResponse = await consumeStreamForCompletion(stream);
@@ -216,54 +283,32 @@ export class ResponseWrapper {
                     currentResponse = value;
                 }
                 else {
-                    throw new Error("Unexpected response type from API");
+                    throw new Error('Unexpected response type from API');
                 }
                 currentRound++;
             }
             // Validate the final response has required fields
             if (!currentResponse || !currentResponse.id || !currentResponse.output) {
-                throw new Error("Invalid final response: missing required fields");
+                throw new Error('Invalid final response: missing required fields');
             }
             // Ensure the response is in a completed state (has output content)
             if (!Array.isArray(currentResponse.output) || currentResponse.output.length === 0) {
-                throw new Error("Invalid final response: empty or invalid output");
+                throw new Error('Invalid final response: empty or invalid output');
             }
             this.finalResponse = currentResponse;
         })();
         return this.toolExecutionPromise;
     }
-    /**
-     * Internal helper to get the message after tool execution
-     */
-    async getMessageInternal() {
-        await this.executeToolsIfNeeded();
-        if (!this.finalResponse) {
-            throw new Error("Response not available");
-        }
-        return extractMessageFromResponse(this.finalResponse);
-    }
     /**
      * Internal helper to get the text after tool execution
      */
     async getTextInternal() {
         await this.executeToolsIfNeeded();
         if (!this.finalResponse) {
-            throw new Error("Response not available");
+            throw new Error('Response not available');
         }
         return extractTextFromResponse(this.finalResponse);
     }
-    /**
-     * Get the completed message from the response.
-     * This will consume the stream until completion, execute any tools, and extract the first message.
-     * Returns an AssistantMessage in chat format.
-     */
-    getMessage() {
-        if (this.messagePromise) {
-            return this.messagePromise;
-        }
-        this.messagePromise = this.getMessageInternal();
-        return this.messagePromise;
-    }
     /**
      * Get just the text content from the response.
      * This will consume the stream until completion, execute any tools, and extract the text.
@@ -311,7 +356,7 @@ export class ResponseWrapper {
                     yield {
                         type: 'tool.preliminary_result',
                         toolCallId,
-                        result,
+                        result: result,
                         timestamp: Date.now(),
                     };
                 }
@@ -332,10 +377,10 @@ export class ResponseWrapper {
         }.call(this);
     }
     /**
-     * Stream incremental message updates as content is added.
+     * Stream incremental message updates as content is added in responses format.
      * Each iteration yields an updated version of the message with new content.
-     * Also yields ToolResponseMessages after tool execution completes.
-     * Returns AssistantMessage or ToolResponseMessage in chat format.
+     * Also yields OpenResponsesFunctionCallOutput after tool execution completes.
+     * Returns ResponsesOutputMessage or OpenResponsesFunctionCallOutput compatible with OpenAI Responses API format.
      */
     getNewMessagesStream() {
         return async function* () {
@@ -343,37 +388,22 @@ export class ResponseWrapper {
             if (!this.reusableStream) {
                 throw new Error('Stream not initialized');
             }
-            // First yield assistant messages from the stream
-            yield* buildMessageStream(this.reusableStream);
+            // First yield messages from the stream in responses format
+            yield* buildResponsesMessageStream(this.reusableStream);
             // Execute tools if needed
             await this.executeToolsIfNeeded();
-            // Yield tool response messages for each executed tool
+            // Yield function call outputs for each executed tool
             for (const round of this.allToolExecutionRounds) {
-                for (const toolCall of round.toolCalls) {
-                    // Find the tool to check if it was executed
-                    const tool = this.options.tools?.find((t) => t.function.name === toolCall.name);
-                    if (!tool || !hasExecuteFunction(tool)) {
-                        continue;
-                    }
-                    // Get the result from preliminary results or construct from the response
-                    const prelimResults = this.preliminaryResults.get(toolCall.id);
-                    const result = prelimResults && prelimResults.length > 0
-                        ? prelimResults[prelimResults.length - 1] // Last result is the final output
-                        : undefined;
-                    // Yield tool response message
-                    yield {
-                        role: 'tool',
-                        content: result !== undefined ? JSON.stringify(result) : '',
-                        toolCallId: toolCall.id,
-                    };
+                for (const toolResult of round.toolResults) {
+                    yield toolResult;
                 }
             }
-            // If tools were executed, yield the final assistant message (if there is one)
+            // If tools were executed, yield the final message (if there is one)
             if (this.finalResponse && this.allToolExecutionRounds.length > 0) {
                 // Check if the final response contains a message
-                const hasMessage = this.finalResponse.output.some((item) => 'type' in item && item.type === 'message');
+                const hasMessage = this.finalResponse.output.some((item) => hasTypeProperty(item) && item.type === 'message');
                 if (hasMessage) {
-                    yield extractMessageFromResponse(this.finalResponse);
+                    yield extractResponsesMessageFromResponse(this.finalResponse);
                 }
             }
         }.call(this);
@@ -418,66 +448,7 @@ export class ResponseWrapper {
                     yield {
                         type: 'preliminary_result',
                         toolCallId,
-                        result,
-                    };
-                }
-            }
-        }.call(this);
-    }
-    /**
-     * Stream events in chat format (compatibility layer).
-     * Note: This transforms responses API events into a chat-like format.
-     * Includes preliminary tool result events after tool execution.
-     *
-     * @remarks
-     * This is a compatibility method that attempts to transform the responses API
-     * stream into a format similar to the chat API. Due to differences in the APIs,
-     * this may not be a perfect mapping.
-     */
-    getFullChatStream() {
-        return async function* () {
-            await this.initStream();
-            if (!this.reusableStream) {
-                throw new Error('Stream not initialized');
-            }
-            const consumer = this.reusableStream.createConsumer();
-            for await (const event of consumer) {
-                if (!('type' in event)) {
-                    continue;
-                }
-                // Transform responses events to chat-like format
-                // This is a simplified transformation - you may need to adjust based on your needs
-                if (event.type === 'response.output_text.delta') {
-                    const deltaEvent = event;
-                    yield {
-                        type: 'content.delta',
-                        delta: deltaEvent.delta,
-                    };
-                }
-                else if (event.type === 'response.completed') {
-                    const completedEvent = event;
-                    yield {
-                        type: 'message.complete',
-                        response: completedEvent.response,
-                    };
-                }
-                else {
-                    // Pass through other events
-                    yield {
-                        type: event.type,
-                        event,
-                    };
-                }
-            }
-            // After stream completes, check if tools were executed and emit preliminary results
-            await this.executeToolsIfNeeded();
-            // Emit all preliminary results
-            for (const [toolCallId, results] of this.preliminaryResults) {
-                for (const result of results) {
-                    yield {
-                        type: 'tool.preliminary_result',
-                        toolCallId,
-                        result,
+                        result: result,
                     };
                 }
             }
@@ -519,4 +490,4 @@ export class ResponseWrapper {
         }
     }
 }
-//# sourceMappingURL=response-wrapper.js.map
+//# sourceMappingURL=model-result.js.map

package/esm/lib/next-turn-params.d.ts

@@ -0,0 +1,30 @@
+import type * as models from '../models/index.js';
+import type { NextTurnParamsContext, ParsedToolCall, Tool } from './tool-types.js';
+/**
+ * Build a NextTurnParamsContext from the current request
+ * Extracts relevant fields that can be modified by nextTurnParams functions
+ *
+ * @param request - The current OpenResponsesRequest
+ * @returns Context object with current parameter values
+ */
+export declare function buildNextTurnParamsContext(request: models.OpenResponsesRequest): NextTurnParamsContext;
+/**
+ * Execute nextTurnParams functions for all called tools
+ * Composes functions when multiple tools modify the same parameter
+ *
+ * @param toolCalls - Tool calls that were executed in this turn
+ * @param tools - All available tools
+ * @param currentRequest - The current request
+ * @returns Object with computed parameter values
+ */
+export declare function executeNextTurnParamsFunctions(toolCalls: ParsedToolCall<Tool>[], tools: readonly Tool[], currentRequest: models.OpenResponsesRequest): Promise<Partial<NextTurnParamsContext>>;
+/**
+ * Apply computed nextTurnParams to the current request
+ * Returns a new request object with updated parameters
+ *
+ * @param request - The current request
+ * @param computedParams - Computed parameter values from nextTurnParams functions
+ * @returns New request with updated parameters
+ */
+export declare function applyNextTurnParamsToRequest(request: models.OpenResponsesRequest, computedParams: Partial<NextTurnParamsContext>): models.OpenResponsesRequest;
+//# sourceMappingURL=next-turn-params.d.ts.map