@openrouter/sdk 0.4.0 → 0.5.1

package/esm/lib/config.d.ts

@@ -1,3 +1,4 @@
+import type { Hook } from "../hooks/types.js";
 import { HTTPClient } from "./http.js";
 import { Logger } from "./logger.js";
 import { RetryConfig } from "./retries.js";
@@ -40,13 +41,18 @@ export type SDKOptions = {
     retryConfig?: RetryConfig;
     timeoutMs?: number;
     debugLogger?: Logger;
+    /**
+     * Hooks for request/response lifecycle events.
+     * Can be a single hook object or an array of hooks.
+     */
+    hooks?: Hook | Hook[];
 };
 export declare function serverURLFromOptions(options: SDKOptions): URL | null;
 export declare const SDK_METADATA: {
     readonly language: "typescript";
     readonly openapiDocVersion: "1.0.0";
-    readonly sdkVersion: "0.4.0";
+    readonly sdkVersion: "0.5.1";
     readonly genVersion: "2.788.4";
-    readonly userAgent: "speakeasy-sdk/typescript 0.4.0 2.788.4 1.0.0 @openrouter/sdk";
+    readonly userAgent: "speakeasy-sdk/typescript 0.5.1 2.788.4 1.0.0 @openrouter/sdk";
 };
 //# sourceMappingURL=config.d.ts.map

package/esm/lib/config.js

