@openrouter/sdk 0.9.11 → 0.11.2

package/esm/models/mcpservertool.d.ts

@@ -0,0 +1,128 @@
+import * as z from "zod/v4";
+import { ClosedEnum, OpenEnum } from "../types/enums.js";
+import { Result as SafeParseResult } from "../types/fp.js";
+import { SDKValidationError } from "./errors/sdkvalidationerror.js";
+export type AllowedTools = {
+    toolNames?: Array<string> | undefined;
+    readOnly?: boolean | undefined;
+};
+export declare const ConnectorId: {
+    readonly ConnectorDropbox: "connector_dropbox";
+    readonly ConnectorGmail: "connector_gmail";
+    readonly ConnectorGooglecalendar: "connector_googlecalendar";
+    readonly ConnectorGoogledrive: "connector_googledrive";
+    readonly ConnectorMicrosoftteams: "connector_microsoftteams";
+    readonly ConnectorOutlookcalendar: "connector_outlookcalendar";
+    readonly ConnectorOutlookemail: "connector_outlookemail";
+    readonly ConnectorSharepoint: "connector_sharepoint";
+};
+export type ConnectorId = OpenEnum<typeof ConnectorId>;
+export declare const RequireApprovalNever: {
+    readonly Never: "never";
+};
+export type RequireApprovalNever = ClosedEnum<typeof RequireApprovalNever>;
+export declare const RequireApprovalAlways: {
+    readonly Always: "always";
+};
+export type RequireApprovalAlways = ClosedEnum<typeof RequireApprovalAlways>;
+export type Never = {
+    toolNames?: Array<string> | undefined;
+};
+export type Always = {
+    toolNames?: Array<string> | undefined;
+};
+export type RequireApproval = {
+    never?: Never | undefined;
+    always?: Always | undefined;
+};
+/**
+ * MCP (Model Context Protocol) tool configuration
+ */
+export type McpServerTool = {
+    type: "mcp";
+    serverLabel: string;
+    allowedTools?: any | null | undefined;
+    authorization?: string | undefined;
+    connectorId?: ConnectorId | undefined;
+    headers?: {
+        [k: string]: string;
+    } | null | undefined;
+    requireApproval?: any | null | undefined;
+    serverDescription?: string | undefined;
+    serverUrl?: string | undefined;
+};
+/** @internal */
+export declare const AllowedTools$inboundSchema: z.ZodType<AllowedTools, unknown>;
+/** @internal */
+export type AllowedTools$Outbound = {
+    tool_names?: Array<string> | undefined;
+    read_only?: boolean | undefined;
+};
+/** @internal */
+export declare const AllowedTools$outboundSchema: z.ZodType<AllowedTools$Outbound, AllowedTools>;
+export declare function allowedToolsToJSON(allowedTools: AllowedTools): string;
+export declare function allowedToolsFromJSON(jsonString: string): SafeParseResult<AllowedTools, SDKValidationError>;
+/** @internal */
+export declare const ConnectorId$inboundSchema: z.ZodType<ConnectorId, unknown>;
+/** @internal */
+export declare const ConnectorId$outboundSchema: z.ZodType<string, ConnectorId>;
+/** @internal */
+export declare const RequireApprovalNever$inboundSchema: z.ZodEnum<typeof RequireApprovalNever>;
+/** @internal */
+export declare const RequireApprovalNever$outboundSchema: z.ZodEnum<typeof RequireApprovalNever>;
+/** @internal */
+export declare const RequireApprovalAlways$inboundSchema: z.ZodEnum<typeof RequireApprovalAlways>;
+/** @internal */
+export declare const RequireApprovalAlways$outboundSchema: z.ZodEnum<typeof RequireApprovalAlways>;
+/** @internal */
+export declare const Never$inboundSchema: z.ZodType<Never, unknown>;
+/** @internal */
+export type Never$Outbound = {
+    tool_names?: Array<string> | undefined;
+};
+/** @internal */
+export declare const Never$outboundSchema: z.ZodType<Never$Outbound, Never>;
+export declare function neverToJSON(never: Never): string;
+export declare function neverFromJSON(jsonString: string): SafeParseResult<Never, SDKValidationError>;
+/** @internal */
+export declare const Always$inboundSchema: z.ZodType<Always, unknown>;
+/** @internal */
+export type Always$Outbound = {
+    tool_names?: Array<string> | undefined;
+};
+/** @internal */
+export declare const Always$outboundSchema: z.ZodType<Always$Outbound, Always>;
+export declare function alwaysToJSON(always: Always): string;
+export declare function alwaysFromJSON(jsonString: string): SafeParseResult<Always, SDKValidationError>;
+/** @internal */
+export declare const RequireApproval$inboundSchema: z.ZodType<RequireApproval, unknown>;
+/** @internal */
+export type RequireApproval$Outbound = {
+    never?: Never$Outbound | undefined;
+    always?: Always$Outbound | undefined;
+};
+/** @internal */
+export declare const RequireApproval$outboundSchema: z.ZodType<RequireApproval$Outbound, RequireApproval>;
+export declare function requireApprovalToJSON(requireApproval: RequireApproval): string;
+export declare function requireApprovalFromJSON(jsonString: string): SafeParseResult<RequireApproval, SDKValidationError>;
+/** @internal */
+export declare const McpServerTool$inboundSchema: z.ZodType<McpServerTool, unknown>;
+/** @internal */
+export type McpServerTool$Outbound = {
+    type: "mcp";
+    server_label: string;
+    allowed_tools?: any | null | undefined;
+    authorization?: string | undefined;
+    connector_id?: string | undefined;
+    headers?: {
+        [k: string]: string;
+    } | null | undefined;
+    require_approval?: any | null | undefined;
+    server_description?: string | undefined;
+    server_url?: string | undefined;
+};
+/** @internal */
+export declare const McpServerTool$outboundSchema: z.ZodType<McpServerTool$Outbound, McpServerTool>;
+export declare function mcpServerToolToJSON(mcpServerTool: McpServerTool): string;
+export declare function mcpServerToolFromJSON(jsonString: string): SafeParseResult<McpServerTool, SDKValidationError>;
+//# sourceMappingURL=mcpservertool.d.ts.map

