@openrouter/sdk 0.3.16 → 0.5.1

package/esm/funcs/modelsListForUser.d.ts

@@ -10,7 +10,10 @@ import * as operations from "../models/operations/index.js";
 import { APIPromise } from "../types/async.js";
 import { Result } from "../types/fp.js";
 /**
- * List models filtered by user provider preferences
+ * List models filtered by user provider preferences, privacy settings, and guardrails
+ *
+ * @remarks
+ * List models filtered by user provider preferences, [privacy settings](https://openrouter.ai/docs/guides/privacy/logging), and [guardrails](https://openrouter.ai/docs/guides/features/guardrails). If requesting through `eu.openrouter.ai/api/v1/...` the results will be filtered to models that satisfy [EU in-region routing](https://openrouter.ai/docs/guides/privacy/logging#enterprise-eu-in-region-routing).
  */
-export declare function modelsListForUser(client: OpenRouterCore, security: operations.ListModelsUserSecurity, options?: RequestOptions): APIPromise<Result<models.ModelsListResponse, errors.UnauthorizedResponseError | errors.InternalServerResponseError | OpenRouterError | ResponseValidationError | ConnectionError | RequestAbortedError | RequestTimeoutError | InvalidRequestError | UnexpectedClientError | SDKValidationError>>;
+export declare function modelsListForUser(client: OpenRouterCore, security: operations.ListModelsUserSecurity, options?: RequestOptions): APIPromise<Result<models.ModelsListResponse, errors.UnauthorizedResponseError | errors.NotFoundResponseError | errors.InternalServerResponseError | OpenRouterError | ResponseValidationError | ConnectionError | RequestAbortedError | RequestTimeoutError | InvalidRequestError | UnexpectedClientError | SDKValidationError>>;
 //# sourceMappingURL=modelsListForUser.d.ts.map

package/esm/funcs/modelsListForUser.js

