@openrouter/sdk 0.1.17 → 0.1.23

package/esm/lib/tool-orchestrator.js

@@ -0,0 +1,132 @@
+import { hasExecuteFunction, } from "./tool-types.js";
+import { executeTool, findToolByName, } from "./tool-executor.js";
+import { extractToolCallsFromResponse, responseHasToolCalls, } from "./stream-transformers.js";
+/**
+ * Execute tool calls and manage multi-turn conversations
+ * This orchestrates the loop of: request -> tool calls -> execute -> send results -> repeat
+ *
+ * @param sendRequest - Function to send a request and get a response
+ * @param initialInput - Starting input for the conversation
+ * @param tools - Enhanced tools with Zod schemas and execute functions
+ * @param apiTools - Converted tools in API format (JSON Schema)
+ * @param options - Execution options
+ * @returns Result containing final response and all execution data
+ */
+export async function executeToolLoop(sendRequest, initialInput, tools, apiTools, options = {}) {
+    const maxRounds = options.maxRounds ?? 5;
+    const onPreliminaryResult = options.onPreliminaryResult;
+    const allResponses = [];
+    const toolExecutionResults = [];
+    let conversationInput = initialInput;
+    let currentRound = 0;
+    let currentResponse;
+    // Initial request
+    currentResponse = await sendRequest(conversationInput, apiTools);
+    allResponses.push(currentResponse);
+    // Loop until no more tool calls or max rounds reached
+    while (responseHasToolCalls(currentResponse) && currentRound < maxRounds) {
+        currentRound++;
+        // Extract tool calls from response
+        const toolCalls = extractToolCallsFromResponse(currentResponse);
+        if (toolCalls.length === 0) {
+            break;
+        }
+        // Check if any tools have execute functions
+        const hasExecutableTools = toolCalls.some((toolCall) => {
+            const tool = findToolByName(tools, toolCall.name);
+            return tool && hasExecuteFunction(tool);
+        });
+        // If no executable tools, return (manual execution mode)
+        if (!hasExecutableTools) {
+            break;
+        }
+        // Execute all tool calls
+        const roundResults = [];
+        for (const toolCall of toolCalls) {
+            const tool = findToolByName(tools, toolCall.name);
+            if (!tool) {
+                // Tool not found in definitions
+                roundResults.push({
+                    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;
+            }
+            // Build turn context
+            const turnContext = {
+                numberOfTurns: currentRound,
+                messageHistory: conversationInput,
+            };
+            // Execute the tool
+            const result = await executeTool(tool, toolCall, turnContext, onPreliminaryResult);
+            roundResults.push(result);
+        }
+        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
+        // For now, we'll keep the conversation going via previousResponseId
+        conversationInput = initialInput; // Keep original input
+        // Note: The OpenRouter Responses API uses previousResponseId for continuation
+        // Tool results are automatically associated with the previous response's tool calls
+        // Send updated conversation to API - this should use previousResponseId
+        currentResponse = await sendRequest(conversationInput, apiTools);
+        allResponses.push(currentResponse);
+    }
+    return {
+        finalResponse: currentResponse,
+        allResponses,
+        toolExecutionResults,
+        conversationInput,
+    };
+}
+/**
+ * Convert tool execution results to a map for easy lookup
+ */
+export function toolResultsToMap(results) {
+    const map = new Map();
+    for (const result of results) {
+        map.set(result.toolCallId, {
+            result: result.result,
+            preliminaryResults: result.preliminaryResults,
+        });
+    }
+    return map;
+}
+/**
+ * Build a summary of tool executions for debugging/logging
+ */
+export function summarizeToolExecutions(results) {
+    const lines = [];
+    for (const result of results) {
+        if (result.error) {
+            lines.push(`❌ ${result.toolName} (${result.toolCallId}): ERROR - ${result.error.message}`);
+        }
+        else {
+            const prelimCount = result.preliminaryResults?.length ?? 0;
+            const prelimInfo = prelimCount > 0 ? ` (${prelimCount} preliminary results)` : "";
+            lines.push(`✅ ${result.toolName} (${result.toolCallId}): SUCCESS${prelimInfo}`);
+        }
+    }
+    return lines.join("\n");
+}
+/**
+ * Check if any tool executions had errors
+ */
+export function hasToolExecutionErrors(results) {
+    return results.some((result) => result.error !== undefined);
+}
+/**
+ * Get all tool execution errors
+ */
+export function getToolExecutionErrors(results) {
+    return results
+        .filter((result) => result.error !== undefined)
+        .map((result) => result.error);
+}
+//# sourceMappingURL=tool-orchestrator.js.map

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

@@ -0,0 +1,199 @@
+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";
+/**
+ * Tool type enum for enhanced tools
+ */
+export declare enum ToolType {
+    Function = "function"
+}
+/**
+ * Turn context passed to tool execute functions
+ * Contains information about the current conversation state
+ */
+export interface TurnContext {
+    /** Number of tool execution turns so far (1-indexed: first turn = 1) */
+    numberOfTurns: number;
+    /** Current message history being sent to the API */
+    messageHistory: models.OpenResponsesInput;
+    /** Model name if request.model is set */
+    model?: string;
+    /** Model names if request.models is set */
+    models?: string[];
+}
+/**
+ * Base tool function interface with inputSchema
+ */
+export interface BaseToolFunction<TInput extends ZodObject<ZodRawShape>> {
+    name: string;
+    description?: string;
+    inputSchema: TInput;
+}
+/**
+ * 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> {
+    outputSchema?: TOutput;
+    execute: (params: z.infer<TInput>, context?: TurnContext) => Promise<z.infer<TOutput>> | z.infer<TOutput>;
+}
+/**
+ * Generator-based tool with async generator execute function
+ * Emits preliminary events (validated by eventSchema) during execution
+ * and a final output (validated by outputSchema) as the last emission
+ *
+ * @example
+ * ```typescript
+ * {
+ *   eventSchema: z.object({ status: z.string() }),  // For progress events
+ *   outputSchema: z.object({ result: z.number() }), // For final output
+ *   execute: async function* (params) {
+ *     yield { status: "processing..." };  // Event
+ *     yield { status: "almost done..." }; // Event
+ *     yield { result: 42 };               // Final output (must be last)
+ *   }
+ * }
+ * ```
+ */
+export interface ToolFunctionWithGenerator<TInput extends ZodObject<ZodRawShape>, TEvent extends ZodType = ZodType<any>, TOutput extends ZodType = ZodType<any>> extends BaseToolFunction<TInput> {
+    eventSchema: TEvent;
+    outputSchema: TOutput;
+    execute: (params: z.infer<TInput>, context?: TurnContext) => AsyncGenerator<z.infer<TEvent>>;
+}
+/**
+ * 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> {
+    outputSchema?: TOutput;
+}
+/**
+ * Tool with execute function (regular or generator)
+ */
+export type ToolWithExecute<TInput extends ZodObject<ZodRawShape> = ZodObject<ZodRawShape>, TOutput extends ZodType = ZodType<any>> = {
+    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>> = {
+    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>> = {
+    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>;
+/**
+ * Type guard to check if a tool has an execute function
+ */
+export declare function hasExecuteFunction(tool: EnhancedTool): 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;
+/**
+ * Type guard to check if a tool is a regular execution tool (not generator)
+ */
+export declare function isRegularExecuteTool(tool: EnhancedTool): tool is ToolWithExecute;
+/**
+ * Parsed tool call from API response
+ */
+export interface ParsedToolCall {
+    id: string;
+    name: string;
+    arguments: unknown;
+}
+/**
+ * Result of tool execution
+ */
+export interface ToolExecutionResult {
+    toolCallId: string;
+    toolName: string;
+    result: unknown;
+    preliminaryResults?: unknown[];
+    error?: Error;
+}
+/**
+ * Type for maxToolRounds - can be a number or a function that determines if execution should continue
+ */
+export type MaxToolRounds = number | ((context: TurnContext) => boolean);
+/**
+ * Result of executeTools operation
+ */
+export interface ExecuteToolsResult {
+    finalResponse: any;
+    allResponses: any[];
+    toolResults: Map<string, {
+        result: unknown;
+        preliminaryResults?: unknown[];
+    }>;
+}
+/**
+ * Standard tool format for OpenRouter API (JSON Schema based)
+ * Matches OpenResponsesRequestToolFunction structure
+ */
+export interface APITool {
+    type: "function";
+    name: string;
+    description?: string | null;
+    strict?: boolean | null;
+    parameters: {
+        [k: string]: any | null;
+    } | null;
+}
+/**
+ * Tool preliminary result event emitted during generator tool execution
+ */
+export type ToolPreliminaryResultEvent = {
+    type: "tool.preliminary_result";
+    toolCallId: string;
+    result: unknown;
+    timestamp: number;
+};
+/**
+ * Enhanced stream event types for getFullResponsesStream
+ * Extends OpenResponsesStreamEvent with tool preliminary results
+ */
+export type EnhancedResponseStreamEvent = OpenResponsesStreamEvent | ToolPreliminaryResultEvent;
+/**
+ * Type guard to check if an event is a tool preliminary result event
+ */
+export declare function isToolPreliminaryResultEvent(event: EnhancedResponseStreamEvent): event is ToolPreliminaryResultEvent;
+/**
+ * Tool stream event types for getToolStream
+ * Includes both argument deltas and preliminary results
+ */
+export type ToolStreamEvent = {
+    type: "delta";
+    content: string;
+} | {
+    type: "preliminary_result";
+    toolCallId: string;
+    result: unknown;
+};
+/**
+ * Chat stream event types for getFullChatStream
+ * Includes content deltas, completion events, and tool preliminary results
+ */
+export type ChatStreamEvent = {
+    type: "content.delta";
+    delta: string;
+} | {
+    type: "message.complete";
+    response: any;
+} | {
+    type: "tool.preliminary_result";
+    toolCallId: string;
+    result: unknown;
+} | {
+    type: string;
+    event: any;
+};
+//# sourceMappingURL=tool-types.d.ts.map

package/esm/lib/tool-types.js

@@ -0,0 +1,32 @@
+/**
+ * Tool type enum for enhanced tools
+ */
+export var ToolType;
+(function (ToolType) {
+    ToolType["Function"] = "function";
+})(ToolType || (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";
+}
+/**
+ * Type guard to check if a tool uses a generator (has eventSchema)
+ */
+export function isGeneratorTool(tool) {
+    return "eventSchema" in tool.function;
+}
+/**
+ * Type guard to check if a tool is a regular execution tool (not generator)
+ */
+export function isRegularExecuteTool(tool) {
+    return hasExecuteFunction(tool) && !isGeneratorTool(tool);
+}
+/**
+ * Type guard to check if an event is a tool preliminary result event
+ */
+export function isToolPreliminaryResultEvent(event) {
+    return event.type === "tool.preliminary_result";
+}
+//# sourceMappingURL=tool-types.js.map

package/esm/sdk/sdk.d.ts

@@ -12,6 +12,12 @@ import { Models } from "./models.js";
 import { OAuth } from "./oauth.js";
 import { ParametersT } from "./parameters.js";
 import { Providers } from "./providers.js";
+import { ResponseWrapper } from "../lib/response-wrapper.js";
+import { RequestOptions } from "../lib/sdks.js";
+import { EnhancedTool, MaxToolRounds, ToolType } from "../lib/tool-types.js";
+import * as models from "../models/index.js";
+export { ToolType };
+export type { EnhancedTool, MaxToolRounds };
 export declare class OpenRouter extends ClientSDK {
     private _beta?;
     get beta(): Beta;
@@ -39,5 +45,9 @@ export declare class OpenRouter extends ClientSDK {
     get chat(): Chat;
     private _completions?;
     get completions(): Completions;
+    callModel(request: Omit<models.OpenResponsesRequest, "stream" | "tools"> & {
+        tools?: EnhancedTool[] | models.OpenResponsesRequest["tools"];
+        maxToolRounds?: MaxToolRounds;
+    }, options?: RequestOptions): ResponseWrapper;
 }
 //# sourceMappingURL=sdk.d.ts.map

package/esm/sdk/sdk.js

@@ -15,6 +15,11 @@ import { Models } from "./models.js";
 import { OAuth } from "./oauth.js";
 import { ParametersT } from "./parameters.js";
 import { Providers } from "./providers.js";
+// #region imports
+import { callModel as callModelFunc } from "../funcs/callModel.js";
+import { ToolType } from "../lib/tool-types.js";
+export { ToolType };
+// #endregion imports
 export class OpenRouter extends ClientSDK {
     get beta() {
         return (this._beta ?? (this._beta = new Beta(this._options)));
@@ -55,5 +60,9 @@ export class OpenRouter extends ClientSDK {
     get completions() {
         return (this._completions ?? (this._completions = new Completions(this._options)));
     }
+    // #region sdk-class-body
+    callModel(request, options) {
+        return callModelFunc(this, request, options);
+    }
 }
 //# sourceMappingURL=sdk.js.map

package/jsr.json

@@ -2,7 +2,7 @@
 
 {
   "name": "@openrouter/sdk",
-  "version": "0.1.17",
+  "version": "0.1.23",
   "exports": {
     ".": "./src/index.ts",    
     "./models/errors": "./src/models/errors/index.ts",    

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@openrouter/sdk",
-  "version": "0.1.17",
+  "version": "0.1.23",
   "author": "OpenRouter",
   "description": "The OpenRouter TypeScript SDK is a type-safe toolkit for building AI applications with access to 300+ language models through a unified API.",
   "keywords": [
@@ -48,11 +48,6 @@
       "types": "./esm/models/operations/index.d.ts",
       "default": "./esm/models/operations/index.js"
     },
-    "./react-query": {
-      "source": "./src/react-query/index.ts",
-      "types": "./esm/react-query/index.d.ts",
-      "default": "./esm/react-query/index.js"
-    },
     "./*.js": {
       "source": "./src/*.ts",
       "types": "./esm/*.d.ts",
@@ -75,20 +70,11 @@
     "prepublishOnly": "npm run build"
   },
   "peerDependencies": {
-    "@tanstack/react-query": "^5",
-    "react": "^18 || ^19",
-    "react-dom": "^18 || ^19"
-  },
-  "peerDependenciesMeta": {
-    "@tanstack/react-query": {"optional":true},
-    "react": {"optional":true},
-    "react-dom": {"optional":true}
+    
   },
   "devDependencies": {
     "@eslint/js": "^9.19.0",
-    "@tanstack/react-query": "^5.61.4",
     "@types/node": "^22.13.12",
-    "@types/react": "^18.3.12",
     "dotenv": "^16.4.7",
     "eslint": "^9.19.0",
     "globals": "^15.14.0",

package/vitest.config.ts

@@ -22,5 +22,9 @@ export default defineConfig({
     include: ["tests/**/*.test.ts"],
     hookTimeout: 30000,
     testTimeout: 30000,
+    typecheck: {
+      enabled: true,
+      include: ["tests/**/*.test.ts"],
+    },
   },
 });