@openrouter/sdk 0.5.1 → 0.9.11

package/esm/models/index.js

@@ -4,10 +4,10 @@
  */
 export * from "./activityitem.js";
 export * from "./assistantmessage.js";
+export * from "./assistantmessageimages.js";
 export * from "./badgatewayresponseerrordata.js";
 export * from "./badrequestresponseerrordata.js";
 export * from "./chatcompletionfinishreason.js";
-export * from "./chaterror.js";
 export * from "./chatgenerationparams.js";
 export * from "./chatgenerationtokenusage.js";
 export * from "./chatmessagecontentitem.js";
@@ -16,6 +16,7 @@ export * from "./chatmessagecontentitemcachecontrol.js";
 export * from "./chatmessagecontentitemimage.js";
 export * from "./chatmessagecontentitemtext.js";
 export * from "./chatmessagecontentitemvideo.js";
+export * from "./chatmessagecontentitemvideolegacy.js";
 export * from "./chatmessagetokenlogprob.js";
 export * from "./chatmessagetokenlogprobs.js";
 export * from "./chatmessagetoolcall.js";
@@ -28,7 +29,9 @@ export * from "./chatstreamingresponsechunk.js";
 export * from "./chatstreamoptions.js";
 export * from "./createchargerequest.js";
 export * from "./datacollection.js";
+export * from "./debugoptions.js";
 export * from "./defaultparameters.js";
+export * from "./developermessage.js";
 export * from "./edgenetworktimeoutresponseerrordata.js";
 export * from "./endpointstatus.js";
 export * from "./filecitation.js";
@@ -107,17 +110,23 @@ export * from "./provideroverloadedresponseerrordata.js";
 export * from "./providerpreferences.js";
 export * from "./providersort.js";
 export * from "./providersortconfig.js";
-export * from "./providersortunion.js";
 export * from "./publicendpoint.js";
 export * from "./publicpricing.js";
 export * from "./quantization.js";
+export * from "./reasoningdetailencrypted.js";
+export * from "./reasoningdetailsummary.js";
+export * from "./reasoningdetailtext.js";
+export * from "./reasoningdetailunion.js";
 export * from "./reasoningsummarytext.js";
 export * from "./reasoningsummaryverbosity.js";
 export * from "./reasoningtextcontent.js";
 export * from "./requesttimeoutresponseerrordata.js";
+export * from "./responseformatjsonobject.js";
 export * from "./responseformatjsonschema.js";
+export * from "./responseformattext.js";
 export * from "./responseformattextconfig.js";
 export * from "./responseformattextgrammar.js";
+export * from "./responseformattextpython.js";
 export * from "./responseinputaudio.js";
 export * from "./responseinputfile.js";
 export * from "./responseinputimage.js";
@@ -125,7 +134,6 @@ export * from "./responseinputtext.js";
 export * from "./responseinputvideo.js";
 export * from "./responseoutputtext.js";
 export * from "./responseserrorfield.js";
-export * from "./responsesformatjsonobject.js";
 export * from "./responsesformattext.js";
 export * from "./responsesformattextjsonschemaconfig.js";
 export * from "./responsesimagegenerationcall.js";
@@ -139,12 +147,11 @@ export * from "./responsessearchcontextsize.js";
 export * from "./responseswebsearchcalloutput.js";
 export * from "./responseswebsearchuserlocation.js";
 export * from "./responsetextconfig.js";
-export * from "./schema0.js";
-export * from "./schema2.js";
 export * from "./security.js";
 export * from "./serviceunavailableresponseerrordata.js";
 export * from "./systemmessage.js";
 export * from "./toolcallstatus.js";
+export * from "./toolchoiceoption.js";
 export * from "./tooldefinitionjson.js";
 export * from "./toolresponsemessage.js";
 export * from "./toomanyrequestsresponseerrordata.js";
@@ -153,6 +160,7 @@ export * from "./unauthorizedresponseerrordata.js";
 export * from "./unprocessableentityresponseerrordata.js";
 export * from "./urlcitation.js";
 export * from "./usermessage.js";
+export * from "./videoinput.js";
 export * from "./websearchengine.js";
 export * from "./websearchpreviewtooluserlocation.js";
 export * from "./websearchstatus.js";

package/esm/models/jsonschemaconfig.d.ts

@@ -1,10 +1,25 @@
 import * as z from "zod/v4";
