@openrouter/sdk 0.11.2 → 0.12.0

package/esm/models/textdoneevent.js

@@ -5,45 +5,22 @@
 import * as z from "zod/v4";
 import { remap as remap$ } from "../lib/primitives.js";
 import { safeParse } from "../lib/schemas.js";
-/** @internal */
-export const TextDoneEventTopLogprob$inboundSchema = z.object({
-    token: z.string().optional(),
-    logprob: z.number().optional(),
-    bytes: z.array(z.number()).optional(),
-});
-export function textDoneEventTopLogprobFromJSON(jsonString) {
-    return safeParse(jsonString, (x) => TextDoneEventTopLogprob$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'TextDoneEventTopLogprob' from JSON`);
-}
-/** @internal */
-export const TextDoneEventLogprob$inboundSchema = z.object({
-    logprob: z.number(),
-    token: z.string(),
-    top_logprobs: z.array(z.lazy(() => TextDoneEventTopLogprob$inboundSchema))
-        .optional(),
-    bytes: z.array(z.number()).optional(),
-}).transform((v) => {
-    return remap$(v, {
-        "top_logprobs": "topLogprobs",
-    });
-});
-export function textDoneEventLogprobFromJSON(jsonString) {
-    return safeParse(jsonString, (x) => TextDoneEventLogprob$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'TextDoneEventLogprob' from JSON`);
-}
+import { StreamLogprob$inboundSchema } from "./streamlogprob.js";
 /** @internal */
 export const TextDoneEvent$inboundSchema = z
     .object({
-    type: z.literal("response.output_text.done"),
-    output_index: z.number(),
+    content_index: z.int(),
     item_id: z.string(),
-    content_index: z.number(),
+    logprobs: z.array(StreamLogprob$inboundSchema),
+    output_index: z.int(),
+    sequence_number: z.int(),
     text: z.string(),
-    sequence_number: z.number(),
-    logprobs: z.array(z.lazy(() => TextDoneEventLogprob$inboundSchema)),
+    type: z.literal("response.output_text.done"),
 }).transform((v) => {
     return remap$(v, {
-        "output_index": "outputIndex",
-        "item_id": "itemId",
         "content_index": "contentIndex",
+        "item_id": "itemId",
+        "output_index": "outputIndex",
         "sequence_number": "sequenceNumber",
     });
 });

package/esm/models/toolcallstatus.d.ts

@@ -0,0 +1,13 @@
+import * as z from "zod/v4";
+import { OpenEnum } from "../types/enums.js";
+export declare const ToolCallStatus: {
+    readonly InProgress: "in_progress";
+    readonly Completed: "completed";
+    readonly Incomplete: "incomplete";
+};
+export type ToolCallStatus = OpenEnum<typeof ToolCallStatus>;
+/** @internal */
+export declare const ToolCallStatus$inboundSchema: z.ZodType<ToolCallStatus, unknown>;
+/** @internal */
+export declare const ToolCallStatus$outboundSchema: z.ZodType<string, ToolCallStatus>;
+//# sourceMappingURL=toolcallstatus.d.ts.map

package/esm/models/toolcallstatus.js

@@ -0,0 +1,15 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ * @generated-id: 54eb9c06bedb
+ */
+import * as openEnums from "../types/enums.js";
+export const ToolCallStatus = {
+    InProgress: "in_progress",
+    Completed: "completed",
+    Incomplete: "incomplete",
+};
+/** @internal */
+export const ToolCallStatus$inboundSchema = openEnums.inboundSchema(ToolCallStatus);
+/** @internal */
+export const ToolCallStatus$outboundSchema = openEnums.outboundSchema(ToolCallStatus);
+//# sourceMappingURL=toolcallstatus.js.map

package/esm/models/toolchoiceallowed.d.ts

