@openrouter/sdk 0.3.15 → 0.4.0

package/esm/lib/tool-executor.js

@@ -87,6 +87,14 @@ export function validateToolInput(schema, args) {
 export function validateToolOutput(schema, result) {
     return z4.parse(schema, result);
 }
+/**
+ * Try to validate a value against a Zod schema without throwing
+ * @returns true if validation succeeds, false otherwise
+ */
+function tryValidate(schema, value) {
+    const result = z4.safeParse(schema, value);
+    return result.success;
+}
 /**
  * Parse tool call arguments from JSON string
  */
@@ -150,29 +158,45 @@ 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);
-        // Execute generator and collect all results
+        // 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 lastEmittedValue = null;
+        let finalResult = undefined;
+        let hasFinalResult = false;
+        let lastEmittedValue = undefined;
         let hasEmittedValue = false;
         for await (const event of tool.function.execute(validatedInput, context)) {
+            lastEmittedValue = event;
             hasEmittedValue = true;
-            // Validate event against eventSchema
-            const validatedEvent = validateToolOutput(tool.function.eventSchema, event);
-            preliminaryResults.push(validatedEvent);
-            lastEmittedValue = validatedEvent;
-            // Emit preliminary result via callback
-            if (onPreliminaryResult) {
-                onPreliminaryResult(toolCall.id, validatedEvent);
+            // 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);
+                }
             }
         }
         // Generator must emit at least one value
         if (!hasEmittedValue) {
             throw new Error(`Generator tool "${toolCall.name}" completed without emitting any values`);
         }
