@openrouter/sdk 0.8.0 → 0.10.2

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

@@ -15,7 +15,13 @@ export type UpdateKeysGlobals = {
      *
      * @remarks
      */
-    xTitle?: string | undefined;
+    appTitle?: string | undefined;
+    /**
+     * Comma-separated list of app categories (e.g. "cli-agent,cloud-agent"). Used for marketplace rankings.
+     *
+     * @remarks
+     */
+    appCategories?: string | undefined;
 };
 /**
  * New limit reset type for the API key (daily, weekly, monthly, or null for no reset). Resets happen automatically at midnight UTC, and weeks are Monday through Sunday.
@@ -64,7 +70,13 @@ export type UpdateKeysRequest = {
      *
      * @remarks
      */
-    xTitle?: string | undefined;
+    appTitle?: string | undefined;
+    /**
+     * Comma-separated list of app categories (e.g. "cli-agent,cloud-agent"). Used for marketplace rankings.
+     *
+     * @remarks
+     */
+    appCategories?: string | undefined;
     /**
      * The hash identifier of the API key to update
      */
@@ -177,7 +189,8 @@ export declare function updateKeysRequestBodyToJSON(updateKeysRequestBody: Updat
 /** @internal */
 export type UpdateKeysRequest$Outbound = {
     "HTTP-Referer"?: string | undefined;
-    "X-Title"?: string | undefined;
+    appTitle?: string | undefined;
+    appCategories?: string | undefined;
     hash: string;
     RequestBody: UpdateKeysRequestBody$Outbound;
 };

package/esm/models/operations/updatekeys.js

@@ -35,13 +35,13 @@ export function updateKeysRequestBodyToJSON(updateKeysRequestBody) {
 /** @internal */
 export const UpdateKeysRequest$outboundSchema = z.object({
     httpReferer: z.string().optional(),
-    xTitle: z.string().optional(),
+    appTitle: z.string().optional(),
+    appCategories: z.string().optional(),
     hash: z.string(),
     requestBody: z.lazy(() => UpdateKeysRequestBody$outboundSchema),
 }).transform((v) => {
     return remap$(v, {
         httpReferer: "HTTP-Referer",
-        xTitle: "X-Title",
         requestBody: "RequestBody",
     });
 });

package/esm/models/outputmessage.d.ts

@@ -26,12 +26,28 @@ export declare const OutputMessageStatusCompleted: {
 export type OutputMessageStatusCompleted = ClosedEnum<typeof OutputMessageStatusCompleted>;
 export type OutputMessageStatusUnion = OutputMessageStatusCompleted | OutputMessageStatusIncomplete | OutputMessageStatusInProgress;
 export type OutputMessageContent = ResponseOutputText | OpenAIResponsesRefusalContent;
+export declare const OutputMessagePhaseFinalAnswer: {
+    readonly FinalAnswer: "final_answer";
+};
+export type OutputMessagePhaseFinalAnswer = ClosedEnum<typeof OutputMessagePhaseFinalAnswer>;
+export declare const OutputMessagePhaseCommentary: {
+    readonly Commentary: "commentary";
+};
+export type OutputMessagePhaseCommentary = ClosedEnum<typeof OutputMessagePhaseCommentary>;
+/**
+ * The phase of an assistant message. Use `commentary` for an intermediate assistant message and `final_answer` for the final assistant message. For follow-up requests with models like `gpt-5.3-codex` and later, preserve and resend phase on all assistant messages. Omitting it can degrade performance. Not used for user messages.
+ */
+export type OutputMessagePhaseUnion = OutputMessagePhaseCommentary | OutputMessagePhaseFinalAnswer | any;
 export type OutputMessage = {
     id: string;
     role: OutputMessageRole;
     type: OutputMessageType;
     status?: OutputMessageStatusCompleted | OutputMessageStatusIncomplete | OutputMessageStatusInProgress | undefined;
     content: Array<ResponseOutputText | OpenAIResponsesRefusalContent>;
+    /**
+     * The phase of an assistant message. Use `commentary` for an intermediate assistant message and `final_answer` for the final assistant message. For follow-up requests with models like `gpt-5.3-codex` and later, preserve and resend phase on all assistant messages. Omitting it can degrade performance. Not used for user messages.
+     */
+    phase?: OutputMessagePhaseCommentary | OutputMessagePhaseFinalAnswer | any | null | undefined;
 };
 /** @internal */
 export declare const OutputMessageRole$inboundSchema: z.ZodEnum<typeof OutputMessageRole>;
@@ -50,6 +66,13 @@ export declare function outputMessageStatusUnionFromJSON(jsonString: string): Sa
 export declare const OutputMessageContent$inboundSchema: z.ZodType<OutputMessageContent, unknown>;
 export declare function outputMessageContentFromJSON(jsonString: string): SafeParseResult<OutputMessageContent, SDKValidationError>;
 /** @internal */
+export declare const OutputMessagePhaseFinalAnswer$inboundSchema: z.ZodEnum<typeof OutputMessagePhaseFinalAnswer>;
+/** @internal */
+export declare const OutputMessagePhaseCommentary$inboundSchema: z.ZodEnum<typeof OutputMessagePhaseCommentary>;
+/** @internal */
+export declare const OutputMessagePhaseUnion$inboundSchema: z.ZodType<OutputMessagePhaseUnion, unknown>;
+export declare function outputMessagePhaseUnionFromJSON(jsonString: string): SafeParseResult<OutputMessagePhaseUnion, SDKValidationError>;
+/** @internal */
 export declare const OutputMessage$inboundSchema: z.ZodType<OutputMessage, unknown>;
 export declare function outputMessageFromJSON(jsonString: string): SafeParseResult<OutputMessage, SDKValidationError>;
 //# sourceMappingURL=outputmessage.d.ts.map

package/esm/models/outputmessage.js

@@ -21,6 +21,12 @@ export const OutputMessageStatusIncomplete = {
 export const OutputMessageStatusCompleted = {
     Completed: "completed",
 };
+export const OutputMessagePhaseFinalAnswer = {
+    FinalAnswer: "final_answer",
+};
+export const OutputMessagePhaseCommentary = {
+    Commentary: "commentary",
+};
 /** @internal */
 export const OutputMessageRole$inboundSchema = z.enum(OutputMessageRole);
 /** @internal */
@@ -49,6 +55,19 @@ export function outputMessageContentFromJSON(jsonString) {
     return safeParse(jsonString, (x) => OutputMessageContent$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'OutputMessageContent' from JSON`);
 }
 /** @internal */
+export const OutputMessagePhaseFinalAnswer$inboundSchema = z.enum(OutputMessagePhaseFinalAnswer);
+/** @internal */
+export const OutputMessagePhaseCommentary$inboundSchema = z.enum(OutputMessagePhaseCommentary);
+/** @internal */
+export const OutputMessagePhaseUnion$inboundSchema = z.union([
+    OutputMessagePhaseCommentary$inboundSchema,
+    OutputMessagePhaseFinalAnswer$inboundSchema,
+    z.any(),
+]);
+export function outputMessagePhaseUnionFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => OutputMessagePhaseUnion$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'OutputMessagePhaseUnion' from JSON`);
+}
+/** @internal */
 export const OutputMessage$inboundSchema = z
     .object({
     id: z.string(),
@@ -63,6 +82,11 @@ export const OutputMessage$inboundSchema = z
         ResponseOutputText$inboundSchema,
         OpenAIResponsesRefusalContent$inboundSchema,
     ])),
+    phase: z.nullable(z.union([
+        OutputMessagePhaseCommentary$inboundSchema,
+        OutputMessagePhaseFinalAnswer$inboundSchema,
+        z.any(),
+    ])).optional(),
 });
 export function outputMessageFromJSON(jsonString) {
     return safeParse(jsonString, (x) => OutputMessage$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'OutputMessage' from JSON`);

package/esm/models/outputmodality.d.ts

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

package/esm/models/outputmodality.js

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

package/esm/models/providername.d.ts

@@ -1,6 +1,7 @@
 import * as z from "zod/v4";
 import { OpenEnum } from "../types/enums.js";
 export declare const ProviderName: {
+    readonly AkashML: "AkashML";
     readonly Ai21: "AI21";
     readonly AionLabs: "AionLabs";
     readonly Alibaba: "Alibaba";
@@ -35,7 +36,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

@@ -4,6 +4,7 @@
  */
 import * as openEnums from "../types/enums.js";
 export const ProviderName = {
+    AkashML: "AkashML",
     Ai21: "AI21",
     AionLabs: "AionLabs",
     Alibaba: "Alibaba",
@@ -38,7 +39,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,76 @@ 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";
+    readonly Exacto: "exacto";
 };
-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";
+    readonly Exacto: "exacto";
 };
-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";
+    readonly Exacto: "exacto";
+};
+/**
+ * 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";
+    readonly Exacto: "exacto";
 };
+/**
+ * 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 +136,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 +166,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 +182,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,26 +9,43 @@ 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",
+    Exacto: "exacto",
 };
-export const ProviderSortConfigEnum = {
+export const ProviderPreferencesProviderSortConfigEnum = {
     Price: "price",
     Throughput: "throughput",
     Latency: "latency",
+    Exacto: "exacto",
 };
+/**
+ * The provider sorting strategy (price, throughput, latency)
+ */
+export const ProviderPreferencesBy = {
+    Price: "price",
+    Throughput: "throughput",
+    Latency: "latency",
+    Exacto: "exacto",
+};
+/**
+ * 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",
     Latency: "latency",
+    Exacto: "exacto",
 };
 /** @internal */
 export const ProviderPreferencesOrder$outboundSchema = z.union([ProviderName$outboundSchema, z.string()]);
@@ -46,27 +63,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 +93,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 +128,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,17 @@
 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";
+    readonly Exacto: "exacto";
 };
+/**
+ * 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,10 +3,14 @@
  * @generated-id: 7d1e919d1ec3
  */
 import * as openEnums from "../types/enums.js";
+/**
+ * The provider sorting strategy (price, throughput, latency)
+ */
 export const ProviderSort = {
     Price: "price",
     Throughput: "throughput",
     Latency: "latency",
+    Exacto: "exacto",
 };
 /** @internal */
 export const ProviderSort$outboundSchema = openEnums.outboundSchema(ProviderSort);

package/esm/models/providersortconfig.d.ts

@@ -1,16 +1,45 @@
 import * as z from "zod/v4";
 import { OpenEnum } from "../types/enums.js";
-import { ProviderSort } from "./providersort.js";
+/**
+ * The provider sorting strategy (price, throughput, latency)
+ */
+export declare const By: {
+    readonly Price: "price";
+    readonly Throughput: "throughput";
+    readonly Latency: "latency";
+    readonly Exacto: "exacto";
+};
+/**
+ * The provider sorting strategy (price, throughput, latency)
+ */
+export type By = OpenEnum<typeof By>;
+/**
+ * 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 Partition: {
     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 Partition = OpenEnum<typeof Partition>;
+/**
+ * The provider sorting strategy (price, throughput, latency)
+ */
 export type ProviderSortConfig = {
-    by?: ProviderSort | null | undefined;
+    /**
+     * The provider sorting strategy (price, throughput, latency)
+     */
+    by?: By | 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?: Partition | null | undefined;
 };
 /** @internal */
+export declare const By$outboundSchema: z.ZodType<string, By>;
+/** @internal */
 export declare const Partition$outboundSchema: z.ZodType<string, Partition>;
 /** @internal */
 export type ProviderSortConfig$Outbound = {

package/esm/models/providersortconfig.js

@@ -4,17 +4,31 @@
  */
 import * as z from "zod/v4";
 import * as openEnums from "../types/enums.js";
-import { ProviderSort$outboundSchema } from "./providersort.js";
+/**
+ * The provider sorting strategy (price, throughput, latency)
+ */
+export const By = {
+    Price: "price",
+    Throughput: "throughput",
+    Latency: "latency",
+    Exacto: "exacto",
+};
+/**
+ * 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 Partition = {
     Model: "model",
     None: "none",
 };
 /** @internal */
+export const By$outboundSchema = openEnums
+    .outboundSchema(By);
+/** @internal */
 export const Partition$outboundSchema = openEnums
     .outboundSchema(Partition);
 /** @internal */
 export const ProviderSortConfig$outboundSchema = z.object({
-    by: z.nullable(ProviderSort$outboundSchema).optional(),
+    by: z.nullable(By$outboundSchema).optional(),
     partition: z.nullable(Partition$outboundSchema).optional(),
 });
 export function providerSortConfigToJSON(providerSortConfig) {

package/esm/models/reasoningdetailencrypted.d.ts

@@ -0,0 +1,42 @@
+import * as z from "zod/v4";
+import { OpenEnum } from "../types/enums.js";
+import { Result as SafeParseResult } from "../types/fp.js";
+import { SDKValidationError } from "./errors/sdkvalidationerror.js";
+export declare const ReasoningDetailEncryptedFormat: {
+    readonly Unknown: "unknown";
+    readonly OpenaiResponsesV1: "openai-responses-v1";
+    readonly AzureOpenaiResponsesV1: "azure-openai-responses-v1";
+    readonly XaiResponsesV1: "xai-responses-v1";
+    readonly AnthropicClaudeV1: "anthropic-claude-v1";
+    readonly GoogleGeminiV1: "google-gemini-v1";
+};
+export type ReasoningDetailEncryptedFormat = OpenEnum<typeof ReasoningDetailEncryptedFormat>;
+/**
+ * Reasoning detail encrypted schema
+ */
+export type ReasoningDetailEncrypted = {
+    type: "reasoning.encrypted";
+    data: string;
+    id?: string | null | undefined;
+    format?: ReasoningDetailEncryptedFormat | null | undefined;
+    index?: number | undefined;
+};
+/** @internal */
+export declare const ReasoningDetailEncryptedFormat$inboundSchema: z.ZodType<ReasoningDetailEncryptedFormat, unknown>;
+/** @internal */
+export declare const ReasoningDetailEncryptedFormat$outboundSchema: z.ZodType<string, ReasoningDetailEncryptedFormat>;
+/** @internal */
+export declare const ReasoningDetailEncrypted$inboundSchema: z.ZodType<ReasoningDetailEncrypted, unknown>;
+/** @internal */
+export type ReasoningDetailEncrypted$Outbound = {
+    type: "reasoning.encrypted";
+    data: string;
+    id?: string | null | undefined;
+    format?: string | null | undefined;
+    index?: number | undefined;
+};
+/** @internal */
+export declare const ReasoningDetailEncrypted$outboundSchema: z.ZodType<ReasoningDetailEncrypted$Outbound, ReasoningDetailEncrypted>;
+export declare function reasoningDetailEncryptedToJSON(reasoningDetailEncrypted: ReasoningDetailEncrypted): string;
+export declare function reasoningDetailEncryptedFromJSON(jsonString: string): SafeParseResult<ReasoningDetailEncrypted, SDKValidationError>;
+//# sourceMappingURL=reasoningdetailencrypted.d.ts.map

package/esm/models/reasoningdetailencrypted.js

@@ -0,0 +1,42 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ * @generated-id: 2064e7820eab
+ */
+import * as z from "zod/v4";
+import { safeParse } from "../lib/schemas.js";
+import * as openEnums from "../types/enums.js";
+export const ReasoningDetailEncryptedFormat = {
+    Unknown: "unknown",
+    OpenaiResponsesV1: "openai-responses-v1",
+    AzureOpenaiResponsesV1: "azure-openai-responses-v1",
+    XaiResponsesV1: "xai-responses-v1",
+    AnthropicClaudeV1: "anthropic-claude-v1",
+    GoogleGeminiV1: "google-gemini-v1",
+};
+/** @internal */
+export const ReasoningDetailEncryptedFormat$inboundSchema = openEnums.inboundSchema(ReasoningDetailEncryptedFormat);
+/** @internal */
+export const ReasoningDetailEncryptedFormat$outboundSchema = openEnums.outboundSchema(ReasoningDetailEncryptedFormat);
+/** @internal */
+export const ReasoningDetailEncrypted$inboundSchema = z.object({
+    type: z.literal("reasoning.encrypted"),
+    data: z.string(),
+    id: z.nullable(z.string()).optional(),
+    format: z.nullable(ReasoningDetailEncryptedFormat$inboundSchema).optional(),
+    index: z.number().optional(),
+});
+/** @internal */
+export const ReasoningDetailEncrypted$outboundSchema = z.object({
+    type: z.literal("reasoning.encrypted"),
+    data: z.string(),
+    id: z.nullable(z.string()).optional(),
+    format: z.nullable(ReasoningDetailEncryptedFormat$outboundSchema).optional(),
+    index: z.number().optional(),
+});
+export function reasoningDetailEncryptedToJSON(reasoningDetailEncrypted) {
+    return JSON.stringify(ReasoningDetailEncrypted$outboundSchema.parse(reasoningDetailEncrypted));
+}
+export function reasoningDetailEncryptedFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => ReasoningDetailEncrypted$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'ReasoningDetailEncrypted' from JSON`);
+}
+//# sourceMappingURL=reasoningdetailencrypted.js.map