@openrouter/sdk 0.13.59 → 0.13.61

package/esm/models/openairesponsefunctiontoolcalloutput.d.ts

@@ -1,23 +1,18 @@
 import * as z from "zod/v4";
 import * as discriminatedUnionTypes from "../types/discriminatedUnion.js";
-import { ClosedEnum, OpenEnum } from "../types/enums.js";
+import { ClosedEnum } from "../types/enums.js";
 import { Result as SafeParseResult } from "../types/fp.js";
 import { SDKValidationError } from "./errors/sdkvalidationerror.js";
 import { InputFile } from "./inputfile.js";
 import { InputImage } from "./inputimage.js";
 import { InputText } from "./inputtext.js";
+import { ToolCallStatus } from "./toolcallstatus.js";
 export type OpenAIResponseFunctionToolCallOutputOutput1 = InputFile | (InputImage & {
     type: "input_image";
 }) | InputText | discriminatedUnionTypes.Unknown<"type">;
 export type OpenAIResponseFunctionToolCallOutputOutput2 = string | Array<InputFile | (InputImage & {
     type: "input_image";
 }) | InputText | discriminatedUnionTypes.Unknown<"type">>;
-export declare const OpenAIResponseFunctionToolCallOutputStatus: {
-    readonly InProgress: "in_progress";
-    readonly Completed: "completed";
-    readonly Incomplete: "incomplete";
-};
-export type OpenAIResponseFunctionToolCallOutputStatus = OpenEnum<typeof OpenAIResponseFunctionToolCallOutputStatus>;
 export declare const OpenAIResponseFunctionToolCallOutputType: {
     readonly FunctionCallOutput: "function_call_output";
 };
@@ -28,7 +23,7 @@ export type OpenAIResponseFunctionToolCallOutput = {
     output: string | Array<InputFile | (InputImage & {
         type: "input_image";
     }) | InputText | discriminatedUnionTypes.Unknown<"type">>;
-    status?: OpenAIResponseFunctionToolCallOutputStatus | null | undefined;
+    status?: ToolCallStatus | null | undefined;
     type: OpenAIResponseFunctionToolCallOutputType;
 };
 /** @internal */