-        // Validate the last emitted value against outputSchema (this is the final result)
-        const finalResult = validateToolOutput(tool.function.outputSchema, lastEmittedValue);
-        // Remove last item from preliminaryResults since it's the final output
-        preliminaryResults.pop();
+        // 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) {
+            finalResult = validateToolOutput(tool.function.outputSchema, lastEmittedValue);
+        }
         return {
             toolCallId: toolCall.id,
             toolName: toolCall.name,

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

@@ -58,6 +58,7 @@ export type NextTurnParamsFunctions<TInput> = {
 export type ToolApprovalCheck<TInput> = (params: TInput, context: TurnContext) => boolean | Promise<boolean>;
 /**
  * Base tool function interface with inputSchema
+ * @template TInput - Zod schema for tool input
  */
 export interface BaseToolFunction<TInput extends $ZodObject<$ZodShape>> {
     name: string;
@@ -175,6 +176,13 @@ export type TypedToolCallUnion<T extends readonly Tool[]> = {
 export type ToolExecutionResultUnion<T extends readonly Tool[]> = {
     [K in keyof T]: T[K] extends Tool ? ToolExecutionResult<T[K]> : never;
 }[number];
+/**
+ * Union of output types for all tools in a tuple
+ * Used for typing tool result events
+ */
+export type InferToolOutputsUnion<T extends readonly Tool[]> = {
+    [K in keyof T]: T[K] extends Tool ? InferToolOutput<T[K]> : never;
+}[number];
 /**
  * Extracts the event type from a generator tool definition
  * Returns `never` for non-generator tools
@@ -300,16 +308,34 @@ export type ToolPreliminaryResultEvent<TEvent = unknown> = {
     result: TEvent;
     timestamp: number;
 };
+/**
+ * Tool result event emitted when a tool execution completes
+ * Contains the final result and any preliminary results that were emitted
+ * @template TResult - The result type from the tool's outputSchema
+ * @template TPreliminaryResults - The event type from generator tools' eventSchema
+ */
+export type ToolResultEvent<TResult = unknown, TPreliminaryResults = unknown> = {
+    type: 'tool.result';
+    toolCallId: string;
+    result: TResult;
+    timestamp: number;
+    preliminaryResults?: TPreliminaryResults[];
+};
 /**
  * Enhanced stream event types for getFullResponsesStream
- * Extends OpenResponsesStreamEvent with tool preliminary results
+ * Extends OpenResponsesStreamEvent with tool preliminary results and tool results
  * @template TEvent - The event type from generator tools
+ * @template TResult - The result type from tool execution
  */
-export type ResponseStreamEvent<TEvent = unknown> = OpenResponsesStreamEvent | ToolPreliminaryResultEvent<TEvent>;
+export type ResponseStreamEvent<TEvent = unknown, TResult = unknown> = OpenResponsesStreamEvent | ToolPreliminaryResultEvent<TEvent> | ToolResultEvent<TResult, TEvent>;
 /**
  * Type guard to check if an event is a tool preliminary result event
  */
 export declare function isToolPreliminaryResultEvent<TEvent = unknown>(event: ResponseStreamEvent<TEvent>): event is ToolPreliminaryResultEvent<TEvent>;
+/**
+ * Type guard to check if an event is a tool result event
+ */
+export declare function isToolResultEvent<TResult = unknown, TPreliminaryResults = unknown>(event: ResponseStreamEvent<TPreliminaryResults, TResult>): event is ToolResultEvent<TResult, TPreliminaryResults>;
 /**
  * Tool stream event types for getToolStream
  * Includes both argument deltas and preliminary results

package/esm/lib/tool-types.js

@@ -35,6 +35,12 @@ export function isManualTool(tool) {
 export function isToolPreliminaryResultEvent(event) {
     return event.type === 'tool.preliminary_result';
 }
+/**
+ * Type guard to check if an event is a tool result event
+ */
+export function isToolResultEvent(event) {
+    return event.type === 'tool.result';
+}
 /**
  * Type guard to check if a tool has approval configured at runtime
  */

package/esm/models/chatgenerationparams.d.ts

@@ -163,17 +163,17 @@ export type Reasoning = {
     effort?: Effort | null | undefined;
     summary?: ReasoningSummaryVerbosity | null | undefined;
 };
-export type ChatGenerationParamsResponseFormatPython = {
+export type ResponseFormatPython = {
     type: "python";
 };
-export type ChatGenerationParamsResponseFormatJSONObject = {
+export type ResponseFormatJSONObject = {
     type: "json_object";
 };
-export type ChatGenerationParamsResponseFormatText = {
+export type ResponseFormatText = {
     type: "text";
 };
-export type ChatGenerationParamsResponseFormatUnion = ChatGenerationParamsResponseFormatText | ChatGenerationParamsResponseFormatJSONObject | ResponseFormatJSONSchema | ResponseFormatTextGrammar | ChatGenerationParamsResponseFormatPython;
-export type ChatGenerationParamsStop = string | Array<string>;
+export type ResponseFormat = ResponseFormatText | ResponseFormatJSONObject | ResponseFormatJSONSchema | ResponseFormatTextGrammar | ResponseFormatPython;
+export type Stop = string | Array<string>;
 export type Debug = {
     echoUpstreamBody?: boolean | undefined;
 };
@@ -214,7 +214,7 @@ export type ChatGenerationParams = {
     } | undefined;
     presencePenalty?: number | null | undefined;
     reasoning?: Reasoning | undefined;
-    responseFormat?: ChatGenerationParamsResponseFormatText | ChatGenerationParamsResponseFormatJSONObject | ResponseFormatJSONSchema | ResponseFormatTextGrammar | ChatGenerationParamsResponseFormatPython | undefined;
+    responseFormat?: ResponseFormatText | ResponseFormatJSONObject | ResponseFormatJSONSchema | ResponseFormatTextGrammar | ResponseFormatPython | undefined;
     seed?: number | null | undefined;
     stop?: string | Array<string> | null | undefined;
     stream?: boolean | undefined;
@@ -366,36 +366,36 @@ export type Reasoning$Outbound = {
 export declare const Reasoning$outboundSchema: z.ZodType<Reasoning$Outbound, Reasoning>;
 export declare function reasoningToJSON(reasoning: Reasoning): string;
 /** @internal */
-export type ChatGenerationParamsResponseFormatPython$Outbound = {
+export type ResponseFormatPython$Outbound = {
     type: "python";
 };
 /** @internal */
-export declare const ChatGenerationParamsResponseFormatPython$outboundSchema: z.ZodType<ChatGenerationParamsResponseFormatPython$Outbound, ChatGenerationParamsResponseFormatPython>;
-export declare function chatGenerationParamsResponseFormatPythonToJSON(chatGenerationParamsResponseFormatPython: ChatGenerationParamsResponseFormatPython): string;
+export declare const ResponseFormatPython$outboundSchema: z.ZodType<ResponseFormatPython$Outbound, ResponseFormatPython>;
+export declare function responseFormatPythonToJSON(responseFormatPython: ResponseFormatPython): string;
 /** @internal */
-export type ChatGenerationParamsResponseFormatJSONObject$Outbound = {
+export type ResponseFormatJSONObject$Outbound = {
     type: "json_object";
 };
 /** @internal */
-export declare const ChatGenerationParamsResponseFormatJSONObject$outboundSchema: z.ZodType<ChatGenerationParamsResponseFormatJSONObject$Outbound, ChatGenerationParamsResponseFormatJSONObject>;
-export declare function chatGenerationParamsResponseFormatJSONObjectToJSON(chatGenerationParamsResponseFormatJSONObject: ChatGenerationParamsResponseFormatJSONObject): string;
+export declare const ResponseFormatJSONObject$outboundSchema: z.ZodType<ResponseFormatJSONObject$Outbound, ResponseFormatJSONObject>;
+export declare function responseFormatJSONObjectToJSON(responseFormatJSONObject: ResponseFormatJSONObject): string;
 /** @internal */
-export type ChatGenerationParamsResponseFormatText$Outbound = {
+export type ResponseFormatText$Outbound = {
     type: "text";
 };
 /** @internal */
-export declare const ChatGenerationParamsResponseFormatText$outboundSchema: z.ZodType<ChatGenerationParamsResponseFormatText$Outbound, ChatGenerationParamsResponseFormatText>;
-export declare function chatGenerationParamsResponseFormatTextToJSON(chatGenerationParamsResponseFormatText: ChatGenerationParamsResponseFormatText): string;
+export declare const ResponseFormatText$outboundSchema: z.ZodType<ResponseFormatText$Outbound, ResponseFormatText>;
+export declare function responseFormatTextToJSON(responseFormatText: ResponseFormatText): string;
 /** @internal */
-export type ChatGenerationParamsResponseFormatUnion$Outbound = ChatGenerationParamsResponseFormatText$Outbound | ChatGenerationParamsResponseFormatJSONObject$Outbound | ResponseFormatJSONSchema$Outbound | ResponseFormatTextGrammar$Outbound | ChatGenerationParamsResponseFormatPython$Outbound;
+export type ResponseFormat$Outbound = ResponseFormatText$Outbound | ResponseFormatJSONObject$Outbound | ResponseFormatJSONSchema$Outbound | ResponseFormatTextGrammar$Outbound | ResponseFormatPython$Outbound;
 /** @internal */
-export declare const ChatGenerationParamsResponseFormatUnion$outboundSchema: z.ZodType<ChatGenerationParamsResponseFormatUnion$Outbound, ChatGenerationParamsResponseFormatUnion>;
-export declare function chatGenerationParamsResponseFormatUnionToJSON(chatGenerationParamsResponseFormatUnion: ChatGenerationParamsResponseFormatUnion): string;
+export declare const ResponseFormat$outboundSchema: z.ZodType<ResponseFormat$Outbound, ResponseFormat>;
+export declare function responseFormatToJSON(responseFormat: ResponseFormat): string;
 /** @internal */
-export type ChatGenerationParamsStop$Outbound = string | Array<string>;
+export type Stop$Outbound = string | Array<string>;
 /** @internal */
-export declare const ChatGenerationParamsStop$outboundSchema: z.ZodType<ChatGenerationParamsStop$Outbound, ChatGenerationParamsStop>;
-export declare function chatGenerationParamsStopToJSON(chatGenerationParamsStop: ChatGenerationParamsStop): string;
+export declare const Stop$outboundSchema: z.ZodType<Stop$Outbound, Stop>;
+export declare function stopToJSON(stop: Stop): string;
 /** @internal */
 export type Debug$Outbound = {
     echo_upstream_body?: boolean | undefined;
@@ -433,7 +433,7 @@ export type ChatGenerationParams$Outbound = {
     } | undefined;
     presence_penalty?: number | null | undefined;
     reasoning?: Reasoning$Outbound | undefined;
-    response_format?: ChatGenerationParamsResponseFormatText$Outbound | ChatGenerationParamsResponseFormatJSONObject$Outbound | ResponseFormatJSONSchema$Outbound | ResponseFormatTextGrammar$Outbound | ChatGenerationParamsResponseFormatPython$Outbound | undefined;
+    response_format?: ResponseFormatText$Outbound | ResponseFormatJSONObject$Outbound | ResponseFormatJSONSchema$Outbound | ResponseFormatTextGrammar$Outbound | ResponseFormatPython$Outbound | undefined;
     seed?: number | null | undefined;
     stop?: string | Array<string> | null | undefined;
     stream: boolean;

package/esm/models/chatgenerationparams.js

@@ -233,41 +233,44 @@ export function reasoningToJSON(reasoning) {
     return JSON.stringify(Reasoning$outboundSchema.parse(reasoning));
 }
 /** @internal */
-export const ChatGenerationParamsResponseFormatPython$outboundSchema = z.object({
+export const ResponseFormatPython$outboundSchema = z.object({
     type: z.literal("python"),
 });
-export function chatGenerationParamsResponseFormatPythonToJSON(chatGenerationParamsResponseFormatPython) {
-    return JSON.stringify(ChatGenerationParamsResponseFormatPython$outboundSchema.parse(chatGenerationParamsResponseFormatPython));
+export function responseFormatPythonToJSON(responseFormatPython) {
+    return JSON.stringify(ResponseFormatPython$outboundSchema.parse(responseFormatPython));
 }
 /** @internal */
-export const ChatGenerationParamsResponseFormatJSONObject$outboundSchema = z.object({
+export const ResponseFormatJSONObject$outboundSchema = z.object({
     type: z.literal("json_object"),
 });
-export function chatGenerationParamsResponseFormatJSONObjectToJSON(chatGenerationParamsResponseFormatJSONObject) {
-    return JSON.stringify(ChatGenerationParamsResponseFormatJSONObject$outboundSchema.parse(chatGenerationParamsResponseFormatJSONObject));
+export function responseFormatJSONObjectToJSON(responseFormatJSONObject) {
+    return JSON.stringify(ResponseFormatJSONObject$outboundSchema.parse(responseFormatJSONObject));
 }
 /** @internal */
-export const ChatGenerationParamsResponseFormatText$outboundSchema = z.object({
+export const ResponseFormatText$outboundSchema = z.object({
     type: z.literal("text"),
 });
-export function chatGenerationParamsResponseFormatTextToJSON(chatGenerationParamsResponseFormatText) {
-    return JSON.stringify(ChatGenerationParamsResponseFormatText$outboundSchema.parse(chatGenerationParamsResponseFormatText));
+export function responseFormatTextToJSON(responseFormatText) {
+    return JSON.stringify(ResponseFormatText$outboundSchema.parse(responseFormatText));
 }
 /** @internal */
-export const ChatGenerationParamsResponseFormatUnion$outboundSchema = z.union([
-    z.lazy(() => ChatGenerationParamsResponseFormatText$outboundSchema),
-    z.lazy(() => ChatGenerationParamsResponseFormatJSONObject$outboundSchema),
+export const ResponseFormat$outboundSchema = z.union([
+    z.lazy(() => ResponseFormatText$outboundSchema),
+    z.lazy(() => ResponseFormatJSONObject$outboundSchema),
     ResponseFormatJSONSchema$outboundSchema,
     ResponseFormatTextGrammar$outboundSchema,
-    z.lazy(() => ChatGenerationParamsResponseFormatPython$outboundSchema),
+    z.lazy(() => ResponseFormatPython$outboundSchema),
 ]);
-export function chatGenerationParamsResponseFormatUnionToJSON(chatGenerationParamsResponseFormatUnion) {
-    return JSON.stringify(ChatGenerationParamsResponseFormatUnion$outboundSchema.parse(chatGenerationParamsResponseFormatUnion));
+export function responseFormatToJSON(responseFormat) {
+    return JSON.stringify(ResponseFormat$outboundSchema.parse(responseFormat));
 }
 /** @internal */
-export const ChatGenerationParamsStop$outboundSchema = z.union([z.string(), z.array(z.string())]);
-export function chatGenerationParamsStopToJSON(chatGenerationParamsStop) {
-    return JSON.stringify(ChatGenerationParamsStop$outboundSchema.parse(chatGenerationParamsStop));
+export const Stop$outboundSchema = z.union([
+    z.string(),
+    z.array(z.string()),
+]);
+export function stopToJSON(stop) {
+    return JSON.stringify(Stop$outboundSchema.parse(stop));
 }
 /** @internal */
 export const Debug$outboundSchema = z.object({
@@ -314,11 +317,11 @@ export const ChatGenerationParams$outboundSchema = z.object({
     presencePenalty: z.nullable(z.number()).optional(),
     reasoning: z.lazy(() => Reasoning$outboundSchema).optional(),
     responseFormat: z.union([
-        z.lazy(() => ChatGenerationParamsResponseFormatText$outboundSchema),
-        z.lazy(() => ChatGenerationParamsResponseFormatJSONObject$outboundSchema),
+        z.lazy(() => ResponseFormatText$outboundSchema),
+        z.lazy(() => ResponseFormatJSONObject$outboundSchema),
         ResponseFormatJSONSchema$outboundSchema,
         ResponseFormatTextGrammar$outboundSchema,
-        z.lazy(() => ChatGenerationParamsResponseFormatPython$outboundSchema),
+        z.lazy(() => ResponseFormatPython$outboundSchema),
     ]).optional(),
     seed: z.nullable(z.int()).optional(),
     stop: z.nullable(z.union([z.string(), z.array(z.string())])).optional(),

package/esm/models/index.d.ts

@@ -22,11 +22,6 @@ export * from "./chatstreamingmessagechunk.js";
 export * from "./chatstreamingmessagetoolcall.js";
 export * from "./chatstreamingresponsechunk.js";
 export * from "./chatstreamoptions.js";
-export * from "./completionchoice.js";
-export * from "./completioncreateparams.js";
-export * from "./completionlogprobs.js";
-export * from "./completionresponse.js";
-export * from "./completionusage.js";
 export * from "./createchargerequest.js";
 export * from "./datacollection.js";
 export * from "./defaultparameters.js";

package/esm/models/index.js

@@ -26,11 +26,6 @@ export * from "./chatstreamingmessagechunk.js";
 export * from "./chatstreamingmessagetoolcall.js";
 export * from "./chatstreamingresponsechunk.js";
 export * from "./chatstreamoptions.js";
-export * from "./completionchoice.js";
-export * from "./completioncreateparams.js";
-export * from "./completionlogprobs.js";
-export * from "./completionresponse.js";
-export * from "./completionusage.js";
 export * from "./createchargerequest.js";
 export * from "./datacollection.js";
 export * from "./defaultparameters.js";

package/esm/models/outputmodality.d.ts

@@ -4,6 +4,7 @@ export declare const OutputModality: {
     readonly Text: "text";
     readonly Image: "image";
     readonly Embeddings: "embeddings";
+    readonly Audio: "audio";
 };
 export type OutputModality = OpenEnum<typeof OutputModality>;
 /** @internal */

package/esm/models/outputmodality.js

@@ -7,6 +7,7 @@ export const OutputModality = {
     Text: "text",
     Image: "image",
     Embeddings: "embeddings",
+    Audio: "audio",
 };
 /** @internal */
 export const OutputModality$inboundSchema = openEnums.inboundSchema(OutputModality);

package/esm/models/publicendpoint.d.ts

@@ -35,6 +35,10 @@ export type Pricing = {
      * A value in string format that is a large number
      */
     audio?: string | undefined;
+    /**
+     * A value in string format that is a large number
+     */
+    audioOutput?: string | undefined;
     /**
      * A value in string format that is a large number
      */
@@ -74,6 +78,10 @@ export type PublicEndpointQuantization = OpenEnum<typeof PublicEndpointQuantizat
  */
 export type PublicEndpoint = {
     name: string;
+    /**
+     * The unique identifier for the model (permaslug)
+     */
+    modelId: string;
     modelName: string;
     contextLength: number;
     pricing: Pricing;

package/esm/models/publicendpoint.js

@@ -30,6 +30,7 @@ export const Pricing$inboundSchema = z.object({
     image_token: z.string().optional(),
     image_output: z.string().optional(),
     audio: z.string().optional(),
+    audio_output: z.string().optional(),
     input_audio_cache: z.string().optional(),
     web_search: z.string().optional(),
     internal_reasoning: z.string().optional(),
@@ -40,6 +41,7 @@ export const Pricing$inboundSchema = z.object({
     return remap$(v, {
         "image_token": "imageToken",
         "image_output": "imageOutput",
+        "audio_output": "audioOutput",
         "input_audio_cache": "inputAudioCache",
         "web_search": "webSearch",
         "internal_reasoning": "internalReasoning",
@@ -55,6 +57,7 @@ export const PublicEndpointQuantization$inboundSchema = openEnums.inboundSchema(
 /** @internal */
 export const PublicEndpoint$inboundSchema = z.object({
     name: z.string(),
+    model_id: z.string(),
     model_name: z.string(),
     context_length: z.number(),
     pricing: z.lazy(() => Pricing$inboundSchema),
@@ -71,6 +74,7 @@ export const PublicEndpoint$inboundSchema = z.object({
     throughput_last_30m: z.nullable(PercentileStats$inboundSchema),
 }).transform((v) => {
     return remap$(v, {
+        "model_id": "modelId",
         "model_name": "modelName",
         "context_length": "contextLength",
         "provider_name": "providerName",

package/esm/models/publicpricing.d.ts

@@ -33,6 +33,10 @@ export type PublicPricing = {
      * A value in string format that is a large number
      */
     audio?: string | undefined;
+    /**
+     * A value in string format that is a large number
+     */
+    audioOutput?: string | undefined;
     /**
      * A value in string format that is a large number
      */

package/esm/models/publicpricing.js

@@ -15,6 +15,7 @@ export const PublicPricing$inboundSchema = z
     image_token: z.string().optional(),
     image_output: z.string().optional(),
     audio: z.string().optional(),
+    audio_output: z.string().optional(),
     input_audio_cache: z.string().optional(),
     web_search: z.string().optional(),
     internal_reasoning: z.string().optional(),
@@ -25,6 +26,7 @@ export const PublicPricing$inboundSchema = z
     return remap$(v, {
         "image_token": "imageToken",
         "image_output": "imageOutput",
+        "audio_output": "audioOutput",
         "input_audio_cache": "inputAudioCache",
         "web_search": "webSearch",
         "internal_reasoning": "internalReasoning",

package/esm/sdk/models.d.ts

@@ -11,7 +11,10 @@ export declare class Models extends ClientSDK {
      */
     list(request?: operations.GetModelsRequest | undefined, options?: RequestOptions): Promise<models.ModelsListResponse>;
     /**
-     * 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).
      */
     listForUser(security: operations.ListModelsUserSecurity, options?: RequestOptions): Promise<models.ModelsListResponse>;
 }

package/esm/sdk/models.js

@@ -21,7 +21,10 @@ export class Models extends ClientSDK {
         return unwrapAsync(modelsList(this, request, options));
     }
     /**
-     * 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).
      */
     async listForUser(security, options) {
         return unwrapAsync(modelsListForUser(this, security, options));

package/esm/sdk/sdk.d.ts

@@ -3,7 +3,6 @@ import { Analytics } from "./analytics.js";
 import { APIKeys } from "./apikeys.js";
 import { Beta } from "./beta.js";
 import { Chat } from "./chat.js";
-import { Completions } from "./completions.js";
 import { Credits } from "./credits.js";
 import { Embeddings } from "./embeddings.js";
 import { Endpoints } from "./endpoints.js";
@@ -42,8 +41,6 @@ export declare class OpenRouter extends ClientSDK {
     get oAuth(): OAuth;
     private _chat?;
     get chat(): Chat;
-    private _completions?;
-    get completions(): Completions;
     callModel<TTools extends readonly Tool[]>(request: CallModelInput<TTools>, options?: RequestOptions): ModelResult<TTools>;
 }
 //# sourceMappingURL=sdk.d.ts.map

package/esm/sdk/sdk.js

@@ -7,7 +7,6 @@ import { Analytics } from "./analytics.js";
 import { APIKeys } from "./apikeys.js";
 import { Beta } from "./beta.js";
 import { Chat } from "./chat.js";
-import { Completions } from "./completions.js";
 import { Credits } from "./credits.js";
 import { Embeddings } from "./embeddings.js";
 import { Endpoints } from "./endpoints.js";
@@ -58,9 +57,6 @@ export class OpenRouter extends ClientSDK {
     get chat() {
         return (this._chat ?? (this._chat = new Chat(this._options)));
     }
-    get completions() {
-        return (this._completions ?? (this._completions = new Completions(this._options)));
-    }
     // #region sdk-class-body
     callModel(request, options) {
         return callModelFunc(this, request, options);

package/jsr.json

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@openrouter/sdk",
-  "version": "0.3.15",
+  "version": "0.4.0",
   "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": [
@@ -64,16 +64,16 @@
     "type": "git",
     "url": "https://github.com/OpenRouterTeam/typescript-sdk.git"
   },
-    "scripts": {
-      "lint": "eslint --cache --max-warnings=0 src",
-      "build": "tsc",
-      "typecheck": "tsc --noEmit",
-      "prepublishOnly": "npm run build",
-      "postinstall": "node scripts/check-types.js || true",
-      "test": "vitest --run --project unit",
-      "test:e2e": "vitest --run --project e2e",
-      "test:watch": "vitest --watch --project unit"
-    },
+  "scripts": {
+    "lint": "eslint --cache --max-warnings=0 src",
+    "build": "tsc",
+    "typecheck": "tsc --noEmit",
+    "prepublishOnly": "npm run build",
+    "postinstall": "node scripts/check-types.js || true",
+    "test": "vitest --run --project unit",
+    "test:e2e": "vitest --run --project e2e",
+    "test:watch": "vitest --watch --project unit"
+  },
   "peerDependencies": {},
   "devDependencies": {
     "@eslint/js": "^9.19.0",
@@ -89,4 +89,4 @@
     "zod": "^3.25.0 || ^4.0.0"
   },
   "packageManager": "pnpm@10.22.0"
-}
+}

package/esm/funcs/completionsGenerate.d.ts

@@ -1,18 +0,0 @@
-import { OpenRouterCore } from "../core.js";
-import { RequestOptions } from "../lib/sdks.js";
-import { ConnectionError, InvalidRequestError, RequestAbortedError, RequestTimeoutError, UnexpectedClientError } from "../models/errors/httpclienterrors.js";
-import * as errors from "../models/errors/index.js";
-import { OpenRouterError } from "../models/errors/openroutererror.js";
-import { ResponseValidationError } from "../models/errors/responsevalidationerror.js";
-import { SDKValidationError } from "../models/errors/sdkvalidationerror.js";
-import * as models from "../models/index.js";
-import { APIPromise } from "../types/async.js";
-import { Result } from "../types/fp.js";
-/**
- * Create a completion
- *
- * @remarks
- * Creates a completion for the provided prompt and parameters. Supports both streaming and non-streaming modes.
- */
-export declare function completionsGenerate(client: OpenRouterCore, request: models.CompletionCreateParams, options?: RequestOptions): APIPromise<Result<models.CompletionResponse, errors.ChatError | OpenRouterError | ResponseValidationError | ConnectionError | RequestAbortedError | RequestTimeoutError | InvalidRequestError | UnexpectedClientError | SDKValidationError>>;
-//# sourceMappingURL=completionsGenerate.d.ts.map