@@ -0,0 +1,62 @@
+import * as z from "zod/v4";
+import { ClosedEnum } from "../types/enums.js";
+import { Result as SafeParseResult } from "../types/fp.js";
+import { SDKValidationError } from "./errors/sdkvalidationerror.js";
+export declare const ModeRequired: {
+    readonly Required: "required";
+};
+export type ModeRequired = ClosedEnum<typeof ModeRequired>;
+export declare const ModeAuto: {
+    readonly Auto: "auto";
+};
+export type ModeAuto = ClosedEnum<typeof ModeAuto>;
+export type Mode = ModeAuto | ModeRequired;
+export declare const ToolChoiceAllowedType: {
+    readonly AllowedTools: "allowed_tools";
+};
+export type ToolChoiceAllowedType = ClosedEnum<typeof ToolChoiceAllowedType>;
+/**
+ * Constrains the model to a pre-defined set of allowed tools
+ */
+export type ToolChoiceAllowed = {
+    mode: ModeAuto | ModeRequired;
+    tools: Array<{
+        [k: string]: any | null;
+    }>;
+    type: ToolChoiceAllowedType;
+};
+/** @internal */
+export declare const ModeRequired$inboundSchema: z.ZodEnum<typeof ModeRequired>;
+/** @internal */
+export declare const ModeRequired$outboundSchema: z.ZodEnum<typeof ModeRequired>;
+/** @internal */
+export declare const ModeAuto$inboundSchema: z.ZodEnum<typeof ModeAuto>;
+/** @internal */
+export declare const ModeAuto$outboundSchema: z.ZodEnum<typeof ModeAuto>;
+/** @internal */
+export declare const Mode$inboundSchema: z.ZodType<Mode, unknown>;
+/** @internal */
+export type Mode$Outbound = string | string;
+/** @internal */
+export declare const Mode$outboundSchema: z.ZodType<Mode$Outbound, Mode>;
+export declare function modeToJSON(mode: Mode): string;
+export declare function modeFromJSON(jsonString: string): SafeParseResult<Mode, SDKValidationError>;
+/** @internal */
+export declare const ToolChoiceAllowedType$inboundSchema: z.ZodEnum<typeof ToolChoiceAllowedType>;
+/** @internal */
+export declare const ToolChoiceAllowedType$outboundSchema: z.ZodEnum<typeof ToolChoiceAllowedType>;
+/** @internal */
+export declare const ToolChoiceAllowed$inboundSchema: z.ZodType<ToolChoiceAllowed, unknown>;
+/** @internal */
+export type ToolChoiceAllowed$Outbound = {
+    mode: string | string;
+    tools: Array<{
+        [k: string]: any | null;
+    }>;
+    type: string;
+};
+/** @internal */
+export declare const ToolChoiceAllowed$outboundSchema: z.ZodType<ToolChoiceAllowed$Outbound, ToolChoiceAllowed>;
+export declare function toolChoiceAllowedToJSON(toolChoiceAllowed: ToolChoiceAllowed): string;
+export declare function toolChoiceAllowedFromJSON(jsonString: string): SafeParseResult<ToolChoiceAllowed, SDKValidationError>;
+//# sourceMappingURL=toolchoiceallowed.d.ts.map

package/esm/models/toolchoiceallowed.js