+/**
+ * JSON Schema configuration object
+ */
 export type JSONSchemaConfig = {
+    /**
+     * Schema name (a-z, A-Z, 0-9, underscores, dashes, max 64 chars)
+     */
     name: string;
+    /**
+     * Schema description for the model
+     */
     description?: string | undefined;
+    /**
+     * JSON Schema object
+     */
     schema?: {
-        [k: string]: any;
+        [k: string]: any | null;
     } | undefined;
+    /**
+     * Enable strict schema adherence
+     */
     strict?: boolean | null | undefined;
 };
 /** @internal */
@@ -12,7 +27,7 @@ export type JSONSchemaConfig$Outbound = {
     name: string;
     description?: string | undefined;
     schema?: {
-        [k: string]: any;
+        [k: string]: any | null;
     } | undefined;
     strict?: boolean | null | undefined;
 };

package/esm/models/jsonschemaconfig.js

@@ -7,7 +7,7 @@ import * as z from "zod/v4";
 export const JSONSchemaConfig$outboundSchema = z.object({
     name: z.string(),
     description: z.string().optional(),
-    schema: z.record(z.string(), z.any()).optional(),
+    schema: z.record(z.string(), z.nullable(z.any())).optional(),
     strict: z.nullable(z.boolean()).optional(),
 });
 export function jsonSchemaConfigToJSON(jsonSchemaConfig) {

package/esm/models/message.d.ts

@@ -1,32 +1,19 @@
 import * as z from "zod/v4";
 import { AssistantMessage, AssistantMessage$Outbound } from "./assistantmessage.js";
-import { ChatMessageContentItemText, ChatMessageContentItemText$Outbound } from "./chatmessagecontentitemtext.js";
+import { DeveloperMessage, DeveloperMessage$Outbound } from "./developermessage.js";
 import { SystemMessage, SystemMessage$Outbound } from "./systemmessage.js";
 import { ToolResponseMessage, ToolResponseMessage$Outbound } from "./toolresponsemessage.js";
 import { UserMessage, UserMessage$Outbound } from "./usermessage.js";
-export type MessageContent = string | Array<ChatMessageContentItemText>;
-export type MessageDeveloper = {
-    role: "developer";
-    content: string | Array<ChatMessageContentItemText>;
-    name?: string | undefined;
-};
-export type Message = SystemMessage | UserMessage | MessageDeveloper | AssistantMessage | ToolResponseMessage;
+/**
+ * Chat completion message with role-based discrimination
+ */
+export type Message = SystemMessage | UserMessage | DeveloperMessage | (AssistantMessage & {
+    role: "assistant";
+}) | ToolResponseMessage;
 /** @internal */
-export type MessageContent$Outbound = string | Array<ChatMessageContentItemText$Outbound>;
-/** @internal */
-export declare const MessageContent$outboundSchema: z.ZodType<MessageContent$Outbound, MessageContent>;
-export declare function messageContentToJSON(messageContent: MessageContent): string;
-/** @internal */
-export type MessageDeveloper$Outbound = {
-    role: "developer";
-    content: string | Array<ChatMessageContentItemText$Outbound>;
-    name?: string | undefined;
-};
-/** @internal */
-export declare const MessageDeveloper$outboundSchema: z.ZodType<MessageDeveloper$Outbound, MessageDeveloper>;
-export declare function messageDeveloperToJSON(messageDeveloper: MessageDeveloper): string;
-/** @internal */
-export type Message$Outbound = SystemMessage$Outbound | UserMessage$Outbound | MessageDeveloper$Outbound | AssistantMessage$Outbound | ToolResponseMessage$Outbound;
+export type Message$Outbound = SystemMessage$Outbound | UserMessage$Outbound | DeveloperMessage$Outbound | (AssistantMessage$Outbound & {
+    role: "assistant";
+}) | ToolResponseMessage$Outbound;
 /** @internal */
 export declare const Message$outboundSchema: z.ZodType<Message$Outbound, Message>;
 export declare function messageToJSON(message: Message): string;

package/esm/models/message.js

@@ -4,34 +4,17 @@
  */
 import * as z from "zod/v4";
 import { AssistantMessage$outboundSchema, } from "./assistantmessage.js";
-import { ChatMessageContentItemText$outboundSchema, } from "./chatmessagecontentitemtext.js";
+import { DeveloperMessage$outboundSchema, } from "./developermessage.js";
 import { SystemMessage$outboundSchema, } from "./systemmessage.js";
 import { ToolResponseMessage$outboundSchema, } from "./toolresponsemessage.js";
 import { UserMessage$outboundSchema, } from "./usermessage.js";
 /** @internal */
-export const MessageContent$outboundSchema = z.union([z.string(), z.array(ChatMessageContentItemText$outboundSchema)]);
-export function messageContentToJSON(messageContent) {
-    return JSON.stringify(MessageContent$outboundSchema.parse(messageContent));
-}
-/** @internal */
-export const MessageDeveloper$outboundSchema = z.object({
-    role: z.literal("developer"),
-    content: z.union([
-        z.string(),
-        z.array(ChatMessageContentItemText$outboundSchema),
-    ]),
-    name: z.string().optional(),
-});
-export function messageDeveloperToJSON(messageDeveloper) {
-    return JSON.stringify(MessageDeveloper$outboundSchema.parse(messageDeveloper));
-}
-/** @internal */
 export const Message$outboundSchema = z
     .union([
     SystemMessage$outboundSchema,
     UserMessage$outboundSchema,
-    z.lazy(() => MessageDeveloper$outboundSchema),
-    AssistantMessage$outboundSchema,
+    DeveloperMessage$outboundSchema,
+    AssistantMessage$outboundSchema.and(z.object({ role: z.literal("assistant") })),
     ToolResponseMessage$outboundSchema,
 ]);
 export function messageToJSON(message) {

package/esm/models/modelscountresponse.d.ts

@@ -4,7 +4,7 @@ import { SDKValidationError } from "./errors/sdkvalidationerror.js";
 /**
  * Model count data
  */
-export type ModelsCountResponseData = {
+export type Data = {
     /**
      * Total number of available models
      */
@@ -17,11 +17,11 @@ export type ModelsCountResponse = {
     /**
      * Model count data
      */
-    data: ModelsCountResponseData;
+    data: Data;
 };
 /** @internal */
-export declare const ModelsCountResponseData$inboundSchema: z.ZodType<ModelsCountResponseData, unknown>;
-export declare function modelsCountResponseDataFromJSON(jsonString: string): SafeParseResult<ModelsCountResponseData, SDKValidationError>;
+export declare const Data$inboundSchema: z.ZodType<Data, unknown>;
+export declare function dataFromJSON(jsonString: string): SafeParseResult<Data, SDKValidationError>;
 /** @internal */
 export declare const ModelsCountResponse$inboundSchema: z.ZodType<ModelsCountResponse, unknown>;
 export declare function modelsCountResponseFromJSON(jsonString: string): SafeParseResult<ModelsCountResponse, SDKValidationError>;

package/esm/models/modelscountresponse.js

@@ -5,15 +5,15 @@
 import * as z from "zod/v4";
 import { safeParse } from "../lib/schemas.js";
 /** @internal */
-export const ModelsCountResponseData$inboundSchema = z.object({
+export const Data$inboundSchema = z.object({
     count: z.number(),
 });
-export function modelsCountResponseDataFromJSON(jsonString) {
-    return safeParse(jsonString, (x) => ModelsCountResponseData$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'ModelsCountResponseData' from JSON`);
+export function dataFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => Data$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'Data' from JSON`);
 }
 /** @internal */
 export const ModelsCountResponse$inboundSchema = z.object({
-    data: z.lazy(() => ModelsCountResponseData$inboundSchema),
+    data: z.lazy(() => Data$inboundSchema),
 });
 export function modelsCountResponseFromJSON(jsonString) {
     return safeParse(jsonString, (x) => ModelsCountResponse$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'ModelsCountResponse' from JSON`);

package/esm/models/namedtoolchoice.d.ts

@@ -1,12 +1,25 @@
 import * as z from "zod/v4";
+import { ClosedEnum } from "../types/enums.js";
+export declare const NamedToolChoiceType: {
+    readonly Function: "function";
+};
+export type NamedToolChoiceType = ClosedEnum<typeof NamedToolChoiceType>;
 export type NamedToolChoiceFunction = {
+    /**
+     * Function name to call
+     */
     name: string;
 };
+/**
+ * Named tool choice for specific function
+ */
 export type NamedToolChoice = {
-    type: "function";
+    type: NamedToolChoiceType;
     function: NamedToolChoiceFunction;
 };
 /** @internal */
+export declare const NamedToolChoiceType$outboundSchema: z.ZodEnum<typeof NamedToolChoiceType>;
+/** @internal */
 export type NamedToolChoiceFunction$Outbound = {
     name: string;
 };
@@ -15,7 +28,7 @@ export declare const NamedToolChoiceFunction$outboundSchema: z.ZodType<NamedTool
 export declare function namedToolChoiceFunctionToJSON(namedToolChoiceFunction: NamedToolChoiceFunction): string;
 /** @internal */
 export type NamedToolChoice$Outbound = {
-    type: "function";
+    type: string;
     function: NamedToolChoiceFunction$Outbound;
 };
 /** @internal */

package/esm/models/namedtoolchoice.js

@@ -3,6 +3,11 @@
  * @generated-id: db68e36b6a77
  */
 import * as z from "zod/v4";
+export const NamedToolChoiceType = {
+    Function: "function",
+};
+/** @internal */
+export const NamedToolChoiceType$outboundSchema = z.enum(NamedToolChoiceType);
 /** @internal */
 export const NamedToolChoiceFunction$outboundSchema = z.object({
     name: z.string(),
@@ -12,7 +17,7 @@ export function namedToolChoiceFunctionToJSON(namedToolChoiceFunction) {
 }
 /** @internal */
 export const NamedToolChoice$outboundSchema = z.object({
-    type: z.literal("function"),
+    type: NamedToolChoiceType$outboundSchema,
     function: z.lazy(() => NamedToolChoiceFunction$outboundSchema),
 });
 export function namedToolChoiceToJSON(namedToolChoice) {

package/esm/models/openairesponsesreasoningconfig.d.ts

@@ -5,7 +5,7 @@ import { OpenAIResponsesReasoningEffort } from "./openairesponsesreasoningeffort
 import { ReasoningSummaryVerbosity } from "./reasoningsummaryverbosity.js";
 export type OpenAIResponsesReasoningConfig = {
     effort?: OpenAIResponsesReasoningEffort | null | undefined;
-    summary?: ReasoningSummaryVerbosity | undefined;
+    summary?: ReasoningSummaryVerbosity | null | undefined;
 };
 /** @internal */
 export declare const OpenAIResponsesReasoningConfig$inboundSchema: z.ZodType<OpenAIResponsesReasoningConfig, unknown>;

package/esm/models/openairesponsesreasoningconfig.js

@@ -9,7 +9,7 @@ import { ReasoningSummaryVerbosity$inboundSchema, } from "./reasoningsummaryverb
 /** @internal */
 export const OpenAIResponsesReasoningConfig$inboundSchema = z.object({
     effort: z.nullable(OpenAIResponsesReasoningEffort$inboundSchema).optional(),
-    summary: ReasoningSummaryVerbosity$inboundSchema.optional(),
+    summary: z.nullable(ReasoningSummaryVerbosity$inboundSchema).optional(),
 });
 export function openAIResponsesReasoningConfigFromJSON(jsonString) {
     return safeParse(jsonString, (x) => OpenAIResponsesReasoningConfig$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'OpenAIResponsesReasoningConfig' from JSON`);

package/esm/models/openresponsesnonstreamingresponse.d.ts

@@ -18,10 +18,10 @@ import { OpenResponsesWebSearchTool } from "./openresponseswebsearchtool.js";
 import { ResponsesErrorField } from "./responseserrorfield.js";
 import { ResponsesOutputItem } from "./responsesoutputitem.js";
 import { ResponseTextConfig } from "./responsetextconfig.js";
-export declare const ObjectT: {
+export declare const OpenResponsesNonStreamingResponseObject: {
     readonly Response: "response";
 };
-export type ObjectT = ClosedEnum<typeof ObjectT>;
+export type OpenResponsesNonStreamingResponseObject = ClosedEnum<typeof OpenResponsesNonStreamingResponseObject>;
 /**
  * Function tool definition
  */
@@ -40,7 +40,7 @@ export type OpenResponsesNonStreamingResponseToolUnion = OpenResponsesNonStreami
  */
 export type OpenResponsesNonStreamingResponse = {
     id: string;
-    object: ObjectT;
+    object: OpenResponsesNonStreamingResponseObject;
     createdAt: number;
     model: string;
     status: OpenAIResponsesResponseStatus;
@@ -89,7 +89,7 @@ export type OpenResponsesNonStreamingResponse = {
     text?: ResponseTextConfig | undefined;
 };
 /** @internal */
-export declare const ObjectT$inboundSchema: z.ZodEnum<typeof ObjectT>;
+export declare const OpenResponsesNonStreamingResponseObject$inboundSchema: z.ZodEnum<typeof OpenResponsesNonStreamingResponseObject>;
 /** @internal */
 export declare const OpenResponsesNonStreamingResponseToolFunction$inboundSchema: z.ZodType<OpenResponsesNonStreamingResponseToolFunction, unknown>;
 export declare function openResponsesNonStreamingResponseToolFunctionFromJSON(jsonString: string): SafeParseResult<OpenResponsesNonStreamingResponseToolFunction, SDKValidationError>;

package/esm/models/openresponsesnonstreamingresponse.js

@@ -21,11 +21,11 @@ import { OpenResponsesWebSearchTool$inboundSchema, } from "./openresponseswebsea
 import { ResponsesErrorField$inboundSchema, } from "./responseserrorfield.js";
 import { ResponsesOutputItem$inboundSchema, } from "./responsesoutputitem.js";
 import { ResponseTextConfig$inboundSchema, } from "./responsetextconfig.js";
-export const ObjectT = {
+export const OpenResponsesNonStreamingResponseObject = {
     Response: "response",
 };
 /** @internal */
-export const ObjectT$inboundSchema = z.enum(ObjectT);
+export const OpenResponsesNonStreamingResponseObject$inboundSchema = z.enum(OpenResponsesNonStreamingResponseObject);
 /** @internal */
 export const OpenResponsesNonStreamingResponseToolFunction$inboundSchema = z.object({
     type: z.literal("function"),
@@ -51,7 +51,7 @@ export function openResponsesNonStreamingResponseToolUnionFromJSON(jsonString) {
 /** @internal */
 export const OpenResponsesNonStreamingResponse$inboundSchema = z.object({
     id: z.string(),
-    object: ObjectT$inboundSchema,
+    object: OpenResponsesNonStreamingResponseObject$inboundSchema,
     created_at: z.number(),
     model: z.string(),
     status: OpenAIResponsesResponseStatus$inboundSchema,

package/esm/models/openresponsesreasoning.d.ts

@@ -34,7 +34,7 @@ export type OpenResponsesReasoningFormat = OpenEnum<typeof OpenResponsesReasonin
 export type OpenResponsesReasoning = {
     type: OpenResponsesReasoningType;
     id: string;
-    content?: Array<ReasoningTextContent> | undefined;
+    content?: Array<ReasoningTextContent> | null | undefined;
     summary: Array<ReasoningSummaryText>;
     encryptedContent?: string | null | undefined;
     status?: OpenResponsesReasoningStatusCompleted | OpenResponsesReasoningStatusIncomplete | OpenResponsesReasoningStatusInProgress | undefined;
@@ -60,7 +60,7 @@ export declare const OpenResponsesReasoningFormat$outboundSchema: z.ZodType<stri
 export type OpenResponsesReasoning$Outbound = {
     type: string;
     id: string;
-    content?: Array<ReasoningTextContent$Outbound> | undefined;
+    content?: Array<ReasoningTextContent$Outbound> | null | undefined;
     summary: Array<ReasoningSummaryText$Outbound>;
     encrypted_content?: string | null | undefined;
     status?: string | string | string | undefined;

package/esm/models/openresponsesreasoning.js

@@ -50,7 +50,7 @@ export const OpenResponsesReasoningFormat$outboundSchema = openEnums.outboundSch
 export const OpenResponsesReasoning$outboundSchema = z.object({
     type: OpenResponsesReasoningType$outboundSchema,
     id: z.string(),
-    content: z.array(ReasoningTextContent$outboundSchema).optional(),
+    content: z.nullable(z.array(ReasoningTextContent$outboundSchema)).optional(),
     summary: z.array(ReasoningSummaryText$outboundSchema),
     encryptedContent: z.nullable(z.string()).optional(),
     status: z.union([

package/esm/models/openresponsesreasoningconfig.d.ts

@@ -6,14 +6,14 @@ import { ReasoningSummaryVerbosity } from "./reasoningsummaryverbosity.js";
  */
 export type OpenResponsesReasoningConfig = {
     effort?: OpenAIResponsesReasoningEffort | null | undefined;
-    summary?: ReasoningSummaryVerbosity | undefined;
+    summary?: ReasoningSummaryVerbosity | null | undefined;
     maxTokens?: number | null | undefined;
     enabled?: boolean | null | undefined;
 };
 /** @internal */
 export type OpenResponsesReasoningConfig$Outbound = {
     effort?: string | null | undefined;
-    summary?: string | undefined;
+    summary?: string | null | undefined;
     max_tokens?: number | null | undefined;
     enabled?: boolean | null | undefined;
 };

package/esm/models/openresponsesreasoningconfig.js

@@ -9,7 +9,7 @@ import { ReasoningSummaryVerbosity$outboundSchema, } from "./reasoningsummaryver
 /** @internal */
 export const OpenResponsesReasoningConfig$outboundSchema = z.object({
     effort: z.nullable(OpenAIResponsesReasoningEffort$outboundSchema).optional(),
-    summary: ReasoningSummaryVerbosity$outboundSchema.optional(),
+    summary: z.nullable(ReasoningSummaryVerbosity$outboundSchema).optional(),
     maxTokens: z.nullable(z.number()).optional(),
     enabled: z.nullable(z.boolean()).optional(),
 }).transform((v) => {

package/esm/models/openresponsesrequest.d.ts

@@ -55,24 +55,12 @@ export type OpenResponsesRequestSort = ProviderSort | ProviderSortConfig | any;
  */
 export type OpenResponsesRequestMaxPrice = {
     /**
-     * A value in string format that is a large number
+     * Price per million prompt tokens
      */
     prompt?: string | undefined;
-    /**
-     * A value in string format that is a large number
-     */
     completion?: string | undefined;
-    /**
-     * A value in string format that is a large number
-     */
     image?: string | undefined;
-    /**
-     * A value in string format that is a large number
-     */
     audio?: string | undefined;
-    /**
-     * A value in string format that is a large number
-     */
     request?: string | undefined;
 };
 /**
@@ -187,6 +175,19 @@ export type OpenResponsesRequestPluginAutoRouter = {
     allowedModels?: Array<string> | undefined;
 };
 export type OpenResponsesRequestPluginUnion = OpenResponsesRequestPluginAutoRouter | OpenResponsesRequestPluginModeration | OpenResponsesRequestPluginWeb | OpenResponsesRequestPluginFileParser | OpenResponsesRequestPluginResponseHealing;
+/**
+ * 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 OpenResponsesRequestTrace = {
+    traceId?: string | undefined;
+    traceName?: string | undefined;
+    spanName?: string | undefined;
+    generationName?: string | undefined;
+    parentSpanId?: string | undefined;
+    additionalProperties?: {
+        [k: string]: any | null;
+    } | undefined;
+};
 /**
  * Request schema for Responses endpoint
  */
@@ -259,6 +260,10 @@ export type OpenResponsesRequest = {
      * A unique identifier for grouping related requests (e.g., a conversation or agent workflow) for observability. If provided in both the request body and the x-session-id header, the body value takes precedence. Maximum of 128 characters.
      */
     sessionId?: string | undefined;
+    /**
+     * 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.
+     */
+    trace?: OpenResponsesRequestTrace | undefined;
 };
 /** @internal */
 export type OpenResponsesRequestToolFunction$Outbound = {
@@ -387,6 +392,18 @@ export type OpenResponsesRequestPluginUnion$Outbound = OpenResponsesRequestPlugi
 export declare const OpenResponsesRequestPluginUnion$outboundSchema: z.ZodType<OpenResponsesRequestPluginUnion$Outbound, OpenResponsesRequestPluginUnion>;
 export declare function openResponsesRequestPluginUnionToJSON(openResponsesRequestPluginUnion: OpenResponsesRequestPluginUnion): string;
 /** @internal */
+export type OpenResponsesRequestTrace$Outbound = {
+    trace_id?: string | undefined;
+    trace_name?: string | undefined;
+    span_name?: string | undefined;
+    generation_name?: string | undefined;
+    parent_span_id?: string | undefined;
+    [additionalProperties: string]: unknown;
+};
+/** @internal */
+export declare const OpenResponsesRequestTrace$outboundSchema: z.ZodType<OpenResponsesRequestTrace$Outbound, OpenResponsesRequestTrace>;
+export declare function openResponsesRequestTraceToJSON(openResponsesRequestTrace: OpenResponsesRequestTrace): string;
+/** @internal */
 export type OpenResponsesRequest$Outbound = {
     input?: OpenResponsesInput$Outbound | undefined;
     instructions?: string | null | undefined;
@@ -426,6 +443,7 @@ export type OpenResponsesRequest$Outbound = {
     plugins?: Array<OpenResponsesRequestPluginAutoRouter$Outbound | OpenResponsesRequestPluginModeration$Outbound | OpenResponsesRequestPluginWeb$Outbound | OpenResponsesRequestPluginFileParser$Outbound | OpenResponsesRequestPluginResponseHealing$Outbound> | undefined;
     user?: string | undefined;
     session_id?: string | undefined;
+    trace?: OpenResponsesRequestTrace$Outbound | undefined;
 };
 /** @internal */
 export declare const OpenResponsesRequest$outboundSchema: z.ZodType<OpenResponsesRequest$Outbound, OpenResponsesRequest>;

package/esm/models/openresponsesrequest.js

@@ -201,6 +201,30 @@ export function openResponsesRequestPluginUnionToJSON(openResponsesRequestPlugin
     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({
     input: OpenResponsesInput$outboundSchema.optional(),
     instructions: z.nullable(z.string()).optional(),
@@ -250,6 +274,7 @@ export const OpenResponsesRequest$outboundSchema = z.object({
     ])).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/bulkassignkeystoguardrail.d.ts

@@ -1,6 +1,21 @@
 import * as z from "zod/v4";
 import { Result as SafeParseResult } from "../../types/fp.js";
 import { SDKValidationError } from "../errors/sdkvalidationerror.js";
+export type BulkAssignKeysToGuardrailGlobals = {
+    /**
+     * The app identifier should be your app's URL and is used as the primary identifier for rankings.
+     *
+     * @remarks
+     * This is used to track API usage per application.
+     */
+    httpReferer?: string | undefined;
+    /**
+     * The app display name allows you to customize how your app appears in OpenRouter's dashboard.
+     *
+     * @remarks
+     */
+    xTitle?: string | undefined;
+};
 export type BulkAssignKeysToGuardrailRequestBody = {
     /**
      * Array of API key hashes to assign to the guardrail
@@ -8,6 +23,19 @@ export type BulkAssignKeysToGuardrailRequestBody = {
     keyHashes: Array<string>;
 };
 export type BulkAssignKeysToGuardrailRequest = {
+    /**
+     * The app identifier should be your app's URL and is used as the primary identifier for rankings.
+     *
+     * @remarks
+     * This is used to track API usage per application.
+     */
+    httpReferer?: string | undefined;
+    /**
+     * The app display name allows you to customize how your app appears in OpenRouter's dashboard.
+     *
+     * @remarks
+     */
+    xTitle?: string | undefined;
     /**
      * The unique identifier of the guardrail
      */
@@ -32,6 +60,8 @@ export declare const BulkAssignKeysToGuardrailRequestBody$outboundSchema: z.ZodT
 export declare function bulkAssignKeysToGuardrailRequestBodyToJSON(bulkAssignKeysToGuardrailRequestBody: BulkAssignKeysToGuardrailRequestBody): string;
 /** @internal */
 export type BulkAssignKeysToGuardrailRequest$Outbound = {
+    "HTTP-Referer"?: string | undefined;
+    "X-Title"?: string | undefined;
     id: string;
     RequestBody: BulkAssignKeysToGuardrailRequestBody$Outbound;
 };

package/esm/models/operations/bulkassignkeystoguardrail.js

@@ -18,10 +18,14 @@ export function bulkAssignKeysToGuardrailRequestBodyToJSON(bulkAssignKeysToGuard
 }
 /** @internal */
 export const BulkAssignKeysToGuardrailRequest$outboundSchema = z.object({
+    httpReferer: z.string().optional(),
+    xTitle: z.string().optional(),
     id: z.string(),
     requestBody: z.lazy(() => BulkAssignKeysToGuardrailRequestBody$outboundSchema),
 }).transform((v) => {
     return remap$(v, {
+        httpReferer: "HTTP-Referer",
+        xTitle: "X-Title",
         requestBody: "RequestBody",
     });
 });