@openrouter/sdk 0.3.7 → 0.3.10

package/esm/lib/model-result.js

@@ -1,38 +1,28 @@
-import { betaResponsesSend } from "../funcs/betaResponsesSend.js";
-import { ReusableReadableStream } from "./reusable-stream.js";
-import { buildResponsesMessageStream, buildToolCallStream, consumeStreamForCompletion, extractReasoningDeltas, extractResponsesMessageFromResponse, extractTextDeltas, extractTextFromResponse, extractToolCallsFromResponse, extractToolDeltas, } from "./stream-transformers.js";
-import { executeTool } from "./tool-executor.js";
-import { hasExecuteFunction } from "./tool-types.js";
+import { betaResponsesSend } from '../funcs/betaResponsesSend.js';
+import { hasAsyncFunctions, resolveAsyncFunctions, } from './async-params.js';
+import { ReusableReadableStream } from './reusable-stream.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 response.output_text.delta events
- */
-function isOutputTextDeltaEvent(event) {
-    return "type" in event && event.type === "response.output_text.delta";
-}
-/**
- * Type guard for response.completed events
- */
-function isResponseCompletedEvent(event) {
-    return "type" in event && event.type === "response.completed";
+        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" &&
+    return (typeof item === 'object' &&
         item !== null &&
-        "type" in item &&
-        typeof item.type === "string");
+        'type' in item &&
+        typeof item.type === 'string');
 }
 /**
  * A wrapper around a streaming response that provides multiple consumption patterns.
@@ -50,6 +40,8 @@ function hasTypeProperty(item) {
  *
  * 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 ModelResult {
     constructor(options) {
@@ -61,6 +53,8 @@ export class ModelResult {
         this.finalResponse = null;
         this.preliminaryResults = new Map();
         this.allToolExecutionRounds = [];
+        // Track resolved request after async function resolution
+        this.resolvedRequest = null;
         this.options = options;
     }
     /**
@@ -68,11 +62,11 @@ export class ModelResult {
      */
     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