@@ -0,0 +1,63 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ * @generated-id: 82ee236509d6
+ */
+import * as z from "zod/v4";
+import { safeParse } from "../lib/schemas.js";
+export const ModeRequired = {
+    Required: "required",
+};
+export const ModeAuto = {
+    Auto: "auto",
+};
+export const ToolChoiceAllowedType = {
+    AllowedTools: "allowed_tools",
+};
+/** @internal */
+export const ModeRequired$inboundSchema = z
+    .enum(ModeRequired);
+/** @internal */
+export const ModeRequired$outboundSchema = ModeRequired$inboundSchema;
+/** @internal */
+export const ModeAuto$inboundSchema = z.enum(ModeAuto);
+/** @internal */
+export const ModeAuto$outboundSchema = ModeAuto$inboundSchema;
+/** @internal */
+export const Mode$inboundSchema = z.union([
+    ModeAuto$inboundSchema,
+    ModeRequired$inboundSchema,
+]);
+/** @internal */
+export const Mode$outboundSchema = z.union([
+    ModeAuto$outboundSchema,
+    ModeRequired$outboundSchema,
+]);
+export function modeToJSON(mode) {
+    return JSON.stringify(Mode$outboundSchema.parse(mode));
+}
+export function modeFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => Mode$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'Mode' from JSON`);
+}
+/** @internal */
+export const ToolChoiceAllowedType$inboundSchema = z.enum(ToolChoiceAllowedType);
+/** @internal */
+export const ToolChoiceAllowedType$outboundSchema = ToolChoiceAllowedType$inboundSchema;
+/** @internal */
+export const ToolChoiceAllowed$inboundSchema = z.object({
+    mode: z.union([ModeAuto$inboundSchema, ModeRequired$inboundSchema]),
+    tools: z.array(z.record(z.string(), z.nullable(z.any()))),
+    type: ToolChoiceAllowedType$inboundSchema,
+});
+/** @internal */
+export const ToolChoiceAllowed$outboundSchema = z.object({
+    mode: z.union([ModeAuto$outboundSchema, ModeRequired$outboundSchema]),
+    tools: z.array(z.record(z.string(), z.nullable(z.any()))),
+    type: ToolChoiceAllowedType$outboundSchema,
+});
+export function toolChoiceAllowedToJSON(toolChoiceAllowed) {
+    return JSON.stringify(ToolChoiceAllowed$outboundSchema.parse(toolChoiceAllowed));
+}
+export function toolChoiceAllowedFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => ToolChoiceAllowed$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'ToolChoiceAllowed' from JSON`);
+}
+//# sourceMappingURL=toolchoiceallowed.js.map

package/esm/models/topproviderinfo.d.ts

@@ -9,14 +9,14 @@ export type TopProviderInfo = {
      * Context length from the top provider
      */
     contextLength?: number | null | undefined;
-    /**
-     * Maximum completion tokens from the top provider
-     */
-    maxCompletionTokens?: number | null | undefined;
     /**
      * Whether the top provider moderates content
      */
     isModerated: boolean;
+    /**
+     * Maximum completion tokens from the top provider
+     */
+    maxCompletionTokens?: number | null | undefined;
 };
 /** @internal */
 export declare const TopProviderInfo$inboundSchema: z.ZodType<TopProviderInfo, unknown>;

package/esm/models/topproviderinfo.js