@@ -38,8 +33,6 @@ export declare function openAIResponseFunctionToolCallOutputOutput1FromJSON(json
 export declare const OpenAIResponseFunctionToolCallOutputOutput2$inboundSchema: z.ZodType<OpenAIResponseFunctionToolCallOutputOutput2, unknown>;
 export declare function openAIResponseFunctionToolCallOutputOutput2FromJSON(jsonString: string): SafeParseResult<OpenAIResponseFunctionToolCallOutputOutput2, SDKValidationError>;
 /** @internal */
-export declare const OpenAIResponseFunctionToolCallOutputStatus$inboundSchema: z.ZodType<OpenAIResponseFunctionToolCallOutputStatus, unknown>;
-/** @internal */
 export declare const OpenAIResponseFunctionToolCallOutputType$inboundSchema: z.ZodEnum<typeof OpenAIResponseFunctionToolCallOutputType>;
 /** @internal */
 export declare const OpenAIResponseFunctionToolCallOutput$inboundSchema: z.ZodType<OpenAIResponseFunctionToolCallOutput, unknown>;

package/esm/models/openairesponsefunctiontoolcalloutput.js

@@ -6,15 +6,10 @@ import * as z from "zod/v4";
 import { remap as remap$ } from "../lib/primitives.js";
 import { safeParse } from "../lib/schemas.js";
 import { discriminatedUnion } from "../types/discriminatedUnion.js";
-import * as openEnums from "../types/enums.js";
 import { InputFile$inboundSchema } from "./inputfile.js";
 import { InputImage$inboundSchema } from "./inputimage.js";
 import { InputText$inboundSchema } from "./inputtext.js";
-export const OpenAIResponseFunctionToolCallOutputStatus = {
-    InProgress: "in_progress",
-    Completed: "completed",
-    Incomplete: "incomplete",
-};
+import { ToolCallStatus$inboundSchema, } from "./toolcallstatus.js";
 export const OpenAIResponseFunctionToolCallOutputType = {
     FunctionCallOutput: "function_call_output",
 };
@@ -40,9 +35,6 @@ export function openAIResponseFunctionToolCallOutputOutput2FromJSON(jsonString)
     return safeParse(jsonString, (x) => OpenAIResponseFunctionToolCallOutputOutput2$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'OpenAIResponseFunctionToolCallOutputOutput2' from JSON`);
 }
 /** @internal */
-export const OpenAIResponseFunctionToolCallOutputStatus$inboundSchema = openEnums
-    .inboundSchema(OpenAIResponseFunctionToolCallOutputStatus);
-/** @internal */
 export const OpenAIResponseFunctionToolCallOutputType$inboundSchema = z.enum(OpenAIResponseFunctionToolCallOutputType);
 /** @internal */
 export const OpenAIResponseFunctionToolCallOutput$inboundSchema = z.object({
@@ -56,8 +48,7 @@ export const OpenAIResponseFunctionToolCallOutput$inboundSchema = z.object({
             input_text: InputText$inboundSchema,
         })),
     ]),
-    status: z.nullable(OpenAIResponseFunctionToolCallOutputStatus$inboundSchema)
-        .optional(),
+    status: z.nullable(ToolCallStatus$inboundSchema).optional(),
     type: OpenAIResponseFunctionToolCallOutputType$inboundSchema,
 }).transform((v) => {
     return remap$(v, {

package/esm/models/openresponsesresult.d.ts

@@ -24,11 +24,11 @@ import { OutputItems } from "./outputitems.js";
 import { Preview20250311WebSearchServerTool } from "./preview20250311websearchservertool.js";
 import { PreviewWebSearchServerTool } from "./previewwebsearchservertool.js";
 import { ResponsesErrorField } from "./responseserrorfield.js";
+import { ServerToolUseDetails } from "./servertoolusedetails.js";
 import { ShellServerTool } from "./shellservertool.js";
 import { StoredPromptTemplate } from "./storedprompttemplate.js";
 import { TextExtendedConfig } from "./textextendedconfig.js";
 import { Truncation } from "./truncation.js";
-import { Usage } from "./usage.js";
 import { WebSearchServerTool } from "./websearchservertool.js";
 export declare const OpenResponsesResultObject: {
     readonly Response: "response";
@@ -41,7 +41,7 @@ export type OpenResponsesResultToolFunction = {
     description?: string | null | undefined;
     name: string;
     parameters: {
-        [k: string]: any | null;
+        [k: string]: any;
     } | null;
     strict?: boolean | null | undefined;
     type: "function";
@@ -75,6 +75,38 @@ export type OpenResponsesResultToolUnion = OpenResponsesResultToolFunction | (Pr
 }) | (NamespaceTool & {
     type: "namespace";
 }) | discriminatedUnionTypes.Unknown<"type">;
+export type InputTokensDetails = {
+    cacheWriteTokens?: number | null | undefined;
+    cachedTokens: number;
+};
+export type OutputTokensDetails = {
+    reasoningTokens: number;
+};
+export type UsageCostDetails = {
+    upstreamInferenceCost?: number | null | undefined;
+    upstreamInferenceInputCost: number;
+    upstreamInferenceOutputCost: number;
+};
+export type Usage = {
+    inputTokens: number;
+    inputTokensDetails: InputTokensDetails;
+    outputTokens: number;
+    outputTokensDetails: OutputTokensDetails;
+    totalTokens: number;
+    /**
+     * Cost of the completion
+     */
+    cost?: number | null | undefined;
+    costDetails?: UsageCostDetails | undefined;
+    /**
+     * Whether a request was made using a Bring Your Own Key configuration
+     */
+    isByok?: boolean | undefined;
+    /**
+     * Usage for server-side tool execution (e.g., web search)
+     */
+    serverToolUseDetails?: ServerToolUseDetails | null | undefined;
+};
 /**
  * Complete non-streaming response from the Responses API
  */
@@ -170,6 +202,18 @@ export declare function openResponsesResultToolFunctionFromJSON(jsonString: stri
 export declare const OpenResponsesResultToolUnion$inboundSchema: z.ZodType<OpenResponsesResultToolUnion, unknown>;
 export declare function openResponsesResultToolUnionFromJSON(jsonString: string): SafeParseResult<OpenResponsesResultToolUnion, SDKValidationError>;
 /** @internal */
+export declare const InputTokensDetails$inboundSchema: z.ZodType<InputTokensDetails, unknown>;
+export declare function inputTokensDetailsFromJSON(jsonString: string): SafeParseResult<InputTokensDetails, SDKValidationError>;
+/** @internal */
+export declare const OutputTokensDetails$inboundSchema: z.ZodType<OutputTokensDetails, unknown>;
+export declare function outputTokensDetailsFromJSON(jsonString: string): SafeParseResult<OutputTokensDetails, SDKValidationError>;
+/** @internal */
+export declare const UsageCostDetails$inboundSchema: z.ZodType<UsageCostDetails, unknown>;
+export declare function usageCostDetailsFromJSON(jsonString: string): SafeParseResult<UsageCostDetails, SDKValidationError>;
+/** @internal */
+export declare const Usage$inboundSchema: z.ZodType<Usage, unknown>;
+export declare function usageFromJSON(jsonString: string): SafeParseResult<Usage, SDKValidationError>;
+/** @internal */
 export declare const OpenResponsesResult$inboundSchema: z.ZodType<OpenResponsesResult, unknown>;
 export declare function openResponsesResultFromJSON(jsonString: string): SafeParseResult<OpenResponsesResult, SDKValidationError>;
 //# sourceMappingURL=openresponsesresult.d.ts.map

package/esm/models/openresponsesresult.js

@@ -27,11 +27,11 @@ import { OutputItems$inboundSchema } from "./outputitems.js";
 import { Preview20250311WebSearchServerTool$inboundSchema, } from "./preview20250311websearchservertool.js";
 import { PreviewWebSearchServerTool$inboundSchema, } from "./previewwebsearchservertool.js";
 import { ResponsesErrorField$inboundSchema, } from "./responseserrorfield.js";
+import { ServerToolUseDetails$inboundSchema, } from "./servertoolusedetails.js";
 import { ShellServerTool$inboundSchema, } from "./shellservertool.js";
 import { StoredPromptTemplate$inboundSchema, } from "./storedprompttemplate.js";
 import { TextExtendedConfig$inboundSchema, } from "./textextendedconfig.js";
 import { Truncation$inboundSchema } from "./truncation.js";
-import { Usage$inboundSchema } from "./usage.js";
 import { WebSearchServerTool$inboundSchema, } from "./websearchservertool.js";
 export const OpenResponsesResultObject = {
     Response: "response",
@@ -42,7 +42,7 @@ export const OpenResponsesResultObject$inboundSchema = z.enum(OpenResponsesResul
 export const OpenResponsesResultToolFunction$inboundSchema = z.object({
     description: z.nullable(z.string()).optional(),
     name: z.string(),
-    parameters: z.nullable(z.record(z.string(), z.nullable(z.any()))),
+    parameters: z.nullable(z.record(z.string(), z.any())),
     strict: z.nullable(z.boolean()).optional(),
     type: z.literal("function"),
 });
@@ -71,6 +71,72 @@ export function openResponsesResultToolUnionFromJSON(jsonString) {
     return safeParse(jsonString, (x) => OpenResponsesResultToolUnion$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'OpenResponsesResultToolUnion' from JSON`);
 }
 /** @internal */