@@ -26,8 +26,8 @@ export function serverURLFromOptions(options) {
 export const SDK_METADATA = {
     language: "typescript",
     openapiDocVersion: "1.0.0",
-    sdkVersion: "0.4.0",
+    sdkVersion: "0.5.1",
     genVersion: "2.788.4",
-    userAgent: "speakeasy-sdk/typescript 0.4.0 2.788.4 1.0.0 @openrouter/sdk",
+    userAgent: "speakeasy-sdk/typescript 0.5.1 2.788.4 1.0.0 @openrouter/sdk",
 };
 //# sourceMappingURL=config.js.map

package/esm/lib/model-result.d.ts

@@ -267,10 +267,11 @@ export declare class ModelResult<TTools extends readonly Tool[]> {
      *
      * 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 OpenResponsesFunctionCallOutput after tool execution completes.
-     * Returns ResponsesOutputMessage or OpenResponsesFunctionCallOutput compatible with OpenAI Responses API format.
+     * Also yields function_call items and OpenResponsesFunctionCallOutput after tool execution completes.
+     * Returns ResponsesOutputMessage, ResponsesOutputItemFunctionCall, or OpenResponsesFunctionCallOutput
+     * compatible with OpenAI Responses API format.
      */
-    getNewMessagesStream(): AsyncIterableIterator<models.ResponsesOutputMessage | models.OpenResponsesFunctionCallOutput>;
+    getNewMessagesStream(): AsyncIterableIterator<models.ResponsesOutputMessage | models.OpenResponsesFunctionCallOutput | models.ResponsesOutputItemFunctionCall>;
     /**
      * Stream only reasoning deltas as they arrive.
      * This filters the full event stream to only yield reasoning content.

package/esm/lib/model-result.js

@@ -8,7 +8,7 @@ import { executeTool } from './tool-executor.js';
 import { executeNextTurnParamsFunctions, applyNextTurnParamsToRequest } from './next-turn-params.js';
 import { hasExecuteFunction } from './tool-types.js';
 import { isStopConditionMet, stepCountIs } from './stop-conditions.js';
-import { isOutputMessage, isFunctionCallOutputItem, isReasoningOutputItem, isWebSearchCallOutputItem, isFileSearchCallOutputItem, isImageGenerationCallOutputItem, hasTypeProperty, } from './stream-type-guards.js';
+import { isOutputMessage, isFunctionCallItem, isReasoningOutputItem, isWebSearchCallOutputItem, isFileSearchCallOutputItem, isImageGenerationCallOutputItem, hasTypeProperty, } from './stream-type-guards.js';
 /**
  * Default maximum number of tool execution steps if no stopWhen is specified.
  * This prevents infinite loops in tool execution.
@@ -305,6 +305,32 @@ export class ModelResult {
             const tool = this.options.tools?.find((t) => t.function.name === toolCall.name);
             if (!tool || !hasExecuteFunction(tool))
                 continue;
+            // Check if arguments failed to parse (remained as string instead of object)
+            // This happens when the model returns invalid JSON for tool call arguments
+            // We use 'unknown' cast because the type system doesn't know arguments can be a string
+            // when JSON parsing fails in stream-transformers.ts
+            const args = toolCall.arguments;
+            if (typeof args === 'string') {
+                const rawArgs = args;
+                const errorMessage = `Failed to parse tool call arguments for "${toolCall.name}": The model provided invalid JSON. ` +
+                    `Raw arguments received: "${rawArgs}". ` +
+                    `Please provide valid JSON arguments for this tool call.`;
+                // Emit error event if broadcaster exists
+                if (this.toolEventBroadcaster) {
+                    this.toolEventBroadcaster.push({
+                        type: 'tool_result',
+                        toolCallId: toolCall.id,
+                        result: { error: errorMessage },
+                    });
+                }
+                toolResults.push({
+                    type: 'function_call_output',
+                    id: `output_${toolCall.id}`,
+                    callId: toolCall.id,
+                    output: JSON.stringify({ error: errorMessage }),
+                });
+                continue;
+            }
             // Track preliminary results for this specific tool call
             const preliminaryResultsForCall = [];
             // Create callback for real-time preliminary results
@@ -352,7 +378,13 @@ export class ModelResult {
     async resolveAsyncFunctionsForTurn(turnContext) {
         if (hasAsyncFunctions(this.options.request)) {
             const resolved = await resolveAsyncFunctions(this.options.request, turnContext);
-            this.resolvedRequest = { ...resolved, stream: false };
+            // Preserve accumulated input from previous turns
+            const preservedInput = this.resolvedRequest?.input;
+            this.resolvedRequest = {
+                ...resolved,
+                stream: false,
+                ...(preservedInput !== undefined && { input: preservedInput }),
+            };
         }
     }
     /**
@@ -379,8 +411,15 @@ export class ModelResult {
      * @returns The new response from the API
      */
     async makeFollowupRequest(currentResponse, toolResults) {
-        // Build new input with tool results
+        // Build new input preserving original conversation + tool results
+        const originalInput = this.resolvedRequest?.input;
+        const normalizedOriginalInput = Array.isArray(originalInput)
+            ? originalInput
+            : originalInput
+                ? [{ role: 'user', content: originalInput }]
+                : [];
         const newInput = [
+            ...normalizedOriginalInput,
             ...(Array.isArray(currentResponse.output)
                 ? currentResponse.output
                 : [currentResponse.output]),
@@ -389,9 +428,13 @@ export class ModelResult {
         if (!this.resolvedRequest) {
             throw new Error('Request not initialized');
         }
-        const newRequest = {
+        // Update resolvedRequest.input with accumulated conversation for next turn
+        this.resolvedRequest = {
             ...this.resolvedRequest,
             input: newInput,
+        };
+        const newRequest = {
+            ...this.resolvedRequest,
             stream: false,
         };
         const newResult = await betaResponsesSend(this.options.client, newRequest, this.options.options);
@@ -890,8 +933,16 @@ export class ModelResult {
             yield* buildItemsStream(this.reusableStream);
             // Execute tools if needed
             await this.executeToolsIfNeeded();
-            // Yield function call outputs for each executed tool
+            // Yield function calls and outputs for each tool round
             for (const round of this.allToolExecutionRounds) {
+                // Round 0's function_calls already yielded via buildItemsStream
+                if (round.round > 0) {
+                    for (const item of round.response.output) {
+                        if (isFunctionCallItem(item)) {
+                            yield item;
+                        }
+                    }
+                }
                 for (const toolResult of round.toolResults) {
                     yield toolResult;
                 }
@@ -900,7 +951,7 @@ export class ModelResult {
             if (this.finalResponse && this.allToolExecutionRounds.length > 0) {
                 for (const item of this.finalResponse.output) {
                     if (isOutputMessage(item) ||
-                        isFunctionCallOutputItem(item) ||
+                        isFunctionCallItem(item) ||
                         isReasoningOutputItem(item) ||
                         isWebSearchCallOutputItem(item) ||
                         isFileSearchCallOutputItem(item) ||
@@ -918,8 +969,9 @@ export class ModelResult {
      *
      * 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 OpenResponsesFunctionCallOutput after tool execution completes.
-     * Returns ResponsesOutputMessage or OpenResponsesFunctionCallOutput compatible with OpenAI Responses API format.
+     * Also yields function_call items and OpenResponsesFunctionCallOutput after tool execution completes.
+     * Returns ResponsesOutputMessage, ResponsesOutputItemFunctionCall, or OpenResponsesFunctionCallOutput
+     * compatible with OpenAI Responses API format.
      */
     getNewMessagesStream() {
         return async function* () {
@@ -931,8 +983,15 @@ export class ModelResult {
             yield* buildResponsesMessageStream(this.reusableStream);
             // Execute tools if needed
             await this.executeToolsIfNeeded();
-            // Yield function call outputs for each executed tool
+            // Yield function calls and their outputs for each executed tool
             for (const round of this.allToolExecutionRounds) {
+                // First yield the function_call items from the response that triggered tool execution
+                for (const item of round.response.output) {
+                    if (isFunctionCallItem(item)) {
+                        yield item;
+                    }
+                }
+                // Then yield the function_call_output results
                 for (const toolResult of round.toolResults) {
                     yield toolResult;
                 }

package/esm/lib/sdks.d.ts

@@ -1,5 +1,5 @@
 import { SDKHooks } from "../hooks/hooks.js";
-import { HookContext } from "../hooks/types.js";
+import type { HookContext } from "../hooks/types.js";
 import { ConnectionError, InvalidRequestError, RequestAbortedError, RequestTimeoutError, UnexpectedClientError } from "../models/errors/httpclienterrors.js";
 import { Result } from "../types/fp.js";
 import { SDKOptions } from "./config.js";

package/esm/lib/sdks.js

@@ -13,7 +13,7 @@ var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (
     if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
     return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
 };
-var _ClientSDK_httpClient, _ClientSDK_hooks, _ClientSDK_logger;
+var _ClientSDK_instances, _ClientSDK_httpClient, _ClientSDK_hooks, _ClientSDK_logger, _ClientSDK_registerHook;
 import { SDKHooks } from "../hooks/hooks.js";
 import { ConnectionError, InvalidRequestError, RequestAbortedError, RequestTimeoutError, UnexpectedClientError, } from "../models/errors/httpclienterrors.js";
 import { ERR, OK } from "../types/fp.js";
@@ -33,18 +33,22 @@ const isBrowserLike = webWorkerLike
     || (typeof window === "object" && typeof window.document !== "undefined");
 export class ClientSDK {
     constructor(options = {}) {
+        _ClientSDK_instances.add(this);
         _ClientSDK_httpClient.set(this, void 0);
         _ClientSDK_hooks.set(this, void 0);
         _ClientSDK_logger.set(this, void 0);
-        const opt = options;
-        if (typeof opt === "object"
-            && opt != null
-            && "hooks" in opt
-            && opt.hooks instanceof SDKHooks) {
-            __classPrivateFieldSet(this, _ClientSDK_hooks, opt.hooks, "f");
+        // Reuse existing SDKHooks if passed (for sub-SDKs)
+        if (options.hooks instanceof SDKHooks) {
+            __classPrivateFieldSet(this, _ClientSDK_hooks, options.hooks, "f");
         }
         else {
             __classPrivateFieldSet(this, _ClientSDK_hooks, new SDKHooks(), "f");
+            if (options.hooks) {
+                const hooksArray = Array.isArray(options.hooks) ? options.hooks : [options.hooks];
+                for (const hook of hooksArray) {
+                    __classPrivateFieldGet(this, _ClientSDK_instances, "m", _ClientSDK_registerHook).call(this, hook);
+                }
+            }
         }
         const defaultHttpClient = new HTTPClient();
         options.httpClient = options.httpClient || defaultHttpClient;
@@ -185,7 +189,23 @@ export class ClientSDK {
         });
     }
 }
-_ClientSDK_httpClient = new WeakMap(), _ClientSDK_hooks = new WeakMap(), _ClientSDK_logger = new WeakMap();
+_ClientSDK_httpClient = new WeakMap(), _ClientSDK_hooks = new WeakMap(), _ClientSDK_logger = new WeakMap(), _ClientSDK_instances = new WeakSet(), _ClientSDK_registerHook = function _ClientSDK_registerHook(hook) {
+    if ("sdkInit" in hook) {
+        __classPrivateFieldGet(this, _ClientSDK_hooks, "f").registerSDKInitHook(hook);
+    }
+    if ("beforeCreateRequest" in hook) {
+        __classPrivateFieldGet(this, _ClientSDK_hooks, "f").registerBeforeCreateRequestHook(hook);
+    }
+    if ("beforeRequest" in hook) {
+        __classPrivateFieldGet(this, _ClientSDK_hooks, "f").registerBeforeRequestHook(hook);
+    }
+    if ("afterSuccess" in hook) {
+        __classPrivateFieldGet(this, _ClientSDK_hooks, "f").registerAfterSuccessHook(hook);
+    }
+    if ("afterError" in hook) {
+        __classPrivateFieldGet(this, _ClientSDK_hooks, "f").registerAfterErrorHook(hook);
+    }
+};
 const jsonLikeContentTypeRE = /(application|text)\/.*?\+*json.*/;
 const jsonlLikeContentTypeRE = /(application|text)\/(.*?\+*\bjsonl\b.*|.*?\+*\bx-ndjson\b.*)/;
 async function logRequest(logger, req) {

package/esm/lib/stream-transformers.js

@@ -1,4 +1,4 @@
-import { isOutputTextDeltaEvent, isReasoningDeltaEvent, isFunctionCallArgumentsDeltaEvent, isOutputItemAddedEvent, isOutputItemDoneEvent, isResponseCompletedEvent, isResponseFailedEvent, isResponseIncompleteEvent, isFunctionCallArgumentsDoneEvent, isOutputMessage, isFunctionCallOutputItem, isReasoningOutputItem, isWebSearchCallOutputItem, isFileSearchCallOutputItem, isImageGenerationCallOutputItem, isOutputTextPart, isRefusalPart, isFileCitationAnnotation, isURLCitationAnnotation, isFilePathAnnotation, } from './stream-type-guards.js';
+import { isOutputTextDeltaEvent, isReasoningDeltaEvent, isFunctionCallArgumentsDeltaEvent, isOutputItemAddedEvent, isOutputItemDoneEvent, isResponseCompletedEvent, isResponseFailedEvent, isResponseIncompleteEvent, isFunctionCallArgumentsDoneEvent, isOutputMessage, isFunctionCallItem, isReasoningOutputItem, isWebSearchCallOutputItem, isFileSearchCallOutputItem, isImageGenerationCallOutputItem, isOutputTextPart, isRefusalPart, isFileCitationAnnotation, isURLCitationAnnotation, isFilePathAnnotation, } from './stream-type-guards.js';
 /**
  * Extract text deltas from responses stream events
  */
@@ -149,7 +149,7 @@ function handleOutputItemAdded(event, itemsInProgress) {
             content: [],
         };
     }
-    if (isFunctionCallOutputItem(item)) {
+    if (isFunctionCallItem(item)) {
         // Use item.id if available (matches itemId in delta events), fall back to callId
         const itemKey = item.id ?? item.callId;
         itemsInProgress.set(itemKey, {
@@ -276,7 +276,7 @@ function handleOutputItemDone(event, itemsInProgress) {
         itemsInProgress.delete(item.id);
         return item;
     }
-    if (isFunctionCallOutputItem(item)) {
+    if (isFunctionCallItem(item)) {
         // Use item.id if available (matches itemId in delta events), fall back to callId
         itemsInProgress.delete(item.id ?? item.callId);
         return item;
@@ -438,7 +438,7 @@ export function extractTextFromResponse(response) {
 export function extractToolCallsFromResponse(response) {
     const toolCalls = [];
     for (const item of response.output) {
-        if (isFunctionCallOutputItem(item)) {
+        if (isFunctionCallItem(item)) {
             try {
                 const parsedArguments = JSON.parse(item.arguments);
                 toolCalls.push({
@@ -474,7 +474,7 @@ export async function* buildToolCallStream(stream) {
         }
         switch (event.type) {
             case 'response.output_item.added': {
-                if (isOutputItemAddedEvent(event) && event.item && isFunctionCallOutputItem(event.item)) {
+                if (isOutputItemAddedEvent(event) && event.item && isFunctionCallItem(event.item)) {
                     toolCallsInProgress.set(event.item.callId, {
                         id: event.item.callId,
                         name: event.item.name,
@@ -521,7 +521,7 @@ export async function* buildToolCallStream(stream) {
                 break;
             }
             case 'response.output_item.done': {
-                if (isOutputItemDoneEvent(event) && event.item && isFunctionCallOutputItem(event.item)) {
+                if (isOutputItemDoneEvent(event) && event.item && isFunctionCallItem(event.item)) {
                     // Yield final tool call if we haven't already
                     if (toolCallsInProgress.has(event.item.callId)) {
                         try {
@@ -709,7 +709,7 @@ export function convertToClaudeMessage(response) {
                 break;
             }
             case 'function_call': {
-                if (isFunctionCallOutputItem(item)) {
+                if (isFunctionCallItem(item)) {
                     let parsedInput;
                     try {
                         parsedInput = JSON.parse(item.arguments);

package/esm/lib/stream-type-guards.d.ts

@@ -13,7 +13,7 @@ export declare function isResponseFailedEvent(event: models.OpenResponsesStreamE
 export declare function isResponseIncompleteEvent(event: models.OpenResponsesStreamEvent): event is models.OpenResponsesStreamEventResponseIncomplete;
 export declare function isFunctionCallArgumentsDoneEvent(event: models.OpenResponsesStreamEvent): event is models.OpenResponsesStreamEventResponseFunctionCallArgumentsDone;
 export declare function isOutputMessage(item: unknown): item is models.ResponsesOutputMessage;
-export declare function isFunctionCallOutputItem(item: unknown): item is models.ResponsesOutputItemFunctionCall;
+export declare function isFunctionCallItem(item: unknown): item is models.ResponsesOutputItemFunctionCall;
 export declare function isReasoningOutputItem(item: unknown): item is models.ResponsesOutputItemReasoning;
 export declare function isWebSearchCallOutputItem(item: unknown): item is models.ResponsesWebSearchCallOutput;
 export declare function isFileSearchCallOutputItem(item: unknown): item is models.ResponsesOutputItemFileSearchCall;

package/esm/lib/stream-type-guards.js

@@ -37,7 +37,7 @@ export function isOutputMessage(item) {
         'type' in item &&
         item.type === 'message');
 }
-export function isFunctionCallOutputItem(item) {
+export function isFunctionCallItem(item) {
     return (typeof item === 'object' &&
         item !== null &&
         'type' in item &&

package/esm/lib/tool-executor.js

@@ -158,43 +158,40 @@ export async function executeGeneratorTool(tool, toolCall, context, onPreliminar
         // Validate input - the schema validation ensures type safety at runtime
         // The inputSchema's inferred type matches the execute function's parameter type by construction
         const validatedInput = validateToolInput(tool.function.inputSchema, toolCall.arguments);
-        // Stream preliminary results in realtime
-        // Final result is identified by: matches outputSchema BUT NOT eventSchema
-        // All other yields are preliminary results (validated against eventSchema)
-        // If no explicit final result is found, the last emitted value is used as the final result
         const preliminaryResults = [];
         let finalResult = undefined;
         let hasFinalResult = false;
         let lastEmittedValue = undefined;
         let hasEmittedValue = false;
-        for await (const event of tool.function.execute(validatedInput, context)) {
+        const iterator = tool.function.execute(validatedInput, context);
+        let iterResult = await iterator.next();
+        while (!iterResult.done) {
+            const event = iterResult.value;
             lastEmittedValue = event;
             hasEmittedValue = true;
-            // Try to determine if this is the final result:
-            // It must match outputSchema but NOT match eventSchema
             const matchesOutputSchema = tryValidate(tool.function.outputSchema, event);
             const matchesEventSchema = tryValidate(tool.function.eventSchema, event);
             if (matchesOutputSchema && !matchesEventSchema && !hasFinalResult) {
-                // This is the final result - matches output but not event schema
                 finalResult = validateToolOutput(tool.function.outputSchema, event);
                 hasFinalResult = true;
             }
             else {
-                // This is a preliminary result - validate against eventSchema and emit in realtime
                 const validatedPreliminary = validateToolOutput(tool.function.eventSchema, event);
                 preliminaryResults.push(validatedPreliminary);
                 if (onPreliminaryResult) {
                     onPreliminaryResult(toolCall.id, validatedPreliminary);
                 }
             }
+            iterResult = await iterator.next();
         }
-        // Generator must emit at least one value
-        if (!hasEmittedValue) {
-            throw new Error(`Generator tool "${toolCall.name}" completed without emitting any values`);
+        if (iterResult.value !== undefined) {
+            finalResult = validateToolOutput(tool.function.outputSchema, iterResult.value);
+            hasFinalResult = true;
         }
-        // If no explicit final result was found (no yield matched outputSchema but not eventSchema),
-        // use the last emitted value as the final result
         if (!hasFinalResult) {
+            if (!hasEmittedValue) {
+                throw new Error(`Generator tool "${toolCall.name}" completed without emitting any values or returning a result`);
+            }
             finalResult = validateToolOutput(tool.function.outputSchema, lastEmittedValue);
         }
         return {

package/esm/lib/tool-orchestrator.js

@@ -1,5 +1,5 @@
 import { extractToolCallsFromResponse, responseHasToolCalls } from './stream-transformers.js';
-import { isFunctionCallOutputItem } from './stream-type-guards.js';
+import { isFunctionCallItem } from './stream-type-guards.js';
 import { executeTool, findToolByName } from './tool-executor.js';
 import { hasExecuteFunction } from './tool-types.js';
 import { buildTurnContext } from './turn-context.js';
@@ -61,7 +61,7 @@ export async function executeToolLoop(sendRequest, initialInput, initialRequest,
                 return null;
             }
             // Find the raw tool call from the response output
-            const rawToolCall = currentResponse.output.find((item) => isFunctionCallOutputItem(item) && item.callId === toolCall.id);
+            const rawToolCall = currentResponse.output.find((item) => isFunctionCallItem(item) && item.callId === toolCall.id);
             if (!rawToolCall) {
                 throw new Error(`Could not find raw tool call for ${toolCall.id}`);
             }

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

@@ -103,7 +103,7 @@ export interface ToolFunctionWithExecute<TInput extends $ZodObject<$ZodShape>, T
 export interface ToolFunctionWithGenerator<TInput extends $ZodObject<$ZodShape>, TEvent extends $ZodType = $ZodType<unknown>, TOutput extends $ZodType = $ZodType<unknown>> extends BaseToolFunction<TInput> {
     eventSchema: TEvent;
     outputSchema: TOutput;
-    execute: (params: zodInfer<TInput>, context?: TurnContext) => AsyncGenerator<zodInfer<TEvent> | zodInfer<TOutput>>;
+    execute: (params: zodInfer<TInput>, context?: TurnContext) => AsyncGenerator<zodInfer<TEvent> | zodInfer<TOutput>, zodInfer<TOutput> | void>;
 }
 /**
  * Manual tool without execute function - requires manual handling by developer

package/jsr.json

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@openrouter/sdk",
-  "version": "0.4.0",
+  "version": "0.5.1",
   "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": [
@@ -89,4 +89,4 @@
     "zod": "^3.25.0 || ^4.0.0"
   },
   "packageManager": "pnpm@10.22.0"
-}
+}