@@ -7,14 +7,14 @@ import { remap as remap$ } from "../lib/primitives.js";
 import { safeParse } from "../lib/schemas.js";
 /** @internal */
 export const TopProviderInfo$inboundSchema = z.object({
-    context_length: z.nullable(z.number()).optional(),
-    max_completion_tokens: z.nullable(z.number()).optional(),
+    context_length: z.nullable(z.int()).optional(),
     is_moderated: z.boolean(),
+    max_completion_tokens: z.nullable(z.int()).optional(),
 }).transform((v) => {
     return remap$(v, {
         "context_length": "contextLength",
-        "max_completion_tokens": "maxCompletionTokens",
         "is_moderated": "isModerated",
+        "max_completion_tokens": "maxCompletionTokens",
     });
 });
 export function topProviderInfoFromJSON(jsonString) {

package/esm/models/traceconfig.d.ts

@@ -0,0 +1,27 @@
+import * as z from "zod/v4";
+/**
+ * Metadata for observability and tracing. Known keys (trace_id, trace_name, span_name, generation_name, parent_span_id) have special handling. Additional keys are passed through as custom metadata to configured broadcast destinations.
+ */
+export type TraceConfig = {
+    generationName?: string | undefined;
+    parentSpanId?: string | undefined;
+    spanName?: string | undefined;
+    traceId?: string | undefined;
+    traceName?: string | undefined;
+    additionalProperties?: {
+        [k: string]: any | null;
+    } | undefined;
+};
+/** @internal */
+export type TraceConfig$Outbound = {
+    generation_name?: string | undefined;
+    parent_span_id?: string | undefined;
+    span_name?: string | undefined;
+    trace_id?: string | undefined;
+    trace_name?: string | undefined;
+    [additionalProperties: string]: unknown;
+};
+/** @internal */
+export declare const TraceConfig$outboundSchema: z.ZodType<TraceConfig$Outbound, TraceConfig>;
+export declare function traceConfigToJSON(traceConfig: TraceConfig): string;
+//# sourceMappingURL=traceconfig.d.ts.map

package/esm/models/traceconfig.js

@@ -0,0 +1,31 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ * @generated-id: 50ce6e8a7bcd
+ */
+import * as z from "zod/v4";
+import { remap as remap$ } from "../lib/primitives.js";
+/** @internal */
+export const TraceConfig$outboundSchema = z.object({
+    generationName: z.string().optional(),
+    parentSpanId: z.string().optional(),
+    spanName: z.string().optional(),
+    traceId: z.string().optional(),
+    traceName: z.string().optional(),
+    additionalProperties: z.record(z.string(), z.nullable(z.any())).optional(),
+}).transform((v) => {
+    return {
+        ...v.additionalProperties,
+        ...remap$(v, {
+            generationName: "generation_name",
+            parentSpanId: "parent_span_id",
+            spanName: "span_name",
+            traceId: "trace_id",
+            traceName: "trace_name",
+            additionalProperties: null,
+        }),
+    };
+});
+export function traceConfigToJSON(traceConfig) {
+    return JSON.stringify(TraceConfig$outboundSchema.parse(traceConfig));
+}
+//# sourceMappingURL=traceconfig.js.map

package/esm/models/truncation.d.ts

@@ -0,0 +1,10 @@
+import * as z from "zod/v4";
+import { OpenEnum } from "../types/enums.js";
+export declare const Truncation: {
+    readonly Auto: "auto";
+    readonly Disabled: "disabled";
+};
+export type Truncation = OpenEnum<typeof Truncation>;
+/** @internal */
+export declare const Truncation$inboundSchema: z.ZodType<Truncation, unknown>;
+//# sourceMappingURL=truncation.d.ts.map

package/esm/models/truncation.js

@@ -0,0 +1,12 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ * @generated-id: 8aa9a16a7a40
+ */
+import * as openEnums from "../types/enums.js";
+export const Truncation = {
+    Auto: "auto",
+    Disabled: "disabled",
+};
+/** @internal */
+export const Truncation$inboundSchema = openEnums.inboundSchema(Truncation);
+//# sourceMappingURL=truncation.js.map

package/esm/models/updateguardrailrequest.d.ts

@@ -0,0 +1,51 @@
+import * as z from "zod/v4";
+import { GuardrailInterval } from "./guardrailinterval.js";
+export type UpdateGuardrailRequest = {
+    /**
+     * Array of model identifiers (slug or canonical_slug accepted)
+     */
+    allowedModels?: Array<string> | null | undefined;
+    /**
+     * New list of allowed provider IDs
+     */
+    allowedProviders?: Array<string> | null | undefined;
+    /**
+     * New description for the guardrail
+     */
+    description?: string | null | undefined;
+    /**
+     * Whether to enforce zero data retention
+     */
+    enforceZdr?: boolean | null | undefined;
+    /**
+     * List of provider IDs to exclude from routing
+     */
+    ignoredProviders?: Array<string> | null | undefined;
+    /**
+     * New spending limit in USD
+     */
+    limitUsd?: number | undefined;
+    /**
+     * New name for the guardrail
+     */
+    name?: string | undefined;
+    /**
+     * Interval at which the limit resets (daily, weekly, monthly)
+     */
+    resetInterval?: GuardrailInterval | null | undefined;
+};
+/** @internal */
+export type UpdateGuardrailRequest$Outbound = {
+    allowed_models?: Array<string> | null | undefined;
+    allowed_providers?: Array<string> | null | undefined;
+    description?: string | null | undefined;
+    enforce_zdr?: boolean | null | undefined;
+    ignored_providers?: Array<string> | null | undefined;
+    limit_usd?: number | undefined;
+    name?: string | undefined;
+    reset_interval?: string | null | undefined;
+};
+/** @internal */
+export declare const UpdateGuardrailRequest$outboundSchema: z.ZodType<UpdateGuardrailRequest$Outbound, UpdateGuardrailRequest>;
+export declare function updateGuardrailRequestToJSON(updateGuardrailRequest: UpdateGuardrailRequest): string;
+//# sourceMappingURL=updateguardrailrequest.d.ts.map

package/esm/models/updateguardrailrequest.js

@@ -0,0 +1,31 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ * @generated-id: 8ae5b029f2d5
+ */
+import * as z from "zod/v4";
+import { remap as remap$ } from "../lib/primitives.js";
+import { GuardrailInterval$outboundSchema, } from "./guardrailinterval.js";
+/** @internal */
+export const UpdateGuardrailRequest$outboundSchema = z.object({
+    allowedModels: z.nullable(z.array(z.string())).optional(),
+    allowedProviders: z.nullable(z.array(z.string())).optional(),
+    description: z.nullable(z.string()).optional(),
+    enforceZdr: z.nullable(z.boolean()).optional(),
+    ignoredProviders: z.nullable(z.array(z.string())).optional(),
+    limitUsd: z.number().optional(),
+    name: z.string().optional(),
+    resetInterval: z.nullable(GuardrailInterval$outboundSchema).optional(),
+}).transform((v) => {
+    return remap$(v, {
+        allowedModels: "allowed_models",
+        allowedProviders: "allowed_providers",
+        enforceZdr: "enforce_zdr",
+        ignoredProviders: "ignored_providers",
+        limitUsd: "limit_usd",
+        resetInterval: "reset_interval",
+    });
+});
+export function updateGuardrailRequestToJSON(updateGuardrailRequest) {
+    return JSON.stringify(UpdateGuardrailRequest$outboundSchema.parse(updateGuardrailRequest));
+}
+//# sourceMappingURL=updateguardrailrequest.js.map

package/esm/models/updateguardrailresponse.d.ts

@@ -0,0 +1,11 @@
+import * as z from "zod/v4";
+import { Result as SafeParseResult } from "../types/fp.js";
+import { SDKValidationError } from "./errors/sdkvalidationerror.js";
+import { Guardrail } from "./guardrail.js";
+export type UpdateGuardrailResponse = {
+    data: Guardrail;
+};
+/** @internal */
+export declare const UpdateGuardrailResponse$inboundSchema: z.ZodType<UpdateGuardrailResponse, unknown>;
+export declare function updateGuardrailResponseFromJSON(jsonString: string): SafeParseResult<UpdateGuardrailResponse, SDKValidationError>;
+//# sourceMappingURL=updateguardrailresponse.d.ts.map

package/esm/models/updateguardrailresponse.js

@@ -0,0 +1,15 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ * @generated-id: a1debd60e96d
+ */
+import * as z from "zod/v4";
+import { safeParse } from "../lib/schemas.js";
+import { Guardrail$inboundSchema } from "./guardrail.js";
+/** @internal */
+export const UpdateGuardrailResponse$inboundSchema = z.object({
+    data: Guardrail$inboundSchema,
+});
+export function updateGuardrailResponseFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => UpdateGuardrailResponse$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'UpdateGuardrailResponse' from JSON`);
+}
+//# sourceMappingURL=updateguardrailresponse.js.map

package/esm/models/urlcitation.d.ts

@@ -2,21 +2,21 @@ import * as z from "zod/v4";
 import { Result as SafeParseResult } from "../types/fp.js";
 import { SDKValidationError } from "./errors/sdkvalidationerror.js";
 export type URLCitation = {
+    endIndex: number;
+    startIndex: number;
+    title: string;
     type: "url_citation";
     url: string;
-    title: string;
-    startIndex: number;
-    endIndex: number;
 };
 /** @internal */
 export declare const URLCitation$inboundSchema: z.ZodType<URLCitation, unknown>;
 /** @internal */
 export type URLCitation$Outbound = {
+    end_index: number;
+    start_index: number;
+    title: string;
     type: "url_citation";
     url: string;
-    title: string;
-    start_index: number;
-    end_index: number;
 };
 /** @internal */
 export declare const URLCitation$outboundSchema: z.ZodType<URLCitation$Outbound, URLCitation>;

package/esm/models/urlcitation.js

@@ -8,28 +8,28 @@ import { safeParse } from "../lib/schemas.js";
 /** @internal */
 export const URLCitation$inboundSchema = z
     .object({
+    end_index: z.int(),
+    start_index: z.int(),
+    title: z.string(),
     type: z.literal("url_citation"),
     url: z.string(),
-    title: z.string(),
-    start_index: z.number(),
-    end_index: z.number(),
 }).transform((v) => {
     return remap$(v, {
-        "start_index": "startIndex",
         "end_index": "endIndex",
+        "start_index": "startIndex",
     });
 });
 /** @internal */
 export const URLCitation$outboundSchema = z.object({
+    endIndex: z.int(),
+    startIndex: z.int(),
+    title: z.string(),
     type: z.literal("url_citation"),
     url: z.string(),
-    title: z.string(),
-    startIndex: z.number(),
-    endIndex: z.number(),
 }).transform((v) => {
     return remap$(v, {
-        startIndex: "start_index",
         endIndex: "end_index",
+        startIndex: "start_index",
     });
 });
 export function urlCitationToJSON(urlCitation) {

package/esm/models/usage.d.ts

@@ -8,7 +8,7 @@ export type OutputTokensDetails = {
     reasoningTokens: number;
 };
 export type CostDetails = {
-    upstreamInferenceCost?: number | null | undefined;
+    upstreamInferenceCost?: number | undefined;
     upstreamInferenceInputCost: number;
     upstreamInferenceOutputCost: number;
 };
@@ -24,12 +24,12 @@ export type Usage = {
     /**
      * Cost of the completion
      */
-    cost?: number | null | undefined;
+    cost?: number | undefined;
+    costDetails?: CostDetails | undefined;
     /**
      * Whether a request was made using a Bring Your Own Key configuration
      */
     isByok?: boolean | undefined;
-    costDetails?: CostDetails | undefined;
 };
 /** @internal */
 export declare const InputTokensDetails$inboundSchema: z.ZodType<InputTokensDetails, unknown>;

package/esm/models/usage.js

@@ -7,7 +7,7 @@ import { remap as remap$ } from "../lib/primitives.js";
 import { safeParse } from "../lib/schemas.js";
 /** @internal */
 export const InputTokensDetails$inboundSchema = z.object({
-    cached_tokens: z.number(),
+    cached_tokens: z.int(),
 }).transform((v) => {
     return remap$(v, {
         "cached_tokens": "cachedTokens",
@@ -18,7 +18,7 @@ export function inputTokensDetailsFromJSON(jsonString) {
 }
 /** @internal */
 export const OutputTokensDetails$inboundSchema = z.object({
-    reasoning_tokens: z.number(),
+    reasoning_tokens: z.int(),
 }).transform((v) => {
     return remap$(v, {
         "reasoning_tokens": "reasoningTokens",
@@ -30,7 +30,7 @@ export function outputTokensDetailsFromJSON(jsonString) {
 /** @internal */
 export const CostDetails$inboundSchema = z
     .object({
-    upstream_inference_cost: z.nullable(z.number()).optional(),
+    upstream_inference_cost: z.number().optional(),
     upstream_inference_input_cost: z.number(),
     upstream_inference_output_cost: z.number(),
 }).transform((v) => {
@@ -45,14 +45,14 @@ export function costDetailsFromJSON(jsonString) {
 }
 /** @internal */
 export const Usage$inboundSchema = z.object({
-    input_tokens: z.number(),
+    input_tokens: z.int(),
     input_tokens_details: z.lazy(() => InputTokensDetails$inboundSchema),
-    output_tokens: z.number(),
+    output_tokens: z.int(),
     output_tokens_details: z.lazy(() => OutputTokensDetails$inboundSchema),
-    total_tokens: z.number(),
-    cost: z.nullable(z.number()).optional(),
-    is_byok: z.boolean().optional(),
+    total_tokens: z.int(),
+    cost: z.number().optional(),
     cost_details: z.lazy(() => CostDetails$inboundSchema).optional(),
+    is_byok: z.boolean().optional(),
 }).transform((v) => {
     return remap$(v, {
         "input_tokens": "inputTokens",
@@ -60,8 +60,8 @@ export const Usage$inboundSchema = z.object({
         "output_tokens": "outputTokens",
         "output_tokens_details": "outputTokensDetails",
         "total_tokens": "totalTokens",
-        "is_byok": "isByok",
         "cost_details": "costDetails",
+        "is_byok": "isByok",
     });
 });
 export function usageFromJSON(jsonString) {