@openrouter/sdk 0.8.0 → 0.9.11

package/esm/models/openresponsesrequest.js

@@ -99,15 +99,16 @@ export function openResponsesRequestMaxPriceToJSON(openResponsesRequestMaxPrice)
     return JSON.stringify(OpenResponsesRequestMaxPrice$outboundSchema.parse(openResponsesRequestMaxPrice));
 }
 /** @internal */
-export const Provider$outboundSchema = z
-    .object({
+export const OpenResponsesRequestProvider$outboundSchema = z.object({
     allowFallbacks: z.nullable(z.boolean()).optional(),
     requireParameters: z.nullable(z.boolean()).optional(),
     dataCollection: z.nullable(DataCollection$outboundSchema).optional(),
     zdr: z.nullable(z.boolean()).optional(),
     enforceDistillableText: z.nullable(z.boolean()).optional(),
-    order: z.nullable(z.array(z.union([ProviderName$outboundSchema, z.string()]))).optional(),
-    only: z.nullable(z.array(z.union([ProviderName$outboundSchema, z.string()]))).optional(),
+    order: z.nullable(z.array(z.union([ProviderName$outboundSchema, z.string()])))
+        .optional(),
+    only: z.nullable(z.array(z.union([ProviderName$outboundSchema, z.string()])))
+        .optional(),
     ignore: z.nullable(z.array(z.union([ProviderName$outboundSchema, z.string()]))).optional(),
     quantizations: z.nullable(z.array(Quantization$outboundSchema)).optional(),
     sort: z.nullable(z.union([
@@ -132,28 +133,28 @@ export const Provider$outboundSchema = z
         preferredMaxLatency: "preferred_max_latency",
     });
 });
-export function providerToJSON(provider) {
-    return JSON.stringify(Provider$outboundSchema.parse(provider));
+export function openResponsesRequestProviderToJSON(openResponsesRequestProvider) {
+    return JSON.stringify(OpenResponsesRequestProvider$outboundSchema.parse(openResponsesRequestProvider));
 }
 /** @internal */
-export const PluginResponseHealing$outboundSchema = z.object({
+export const OpenResponsesRequestPluginResponseHealing$outboundSchema = z.object({
     id: z.literal("response-healing"),
     enabled: z.boolean().optional(),
 });
-export function pluginResponseHealingToJSON(pluginResponseHealing) {
-    return JSON.stringify(PluginResponseHealing$outboundSchema.parse(pluginResponseHealing));
+export function openResponsesRequestPluginResponseHealingToJSON(openResponsesRequestPluginResponseHealing) {
+    return JSON.stringify(OpenResponsesRequestPluginResponseHealing$outboundSchema.parse(openResponsesRequestPluginResponseHealing));
 }
 /** @internal */
-export const PluginFileParser$outboundSchema = z.object({
+export const OpenResponsesRequestPluginFileParser$outboundSchema = z.object({
     id: z.literal("file-parser"),
     enabled: z.boolean().optional(),
     pdf: PDFParserOptions$outboundSchema.optional(),
 });
-export function pluginFileParserToJSON(pluginFileParser) {
-    return JSON.stringify(PluginFileParser$outboundSchema.parse(pluginFileParser));
+export function openResponsesRequestPluginFileParserToJSON(openResponsesRequestPluginFileParser) {
+    return JSON.stringify(OpenResponsesRequestPluginFileParser$outboundSchema.parse(openResponsesRequestPluginFileParser));
 }
 /** @internal */
-export const PluginWeb$outboundSchema = z.object({
+export const OpenResponsesRequestPluginWeb$outboundSchema = z.object({
     id: z.literal("web"),
     enabled: z.boolean().optional(),
     maxResults: z.number().optional(),
@@ -165,18 +166,18 @@ export const PluginWeb$outboundSchema = z.object({
         searchPrompt: "search_prompt",
     });
 });
-export function pluginWebToJSON(pluginWeb) {
-    return JSON.stringify(PluginWeb$outboundSchema.parse(pluginWeb));
+export function openResponsesRequestPluginWebToJSON(openResponsesRequestPluginWeb) {
+    return JSON.stringify(OpenResponsesRequestPluginWeb$outboundSchema.parse(openResponsesRequestPluginWeb));
 }
 /** @internal */
-export const PluginModeration$outboundSchema = z.object({
+export const OpenResponsesRequestPluginModeration$outboundSchema = z.object({
     id: z.literal("moderation"),
 });
-export function pluginModerationToJSON(pluginModeration) {
-    return JSON.stringify(PluginModeration$outboundSchema.parse(pluginModeration));
+export function openResponsesRequestPluginModerationToJSON(openResponsesRequestPluginModeration) {
+    return JSON.stringify(OpenResponsesRequestPluginModeration$outboundSchema.parse(openResponsesRequestPluginModeration));
 }
 /** @internal */
-export const PluginAutoRouter$outboundSchema = z.object({
+export const OpenResponsesRequestPluginAutoRouter$outboundSchema = z.object({
     id: z.literal("auto-router"),
     enabled: z.boolean().optional(),
     allowedModels: z.array(z.string()).optional(),
@@ -185,20 +186,43 @@ export const PluginAutoRouter$outboundSchema = z.object({
         allowedModels: "allowed_models",
     });
 });
-export function pluginAutoRouterToJSON(pluginAutoRouter) {
-    return JSON.stringify(PluginAutoRouter$outboundSchema.parse(pluginAutoRouter));
+export function openResponsesRequestPluginAutoRouterToJSON(openResponsesRequestPluginAutoRouter) {
+    return JSON.stringify(OpenResponsesRequestPluginAutoRouter$outboundSchema.parse(openResponsesRequestPluginAutoRouter));
 }
 /** @internal */
-export const Plugin$outboundSchema = z
-    .union([
-    z.lazy(() => PluginAutoRouter$outboundSchema),
-    z.lazy(() => PluginModeration$outboundSchema),
-    z.lazy(() => PluginWeb$outboundSchema),
-    z.lazy(() => PluginFileParser$outboundSchema),
-    z.lazy(() => PluginResponseHealing$outboundSchema),
+export const OpenResponsesRequestPluginUnion$outboundSchema = z.union([
+    z.lazy(() => OpenResponsesRequestPluginAutoRouter$outboundSchema),
+    z.lazy(() => OpenResponsesRequestPluginModeration$outboundSchema),
+    z.lazy(() => OpenResponsesRequestPluginWeb$outboundSchema),
+    z.lazy(() => OpenResponsesRequestPluginFileParser$outboundSchema),
+    z.lazy(() => OpenResponsesRequestPluginResponseHealing$outboundSchema),
 ]);
-export function pluginToJSON(plugin) {
-    return JSON.stringify(Plugin$outboundSchema.parse(plugin));
+export function openResponsesRequestPluginUnionToJSON(openResponsesRequestPluginUnion) {
+    return JSON.stringify(OpenResponsesRequestPluginUnion$outboundSchema.parse(openResponsesRequestPluginUnion));
+}
+/** @internal */
+export const OpenResponsesRequestTrace$outboundSchema = z.object({
+    traceId: z.string().optional(),
+    traceName: z.string().optional(),
+    spanName: z.string().optional(),
+    generationName: z.string().optional(),
+    parentSpanId: z.string().optional(),
+    additionalProperties: z.record(z.string(), z.nullable(z.any())).optional(),
+}).transform((v) => {
+    return {
+        ...v.additionalProperties,
+        ...remap$(v, {
+            traceId: "trace_id",
+            traceName: "trace_name",
+            spanName: "span_name",
+            generationName: "generation_name",
+            parentSpanId: "parent_span_id",
+            additionalProperties: null,
+        }),
+    };
+});
+export function openResponsesRequestTraceToJSON(openResponsesRequestTrace) {
+    return JSON.stringify(OpenResponsesRequestTrace$outboundSchema.parse(openResponsesRequestTrace));
 }
 /** @internal */
 export const OpenResponsesRequest$outboundSchema = z.object({
@@ -240,16 +264,17 @@ export const OpenResponsesRequest$outboundSchema = z.object({
     serviceTier: ServiceTier$outboundSchema.default("auto"),
     truncation: z.nullable(Truncation$outboundSchema).optional(),
     stream: z.boolean().default(false),
-    provider: z.nullable(z.lazy(() => Provider$outboundSchema)).optional(),
+    provider: z.nullable(z.lazy(() => OpenResponsesRequestProvider$outboundSchema)).optional(),
     plugins: z.array(z.union([
-        z.lazy(() => PluginAutoRouter$outboundSchema),
-        z.lazy(() => PluginModeration$outboundSchema),
-        z.lazy(() => PluginWeb$outboundSchema),
-        z.lazy(() => PluginFileParser$outboundSchema),
-        z.lazy(() => PluginResponseHealing$outboundSchema),
+        z.lazy(() => OpenResponsesRequestPluginAutoRouter$outboundSchema),
+        z.lazy(() => OpenResponsesRequestPluginModeration$outboundSchema),
+        z.lazy(() => OpenResponsesRequestPluginWeb$outboundSchema),
+        z.lazy(() => OpenResponsesRequestPluginFileParser$outboundSchema),
+        z.lazy(() => OpenResponsesRequestPluginResponseHealing$outboundSchema),
     ])).optional(),
     user: z.string().optional(),
     sessionId: z.string().optional(),
+    trace: z.lazy(() => OpenResponsesRequestTrace$outboundSchema).optional(),
 }).transform((v) => {
     return remap$(v, {
         toolChoice: "tool_choice",

package/esm/models/operations/createauthkeyscode.d.ts

@@ -28,6 +28,18 @@ export declare const CreateAuthKeysCodeCodeChallengeMethod: {
  * The method used to generate the code challenge
  */
 export type CreateAuthKeysCodeCodeChallengeMethod = OpenEnum<typeof CreateAuthKeysCodeCodeChallengeMethod>;
+/**
+ * Optional credit limit reset interval. When set, the credit limit resets on this interval.
+ */
+export declare const UsageLimitType: {
+    readonly Daily: "daily";
+    readonly Weekly: "weekly";
+    readonly Monthly: "monthly";
+};
+/**
+ * Optional credit limit reset interval. When set, the credit limit resets on this interval.
+ */
+export type UsageLimitType = OpenEnum<typeof UsageLimitType>;
 export type CreateAuthKeysCodeRequestBody = {
     /**
      * The callback URL to redirect to after authorization. Note, only https URLs on ports 443 and 3000 are allowed.
@@ -49,6 +61,14 @@ export type CreateAuthKeysCodeRequestBody = {
      * Optional expiration time for the API key to be created
      */
     expiresAt?: Date | null | undefined;
+    /**
+     * Optional custom label for the API key. Defaults to the app name if not provided.
+     */
+    keyLabel?: string | undefined;
+    /**
+     * Optional credit limit reset interval. When set, the credit limit resets on this interval.
+     */
+    usageLimitType?: UsageLimitType | undefined;
 };
 export type CreateAuthKeysCodeRequest = {
     /**
@@ -95,12 +115,16 @@ export type CreateAuthKeysCodeResponse = {
 /** @internal */
 export declare const CreateAuthKeysCodeCodeChallengeMethod$outboundSchema: z.ZodType<string, CreateAuthKeysCodeCodeChallengeMethod>;
 /** @internal */
+export declare const UsageLimitType$outboundSchema: z.ZodType<string, UsageLimitType>;
+/** @internal */
 export type CreateAuthKeysCodeRequestBody$Outbound = {
     callback_url: string;
     code_challenge?: string | undefined;
     code_challenge_method?: string | undefined;
     limit?: number | undefined;
     expires_at?: string | null | undefined;
+    key_label?: string | undefined;
+    usage_limit_type?: string | undefined;
 };
 /** @internal */
 export declare const CreateAuthKeysCodeRequestBody$outboundSchema: z.ZodType<CreateAuthKeysCodeRequestBody$Outbound, CreateAuthKeysCodeRequestBody>;

package/esm/models/operations/createauthkeyscode.js

@@ -13,9 +13,19 @@ export const CreateAuthKeysCodeCodeChallengeMethod = {
     S256: "S256",
     Plain: "plain",
 };
+/**
+ * Optional credit limit reset interval. When set, the credit limit resets on this interval.
+ */
+export const UsageLimitType = {
+    Daily: "daily",
+    Weekly: "weekly",
+    Monthly: "monthly",
+};
 /** @internal */
 export const CreateAuthKeysCodeCodeChallengeMethod$outboundSchema = openEnums.outboundSchema(CreateAuthKeysCodeCodeChallengeMethod);
 /** @internal */
+export const UsageLimitType$outboundSchema = openEnums.outboundSchema(UsageLimitType);
+/** @internal */
 export const CreateAuthKeysCodeRequestBody$outboundSchema = z.object({
     callbackUrl: z.string(),
     codeChallenge: z.string().optional(),
@@ -23,12 +33,16 @@ export const CreateAuthKeysCodeRequestBody$outboundSchema = z.object({
         .optional(),
     limit: z.number().optional(),
     expiresAt: z.nullable(z.date().transform(v => v.toISOString())).optional(),
+    keyLabel: z.string().optional(),
+    usageLimitType: UsageLimitType$outboundSchema.optional(),
 }).transform((v) => {
     return remap$(v, {
         callbackUrl: "callback_url",
         codeChallenge: "code_challenge",
         codeChallengeMethod: "code_challenge_method",
         expiresAt: "expires_at",
+        keyLabel: "key_label",
+        usageLimitType: "usage_limit_type",
     });
 });
 export function createAuthKeysCodeRequestBodyToJSON(createAuthKeysCodeRequestBody) {

package/esm/models/operations/getgeneration.d.ts

@@ -107,7 +107,9 @@ export declare const ProviderName: {
     readonly Inception: "Inception";
     readonly Inceptron: "Inceptron";
     readonly InferenceNet: "InferenceNet";
+    readonly Ionstream: "Ionstream";
     readonly Infermatic: "Infermatic";
+    readonly IoNet: "Io Net";
     readonly Inflection: "Inflection";
     readonly Liquid: "Liquid";
     readonly Mara: "Mara";

package/esm/models/operations/getgeneration.js

@@ -76,7 +76,9 @@ export const ProviderName = {
     Inception: "Inception",
     Inceptron: "Inceptron",
     InferenceNet: "InferenceNet",
+    Ionstream: "Ionstream",
     Infermatic: "Infermatic",
+    IoNet: "Io Net",
     Inflection: "Inflection",
     Liquid: "Liquid",
     Mara: "Mara",

package/esm/models/operations/sendchatcompletionrequest.d.ts

@@ -32,12 +32,18 @@ export type SendChatCompletionRequestRequest = {
      * @remarks
      */
     xTitle?: string | undefined;
+    chatGenerationParams: models.ChatGenerationParams;
+};
+/**
+ * Successful chat completion response
+ */
+export type SendChatCompletionRequestResponseBody = {
     /**
-     * Chat completion request parameters
+     * Streaming chat completion chunk
      */
-    chatGenerationParams: models.ChatGenerationParams;
+    data: models.ChatStreamingResponseChunk;
 };
-export type SendChatCompletionRequestResponse = models.ChatResponse | EventStream<models.ChatStreamingResponseChunkData>;
+export type SendChatCompletionRequestResponse = models.ChatResponse | EventStream<models.ChatStreamingResponseChunk>;
 /** @internal */
 export type SendChatCompletionRequestRequest$Outbound = {
     "HTTP-Referer"?: string | undefined;
@@ -48,6 +54,9 @@ export type SendChatCompletionRequestRequest$Outbound = {
 export declare const SendChatCompletionRequestRequest$outboundSchema: z.ZodType<SendChatCompletionRequestRequest$Outbound, SendChatCompletionRequestRequest>;
 export declare function sendChatCompletionRequestRequestToJSON(sendChatCompletionRequestRequest: SendChatCompletionRequestRequest): string;
 /** @internal */
+export declare const SendChatCompletionRequestResponseBody$inboundSchema: z.ZodType<SendChatCompletionRequestResponseBody, unknown>;
+export declare function sendChatCompletionRequestResponseBodyFromJSON(jsonString: string): SafeParseResult<SendChatCompletionRequestResponseBody, SDKValidationError>;
+/** @internal */
 export declare const SendChatCompletionRequestResponse$inboundSchema: z.ZodType<SendChatCompletionRequestResponse, unknown>;
 export declare function sendChatCompletionRequestResponseFromJSON(jsonString: string): SafeParseResult<SendChatCompletionRequestResponse, SDKValidationError>;
 //# sourceMappingURL=sendchatcompletionrequest.d.ts.map

package/esm/models/operations/sendchatcompletionrequest.js

@@ -23,6 +23,25 @@ export function sendChatCompletionRequestRequestToJSON(sendChatCompletionRequest
     return JSON.stringify(SendChatCompletionRequestRequest$outboundSchema.parse(sendChatCompletionRequestRequest));
 }
 /** @internal */
+export const SendChatCompletionRequestResponseBody$inboundSchema = z.object({
+    data: z.string().transform((v, ctx) => {
+        try {
+            return JSON.parse(v);
+        }
+        catch (err) {
+            ctx.addIssue({
+                input: v,
+                code: "custom",
+                message: `malformed json: ${err}`,
+            });
+            return z.NEVER;
+        }
+    }).pipe(models.ChatStreamingResponseChunk$inboundSchema),
+});
+export function sendChatCompletionRequestResponseBodyFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => SendChatCompletionRequestResponseBody$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'SendChatCompletionRequestResponseBody' from JSON`);
+}
+/** @internal */
 export const SendChatCompletionRequestResponse$inboundSchema = z.union([
     models.ChatResponse$inboundSchema,
     z.custom(x => x instanceof ReadableStream)
@@ -31,8 +50,7 @@ export const SendChatCompletionRequestResponse$inboundSchema = z.union([
             if (rawEvent.data === "[DONE]")
                 return { done: true };
             return {
-                value: models.ChatStreamingResponseChunk$inboundSchema.parse(rawEvent)
-                    ?.data,
+                value: z.lazy(() => SendChatCompletionRequestResponseBody$inboundSchema).parse(rawEvent)?.data,
             };
         });
     }),

package/esm/models/providername.d.ts

@@ -35,7 +35,9 @@ export declare const ProviderName: {
     readonly Inception: "Inception";
     readonly Inceptron: "Inceptron";
     readonly InferenceNet: "InferenceNet";
+    readonly Ionstream: "Ionstream";
     readonly Infermatic: "Infermatic";
+    readonly IoNet: "Io Net";
     readonly Inflection: "Inflection";
     readonly Liquid: "Liquid";
     readonly Mara: "Mara";

package/esm/models/providername.js

@@ -38,7 +38,9 @@ export const ProviderName = {
     Inception: "Inception",
     Inceptron: "Inceptron",
     InferenceNet: "InferenceNet",
+    Ionstream: "Ionstream",
     Infermatic: "Infermatic",
+    IoNet: "Io Net",
     Inflection: "Inflection",
     Liquid: "Liquid",
     Mara: "Mara",

package/esm/models/providerpreferences.d.ts

@@ -4,43 +4,72 @@ import { DataCollection } from "./datacollection.js";
 import { PreferredMaxLatency, PreferredMaxLatency$Outbound } from "./preferredmaxlatency.js";
 import { PreferredMinThroughput, PreferredMinThroughput$Outbound } from "./preferredminthroughput.js";
 import { ProviderName } from "./providername.js";
-import { ProviderSort } from "./providersort.js";
 import { Quantization } from "./quantization.js";
 export type ProviderPreferencesOrder = ProviderName | string;
 export type ProviderPreferencesOnly = ProviderName | string;
 export type ProviderPreferencesIgnore = ProviderName | string;
-export declare const SortEnum: {
+export declare const ProviderPreferencesSortEnum: {
     readonly Price: "price";
     readonly Throughput: "throughput";
     readonly Latency: "latency";
 };
-export type SortEnum = OpenEnum<typeof SortEnum>;
-export declare const ProviderSortConfigEnum: {
+export type ProviderPreferencesSortEnum = OpenEnum<typeof ProviderPreferencesSortEnum>;
+export declare const ProviderPreferencesProviderSortConfigEnum: {
     readonly Price: "price";
     readonly Throughput: "throughput";
     readonly Latency: "latency";
 };
-export type ProviderSortConfigEnum = ClosedEnum<typeof ProviderSortConfigEnum>;
+export type ProviderPreferencesProviderSortConfigEnum = ClosedEnum<typeof ProviderPreferencesProviderSortConfigEnum>;
+/**
+ * The provider sorting strategy (price, throughput, latency)
+ */
+export declare const ProviderPreferencesBy: {
+    readonly Price: "price";
+    readonly Throughput: "throughput";
+    readonly Latency: "latency";
+};
+/**
+ * The provider sorting strategy (price, throughput, latency)
+ */
+export type ProviderPreferencesBy = OpenEnum<typeof ProviderPreferencesBy>;
+/**
+ * Partitioning strategy for sorting: "model" (default) groups endpoints by model before sorting (fallback models remain fallbacks), "none" sorts all endpoints together regardless of model.
+ */
 export declare const ProviderPreferencesPartition: {
     readonly Model: "model";
     readonly None: "none";
 };
+/**
+ * Partitioning strategy for sorting: "model" (default) groups endpoints by model before sorting (fallback models remain fallbacks), "none" sorts all endpoints together regardless of model.
+ */
 export type ProviderPreferencesPartition = OpenEnum<typeof ProviderPreferencesPartition>;
 export type ProviderPreferencesProviderSortConfig = {
-    by?: ProviderSort | null | undefined;
+    /**
+     * The provider sorting strategy (price, throughput, latency)
+     */
+    by?: ProviderPreferencesBy | null | undefined;
+    /**
+     * Partitioning strategy for sorting: "model" (default) groups endpoints by model before sorting (fallback models remain fallbacks), "none" sorts all endpoints together regardless of model.
+     */
     partition?: ProviderPreferencesPartition | null | undefined;
 };
-export type ProviderSortConfigUnion = ProviderPreferencesProviderSortConfig | ProviderSortConfigEnum;
+export type ProviderPreferencesProviderSortConfigUnion = ProviderPreferencesProviderSortConfig | ProviderPreferencesProviderSortConfigEnum;
+/**
+ * The provider sorting strategy (price, throughput, latency)
+ */
 export declare const ProviderPreferencesProviderSort: {
     readonly Price: "price";
     readonly Throughput: "throughput";
     readonly Latency: "latency";
 };
+/**
+ * The provider sorting strategy (price, throughput, latency)
+ */
 export type ProviderPreferencesProviderSort = OpenEnum<typeof ProviderPreferencesProviderSort>;
 /**
  * The sorting strategy to use for this request, if "order" is not specified. When set, no load balancing is performed.
  */
-export type ProviderPreferencesSortUnion = ProviderPreferencesProviderSort | ProviderPreferencesProviderSortConfig | ProviderSortConfigEnum | SortEnum;
+export type ProviderPreferencesSortUnion = ProviderPreferencesProviderSort | ProviderPreferencesProviderSortConfig | ProviderPreferencesProviderSortConfigEnum | ProviderPreferencesSortEnum;
 /**
  * The object specifying the maximum price you want to pay for this request. USD price per million tokens, for prompt and completion.
  */
@@ -103,7 +132,7 @@ export type ProviderPreferences = {
      * A list of quantization levels to filter the provider by.
      */
     quantizations?: Array<Quantization> | null | undefined;
-    sort?: ProviderPreferencesProviderSort | ProviderPreferencesProviderSortConfig | ProviderSortConfigEnum | SortEnum | null | undefined;
+    sort?: ProviderPreferencesProviderSort | ProviderPreferencesProviderSortConfig | ProviderPreferencesProviderSortConfigEnum | ProviderPreferencesSortEnum | null | undefined;
     /**
      * The object specifying the maximum price you want to pay for this request. USD price per million tokens, for prompt and completion.
      */
@@ -133,9 +162,11 @@ export type ProviderPreferencesIgnore$Outbound = string | string;
 export declare const ProviderPreferencesIgnore$outboundSchema: z.ZodType<ProviderPreferencesIgnore$Outbound, ProviderPreferencesIgnore>;
 export declare function providerPreferencesIgnoreToJSON(providerPreferencesIgnore: ProviderPreferencesIgnore): string;
 /** @internal */
-export declare const SortEnum$outboundSchema: z.ZodType<string, SortEnum>;
+export declare const ProviderPreferencesSortEnum$outboundSchema: z.ZodType<string, ProviderPreferencesSortEnum>;
+/** @internal */
+export declare const ProviderPreferencesProviderSortConfigEnum$outboundSchema: z.ZodEnum<typeof ProviderPreferencesProviderSortConfigEnum>;
 /** @internal */
-export declare const ProviderSortConfigEnum$outboundSchema: z.ZodEnum<typeof ProviderSortConfigEnum>;
+export declare const ProviderPreferencesBy$outboundSchema: z.ZodType<string, ProviderPreferencesBy>;
 /** @internal */
 export declare const ProviderPreferencesPartition$outboundSchema: z.ZodType<string, ProviderPreferencesPartition>;
 /** @internal */
@@ -147,10 +178,10 @@ export type ProviderPreferencesProviderSortConfig$Outbound = {
 export declare const ProviderPreferencesProviderSortConfig$outboundSchema: z.ZodType<ProviderPreferencesProviderSortConfig$Outbound, ProviderPreferencesProviderSortConfig>;
 export declare function providerPreferencesProviderSortConfigToJSON(providerPreferencesProviderSortConfig: ProviderPreferencesProviderSortConfig): string;
 /** @internal */
-export type ProviderSortConfigUnion$Outbound = ProviderPreferencesProviderSortConfig$Outbound | string;
+export type ProviderPreferencesProviderSortConfigUnion$Outbound = ProviderPreferencesProviderSortConfig$Outbound | string;
 /** @internal */
-export declare const ProviderSortConfigUnion$outboundSchema: z.ZodType<ProviderSortConfigUnion$Outbound, ProviderSortConfigUnion>;
-export declare function providerSortConfigUnionToJSON(providerSortConfigUnion: ProviderSortConfigUnion): string;
+export declare const ProviderPreferencesProviderSortConfigUnion$outboundSchema: z.ZodType<ProviderPreferencesProviderSortConfigUnion$Outbound, ProviderPreferencesProviderSortConfigUnion>;
+export declare function providerPreferencesProviderSortConfigUnionToJSON(providerPreferencesProviderSortConfigUnion: ProviderPreferencesProviderSortConfigUnion): string;
 /** @internal */
 export declare const ProviderPreferencesProviderSort$outboundSchema: z.ZodType<string, ProviderPreferencesProviderSort>;
 /** @internal */

package/esm/models/providerpreferences.js

@@ -9,22 +9,35 @@ import { DataCollection$outboundSchema, } from "./datacollection.js";
 import { PreferredMaxLatency$outboundSchema, } from "./preferredmaxlatency.js";
 import { PreferredMinThroughput$outboundSchema, } from "./preferredminthroughput.js";
 import { ProviderName$outboundSchema } from "./providername.js";
-import { ProviderSort$outboundSchema } from "./providersort.js";
 import { Quantization$outboundSchema } from "./quantization.js";
-export const SortEnum = {
+export const ProviderPreferencesSortEnum = {
     Price: "price",
     Throughput: "throughput",
     Latency: "latency",
 };
-export const ProviderSortConfigEnum = {
+export const ProviderPreferencesProviderSortConfigEnum = {
     Price: "price",
     Throughput: "throughput",
     Latency: "latency",
 };
+/**
+ * The provider sorting strategy (price, throughput, latency)
+ */
+export const ProviderPreferencesBy = {
+    Price: "price",
+    Throughput: "throughput",
+    Latency: "latency",
+};
+/**
+ * Partitioning strategy for sorting: "model" (default) groups endpoints by model before sorting (fallback models remain fallbacks), "none" sorts all endpoints together regardless of model.
+ */
 export const ProviderPreferencesPartition = {
     Model: "model",
     None: "none",
 };
+/**
+ * The provider sorting strategy (price, throughput, latency)
+ */
 export const ProviderPreferencesProviderSort = {
     Price: "price",
     Throughput: "throughput",
@@ -46,27 +59,28 @@ export function providerPreferencesIgnoreToJSON(providerPreferencesIgnore) {
     return JSON.stringify(ProviderPreferencesIgnore$outboundSchema.parse(providerPreferencesIgnore));
 }
 /** @internal */
-export const SortEnum$outboundSchema = openEnums
-    .outboundSchema(SortEnum);
+export const ProviderPreferencesSortEnum$outboundSchema = openEnums.outboundSchema(ProviderPreferencesSortEnum);
+/** @internal */
+export const ProviderPreferencesProviderSortConfigEnum$outboundSchema = z.enum(ProviderPreferencesProviderSortConfigEnum);
 /** @internal */
-export const ProviderSortConfigEnum$outboundSchema = z.enum(ProviderSortConfigEnum);
+export const ProviderPreferencesBy$outboundSchema = openEnums.outboundSchema(ProviderPreferencesBy);
 /** @internal */
 export const ProviderPreferencesPartition$outboundSchema = openEnums.outboundSchema(ProviderPreferencesPartition);
 /** @internal */
 export const ProviderPreferencesProviderSortConfig$outboundSchema = z.object({
-    by: z.nullable(ProviderSort$outboundSchema).optional(),
+    by: z.nullable(ProviderPreferencesBy$outboundSchema).optional(),
     partition: z.nullable(ProviderPreferencesPartition$outboundSchema).optional(),
 });
 export function providerPreferencesProviderSortConfigToJSON(providerPreferencesProviderSortConfig) {
     return JSON.stringify(ProviderPreferencesProviderSortConfig$outboundSchema.parse(providerPreferencesProviderSortConfig));
 }
 /** @internal */
-export const ProviderSortConfigUnion$outboundSchema = z.union([
+export const ProviderPreferencesProviderSortConfigUnion$outboundSchema = z.union([
     z.lazy(() => ProviderPreferencesProviderSortConfig$outboundSchema),
-    ProviderSortConfigEnum$outboundSchema,
+    ProviderPreferencesProviderSortConfigEnum$outboundSchema,
 ]);
-export function providerSortConfigUnionToJSON(providerSortConfigUnion) {
-    return JSON.stringify(ProviderSortConfigUnion$outboundSchema.parse(providerSortConfigUnion));
+export function providerPreferencesProviderSortConfigUnionToJSON(providerPreferencesProviderSortConfigUnion) {
+    return JSON.stringify(ProviderPreferencesProviderSortConfigUnion$outboundSchema.parse(providerPreferencesProviderSortConfigUnion));
 }
 /** @internal */
 export const ProviderPreferencesProviderSort$outboundSchema = openEnums.outboundSchema(ProviderPreferencesProviderSort);
@@ -75,9 +89,9 @@ export const ProviderPreferencesSortUnion$outboundSchema = z.union([
     ProviderPreferencesProviderSort$outboundSchema,
     z.union([
         z.lazy(() => ProviderPreferencesProviderSortConfig$outboundSchema),
-        ProviderSortConfigEnum$outboundSchema,
+        ProviderPreferencesProviderSortConfigEnum$outboundSchema,
     ]),
-    SortEnum$outboundSchema,
+    ProviderPreferencesSortEnum$outboundSchema,
 ]);
 export function providerPreferencesSortUnionToJSON(providerPreferencesSortUnion) {
     return JSON.stringify(ProviderPreferencesSortUnion$outboundSchema.parse(providerPreferencesSortUnion));
@@ -110,9 +124,9 @@ export const ProviderPreferences$outboundSchema = z.object({
         ProviderPreferencesProviderSort$outboundSchema,
         z.union([
             z.lazy(() => ProviderPreferencesProviderSortConfig$outboundSchema),
-            ProviderSortConfigEnum$outboundSchema,
+            ProviderPreferencesProviderSortConfigEnum$outboundSchema,
         ]),
-        SortEnum$outboundSchema,
+        ProviderPreferencesSortEnum$outboundSchema,
     ])).optional(),
     maxPrice: z.lazy(() => ProviderPreferencesMaxPrice$outboundSchema).optional(),
     preferredMinThroughput: z.nullable(PreferredMinThroughput$outboundSchema)

package/esm/models/providersort.d.ts

@@ -1,10 +1,16 @@
 import * as z from "zod/v4";
 import { OpenEnum } from "../types/enums.js";
+/**
+ * The provider sorting strategy (price, throughput, latency)
+ */
 export declare const ProviderSort: {
     readonly Price: "price";
     readonly Throughput: "throughput";
     readonly Latency: "latency";
 };
+/**
+ * The provider sorting strategy (price, throughput, latency)
+ */
 export type ProviderSort = OpenEnum<typeof ProviderSort>;
 /** @internal */
 export declare const ProviderSort$outboundSchema: z.ZodType<string, ProviderSort>;

package/esm/models/providersort.js

@@ -3,6 +3,9 @@
  * @generated-id: 7d1e919d1ec3
  */
 import * as openEnums from "../types/enums.js";
+/**
+ * The provider sorting strategy (price, throughput, latency)
+ */
 export const ProviderSort = {
     Price: "price",
     Throughput: "throughput",