@openrouter/sdk 0.1.27 → 0.2.9

package/esm/lib/stream-transformers.js

@@ -4,7 +4,7 @@
 export async function* extractTextDeltas(stream) {
     const consumer = stream.createConsumer();
     for await (const event of consumer) {
-        if ("type" in event && event.type === "response.output_text.delta") {
+        if ('type' in event && event.type === 'response.output_text.delta') {
             const deltaEvent = event;
             if (deltaEvent.delta) {
                 yield deltaEvent.delta;
@@ -18,7 +18,7 @@ export async function* extractTextDeltas(stream) {
 export async function* extractReasoningDeltas(stream) {
     const consumer = stream.createConsumer();
     for await (const event of consumer) {
-        if ("type" in event && event.type === "response.reasoning_text.delta") {
+        if ('type' in event && event.type === 'response.reasoning_text.delta') {
             const deltaEvent = event;
             if (deltaEvent.delta) {
                 yield deltaEvent.delta;
@@ -32,7 +32,7 @@ export async function* extractReasoningDeltas(stream) {
 export async function* extractToolDeltas(stream) {
     const consumer = stream.createConsumer();
     for await (const event of consumer) {
-        if ("type" in event && event.type === "response.function_call_arguments.delta") {
+        if ('type' in event && event.type === 'response.function_call_arguments.delta') {
             const deltaEvent = event;
             if (deltaEvent.delta) {
                 yield deltaEvent.delta;
@@ -47,35 +47,38 @@ export async function* extractToolDeltas(stream) {
 export async function* buildMessageStream(stream) {
     const consumer = stream.createConsumer();
     // Track the accumulated text
-    let currentText = "";
+    let currentText = '';
     let hasStarted = false;
     for await (const event of consumer) {
-        if (!("type" in event))
+        if (!('type' in event)) {
             continue;
+        }
         switch (event.type) {
-            case "response.output_item.added": {
+            case 'response.output_item.added': {
                 const itemEvent = event;
-                if (itemEvent.item && "type" in itemEvent.item && itemEvent.item.type === "message") {
+                if (itemEvent.item && 'type' in itemEvent.item && itemEvent.item.type === 'message') {
                     hasStarted = true;
-                    currentText = "";
+                    currentText = '';
                 }
                 break;
             }
-            case "response.output_text.delta": {
+            case 'response.output_text.delta': {
                 const deltaEvent = event;
                 if (hasStarted && deltaEvent.delta) {
                     currentText += deltaEvent.delta;
                     // Yield updated message
                     yield {
-                        role: "assistant",
+                        role: 'assistant',
                         content: currentText,
                     };
                 }
                 break;
             }
-            case "response.output_item.done": {
+            case 'response.output_item.done': {
                 const itemDoneEvent = event;
-                if (itemDoneEvent.item && "type" in itemDoneEvent.item && itemDoneEvent.item.type === "message") {
+                if (itemDoneEvent.item &&
+                    'type' in itemDoneEvent.item &&
+                    itemDoneEvent.item.type === 'message') {
                     // Yield final complete message
                     const outputMessage = itemDoneEvent.item;
                     yield convertToAssistantMessage(outputMessage);
@@ -91,24 +94,25 @@ export async function* buildMessageStream(stream) {
 export async function consumeStreamForCompletion(stream) {
     const consumer = stream.createConsumer();
     for await (const event of consumer) {
-        if (!("type" in event))
+        if (!('type' in event)) {
             continue;
-        if (event.type === "response.completed") {
+        }
+        if (event.type === 'response.completed') {
             const completedEvent = event;
             return completedEvent.response;
         }
-        if (event.type === "response.failed") {
+        if (event.type === 'response.failed') {
             const failedEvent = event;
             // The failed event contains the full response with error information
             throw new Error(`Response failed: ${JSON.stringify(failedEvent.response.error)}`);
         }
-        if (event.type === "response.incomplete") {
+        if (event.type === 'response.incomplete') {
             const incompleteEvent = event;
             // Return the incomplete response
             return incompleteEvent.response;
         }
     }
-    throw new Error("Stream ended without completion event");
+    throw new Error('Stream ended without completion event');
 }
 /**
  * Convert ResponsesOutputMessage to AssistantMessage (chat format)
@@ -116,11 +120,11 @@ export async function consumeStreamForCompletion(stream) {
 function convertToAssistantMessage(outputMessage) {
     // Extract text content
     const textContent = outputMessage.content
-        .filter((part) => "type" in part && part.type === "output_text")
+        .filter((part) => 'type' in part && part.type === 'output_text')
         .map((part) => part.text)
-        .join("");
+        .join('');
     return {
-        role: "assistant",
+        role: 'assistant',
         content: textContent || null,
     };
 }
@@ -128,9 +132,9 @@ function convertToAssistantMessage(outputMessage) {
  * Extract the first message from a completed response
  */
 export function extractMessageFromResponse(response) {
-    const messageItem = response.output.find((item) => "type" in item && item.type === "message");
+    const messageItem = response.output.find((item) => 'type' in item && item.type === 'message');
     if (!messageItem) {
-        throw new Error("No message found in response output");
+        throw new Error('No message found in response output');
     }
     return convertToAssistantMessage(messageItem);
 }
@@ -145,10 +149,10 @@ export function extractTextFromResponse(response) {
     // Otherwise, extract from the first message (convert to AssistantMessage which has string content)
     const message = extractMessageFromResponse(response);
     // AssistantMessage.content is string | Array | null | undefined
-    if (typeof message.content === "string") {
+    if (typeof message.content === 'string') {
         return message.content;
     }
-    return "";
+    return '';
 }
 /**
  * Extract all tool calls from a completed response
@@ -157,7 +161,7 @@ export function extractTextFromResponse(response) {
 export function extractToolCallsFromResponse(response) {
     const toolCalls = [];
     for (const item of response.output) {
-        if ("type" in item && item.type === "function_call") {
+        if ('type' in item && item.type === 'function_call') {
             const functionCallItem = item;
             try {
                 const parsedArguments = JSON.parse(functionCallItem.arguments);
@@ -167,8 +171,7 @@ export function extractToolCallsFromResponse(response) {
                     arguments: parsedArguments,
                 });
             }
-            catch (error) {
-                console.error(`Failed to parse tool call arguments for ${functionCallItem.name}:`, error);
+            catch (_error) {
                 // Include the tool call with unparsed arguments
                 toolCalls.push({
                     id: functionCallItem.callId,
@@ -189,24 +192,23 @@ export async function* buildToolCallStream(stream) {
     // Track tool calls being built
     const toolCallsInProgress = new Map();
     for await (const event of consumer) {
-        if (!("type" in event))
+        if (!('type' in event)) {
             continue;
+        }
         switch (event.type) {
-            case "response.output_item.added": {
+            case 'response.output_item.added': {
                 const itemEvent = event;
-                if (itemEvent.item &&
-                    "type" in itemEvent.item &&
-                    itemEvent.item.type === "function_call") {
+                if (itemEvent.item && 'type' in itemEvent.item && itemEvent.item.type === 'function_call') {
                     const functionCallItem = itemEvent.item;
                     toolCallsInProgress.set(functionCallItem.callId, {
                         id: functionCallItem.callId,
                         name: functionCallItem.name,
-                        argumentsAccumulated: "",
+                        argumentsAccumulated: '',
                     });
                 }
                 break;
             }
-            case "response.function_call_arguments.delta": {
+            case 'response.function_call_arguments.delta': {
                 const deltaEvent = event;
                 const toolCall = toolCallsInProgress.get(deltaEvent.itemId);
                 if (toolCall && deltaEvent.delta) {
@@ -214,7 +216,7 @@ export async function* buildToolCallStream(stream) {
                 }
                 break;
             }
-            case "response.function_call_arguments.done": {
+            case 'response.function_call_arguments.done': {
                 const doneEvent = event;
                 const toolCall = toolCallsInProgress.get(doneEvent.itemId);
                 if (toolCall) {
@@ -227,7 +229,7 @@ export async function* buildToolCallStream(stream) {
                             arguments: parsedArguments,
                         };
                     }
-                    catch (error) {
+                    catch (_error) {
                         // Yield with unparsed arguments if parsing fails
                         yield {
                             id: toolCall.id,
@@ -240,11 +242,11 @@ export async function* buildToolCallStream(stream) {
                 }
                 break;
             }
-            case "response.output_item.done": {
+            case 'response.output_item.done': {
                 const itemDoneEvent = event;
                 if (itemDoneEvent.item &&
-                    "type" in itemDoneEvent.item &&
-                    itemDoneEvent.item.type === "function_call") {
+                    'type' in itemDoneEvent.item &&
+                    itemDoneEvent.item.type === 'function_call') {
                     const functionCallItem = itemDoneEvent.item;
                     // Yield final tool call if we haven't already
                     if (toolCallsInProgress.has(functionCallItem.callId)) {
@@ -256,7 +258,7 @@ export async function* buildToolCallStream(stream) {
                                 arguments: parsedArguments,
                             };
                         }
-                        catch (error) {
+                        catch (_error) {
                             yield {
                                 id: functionCallItem.callId,
                                 name: functionCallItem.name,
@@ -275,6 +277,6 @@ export async function* buildToolCallStream(stream) {
  * Check if a response contains any tool calls
  */
 export function responseHasToolCalls(response) {
-    return response.output.some((item) => "type" in item && item.type === "function_call");
+    return response.output.some((item) => 'type' in item && item.type === 'function_call');
 }
 //# sourceMappingURL=stream-transformers.js.map

package/esm/lib/tool-executor.d.ts

@@ -1,13 +1,13 @@
-import { type ZodType } from "zod/v4";
-import { EnhancedTool, ToolExecutionResult, ParsedToolCall, APITool, TurnContext } from "./tool-types.js";
+import type { ZodType } from 'zod/v4';
+import type { APITool, Tool, ParsedToolCall, ToolExecutionResult, TurnContext } from './tool-types.js';
 /**
  * Convert a Zod schema to JSON Schema using Zod v4's toJSONSchema function
  */
-export declare function convertZodToJsonSchema(zodSchema: ZodType): Record<string, any>;
+export declare function convertZodToJsonSchema(zodSchema: ZodType): Record<string, unknown>;
 /**
- * Convert enhanced tools to OpenRouter API format
+ * Convert tools to OpenRouter API format
  */
-export declare function convertEnhancedToolsToAPIFormat(tools: EnhancedTool[]): APITool[];
+export declare function convertToolsToAPIFormat(tools: Tool[]): APITool[];
 /**
  * Validate tool input against Zod schema
  * @throws ZodError if validation fails
@@ -25,23 +25,23 @@ export declare function parseToolCallArguments(argumentsString: string): unknown
 /**
  * Execute a regular (non-generator) tool
  */
-export declare function executeRegularTool(tool: EnhancedTool, toolCall: ParsedToolCall, context: TurnContext): Promise<ToolExecutionResult>;
+export declare function executeRegularTool(tool: Tool, toolCall: ParsedToolCall, context: TurnContext): Promise<ToolExecutionResult>;
 /**
  * Execute a generator tool and collect preliminary and final results
  * - Intermediate yields are validated against eventSchema (preliminary events)
  * - Last yield is validated against outputSchema (final result sent to model)
  * - Generator must emit at least one value
  */
-export declare function executeGeneratorTool(tool: EnhancedTool, toolCall: ParsedToolCall, context: TurnContext, onPreliminaryResult?: (toolCallId: string, result: unknown) => void): Promise<ToolExecutionResult>;
+export declare function executeGeneratorTool(tool: Tool, toolCall: ParsedToolCall, context: TurnContext, onPreliminaryResult?: (toolCallId: string, result: unknown) => void): Promise<ToolExecutionResult>;
 /**
  * Execute a tool call
  * Automatically detects if it's a regular or generator tool
  */
-export declare function executeTool(tool: EnhancedTool, toolCall: ParsedToolCall, context: TurnContext, onPreliminaryResult?: (toolCallId: string, result: unknown) => void): Promise<ToolExecutionResult>;
+export declare function executeTool(tool: Tool, toolCall: ParsedToolCall, context: TurnContext, onPreliminaryResult?: (toolCallId: string, result: unknown) => void): Promise<ToolExecutionResult>;
 /**
  * Find a tool by name in the tools array
  */
-export declare function findToolByName(tools: EnhancedTool[], name: string): EnhancedTool | undefined;
+export declare function findToolByName(tools: Tool[], name: string): Tool | undefined;
 /**
  * Format tool execution result as a string for sending to the model
  */

package/esm/lib/tool-executor.js

@@ -1,20 +1,20 @@
-import { ZodError, toJSONSchema } from "zod/v4";
-import { hasExecuteFunction, isGeneratorTool, isRegularExecuteTool, } from "./tool-types.js";
+import { toJSONSchema, ZodError } from 'zod/v4';
+import { hasExecuteFunction, isGeneratorTool, isRegularExecuteTool } from './tool-types.js';
 /**
  * Convert a Zod schema to JSON Schema using Zod v4's toJSONSchema function
  */
 export function convertZodToJsonSchema(zodSchema) {
     const jsonSchema = toJSONSchema(zodSchema, {
-        target: "openapi-3.0",
+        target: 'openapi-3.0',
     });
     return jsonSchema;
 }
 /**
- * Convert enhanced tools to OpenRouter API format
+ * Convert tools to OpenRouter API format
  */
-export function convertEnhancedToolsToAPIFormat(tools) {
+export function convertToolsToAPIFormat(tools) {
     return tools.map((tool) => ({
-        type: "function",
+        type: 'function',
         name: tool.function.name,
         description: tool.function.description || null,
         strict: null,
@@ -54,7 +54,7 @@ export async function executeRegularTool(tool, toolCall, context) {
         throw new Error(`Tool "${toolCall.name}" is not a regular execute tool or has no execute function`);
     }
     try {
-        // Validate input
+        // Validate input - the schema validation ensures type safety at runtime
         const validatedInput = validateToolInput(tool.function.inputSchema, toolCall.arguments);
         // Execute tool with context
         const result = await Promise.resolve(tool.function.execute(validatedInput, context));
@@ -93,7 +93,7 @@ export async function executeGeneratorTool(tool, toolCall, context, onPreliminar
         throw new Error(`Tool "${toolCall.name}" is not a generator tool`);
     }
     try {
-        // Validate input
+        // Validate input - the schema validation ensures type safety at runtime
         const validatedInput = validateToolInput(tool.function.inputSchema, toolCall.arguments);
         // Execute generator and collect all results
         const preliminaryResults = [];
@@ -171,7 +171,7 @@ export function formatToolResultForModel(result) {
 export function formatToolExecutionError(error, toolCall) {
     if (error instanceof ZodError) {
         const issues = error.issues.map((issue) => ({
-            path: issue.path.join("."),
+            path: issue.path.join('.'),
             message: issue.message,
         }));
         return `Tool "${toolCall.name}" validation error:\n${JSON.stringify(issues, null, 2)}`;

package/esm/lib/tool-orchestrator.d.ts

@@ -1,5 +1,5 @@
-import * as models from "../models/index.js";
-import { EnhancedTool, ToolExecutionResult } from "./tool-types.js";
+import type * as models from '../models/index.js';
+import type { APITool, Tool, ToolExecutionResult } from './tool-types.js';
 /**
  * Options for tool execution
  */
@@ -27,7 +27,7 @@ export interface ToolOrchestrationResult {
  * @param options - Execution options
  * @returns Result containing final response and all execution data
  */
-export declare function executeToolLoop(sendRequest: (input: models.OpenResponsesInput, tools: any[]) => Promise<models.OpenResponsesNonStreamingResponse>, initialInput: models.OpenResponsesInput, tools: EnhancedTool[], apiTools: any[], options?: ToolExecutionOptions): Promise<ToolOrchestrationResult>;
+export declare function executeToolLoop(sendRequest: (input: models.OpenResponsesInput, tools: APITool[]) => Promise<models.OpenResponsesNonStreamingResponse>, initialInput: models.OpenResponsesInput, tools: Tool[], apiTools: APITool[], options?: ToolExecutionOptions): Promise<ToolOrchestrationResult>;
 /**
  * Convert tool execution results to a map for easy lookup
  */

package/esm/lib/tool-orchestrator.js

@@ -1,6 +1,6 @@
-import { hasExecuteFunction, } from "./tool-types.js";
-import { executeTool, findToolByName, } from "./tool-executor.js";
-import { extractToolCallsFromResponse, responseHasToolCalls, } from "./stream-transformers.js";
+import { extractToolCallsFromResponse, responseHasToolCalls } from './stream-transformers.js';
+import { executeTool, findToolByName } from './tool-executor.js';
+import { hasExecuteFunction } from './tool-types.js';
 /**
  * Execute tool calls and manage multi-turn conversations
  * This orchestrates the loop of: request -> tool calls -> execute -> send results -> repeat
@@ -40,23 +40,21 @@ export async function executeToolLoop(sendRequest, initialInput, tools, apiTools
         if (!hasExecutableTools) {
             break;
         }
-        // Execute all tool calls
-        const roundResults = [];
-        for (const toolCall of toolCalls) {
+        // Execute all tool calls in parallel (parallel tool calling)
+        const toolCallPromises = toolCalls.map(async (toolCall) => {
             const tool = findToolByName(tools, toolCall.name);
             if (!tool) {
                 // Tool not found in definitions
-                roundResults.push({
+                return {
                     toolCallId: toolCall.id,
                     toolName: toolCall.name,
                     result: null,
                     error: new Error(`Tool "${toolCall.name}" not found in tool definitions`),
-                });
-                continue;
+                };
             }
             if (!hasExecuteFunction(tool)) {
-                // Tool has no execute function - skip
-                continue;
+                // Tool has no execute function - return null to filter out
+                return null;
             }
             // Build turn context
             const turnContext = {
@@ -64,9 +62,33 @@ export async function executeToolLoop(sendRequest, initialInput, tools, apiTools
                 messageHistory: conversationInput,
             };
             // Execute the tool
-            const result = await executeTool(tool, toolCall, turnContext, onPreliminaryResult);
-            roundResults.push(result);
-        }
+            return executeTool(tool, toolCall, turnContext, onPreliminaryResult);
+        });
+        // Wait for all tool executions to complete in parallel
+        const settledResults = await Promise.allSettled(toolCallPromises);
+        // Process settled results, handling both fulfilled and rejected promises
+        const roundResults = [];
+        settledResults.forEach((settled, i) => {
+            const toolCall = toolCalls[i];
+            if (!toolCall)
+                return;
+            if (settled.status === "fulfilled") {
+                if (settled.value !== null) {
+                    roundResults.push(settled.value);
+                }
+            }
+            else {
+                // Promise rejected - create error result
+                roundResults.push({
+                    toolCallId: toolCall.id,
+                    toolName: toolCall.name,
+                    result: null,
+                    error: settled.reason instanceof Error
+                        ? settled.reason
+                        : new Error(String(settled.reason)),
+                });
+            }
+        });
         toolExecutionResults.push(...roundResults);
         // Build array input with all output from previous response plus tool results
         // The API expects continuation via previousResponseId, not by including outputs
@@ -109,11 +131,11 @@ export function summarizeToolExecutions(results) {
         }
         else {
             const prelimCount = result.preliminaryResults?.length ?? 0;
-            const prelimInfo = prelimCount > 0 ? ` (${prelimCount} preliminary results)` : "";
+            const prelimInfo = prelimCount > 0 ? ` (${prelimCount} preliminary results)` : '';
             lines.push(`✅ ${result.toolName} (${result.toolCallId}): SUCCESS${prelimInfo}`);
         }
     }
-    return lines.join("\n");
+    return lines.join('\n');
 }
 /**
  * Check if any tool executions had errors
@@ -125,8 +147,6 @@ export function hasToolExecutionErrors(results) {
  * Get all tool execution errors
  */
 export function getToolExecutionErrors(results) {
-    return results
-        .filter((result) => result.error !== undefined)
-        .map((result) => result.error);
+    return results.filter((result) => result.error !== undefined).map((result) => result.error);
 }
 //# sourceMappingURL=tool-orchestrator.js.map

package/esm/lib/tool-types.d.ts

@@ -1,6 +1,7 @@
-import { z, type ZodType, type ZodObject, type ZodRawShape } from "zod/v4";
-import * as models from "../models/index.js";
-import type { OpenResponsesStreamEvent } from "../models/index.js";
+import type { ZodObject, ZodRawShape, ZodType, z } from 'zod/v4';
+import type * as models from '../models/index.js';
+import type { OpenResponsesStreamEvent } from '../models/index.js';
+import type { ResponseWrapper } from './response-wrapper.js';
 /**
  * Tool type enum for enhanced tools
  */
@@ -32,7 +33,7 @@ export interface BaseToolFunction<TInput extends ZodObject<ZodRawShape>> {
 /**
  * Regular tool with synchronous or asynchronous execute function and optional outputSchema
  */
-export interface ToolFunctionWithExecute<TInput extends ZodObject<ZodRawShape>, TOutput extends ZodType = ZodType<any>> extends BaseToolFunction<TInput> {
+export interface ToolFunctionWithExecute<TInput extends ZodObject<ZodRawShape>, TOutput extends ZodType = ZodType<unknown>> extends BaseToolFunction<TInput> {
     outputSchema?: TOutput;
     execute: (params: z.infer<TInput>, context?: TurnContext) => Promise<z.infer<TOutput>> | z.infer<TOutput>;
 }
@@ -54,7 +55,7 @@ export interface ToolFunctionWithExecute<TInput extends ZodObject<ZodRawShape>,
  * }
  * ```
  */
-export interface ToolFunctionWithGenerator<TInput extends ZodObject<ZodRawShape>, TEvent extends ZodType = ZodType<any>, TOutput extends ZodType = ZodType<any>> extends BaseToolFunction<TInput> {
+export interface ToolFunctionWithGenerator<TInput extends ZodObject<ZodRawShape>, TEvent extends ZodType = ZodType<unknown>, TOutput extends ZodType = ZodType<unknown>> extends BaseToolFunction<TInput> {
     eventSchema: TEvent;
     outputSchema: TOutput;
     execute: (params: z.infer<TInput>, context?: TurnContext) => AsyncGenerator<z.infer<TEvent>>;
@@ -62,46 +63,46 @@ export interface ToolFunctionWithGenerator<TInput extends ZodObject<ZodRawShape>
 /**
  * Manual tool without execute function - requires manual handling by developer
  */
-export interface ManualToolFunction<TInput extends ZodObject<ZodRawShape>, TOutput extends ZodType = ZodType<any>> extends BaseToolFunction<TInput> {
+export interface ManualToolFunction<TInput extends ZodObject<ZodRawShape>, TOutput extends ZodType = ZodType<unknown>> extends BaseToolFunction<TInput> {
     outputSchema?: TOutput;
 }
 /**
  * Tool with execute function (regular or generator)
  */
-export type ToolWithExecute<TInput extends ZodObject<ZodRawShape> = ZodObject<ZodRawShape>, TOutput extends ZodType = ZodType<any>> = {
+export type ToolWithExecute<TInput extends ZodObject<ZodRawShape> = ZodObject<ZodRawShape>, TOutput extends ZodType = ZodType<unknown>> = {
     type: ToolType.Function;
     function: ToolFunctionWithExecute<TInput, TOutput>;
 };
 /**
  * Tool with generator execute function
  */
-export type ToolWithGenerator<TInput extends ZodObject<ZodRawShape> = ZodObject<ZodRawShape>, TEvent extends ZodType = ZodType<any>, TOutput extends ZodType = ZodType<any>> = {
+export type ToolWithGenerator<TInput extends ZodObject<ZodRawShape> = ZodObject<ZodRawShape>, TEvent extends ZodType = ZodType<unknown>, TOutput extends ZodType = ZodType<unknown>> = {
     type: ToolType.Function;
     function: ToolFunctionWithGenerator<TInput, TEvent, TOutput>;
 };
 /**
  * Tool without execute function (manual handling)
  */
-export type ManualTool<TInput extends ZodObject<ZodRawShape> = ZodObject<ZodRawShape>, TOutput extends ZodType = ZodType<any>> = {
+export type ManualTool<TInput extends ZodObject<ZodRawShape> = ZodObject<ZodRawShape>, TOutput extends ZodType = ZodType<unknown>> = {
     type: ToolType.Function;
     function: ManualToolFunction<TInput, TOutput>;
 };
 /**
  * Union type of all enhanced tool types
  */
-export type EnhancedTool = ToolWithExecute<any, any> | ToolWithGenerator<any, any> | ManualTool<any, any>;
+export type Tool = ToolWithExecute<ZodObject<ZodRawShape>, ZodType<unknown>> | ToolWithGenerator<ZodObject<ZodRawShape>, ZodType<unknown>, ZodType<unknown>> | ManualTool<ZodObject<ZodRawShape>, ZodType<unknown>>;
 /**
  * Type guard to check if a tool has an execute function
  */
-export declare function hasExecuteFunction(tool: EnhancedTool): tool is ToolWithExecute | ToolWithGenerator;
+export declare function hasExecuteFunction(tool: Tool): tool is ToolWithExecute | ToolWithGenerator;
 /**
  * Type guard to check if a tool uses a generator (has eventSchema)
  */
-export declare function isGeneratorTool(tool: EnhancedTool): tool is ToolWithGenerator;
+export declare function isGeneratorTool(tool: Tool): tool is ToolWithGenerator;
 /**
  * Type guard to check if a tool is a regular execution tool (not generator)
  */
-export declare function isRegularExecuteTool(tool: EnhancedTool): tool is ToolWithExecute;
+export declare function isRegularExecuteTool(tool: Tool): tool is ToolWithExecute;
 /**
  * Parsed tool call from API response
  */
@@ -128,8 +129,8 @@ export type MaxToolRounds = number | ((context: TurnContext) => boolean);
  * Result of executeTools operation
  */
 export interface ExecuteToolsResult {
-    finalResponse: any;
-    allResponses: any[];
+    finalResponse: ResponseWrapper;
+    allResponses: ResponseWrapper[];
     toolResults: Map<string, {
         result: unknown;
         preliminaryResults?: unknown[];
@@ -140,19 +141,19 @@ export interface ExecuteToolsResult {
  * Matches OpenResponsesRequestToolFunction structure
  */
 export interface APITool {
-    type: "function";
+    type: 'function';
     name: string;
     description?: string | null;
     strict?: boolean | null;
     parameters: {
-        [k: string]: any | null;
+        [k: string]: unknown;
     } | null;
 }
 /**
  * Tool preliminary result event emitted during generator tool execution
  */
 export type ToolPreliminaryResultEvent = {
-    type: "tool.preliminary_result";
+    type: 'tool.preliminary_result';
     toolCallId: string;
     result: unknown;
     timestamp: number;
@@ -171,10 +172,10 @@ export declare function isToolPreliminaryResultEvent(event: EnhancedResponseStre
  * Includes both argument deltas and preliminary results
  */
 export type ToolStreamEvent = {
-    type: "delta";
+    type: 'delta';
     content: string;
 } | {
-    type: "preliminary_result";
+    type: 'preliminary_result';
     toolCallId: string;
     result: unknown;
 };
@@ -183,17 +184,17 @@ export type ToolStreamEvent = {
  * Includes content deltas, completion events, and tool preliminary results
  */
 export type ChatStreamEvent = {
-    type: "content.delta";
+    type: 'content.delta';
     delta: string;
 } | {
-    type: "message.complete";
-    response: any;
+    type: 'message.complete';
+    response: models.OpenResponsesNonStreamingResponse;
 } | {
-    type: "tool.preliminary_result";
+    type: 'tool.preliminary_result';
     toolCallId: string;
     result: unknown;
 } | {
     type: string;
-    event: any;
+    event: OpenResponsesStreamEvent;
 };
 //# sourceMappingURL=tool-types.d.ts.map

package/esm/lib/tool-types.js

@@ -9,13 +9,13 @@ export var ToolType;
  * Type guard to check if a tool has an execute function
  */
 export function hasExecuteFunction(tool) {
-    return "execute" in tool.function && typeof tool.function.execute === "function";
+    return 'execute' in tool.function && typeof tool.function.execute === 'function';
 }
 /**
  * Type guard to check if a tool uses a generator (has eventSchema)
  */
 export function isGeneratorTool(tool) {
-    return "eventSchema" in tool.function;
+    return 'eventSchema' in tool.function;
 }
 /**
  * Type guard to check if a tool is a regular execution tool (not generator)
@@ -27,6 +27,6 @@ export function isRegularExecuteTool(tool) {
  * Type guard to check if an event is a tool preliminary result event
  */
 export function isToolPreliminaryResultEvent(event) {
-    return event.type === "tool.preliminary_result";
+    return event.type === 'tool.preliminary_result';
 }
 //# sourceMappingURL=tool-types.js.map

package/esm/models/chatcompletionfinishreason.d.ts

@@ -0,0 +1,13 @@
+import * as z from "zod/v4";
+import { OpenEnum } from "../types/enums.js";
+export declare const ChatCompletionFinishReason: {
+    readonly ToolCalls: "tool_calls";
+    readonly Stop: "stop";
+    readonly Length: "length";
+    readonly ContentFilter: "content_filter";
+    readonly Error: "error";
+};
+export type ChatCompletionFinishReason = OpenEnum<typeof ChatCompletionFinishReason>;
+/** @internal */
+export declare const ChatCompletionFinishReason$inboundSchema: z.ZodType<ChatCompletionFinishReason, unknown>;
+//# sourceMappingURL=chatcompletionfinishreason.d.ts.map