@@ -10,7 +10,10 @@ import * as errors from "../models/errors/index.js";
 import * as models from "../models/index.js";
 import { APIPromise } from "../types/async.js";
 /**
- * List models filtered by user provider preferences
+ * List models filtered by user provider preferences, privacy settings, and guardrails
+ *
+ * @remarks
+ * List models filtered by user provider preferences, [privacy settings](https://openrouter.ai/docs/guides/privacy/logging), and [guardrails](https://openrouter.ai/docs/guides/features/guardrails). If requesting through `eu.openrouter.ai/api/v1/...` the results will be filtered to models that satisfy [EU in-region routing](https://openrouter.ai/docs/guides/privacy/logging#enterprise-eu-in-region-routing).
  */
 export function modelsListForUser(client, security, options) {
     return new APIPromise($do(client, security, options));
@@ -54,7 +57,7 @@ async function $do(client, security, options) {
     const req = requestRes.value;
     const doResult = await client._do(req, {
         context,
-        errorCodes: ["401", "4XX", "500", "5XX"],
+        errorCodes: ["401", "404", "4XX", "500", "5XX"],
         retryConfig: context.retryConfig,
         retryCodes: context.retryCodes,
     });
@@ -65,7 +68,7 @@ async function $do(client, security, options) {
     const responseFields = {
         HttpMeta: { Response: response, Request: req },
     };
-    const [result] = await M.match(M.json(200, models.ModelsListResponse$inboundSchema), M.jsonErr(401, errors.UnauthorizedResponseError$inboundSchema), M.jsonErr(500, errors.InternalServerResponseError$inboundSchema), M.fail("4XX"), M.fail("5XX"))(response, req, { extraFields: responseFields });
+    const [result] = await M.match(M.json(200, models.ModelsListResponse$inboundSchema), M.jsonErr(401, errors.UnauthorizedResponseError$inboundSchema), M.jsonErr(404, errors.NotFoundResponseError$inboundSchema), M.jsonErr(500, errors.InternalServerResponseError$inboundSchema), M.fail("4XX"), M.fail("5XX"))(response, req, { extraFields: responseFields });
     if (!result.ok) {
         return [result, { status: "complete", request: req, response }];
     }

package/esm/index.d.ts

@@ -14,6 +14,7 @@ export { HTTPClient } from './lib/http.js';
 export { applyNextTurnParamsToRequest, buildNextTurnParamsContext, executeNextTurnParamsFunctions, } from './lib/next-turn-params.js';
 export { finishReasonIs, hasToolCall, isStopConditionMet, maxCost, maxTokensUsed, stepCountIs, } from './lib/stop-conditions.js';
 export { extractUnsupportedContent, getUnsupportedContentSummary, hasUnsupportedContent, } from './lib/stream-transformers.js';
+export type { StreamableOutputItem } from './lib/stream-transformers.js';
 export { tool } from './lib/tool.js';
 export { hasApprovalRequiredTools, hasExecuteFunction, isGeneratorTool, isRegularExecuteTool, isToolPreliminaryResultEvent, isToolResultEvent, toolHasApprovalConfigured, ToolType, } from './lib/tool-types.js';
 export { buildTurnContext, normalizeInputToArray } from './lib/turn-context.js';

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.3.16";
+    readonly sdkVersion: "0.5.1";
     readonly genVersion: "2.788.4";
-    readonly userAgent: "speakeasy-sdk/typescript 0.3.16 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.3.16",
+    sdkVersion: "0.5.1",
     genVersion: "2.788.4",
-    userAgent: "speakeasy-sdk/typescript 0.3.16 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

@@ -3,6 +3,7 @@ import type * as models from '../models/index.js';
 import type { CallModelInput } from './async-params.js';
 import type { RequestOptions } from './sdks.js';
 import type { ConversationState, ResponseStreamEvent, InferToolEventsUnion, InferToolOutputsUnion, ParsedToolCall, StateAccessor, StopWhen, Tool, ToolStreamEvent, TurnContext } from './tool-types.js';
+import { type StreamableOutputItem } from './stream-transformers.js';
 export interface GetResponseOptions<TTools extends readonly Tool[]> {
     request: CallModelInput<TTools>;
     client: OpenRouterCore;
@@ -245,12 +246,32 @@ export declare class ModelResult<TTools extends readonly Tool[]> {
      */
     getTextStream(): AsyncIterableIterator<string>;
     /**
+     * Stream all output items cumulatively as they arrive.
+     * Items are emitted with the same ID but progressively updated content as streaming progresses.
+     * Also yields tool results (function_call_output) after tool execution completes.
+     *
+     * Item types include:
+     * - message: Assistant text responses (emitted cumulatively as text streams)
+     * - function_call: Tool calls (emitted cumulatively as arguments stream)
+     * - reasoning: Model reasoning (emitted cumulatively as thinking streams)
+     * - web_search_call: Web search operations
+     * - file_search_call: File search operations
+     * - image_generation_call: Image generation operations
+     * - function_call_output: Results from executed tools
+     */
+    getItemsStream(): AsyncIterableIterator<StreamableOutputItem>;
+    /**
+     * @deprecated Use `getItemsStream()` instead. This method only streams messages,
+     * while `getItemsStream()` streams all output item types (messages, function_calls,
+     * reasoning, etc.) with cumulative updates.
+     *
      * 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

@@ -3,11 +3,12 @@ import { betaResponsesSend } from '../funcs/betaResponsesSend.js';
 import { hasAsyncFunctions, resolveAsyncFunctions, } from './async-params.js';
 import { appendToMessages, createInitialState, createRejectedResult, createUnsentResult, extractTextFromResponse as extractTextFromResponseState, partitionToolCalls, unsentResultsToAPIFormat, updateState, } from './conversation-state.js';
 import { ReusableReadableStream } from './reusable-stream.js';
-import { buildResponsesMessageStream, buildToolCallStream, consumeStreamForCompletion, extractReasoningDeltas, extractResponsesMessageFromResponse, extractTextDeltas, extractTextFromResponse, extractToolCallsFromResponse, extractToolDeltas, } from './stream-transformers.js';
+import { buildItemsStream, 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, stepCountIs } from './stop-conditions.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.
@@ -30,15 +31,6 @@ function isEventStream(value) {
     const maybeStream = value;
     return typeof maybeStream.toReadableStream === 'function';
 }
-/**
- * Type guard for output items with a type property
- */
-function hasTypeProperty(item) {
-    return (typeof item === 'object' &&
-        item !== null &&
-        'type' in item &&
-        typeof item.type === 'string');
-}
 /**
  * A wrapper around a streaming response that provides multiple consumption patterns.
  *
@@ -313,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
@@ -360,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 }),
+            };
         }
     }
     /**
@@ -387,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]),
@@ -397,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);
@@ -875,10 +910,68 @@ export class ModelResult {
         }.call(this);
     }
     /**
+     * Stream all output items cumulatively as they arrive.
+     * Items are emitted with the same ID but progressively updated content as streaming progresses.
+     * Also yields tool results (function_call_output) after tool execution completes.
+     *
+     * Item types include:
+     * - message: Assistant text responses (emitted cumulatively as text streams)
+     * - function_call: Tool calls (emitted cumulatively as arguments stream)
+     * - reasoning: Model reasoning (emitted cumulatively as thinking streams)
+     * - web_search_call: Web search operations
+     * - file_search_call: File search operations
+     * - image_generation_call: Image generation operations
+     * - function_call_output: Results from executed tools
+     */
+    getItemsStream() {
+        return async function* () {
+            await this.initStream();
+            if (!this.reusableStream) {
+                throw new Error('Stream not initialized');
+            }
+            // Stream all items from the API response cumulatively
+            yield* buildItemsStream(this.reusableStream);
+            // Execute tools if needed
+            await this.executeToolsIfNeeded();
+            // 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;
+                }
+            }
+            // If tools were executed, yield all items from the final response
+            if (this.finalResponse && this.allToolExecutionRounds.length > 0) {
+                for (const item of this.finalResponse.output) {
+                    if (isOutputMessage(item) ||
+                        isFunctionCallItem(item) ||
+                        isReasoningOutputItem(item) ||
+                        isWebSearchCallOutputItem(item) ||
+                        isFileSearchCallOutputItem(item) ||
+                        isImageGenerationCallOutputItem(item)) {
+                        yield item;
+                    }
+                }
+            }
+        }.call(this);
+    }
+    /**
+     * @deprecated Use `getItemsStream()` instead. This method only streams messages,
+     * while `getItemsStream()` streams all output item types (messages, function_calls,
+     * reasoning, etc.) with cumulative updates.
+     *
      * 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* () {
@@ -890,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.d.ts

@@ -18,6 +18,18 @@ export declare function extractToolDeltas(stream: ReusableReadableStream<models.
  * Returns ResponsesOutputMessage (assistant/responses format)
  */
 export declare function buildResponsesMessageStream(stream: ReusableReadableStream<models.OpenResponsesStreamEvent>): AsyncIterableIterator<models.ResponsesOutputMessage>;
+/**
+ * Output item types that can be streamed from a response.
+ * This is the union of all item types that appear in response output,
+ * plus function_call_output for tool results.
+ */
+export type StreamableOutputItem = models.ResponsesOutputMessage | models.ResponsesOutputItemFunctionCall | models.ResponsesOutputItemReasoning | models.ResponsesWebSearchCallOutput | models.ResponsesOutputItemFileSearchCall | models.ResponsesImageGenerationCall | models.OpenResponsesFunctionCallOutput;
+/**
+ * Build incremental output item updates from responses stream events.
+ * Yields all item types cumulatively - same item may be emitted multiple times
+ * with the same ID but progressively updated content as streaming progresses.
+ */
+export declare function buildItemsStream(stream: ReusableReadableStream<models.OpenResponsesStreamEvent>): AsyncIterableIterator<StreamableOutputItem>;
 /**
  * Build incremental message updates from responses stream events
  * Returns AssistantMessage (chat format) instead of ResponsesOutputMessage