@@ -83,16 +77,40 @@ export class ModelResult {
             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
@@ -112,14 +130,15 @@ export class ModelResult {
         this.toolExecutionPromise = (async () => {
             await this.initStream();
             if (!this.reusableStream) {
-                throw new Error("Stream not initialized");
+                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) => hasTypeProperty(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;
@@ -137,12 +156,34 @@ export class ModelResult {
                 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;
@@ -154,46 +195,19 @@ export class ModelResult {
                 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) {
@@ -203,12 +217,11 @@ export class ModelResult {
                     }
                     const result = await executeTool(tool, toolCall, turnContext);
                     // Store preliminary results
-                    if (result.preliminaryResults &&
-                        result.preliminaryResults.length > 0) {
+                    if (result.preliminaryResults && result.preliminaryResults.length > 0) {
                         this.preliminaryResults.set(toolCall.id, result.preliminaryResults);
                     }
                     toolResults.push({
-                        type: "function_call_output",
+                        type: 'function_call_output',
                         id: `output_${toolCall.id}`,
                         callId: toolCall.id,
                         output: result.error
@@ -218,19 +231,40 @@ export class ModelResult {
                             : 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 = [
                     ...(Array.isArray(currentResponse.output)
                         ? currentResponse.output
-                        : [currentResponse.output]),
+                        : [
+                            currentResponse.output,
+                        ]),
                     ...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,
                 };
@@ -249,18 +283,17 @@ export class ModelResult {
                     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");
+            if (!Array.isArray(currentResponse.output) || currentResponse.output.length === 0) {
+                throw new Error('Invalid final response: empty or invalid output');
             }
             this.finalResponse = currentResponse;
         })();
@@ -272,7 +305,7 @@ export class ModelResult {
     async getTextInternal() {
         await this.executeToolsIfNeeded();
         if (!this.finalResponse) {
-            throw new Error("Response not available");
+            throw new Error('Response not available');
         }
         return extractTextFromResponse(this.finalResponse);
     }
@@ -295,7 +328,7 @@ export class ModelResult {
     async getResponse() {
         await this.executeToolsIfNeeded();
         if (!this.finalResponse) {
-            throw new Error("Response not available");
+            throw new Error('Response not available');
         }
         return this.finalResponse;
     }
@@ -308,7 +341,7 @@ export class ModelResult {
         return async function* () {
             await this.initStream();
             if (!this.reusableStream) {
-                throw new Error("Stream not initialized");
+                throw new Error('Stream not initialized');
             }
             const consumer = this.reusableStream.createConsumer();
             // Yield original events directly
@@ -321,9 +354,9 @@ export class ModelResult {
             for (const [toolCallId, results] of this.preliminaryResults) {
                 for (const result of results) {
                     yield {
-                        type: "tool.preliminary_result",
+                        type: 'tool.preliminary_result',
                         toolCallId,
-                        result,
+                        result: result,
                         timestamp: Date.now(),
                     };
                 }
@@ -338,7 +371,7 @@ export class ModelResult {
         return async function* () {
             await this.initStream();
             if (!this.reusableStream) {
-                throw new Error("Stream not initialized");
+                throw new Error('Stream not initialized');
             }
             yield* extractTextDeltas(this.reusableStream);
         }.call(this);
@@ -353,38 +386,22 @@ export class ModelResult {
         return async function* () {
             await this.initStream();
             if (!this.reusableStream) {
-                throw new Error("Stream not initialized");
+                throw new Error('Stream not initialized');
             }
             // First yield messages from the stream in responses format
             yield* buildResponsesMessageStream(this.reusableStream);
             // Execute tools if needed
             await this.executeToolsIfNeeded();
-            // Yield function call output 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 function call output in responses format
-                    yield {
-                        type: "function_call_output",
-                        id: `output_${toolCall.id}`,
-                        callId: toolCall.id,
-                        output: result !== undefined ? JSON.stringify(result) : "",
-                    };
+                for (const toolResult of round.toolResults) {
+                    yield toolResult;
                 }
             }
             // 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) => hasTypeProperty(item) && item.type === "message");
+                const hasMessage = this.finalResponse.output.some((item) => hasTypeProperty(item) && item.type === 'message');
                 if (hasMessage) {
                     yield extractResponsesMessageFromResponse(this.finalResponse);
                 }
@@ -399,7 +416,7 @@ export class ModelResult {
         return async function* () {
             await this.initStream();
             if (!this.reusableStream) {
-                throw new Error("Stream not initialized");
+                throw new Error('Stream not initialized');
             }
             yield* extractReasoningDeltas(this.reusableStream);
         }.call(this);
@@ -414,12 +431,12 @@ export class ModelResult {
         return async function* () {
             await this.initStream();
             if (!this.reusableStream) {
-                throw new Error("Stream not initialized");
+                throw new Error('Stream not initialized');
             }
             // Yield tool deltas as structured events
             for await (const delta of extractToolDeltas(this.reusableStream)) {
                 yield {
-                    type: "delta",
+                    type: 'delta',
                     content: delta,
                 };
             }
@@ -429,65 +446,9 @@ export class ModelResult {
             for (const [toolCallId, results] of this.preliminaryResults) {
                 for (const result of results) {
                     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 using type guards
-                if (isOutputTextDeltaEvent(event)) {
-                    yield {
-                        type: "content.delta",
-                        delta: event.delta,
-                    };
-                }
-                else if (isResponseCompletedEvent(event)) {
-                    yield {
-                        type: "message.complete",
-                        response: event.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",
+                        type: 'preliminary_result',
                         toolCallId,
-                        result,
+                        result: result,
                     };
                 }
             }
@@ -502,7 +463,7 @@ export class ModelResult {
     async getToolCalls() {
         await this.initStream();
         if (!this.reusableStream) {
-            throw new Error("Stream not initialized");
+            throw new Error('Stream not initialized');
         }
         const completedResponse = await consumeStreamForCompletion(this.reusableStream);
         return extractToolCallsFromResponse(completedResponse);
@@ -515,7 +476,7 @@ export class ModelResult {
         return async function* () {
             await this.initStream();
             if (!this.reusableStream) {
-                throw new Error("Stream not initialized");
+                throw new Error('Stream not initialized');
             }
             yield* buildToolCallStream(this.reusableStream);
         }.call(this);

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