+export const InputTokensDetails$inboundSchema = z.object({
+    cache_write_tokens: z.nullable(z.int()).optional(),
+    cached_tokens: z.int(),
+}).transform((v) => {
+    return remap$(v, {
+        "cache_write_tokens": "cacheWriteTokens",
+        "cached_tokens": "cachedTokens",
+    });
+});
+export function inputTokensDetailsFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => InputTokensDetails$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'InputTokensDetails' from JSON`);
+}
+/** @internal */
+export const OutputTokensDetails$inboundSchema = z.object({
+    reasoning_tokens: z.int(),
+}).transform((v) => {
+    return remap$(v, {
+        "reasoning_tokens": "reasoningTokens",
+    });
+});
+export function outputTokensDetailsFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => OutputTokensDetails$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'OutputTokensDetails' from JSON`);
+}
+/** @internal */
+export const UsageCostDetails$inboundSchema = z.object({
+    upstream_inference_cost: z.nullable(z.number()).optional(),
+    upstream_inference_input_cost: z.number(),
+    upstream_inference_output_cost: z.number(),
+}).transform((v) => {
+    return remap$(v, {
+        "upstream_inference_cost": "upstreamInferenceCost",
+        "upstream_inference_input_cost": "upstreamInferenceInputCost",
+        "upstream_inference_output_cost": "upstreamInferenceOutputCost",
+    });
+});
+export function usageCostDetailsFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => UsageCostDetails$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'UsageCostDetails' from JSON`);
+}
+/** @internal */
+export const Usage$inboundSchema = z.object({
+    input_tokens: z.int(),
+    input_tokens_details: z.lazy(() => InputTokensDetails$inboundSchema),
+    output_tokens: z.int(),
+    output_tokens_details: z.lazy(() => OutputTokensDetails$inboundSchema),
+    total_tokens: z.int(),
+    cost: z.nullable(z.number()).optional(),
+    cost_details: z.lazy(() => UsageCostDetails$inboundSchema).optional(),
+    is_byok: z.boolean().optional(),
+    server_tool_use_details: z.nullable(ServerToolUseDetails$inboundSchema)
+        .optional(),
+}).transform((v) => {
+    return remap$(v, {
+        "input_tokens": "inputTokens",
+        "input_tokens_details": "inputTokensDetails",
+        "output_tokens": "outputTokens",
+        "output_tokens_details": "outputTokensDetails",
+        "total_tokens": "totalTokens",
+        "cost_details": "costDetails",
+        "is_byok": "isByok",
+        "server_tool_use_details": "serverToolUseDetails",
+    });
+});
+export function usageFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => Usage$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'Usage' from JSON`);
+}
+/** @internal */
 export const OpenResponsesResult$inboundSchema = z.object({
     background: z.nullable(z.boolean()).optional(),
     completed_at: z.nullable(z.int()),
@@ -120,7 +186,7 @@ export const OpenResponsesResult$inboundSchema = z.object({
     top_logprobs: z.nullable(z.int()).optional(),
     top_p: z.nullable(z.number()),
     truncation: z.nullable(Truncation$inboundSchema).optional(),
-    usage: z.nullable(Usage$inboundSchema).optional(),
+    usage: z.nullable(z.lazy(() => Usage$inboundSchema)).optional(),
     user: z.nullable(z.string()).optional(),
     error_type: ApiErrorType$inboundSchema.optional(),
     openrouter_metadata: OpenRouterMetadata$inboundSchema.optional(),

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

@@ -111,6 +111,7 @@ export declare const Provider: {
     readonly Stepfun: "stepfun";
     readonly Streamlake: "streamlake";
     readonly Switchpoint: "switchpoint";
+    readonly Tencent: "tencent";
     readonly Tenstorrent: "tenstorrent";
     readonly Together: "together";
     readonly Upstage: "upstage";

package/esm/models/operations/listbyokkeys.js

@@ -94,6 +94,7 @@ export const Provider = {
     Stepfun: "stepfun",
     Streamlake: "streamlake",
     Switchpoint: "switchpoint",
+    Tencent: "tencent",
     Tenstorrent: "tenstorrent",
     Together: "together",
     Upstage: "upstage",

package/esm/models/outputcomputercallitem.d.ts

@@ -18,7 +18,7 @@ export declare const OutputComputerCallItemType: {
 };
 export type OutputComputerCallItemType = ClosedEnum<typeof OutputComputerCallItemType>;
 export type OutputComputerCallItem = {
-    action?: any | null | undefined;
+    action?: any | undefined;
     callId: string;
     id?: string | undefined;
     pendingSafetyChecks: Array<PendingSafetyCheck>;
@@ -49,7 +49,7 @@ export declare const OutputComputerCallItemType$outboundSchema: z.ZodEnum<typeof
 export declare const OutputComputerCallItem$inboundSchema: z.ZodType<OutputComputerCallItem, unknown>;
 /** @internal */
 export type OutputComputerCallItem$Outbound = {
-    action?: any | null | undefined;
+    action?: any | undefined;
     call_id: string;
     id?: string | undefined;
     pending_safety_checks: Array<PendingSafetyCheck$Outbound>;

package/esm/models/outputcomputercallitem.js

@@ -42,7 +42,7 @@ export const OutputComputerCallItemType$inboundSchema = z.enum(OutputComputerCal
 export const OutputComputerCallItemType$outboundSchema = OutputComputerCallItemType$inboundSchema;
 /** @internal */
 export const OutputComputerCallItem$inboundSchema = z.object({
-    action: z.nullable(z.any()).optional(),
+    action: z.any().optional(),
     call_id: z.string(),
     id: z.string().optional(),
     pending_safety_checks: z.array(z.lazy(() => PendingSafetyCheck$inboundSchema)),
@@ -56,7 +56,7 @@ export const OutputComputerCallItem$inboundSchema = z.object({
 });
 /** @internal */
 export const OutputComputerCallItem$outboundSchema = z.object({
-    action: z.nullable(z.any()).optional(),
+    action: z.any().optional(),
     callId: z.string(),
     id: z.string().optional(),
     pendingSafetyChecks: z.array(z.lazy(() => PendingSafetyCheck$outboundSchema)),

package/esm/models/outputmemoryservertoolitem.d.ts

@@ -22,7 +22,7 @@ export type OutputMemoryServerToolItem = {
     key?: string | undefined;
     status: ToolCallStatus;
     type: OutputMemoryServerToolItemType;
-    value?: any | null | undefined;
+    value?: any | undefined;
 };
 /** @internal */
 export declare const ActionEnum$inboundSchema: z.ZodType<ActionEnum, unknown>;
@@ -41,7 +41,7 @@ export type OutputMemoryServerToolItem$Outbound = {
     key?: string | undefined;
     status: string;
     type: string;
-    value?: any | null | undefined;
+    value?: any | undefined;
 };
 /** @internal */
 export declare const OutputMemoryServerToolItem$outboundSchema: z.ZodType<OutputMemoryServerToolItem$Outbound, OutputMemoryServerToolItem>;

package/esm/models/outputmemoryservertoolitem.js

@@ -29,7 +29,7 @@ export const OutputMemoryServerToolItem$inboundSchema = z.object({
     key: z.string().optional(),
     status: ToolCallStatus$inboundSchema,
     type: OutputMemoryServerToolItemType$inboundSchema,
-    value: z.nullable(z.any()).optional(),
+    value: z.any().optional(),
 });
 /** @internal */
 export const OutputMemoryServerToolItem$outboundSchema = z.object({
@@ -38,7 +38,7 @@ export const OutputMemoryServerToolItem$outboundSchema = z.object({
     key: z.string().optional(),
     status: ToolCallStatus$outboundSchema,
     type: OutputMemoryServerToolItemType$outboundSchema,
-    value: z.nullable(z.any()).optional(),
+    value: z.any().optional(),
 });
 export function outputMemoryServerToolItemToJSON(outputMemoryServerToolItem) {
     return JSON.stringify(OutputMemoryServerToolItem$outboundSchema.parse(outputMemoryServerToolItem));

package/esm/models/outputmessage.d.ts

@@ -17,7 +17,7 @@ export type OutputMessagePhaseCommentary = ClosedEnum<typeof OutputMessagePhaseC
 /**
  * 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 OutputMessagePhaseUnion = OutputMessagePhaseCommentary | OutputMessagePhaseFinalAnswer;
 export declare const OutputMessageRole: {
     readonly Assistant: "assistant";
 };
@@ -45,7 +45,7 @@ export type OutputMessage = {
     /**
      * 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;
+    phase?: OutputMessagePhaseCommentary | OutputMessagePhaseFinalAnswer | null | undefined;
     role: OutputMessageRole;
     status?: OutputMessageStatusCompleted | OutputMessageStatusIncomplete | OutputMessageStatusInProgress | undefined;
     type: OutputMessageType;

package/esm/models/outputmessage.js

@@ -44,7 +44,6 @@ export const OutputMessagePhaseCommentary$inboundSchema = z.enum(OutputMessagePh
 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`);
@@ -79,7 +78,6 @@ export const OutputMessage$inboundSchema = z
     phase: z.nullable(z.union([
         OutputMessagePhaseCommentary$inboundSchema,
         OutputMessagePhaseFinalAnswer$inboundSchema,
-        z.any(),
     ])).optional(),
     role: OutputMessageRole$inboundSchema,
     status: z.union([

package/esm/models/outputmessageitem.d.ts

@@ -17,7 +17,7 @@ export type OutputMessageItemPhaseCommentary = ClosedEnum<typeof OutputMessageIt
 /**
  * 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 OutputMessageItemPhaseUnion = OutputMessageItemPhaseCommentary | OutputMessageItemPhaseFinalAnswer | any;
+export type OutputMessageItemPhaseUnion = OutputMessageItemPhaseCommentary | OutputMessageItemPhaseFinalAnswer;
 export declare const OutputMessageItemRole: {
     readonly Assistant: "assistant";
 };
@@ -44,7 +44,7 @@ export type OutputMessageItem = {
     /**
      * 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?: OutputMessageItemPhaseCommentary | OutputMessageItemPhaseFinalAnswer | any | null | undefined;
+    phase?: OutputMessageItemPhaseCommentary | OutputMessageItemPhaseFinalAnswer | null | undefined;
     role: OutputMessageItemRole;
     status?: OutputMessageItemStatusCompleted | OutputMessageItemStatusIncomplete | OutputMessageItemStatusInProgress | undefined;
     type: "message";

package/esm/models/outputmessageitem.js

@@ -41,7 +41,6 @@ export const OutputMessageItemPhaseCommentary$inboundSchema = z.enum(OutputMessa
 export const OutputMessageItemPhaseUnion$inboundSchema = z.union([
     OutputMessageItemPhaseCommentary$inboundSchema,
     OutputMessageItemPhaseFinalAnswer$inboundSchema,
-    z.any(),
 ]);
 export function outputMessageItemPhaseUnionFromJSON(jsonString) {
     return safeParse(jsonString, (x) => OutputMessageItemPhaseUnion$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'OutputMessageItemPhaseUnion' from JSON`);
@@ -73,7 +72,6 @@ export const OutputMessageItem$inboundSchema = z.object({
     phase: z.nullable(z.union([
         OutputMessageItemPhaseCommentary$inboundSchema,
         OutputMessageItemPhaseFinalAnswer$inboundSchema,
-        z.any(),
     ])).optional(),
     role: OutputMessageItemRole$inboundSchema,
     status: z.union([

package/esm/models/payloadtoolargeresponseerrordata.d.ts

@@ -8,7 +8,7 @@ export type PayloadTooLargeResponseErrorData = {
     code: number;
     message: string;
     metadata?: {
-        [k: string]: any | null;
+        [k: string]: any;
     } | null | undefined;
 };
 /** @internal */

package/esm/models/payloadtoolargeresponseerrordata.js

@@ -8,7 +8,7 @@ import { safeParse } from "../lib/schemas.js";
 export const PayloadTooLargeResponseErrorData$inboundSchema = z.object({
     code: z.int(),
     message: z.string(),
-    metadata: z.nullable(z.record(z.string(), z.nullable(z.any()))).optional(),
+    metadata: z.nullable(z.record(z.string(), z.any())).optional(),
 });
 export function payloadTooLargeResponseErrorDataFromJSON(jsonString) {
     return safeParse(jsonString, (x) => PayloadTooLargeResponseErrorData$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'PayloadTooLargeResponseErrorData' from JSON`);

package/esm/models/paymentrequiredresponseerrordata.d.ts

@@ -8,7 +8,7 @@ export type PaymentRequiredResponseErrorData = {
     code: number;
     message: string;
     metadata?: {
-        [k: string]: any | null;
+        [k: string]: any;
     } | null | undefined;
 };
 /** @internal */

package/esm/models/paymentrequiredresponseerrordata.js

@@ -8,7 +8,7 @@ import { safeParse } from "../lib/schemas.js";
 export const PaymentRequiredResponseErrorData$inboundSchema = z.object({
     code: z.int(),
     message: z.string(),
-    metadata: z.nullable(z.record(z.string(), z.nullable(z.any()))).optional(),
+    metadata: z.nullable(z.record(z.string(), z.any())).optional(),
 });
 export function paymentRequiredResponseErrorDataFromJSON(jsonString) {
     return safeParse(jsonString, (x) => PaymentRequiredResponseErrorData$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'PaymentRequiredResponseErrorData' from JSON`);

package/esm/models/pipelinestage.d.ts

@@ -5,7 +5,7 @@ import { PipelineStageType } from "./pipelinestagetype.js";
 export type PipelineStage = {
     costUsd?: number | null | undefined;
     data?: {
-        [k: string]: any | null;
+        [k: string]: any;
     } | undefined;
     guardrailId?: string | undefined;
     guardrailScope?: string | undefined;

package/esm/models/pipelinestage.js

@@ -10,7 +10,7 @@ import { PipelineStageType$inboundSchema, } from "./pipelinestagetype.js";
 export const PipelineStage$inboundSchema = z
     .object({
     cost_usd: z.nullable(z.number()).optional(),
-    data: z.record(z.string(), z.nullable(z.any())).optional(),
+    data: z.record(z.string(), z.any()).optional(),
     guardrail_id: z.string().optional(),
     guardrail_scope: z.string().optional(),
     name: z.string(),

package/esm/models/preferredmaxlatency.d.ts

@@ -3,9 +3,9 @@ import { PercentileLatencyCutoffs, PercentileLatencyCutoffs$Outbound } from "./p
 /**
  * Preferred maximum latency (in seconds). Can be a number (applies to p50) or an object with percentile-specific cutoffs. Endpoints above the threshold(s) may still be used, but are deprioritized in routing. When using fallback models, this may cause a fallback model to be used instead of the primary model if it meets the threshold.
  */
-export type PreferredMaxLatency = number | PercentileLatencyCutoffs | any;
+export type PreferredMaxLatency = number | PercentileLatencyCutoffs;
 /** @internal */
-export type PreferredMaxLatency$Outbound = number | PercentileLatencyCutoffs$Outbound | any;
+export type PreferredMaxLatency$Outbound = number | PercentileLatencyCutoffs$Outbound;
 /** @internal */
 export declare const PreferredMaxLatency$outboundSchema: z.ZodType<PreferredMaxLatency$Outbound, PreferredMaxLatency>;
 export declare function preferredMaxLatencyToJSON(preferredMaxLatency: PreferredMaxLatency): string;

package/esm/models/preferredmaxlatency.js

@@ -5,7 +5,7 @@
 import * as z from "zod/v4";
 import { PercentileLatencyCutoffs$outboundSchema, } from "./percentilelatencycutoffs.js";
 /** @internal */
-export const PreferredMaxLatency$outboundSchema = z.union([z.number(), PercentileLatencyCutoffs$outboundSchema, z.any()]);
+export const PreferredMaxLatency$outboundSchema = z.union([z.number(), PercentileLatencyCutoffs$outboundSchema]);
 export function preferredMaxLatencyToJSON(preferredMaxLatency) {
     return JSON.stringify(PreferredMaxLatency$outboundSchema.parse(preferredMaxLatency));
 }

package/esm/models/preferredminthroughput.d.ts

@@ -3,9 +3,9 @@ import { PercentileThroughputCutoffs, PercentileThroughputCutoffs$Outbound } fro
 /**
  * Preferred minimum throughput (in tokens per second). Can be a number (applies to p50) or an object with percentile-specific cutoffs. Endpoints below the threshold(s) may still be used, but are deprioritized in routing. When using fallback models, this may cause a fallback model to be used instead of the primary model if it meets the threshold.
  */
-export type PreferredMinThroughput = number | PercentileThroughputCutoffs | any;
+export type PreferredMinThroughput = number | PercentileThroughputCutoffs;
 /** @internal */
-export type PreferredMinThroughput$Outbound = number | PercentileThroughputCutoffs$Outbound | any;
+export type PreferredMinThroughput$Outbound = number | PercentileThroughputCutoffs$Outbound;
 /** @internal */
 export declare const PreferredMinThroughput$outboundSchema: z.ZodType<PreferredMinThroughput$Outbound, PreferredMinThroughput>;
 export declare function preferredMinThroughputToJSON(preferredMinThroughput: PreferredMinThroughput): string;

package/esm/models/preferredminthroughput.js

@@ -5,7 +5,7 @@
 import * as z from "zod/v4";
 import { PercentileThroughputCutoffs$outboundSchema, } from "./percentilethroughputcutoffs.js";
 /** @internal */
-export const PreferredMinThroughput$outboundSchema = z.union([z.number(), PercentileThroughputCutoffs$outboundSchema, z.any()]);
+export const PreferredMinThroughput$outboundSchema = z.union([z.number(), PercentileThroughputCutoffs$outboundSchema]);
 export function preferredMinThroughputToJSON(preferredMinThroughput) {
     return JSON.stringify(PreferredMinThroughput$outboundSchema.parse(preferredMinThroughput));
 }

package/esm/models/presetdesignatedversion.d.ts

@@ -6,7 +6,7 @@ import { SDKValidationError } from "./errors/sdkvalidationerror.js";
  */
 export type PresetDesignatedVersion = {
     config: {
-        [k: string]: any | null;
+        [k: string]: any;
     };
     createdAt: string;
     creatorId: string;

package/esm/models/presetdesignatedversion.js

@@ -7,7 +7,7 @@ import { remap as remap$ } from "../lib/primitives.js";
 import { safeParse } from "../lib/schemas.js";
 /** @internal */
 export const PresetDesignatedVersion$inboundSchema = z.object({
-    config: z.record(z.string(), z.nullable(z.any())),
+    config: z.record(z.string(), z.any()),
     created_at: z.string(),
     creator_id: z.string(),
     id: z.string(),

package/esm/models/providername.d.ts

@@ -1,7 +1,6 @@
 import * as z from "zod/v4";
 import { OpenEnum } from "../types/enums.js";
 export declare const ProviderName: {
-    readonly Meta: "Meta";
     readonly AkashML: "AkashML";
     readonly Ai21: "AI21";
     readonly AionLabs: "AionLabs";
@@ -52,6 +51,7 @@ export declare const ProviderName: {
     readonly Liquid: "Liquid";
     readonly Mara: "Mara";
     readonly Mancer2: "Mancer 2";
+    readonly Meta: "Meta";
     readonly Minimax: "Minimax";
     readonly ModelRun: "ModelRun";
     readonly Mistral: "Mistral";
@@ -84,6 +84,7 @@ export declare const ProviderName: {
     readonly Stealth: "Stealth";
     readonly StreamLake: "StreamLake";
     readonly Switchpoint: "Switchpoint";
+    readonly Tencent: "Tencent";
     readonly Tenstorrent: "Tenstorrent";
     readonly Together: "Together";
     readonly Upstage: "Upstage";

package/esm/models/providername.js

@@ -4,7 +4,6 @@
  */
 import * as openEnums from "../types/enums.js";
 export const ProviderName = {
-    Meta: "Meta",
     AkashML: "AkashML",
     Ai21: "AI21",
     AionLabs: "AionLabs",
@@ -55,6 +54,7 @@ export const ProviderName = {
     Liquid: "Liquid",
     Mara: "Mara",
     Mancer2: "Mancer 2",
+    Meta: "Meta",
     Minimax: "Minimax",
     ModelRun: "ModelRun",
     Mistral: "Mistral",
@@ -87,6 +87,7 @@ export const ProviderName = {
     Stealth: "Stealth",
     StreamLake: "StreamLake",
     Switchpoint: "Switchpoint",
+    Tencent: "Tencent",
     Tenstorrent: "Tenstorrent",
     Together: "Together",
     Upstage: "Upstage",