package/esm/models/mcpservertool.js

@@ -0,0 +1,174 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ * @generated-id: 5e5a26b93ed7
+ */
+import * as z from "zod/v4";
+import { remap as remap$ } from "../lib/primitives.js";
+import { safeParse } from "../lib/schemas.js";
+import * as openEnums from "../types/enums.js";
+export const ConnectorId = {
+    ConnectorDropbox: "connector_dropbox",
+    ConnectorGmail: "connector_gmail",
+    ConnectorGooglecalendar: "connector_googlecalendar",
+    ConnectorGoogledrive: "connector_googledrive",
+    ConnectorMicrosoftteams: "connector_microsoftteams",
+    ConnectorOutlookcalendar: "connector_outlookcalendar",
+    ConnectorOutlookemail: "connector_outlookemail",
+    ConnectorSharepoint: "connector_sharepoint",
+};
+export const RequireApprovalNever = {
+    Never: "never",
+};
+export const RequireApprovalAlways = {
+    Always: "always",
+};
+/** @internal */
+export const AllowedTools$inboundSchema = z
+    .object({
+    tool_names: z.array(z.string()).optional(),
+    read_only: z.boolean().optional(),
+}).transform((v) => {
+    return remap$(v, {
+        "tool_names": "toolNames",
+        "read_only": "readOnly",
+    });
+});
+/** @internal */
+export const AllowedTools$outboundSchema = z.object({
+    toolNames: z.array(z.string()).optional(),
+    readOnly: z.boolean().optional(),
+}).transform((v) => {
+    return remap$(v, {
+        toolNames: "tool_names",
+        readOnly: "read_only",
+    });
+});
+export function allowedToolsToJSON(allowedTools) {
+    return JSON.stringify(AllowedTools$outboundSchema.parse(allowedTools));
+}
+export function allowedToolsFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => AllowedTools$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'AllowedTools' from JSON`);
+}
+/** @internal */
+export const ConnectorId$inboundSchema = openEnums.inboundSchema(ConnectorId);
+/** @internal */
+export const ConnectorId$outboundSchema = openEnums.outboundSchema(ConnectorId);
+/** @internal */
+export const RequireApprovalNever$inboundSchema = z.enum(RequireApprovalNever);
+/** @internal */
+export const RequireApprovalNever$outboundSchema = RequireApprovalNever$inboundSchema;
+/** @internal */
+export const RequireApprovalAlways$inboundSchema = z.enum(RequireApprovalAlways);
+/** @internal */
+export const RequireApprovalAlways$outboundSchema = RequireApprovalAlways$inboundSchema;
+/** @internal */
+export const Never$inboundSchema = z.object({
+    tool_names: z.array(z.string()).optional(),
+}).transform((v) => {
+    return remap$(v, {
+        "tool_names": "toolNames",
+    });
+});
+/** @internal */
+export const Never$outboundSchema = z.object({
+    toolNames: z.array(z.string()).optional(),
+}).transform((v) => {
+    return remap$(v, {
+        toolNames: "tool_names",
+    });
+});
+export function neverToJSON(never) {
+    return JSON.stringify(Never$outboundSchema.parse(never));
+}
+export function neverFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => Never$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'Never' from JSON`);
+}
+/** @internal */
+export const Always$inboundSchema = z.object({
+    tool_names: z.array(z.string()).optional(),
+}).transform((v) => {
+    return remap$(v, {
+        "tool_names": "toolNames",
+    });
+});
+/** @internal */
+export const Always$outboundSchema = z
+    .object({
+    toolNames: z.array(z.string()).optional(),
+}).transform((v) => {
+    return remap$(v, {
+        toolNames: "tool_names",
+    });
+});
+export function alwaysToJSON(always) {
+    return JSON.stringify(Always$outboundSchema.parse(always));
+}
+export function alwaysFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => Always$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'Always' from JSON`);
+}
+/** @internal */
+export const RequireApproval$inboundSchema = z.object({
+    never: z.lazy(() => Never$inboundSchema).optional(),
+    always: z.lazy(() => Always$inboundSchema).optional(),
+});
+/** @internal */
+export const RequireApproval$outboundSchema = z.object({
+    never: z.lazy(() => Never$outboundSchema).optional(),
+    always: z.lazy(() => Always$outboundSchema).optional(),
+});
+export function requireApprovalToJSON(requireApproval) {
+    return JSON.stringify(RequireApproval$outboundSchema.parse(requireApproval));
+}
+export function requireApprovalFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => RequireApproval$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'RequireApproval' from JSON`);
+}
+/** @internal */
+export const McpServerTool$inboundSchema = z
+    .object({
+    type: z.literal("mcp"),
+    server_label: z.string(),
+    allowed_tools: z.nullable(z.any()).optional(),
+    authorization: z.string().optional(),
+    connector_id: ConnectorId$inboundSchema.optional(),
+    headers: z.nullable(z.record(z.string(), z.string())).optional(),
+    require_approval: z.nullable(z.any()).optional(),
+    server_description: z.string().optional(),
+    server_url: z.string().optional(),
+}).transform((v) => {
+    return remap$(v, {
+        "server_label": "serverLabel",
+        "allowed_tools": "allowedTools",
+        "connector_id": "connectorId",
+        "require_approval": "requireApproval",
+        "server_description": "serverDescription",
+        "server_url": "serverUrl",
+    });
+});
+/** @internal */
+export const McpServerTool$outboundSchema = z.object({
+    type: z.literal("mcp"),
+    serverLabel: z.string(),
+    allowedTools: z.nullable(z.any()).optional(),
+    authorization: z.string().optional(),
+    connectorId: ConnectorId$outboundSchema.optional(),
+    headers: z.nullable(z.record(z.string(), z.string())).optional(),
+    requireApproval: z.nullable(z.any()).optional(),
+    serverDescription: z.string().optional(),
+    serverUrl: z.string().optional(),
+}).transform((v) => {
+    return remap$(v, {
+        serverLabel: "server_label",
+        allowedTools: "allowed_tools",
+        connectorId: "connector_id",
+        requireApproval: "require_approval",
+        serverDescription: "server_description",
+        serverUrl: "server_url",
+    });
+});
+export function mcpServerToolToJSON(mcpServerTool) {
+    return JSON.stringify(McpServerTool$outboundSchema.parse(mcpServerTool));
+}
+export function mcpServerToolFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => McpServerTool$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'McpServerTool' from JSON`);
+}
+//# sourceMappingURL=mcpservertool.js.map

package/esm/models/model.d.ts

@@ -63,6 +63,10 @@ export type Model = {
      * Default parameters for this model
      */
     defaultParameters: DefaultParameters | null;
+    /**
+     * The date up to which the model was trained on data. ISO 8601 date string (YYYY-MM-DD) or null if unknown.
+     */
+    knowledgeCutoff?: string | null | undefined;
     /**
      * The date after which the model may be removed. ISO 8601 date string (YYYY-MM-DD) or null if no expiration.
      */

package/esm/models/model.js

@@ -26,6 +26,7 @@ export const Model$inboundSchema = z.object({
     per_request_limits: z.nullable(PerRequestLimits$inboundSchema),
     supported_parameters: z.array(Parameter$inboundSchema),
     default_parameters: z.nullable(DefaultParameters$inboundSchema),
+    knowledge_cutoff: z.nullable(z.string()).optional(),
     expiration_date: z.nullable(z.string()).optional(),
 }).transform((v) => {
     return remap$(v, {
@@ -36,6 +37,7 @@ export const Model$inboundSchema = z.object({
         "per_request_limits": "perRequestLimits",
         "supported_parameters": "supportedParameters",
         "default_parameters": "defaultParameters",
+        "knowledge_cutoff": "knowledgeCutoff",
         "expiration_date": "expirationDate",
     });
 });

package/esm/models/openairesponsestruncation.d.ts

@@ -6,5 +6,5 @@ export declare const OpenAIResponsesTruncation: {
 };
 export type OpenAIResponsesTruncation = OpenEnum<typeof OpenAIResponsesTruncation>;
 /** @internal */
-export declare const OpenAIResponsesTruncation$inboundSchema: z.ZodType<OpenAIResponsesTruncation, unknown>;
+export declare const OpenAIResponsesTruncation$outboundSchema: z.ZodType<string, OpenAIResponsesTruncation>;
 //# sourceMappingURL=openairesponsestruncation.d.ts.map

package/esm/models/openairesponsestruncation.js

@@ -8,5 +8,5 @@ export const OpenAIResponsesTruncation = {
     Disabled: "disabled",
 };
 /** @internal */
-export const OpenAIResponsesTruncation$inboundSchema = openEnums.inboundSchema(OpenAIResponsesTruncation);
+export const OpenAIResponsesTruncation$outboundSchema = openEnums.outboundSchema(OpenAIResponsesTruncation);
 //# sourceMappingURL=openairesponsestruncation.js.map

package/esm/models/openresponsesresult.d.ts

@@ -0,0 +1,110 @@
+import * as z from "zod/v4";
+import { ClosedEnum } from "../types/enums.js";
+import { Result as SafeParseResult } from "../types/fp.js";
+import { ApplyPatchServerTool } from "./applypatchservertool.js";
+import { BaseInputsUnion } from "./baseinputsunion.js";
+import { BaseReasoningConfig } from "./basereasoningconfig.js";
+import { CodeInterpreterServerTool } from "./codeinterpreterservertool.js";
+import { CodexLocalShellTool } from "./codexlocalshelltool.js";
+import { ComputerUseServerTool } from "./computeruseservertool.js";
+import { CustomTool } from "./customtool.js";
+import { SDKValidationError } from "./errors/sdkvalidationerror.js";
+import { FileSearchServerTool } from "./filesearchservertool.js";
+import { ImageGenerationServerTool } from "./imagegenerationservertool.js";
+import { IncompleteDetails } from "./incompletedetails.js";
+import { LegacyWebSearchServerTool } from "./legacywebsearchservertool.js";
+import { McpServerTool } from "./mcpservertool.js";
+import { OpenAIResponsesResponseStatus } from "./openairesponsesresponsestatus.js";
+import { OpenAIResponsesToolChoiceUnion } from "./openairesponsestoolchoiceunion.js";
+import { OutputItems } from "./outputitems.js";
+import { Preview20250311WebSearchServerTool } from "./preview20250311websearchservertool.js";
+import { PreviewWebSearchServerTool } from "./previewwebsearchservertool.js";
+import { ResponsesErrorField } from "./responseserrorfield.js";
+import { ShellServerTool } from "./shellservertool.js";
+import { StoredPromptTemplate } from "./storedprompttemplate.js";
+import { TextConfig } from "./textconfig.js";
+import { TruncationEnum } from "./truncationenum.js";
+import { Usage } from "./usage.js";
+import { WebSearchServerTool } from "./websearchservertool.js";
+export declare const OpenResponsesResultObject: {
+    readonly Response: "response";
+};
+export type OpenResponsesResultObject = ClosedEnum<typeof OpenResponsesResultObject>;
+/**
+ * Function tool definition
+ */
+export type OpenResponsesResultToolFunction = {
+    type: "function";
+    name: string;
+    description?: string | null | undefined;
+    strict?: boolean | null | undefined;
+    parameters: {
+        [k: string]: any | null;
+    } | null;
+};
+export type OpenResponsesResultToolUnion = OpenResponsesResultToolFunction | PreviewWebSearchServerTool | Preview20250311WebSearchServerTool | LegacyWebSearchServerTool | WebSearchServerTool | FileSearchServerTool | ComputerUseServerTool | CodeInterpreterServerTool | McpServerTool | ImageGenerationServerTool | CodexLocalShellTool | ShellServerTool | ApplyPatchServerTool | CustomTool;
+/**
+ * Complete non-streaming response from the Responses API
+ */
+export type OpenResponsesResult = {
+    id: string;
+    object: OpenResponsesResultObject;
+    createdAt: number;
+    model: string;
+    status: OpenAIResponsesResponseStatus;
+    completedAt: number | null;
+    output: Array<OutputItems>;
+    user?: string | null | undefined;
+    outputText?: string | undefined;
+    promptCacheKey?: string | null | undefined;
+    safetyIdentifier?: string | null | undefined;
+    /**
+     * Error information returned from the API
+     */
+    error: ResponsesErrorField | null;
+    incompleteDetails: IncompleteDetails | null;
+    /**
+     * Token usage information for the response
+     */
+    usage?: Usage | null | undefined;
+    maxToolCalls?: number | null | undefined;
+    topLogprobs?: number | undefined;
+    maxOutputTokens?: number | null | undefined;
+    temperature: number | null;
+    topP: number | null;
+    presencePenalty: number | null;
+    frequencyPenalty: number | null;
+    instructions: BaseInputsUnion | null;
+    /**
+     * Metadata key-value pairs for the request. Keys must be ≤64 characters and cannot contain brackets. Values must be ≤512 characters. Maximum 16 pairs allowed.
+     */
+    metadata: {
+        [k: string]: string;
+    } | null;
+    tools: Array<OpenResponsesResultToolFunction | PreviewWebSearchServerTool | Preview20250311WebSearchServerTool | LegacyWebSearchServerTool | WebSearchServerTool | FileSearchServerTool | ComputerUseServerTool | CodeInterpreterServerTool | McpServerTool | ImageGenerationServerTool | CodexLocalShellTool | ShellServerTool | ApplyPatchServerTool | CustomTool>;
+    toolChoice: OpenAIResponsesToolChoiceUnion;
+    parallelToolCalls: boolean;
+    prompt?: StoredPromptTemplate | null | undefined;
+    background?: boolean | null | undefined;
+    previousResponseId?: string | null | undefined;
+    reasoning?: BaseReasoningConfig | null | undefined;
+    serviceTier?: string | null | undefined;
+    store?: boolean | undefined;
+    truncation?: TruncationEnum | null | undefined;
+    /**
+     * Text output configuration including format and verbosity
+     */
+    text?: TextConfig | undefined;
+};
+/** @internal */
+export declare const OpenResponsesResultObject$inboundSchema: z.ZodEnum<typeof OpenResponsesResultObject>;
+/** @internal */
+export declare const OpenResponsesResultToolFunction$inboundSchema: z.ZodType<OpenResponsesResultToolFunction, unknown>;
+export declare function openResponsesResultToolFunctionFromJSON(jsonString: string): SafeParseResult<OpenResponsesResultToolFunction, SDKValidationError>;
+/** @internal */
+export declare const OpenResponsesResultToolUnion$inboundSchema: z.ZodType<OpenResponsesResultToolUnion, unknown>;
+export declare function openResponsesResultToolUnionFromJSON(jsonString: string): SafeParseResult<OpenResponsesResultToolUnion, 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

@@ -0,0 +1,142 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ * @generated-id: 95391b93fcbf
+ */
+import * as z from "zod/v4";
+import { remap as remap$ } from "../lib/primitives.js";
+import { safeParse } from "../lib/schemas.js";
+import { ApplyPatchServerTool$inboundSchema, } from "./applypatchservertool.js";
+import { BaseInputsUnion$inboundSchema, } from "./baseinputsunion.js";
+import { BaseReasoningConfig$inboundSchema, } from "./basereasoningconfig.js";
+import { CodeInterpreterServerTool$inboundSchema, } from "./codeinterpreterservertool.js";
+import { CodexLocalShellTool$inboundSchema, } from "./codexlocalshelltool.js";
+import { ComputerUseServerTool$inboundSchema, } from "./computeruseservertool.js";
+import { CustomTool$inboundSchema } from "./customtool.js";
+import { FileSearchServerTool$inboundSchema, } from "./filesearchservertool.js";
+import { ImageGenerationServerTool$inboundSchema, } from "./imagegenerationservertool.js";
+import { IncompleteDetails$inboundSchema, } from "./incompletedetails.js";
+import { LegacyWebSearchServerTool$inboundSchema, } from "./legacywebsearchservertool.js";
+import { McpServerTool$inboundSchema } from "./mcpservertool.js";
+import { OpenAIResponsesResponseStatus$inboundSchema, } from "./openairesponsesresponsestatus.js";
+import { OpenAIResponsesToolChoiceUnion$inboundSchema, } from "./openairesponsestoolchoiceunion.js";
+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 { ShellServerTool$inboundSchema, } from "./shellservertool.js";
+import { StoredPromptTemplate$inboundSchema, } from "./storedprompttemplate.js";
+import { TextConfig$inboundSchema } from "./textconfig.js";
+import { TruncationEnum$inboundSchema, } from "./truncationenum.js";
+import { Usage$inboundSchema } from "./usage.js";
+import { WebSearchServerTool$inboundSchema, } from "./websearchservertool.js";
+export const OpenResponsesResultObject = {
+    Response: "response",
+};
+/** @internal */
+export const OpenResponsesResultObject$inboundSchema = z.enum(OpenResponsesResultObject);
+/** @internal */
+export const OpenResponsesResultToolFunction$inboundSchema = z.object({
+    type: z.literal("function"),
+    name: z.string(),
+    description: z.nullable(z.string()).optional(),
+    strict: z.nullable(z.boolean()).optional(),
+    parameters: z.nullable(z.record(z.string(), z.nullable(z.any()))),
+});
+export function openResponsesResultToolFunctionFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => OpenResponsesResultToolFunction$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'OpenResponsesResultToolFunction' from JSON`);
+}
+/** @internal */
+export const OpenResponsesResultToolUnion$inboundSchema = z.union([
+    z.lazy(() => OpenResponsesResultToolFunction$inboundSchema),
+    PreviewWebSearchServerTool$inboundSchema,
+    Preview20250311WebSearchServerTool$inboundSchema,
+    LegacyWebSearchServerTool$inboundSchema,
+    WebSearchServerTool$inboundSchema,
+    FileSearchServerTool$inboundSchema,
+    ComputerUseServerTool$inboundSchema,
+    CodeInterpreterServerTool$inboundSchema,
+    McpServerTool$inboundSchema,
+    ImageGenerationServerTool$inboundSchema,
+    CodexLocalShellTool$inboundSchema,
+    ShellServerTool$inboundSchema,
+    ApplyPatchServerTool$inboundSchema,
+    CustomTool$inboundSchema,
+]);
+export function openResponsesResultToolUnionFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => OpenResponsesResultToolUnion$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'OpenResponsesResultToolUnion' from JSON`);
+}
+/** @internal */
+export const OpenResponsesResult$inboundSchema = z.object({
+    id: z.string(),
+    object: OpenResponsesResultObject$inboundSchema,
+    created_at: z.number(),
+    model: z.string(),
+    status: OpenAIResponsesResponseStatus$inboundSchema,
+    completed_at: z.nullable(z.number()),
+    output: z.array(OutputItems$inboundSchema),
+    user: z.nullable(z.string()).optional(),
+    output_text: z.string().optional(),
+    prompt_cache_key: z.nullable(z.string()).optional(),
+    safety_identifier: z.nullable(z.string()).optional(),
+    error: z.nullable(ResponsesErrorField$inboundSchema),
+    incomplete_details: z.nullable(IncompleteDetails$inboundSchema),
+    usage: z.nullable(Usage$inboundSchema).optional(),
+    max_tool_calls: z.nullable(z.number()).optional(),
+    top_logprobs: z.number().optional(),
+    max_output_tokens: z.nullable(z.number()).optional(),
+    temperature: z.nullable(z.number()),
+    top_p: z.nullable(z.number()),
+    presence_penalty: z.nullable(z.number()),
+    frequency_penalty: z.nullable(z.number()),
+    instructions: z.nullable(BaseInputsUnion$inboundSchema),
+    metadata: z.nullable(z.record(z.string(), z.string())),
+    tools: z.array(z.union([
+        z.lazy(() => OpenResponsesResultToolFunction$inboundSchema),
+        PreviewWebSearchServerTool$inboundSchema,
+        Preview20250311WebSearchServerTool$inboundSchema,
+        LegacyWebSearchServerTool$inboundSchema,
+        WebSearchServerTool$inboundSchema,
+        FileSearchServerTool$inboundSchema,
+        ComputerUseServerTool$inboundSchema,
+        CodeInterpreterServerTool$inboundSchema,
+        McpServerTool$inboundSchema,
+        ImageGenerationServerTool$inboundSchema,
+        CodexLocalShellTool$inboundSchema,
+        ShellServerTool$inboundSchema,
+        ApplyPatchServerTool$inboundSchema,
+        CustomTool$inboundSchema,
+    ])),
+    tool_choice: OpenAIResponsesToolChoiceUnion$inboundSchema,
+    parallel_tool_calls: z.boolean(),
+    prompt: z.nullable(StoredPromptTemplate$inboundSchema).optional(),
+    background: z.nullable(z.boolean()).optional(),
+    previous_response_id: z.nullable(z.string()).optional(),
+    reasoning: z.nullable(BaseReasoningConfig$inboundSchema).optional(),
+    service_tier: z.nullable(z.string()).optional(),
+    store: z.boolean().optional(),
+    truncation: z.nullable(TruncationEnum$inboundSchema).optional(),
+    text: TextConfig$inboundSchema.optional(),
+}).transform((v) => {
+    return remap$(v, {
+        "created_at": "createdAt",
+        "completed_at": "completedAt",
+        "output_text": "outputText",
+        "prompt_cache_key": "promptCacheKey",
+        "safety_identifier": "safetyIdentifier",
+        "incomplete_details": "incompleteDetails",
+        "max_tool_calls": "maxToolCalls",
+        "top_logprobs": "topLogprobs",
+        "max_output_tokens": "maxOutputTokens",
+        "top_p": "topP",
+        "presence_penalty": "presencePenalty",
+        "frequency_penalty": "frequencyPenalty",
+        "tool_choice": "toolChoice",
+        "parallel_tool_calls": "parallelToolCalls",
+        "previous_response_id": "previousResponseId",
+        "service_tier": "serviceTier",
+    });
+});
+export function openResponsesResultFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => OpenResponsesResult$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'OpenResponsesResult' from JSON`);
+}
+//# sourceMappingURL=openresponsesresult.js.map

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

@@ -14,7 +14,13 @@ export type BulkAssignKeysToGuardrailGlobals = {
      *
      * @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;
 };
 export type BulkAssignKeysToGuardrailRequestBody = {
     /**
@@ -35,7 +41,13 @@ export type BulkAssignKeysToGuardrailRequest = {
      *
      * @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 unique identifier of the guardrail
      */
@@ -61,7 +73,8 @@ export declare function bulkAssignKeysToGuardrailRequestBodyToJSON(bulkAssignKey
 /** @internal */
 export type BulkAssignKeysToGuardrailRequest$Outbound = {
     "HTTP-Referer"?: string | undefined;
-    "X-Title"?: string | undefined;
+    appTitle?: string | undefined;
+    appCategories?: string | undefined;
     id: string;
     RequestBody: BulkAssignKeysToGuardrailRequestBody$Outbound;
 };

package/esm/models/operations/bulkassignkeystoguardrail.js

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