@openrouter/sdk 0.3.14 → 0.3.15

package/esm/lib/tool-types.d.ts

@@ -50,6 +50,12 @@ export type NextTurnParamsContext = {
 export type NextTurnParamsFunctions<TInput> = {
     [K in keyof NextTurnParamsContext]?: (params: TInput, context: NextTurnParamsContext) => NextTurnParamsContext[K] | Promise<NextTurnParamsContext[K]>;
 };
+/**
+ * Tool-level approval check function type
+ * Receives the tool's input params and turn context
+ * Returns true if approval is required, false otherwise
+ */
+export type ToolApprovalCheck<TInput> = (params: TInput, context: TurnContext) => boolean | Promise<boolean>;
 /**
  * Base tool function interface with inputSchema
  */
@@ -58,6 +64,11 @@ export interface BaseToolFunction<TInput extends $ZodObject<$ZodShape>> {
     description?: string;
     inputSchema: TInput;
     nextTurnParams?: NextTurnParamsFunctions<zodInfer<TInput>>;
+    /**
+     * Whether this tool requires human approval before execution
+     * Can be a boolean or an async function that receives the tool's input params and context
+     */
+    requireApproval?: boolean | ToolApprovalCheck<zodInfer<TInput>>;
 }
 /**
  * Regular tool with synchronous or asynchronous execute function and optional outputSchema
@@ -331,4 +342,101 @@ export type ChatStreamEvent<TEvent = unknown> = {
     type: string;
     event: OpenResponsesStreamEvent;
 };
+/**
+ * Result of a tool execution that hasn't been sent to the model yet
+ * Used for interrupted or awaiting approval states
+ * @template TTools - The tools array type for proper type inference
+ */
+export interface UnsentToolResult<TTools extends readonly Tool[] = readonly Tool[]> {
+    /** The ID of the tool call this result is for */
+    callId: string;
+    /** The name of the tool that was executed */
+    name: TTools[number]['function']['name'];
+    /** The output of the tool execution */
+    output: unknown;
+    /** Error message if the tool call was rejected or failed */
+    error?: string;
+}
+/**
+ * Partial response captured during interruption
+ * @template TTools - The tools array type for proper type inference
+ */
+export interface PartialResponse<TTools extends readonly Tool[] = readonly Tool[]> {
+    /** Partial text response accumulated before interruption */
+    text?: string;
+    /** Tool calls that were in progress when interrupted */
+    toolCalls?: Array<ParsedToolCall<TTools[number]>>;
+}
+/**
+ * Status of a conversation state
+ */
+export type ConversationStatus = 'complete' | 'interrupted' | 'awaiting_approval' | 'in_progress';
+/**
+ * State for multi-turn conversations with persistence and approval gates
+ * @template TTools - The tools array type for proper type inference
+ */
+export interface ConversationState<TTools extends readonly Tool[] = readonly Tool[]> {
+    /** Unique identifier for this conversation */
+    id: string;
+    /** Full message history */
+    messages: models.OpenResponsesInput;
+    /** Previous response ID for chaining (OpenRouter server-side optimization) */
+    previousResponseId?: string;
+    /** Tool calls awaiting human approval */
+    pendingToolCalls?: Array<ParsedToolCall<TTools[number]>>;
+    /** Tool results executed but not yet sent to the model */
+    unsentToolResults?: Array<UnsentToolResult<TTools>>;
+    /** Partial response data captured during interruption */
+    partialResponse?: PartialResponse<TTools>;
+    /** Signal from a new request to interrupt this conversation */
+    interruptedBy?: string;
+    /** Current status of the conversation */
+    status: ConversationStatus;
+    /** Creation timestamp (Unix ms) */
+    createdAt: number;
+    /** Last update timestamp (Unix ms) */
+    updatedAt: number;
+}
+/**
+ * State accessor for loading and saving conversation state
+ * Enables any storage backend (memory, Redis, database, etc.)
+ * @template TTools - The tools array type for proper type inference
+ */
+export interface StateAccessor<TTools extends readonly Tool[] = readonly Tool[]> {
+    /** Load the current conversation state, or null if none exists */
+    load: () => Promise<ConversationState<TTools> | null>;
+    /** Save the conversation state */
+    save: (state: ConversationState<TTools>) => Promise<void>;
+}
+/**
+ * Check if a single tool has approval configured (non-false, non-undefined)
+ * Returns true if the tool definitely requires approval,
+ * false if it definitely doesn't, or boolean if it's uncertain
+ */
+export type ToolHasApproval<T extends Tool> = T extends {
+    function: {
+        requireApproval: true | ToolApprovalCheck<unknown>;
+    };
+} ? true : T extends {
+    function: {
+        requireApproval: false;
+    };
+} ? false : T extends {
+    function: {
+        requireApproval: undefined;
+    };
+} ? false : boolean;
+/**
+ * Check if ANY tool in an array has approval configured
+ * Returns true if at least one tool might require approval
+ */
+export type HasApprovalTools<TTools extends readonly Tool[]> = TTools extends readonly [infer First extends Tool, ...infer Rest extends Tool[]] ? ToolHasApproval<First> extends true ? true : HasApprovalTools<Rest> : false;
+/**
+ * Type guard to check if a tool has approval configured at runtime
+ */
+export declare function toolHasApprovalConfigured(tool: Tool): boolean;
+/**
+ * Type guard to check if any tools in array have approval configured at runtime
+ */
+export declare function hasApprovalRequiredTools(tools: readonly Tool[]): boolean;
 //# sourceMappingURL=tool-types.d.ts.map

package/esm/lib/tool-types.js

@@ -35,4 +35,17 @@ export function isManualTool(tool) {
 export function isToolPreliminaryResultEvent(event) {
     return event.type === 'tool.preliminary_result';
 }
+/**
+ * Type guard to check if a tool has approval configured at runtime
+ */
+export function toolHasApprovalConfigured(tool) {
+    const requireApproval = tool.function.requireApproval;
+    return requireApproval === true || typeof requireApproval === 'function';
+}
+/**
+ * Type guard to check if any tools in array have approval configured at runtime
+ */
+export function hasApprovalRequiredTools(tools) {
+    return tools.some(toolHasApprovalConfigured);
+}
 //# sourceMappingURL=tool-types.js.map

package/esm/lib/tool.d.ts

@@ -1,5 +1,5 @@
 import type { $ZodObject, $ZodShape, $ZodType, infer as zodInfer } from 'zod/v4/core';
-import { type TurnContext, type ToolWithExecute, type ToolWithGenerator, type ManualTool, type NextTurnParamsFunctions } from "./tool-types.js";
+import { type TurnContext, type ToolWithExecute, type ToolWithGenerator, type ManualTool, type NextTurnParamsFunctions, type ToolApprovalCheck } from "./tool-types.js";
 /**
  * Configuration for a regular tool with outputSchema
  */
@@ -10,6 +10,11 @@ type RegularToolConfigWithOutput<TInput extends $ZodObject<$ZodShape>, TOutput e
     outputSchema: TOutput;
     eventSchema?: undefined;
     nextTurnParams?: NextTurnParamsFunctions<zodInfer<TInput>>;
+    /**
+     * Whether this tool requires human approval before execution
+     * Can be a boolean or an async function that receives the tool's input params and context
+     */
+    requireApproval?: boolean | ToolApprovalCheck<zodInfer<TInput>>;
     execute: (params: zodInfer<TInput>, context?: TurnContext) => Promise<zodInfer<TOutput>> | zodInfer<TOutput>;
 };
 /**
@@ -22,6 +27,11 @@ type RegularToolConfigWithoutOutput<TInput extends $ZodObject<$ZodShape>, TRetur
     outputSchema?: undefined;
     eventSchema?: undefined;
     nextTurnParams?: NextTurnParamsFunctions<zodInfer<TInput>>;
+    /**
+     * Whether this tool requires human approval before execution
+     * Can be a boolean or an async function that receives the tool's input params and context
+     */
+    requireApproval?: boolean | ToolApprovalCheck<zodInfer<TInput>>;
     execute: (params: zodInfer<TInput>, context?: TurnContext) => Promise<TReturn> | TReturn;
 };
 /**
@@ -34,6 +44,11 @@ type GeneratorToolConfig<TInput extends $ZodObject<$ZodShape>, TEvent extends $Z
     eventSchema: TEvent;
     outputSchema: TOutput;
     nextTurnParams?: NextTurnParamsFunctions<zodInfer<TInput>>;
+    /**
+     * Whether this tool requires human approval before execution
+     * Can be a boolean or an async function that receives the tool's input params and context
+     */
+    requireApproval?: boolean | ToolApprovalCheck<zodInfer<TInput>>;
     execute: (params: zodInfer<TInput>, context?: TurnContext) => AsyncGenerator<zodInfer<TEvent> | zodInfer<TOutput>>;
 };
 /**
@@ -44,6 +59,11 @@ type ManualToolConfig<TInput extends $ZodObject<$ZodShape>> = {
     description?: string;
     inputSchema: TInput;
     nextTurnParams?: NextTurnParamsFunctions<zodInfer<TInput>>;
+    /**
+     * Whether this tool requires human approval before execution
+     * Can be a boolean or an async function that receives the tool's input params and context
+     */
+    requireApproval?: boolean | ToolApprovalCheck<zodInfer<TInput>>;
     execute: false;
 };
 /**

package/esm/lib/tool.js

@@ -25,6 +25,9 @@ export function tool(config) {
         if (config.nextTurnParams !== undefined) {
             fn.nextTurnParams = config.nextTurnParams;
         }
+        if (config.requireApproval !== undefined) {
+            fn.requireApproval = config.requireApproval;
+        }
         return {
             type: ToolType.Function,
             function: fn,
@@ -46,6 +49,9 @@ export function tool(config) {
         if (config.nextTurnParams !== undefined) {
             fn.nextTurnParams = config.nextTurnParams;
         }
+        if (config.requireApproval !== undefined) {
+            fn.requireApproval = config.requireApproval;
+        }
         return {
             type: ToolType.Function,
             function: fn,
@@ -61,6 +67,7 @@ export function tool(config) {
         ...(config.description !== undefined && { description: config.description }),
         ...(config.outputSchema !== undefined && { outputSchema: config.outputSchema }),
         ...(config.nextTurnParams !== undefined && { nextTurnParams: config.nextTurnParams }),
+        ...(config.requireApproval !== undefined && { requireApproval: config.requireApproval }),
     };
     // The function signature guarantees this is type-safe via overloads
     return {

package/esm/models/assistantmessage.d.ts

@@ -3,7 +3,14 @@ import { Result as SafeParseResult } from "../types/fp.js";
 import { ChatMessageContentItem, ChatMessageContentItem$Outbound } from "./chatmessagecontentitem.js";
 import { ChatMessageToolCall, ChatMessageToolCall$Outbound } from "./chatmessagetoolcall.js";
 import { SDKValidationError } from "./errors/sdkvalidationerror.js";
+import { Schema2, Schema2$Outbound } from "./schema2.js";
 export type AssistantMessageContent = string | Array<ChatMessageContentItem>;
+export type AssistantMessageImageUrl = {
+    url: string;
+};
+export type Image = {
+    imageUrl: AssistantMessageImageUrl;
+};
 export type AssistantMessage = {
     role: "assistant";
     content?: string | Array<ChatMessageContentItem> | null | undefined;
@@ -11,6 +18,8 @@ export type AssistantMessage = {
     toolCalls?: Array<ChatMessageToolCall> | undefined;
     refusal?: string | null | undefined;
     reasoning?: string | null | undefined;
+    reasoningDetails?: Array<Schema2> | undefined;
+    images?: Array<Image> | undefined;
 };
 /** @internal */
 export declare const AssistantMessageContent$inboundSchema: z.ZodType<AssistantMessageContent, unknown>;
@@ -21,6 +30,26 @@ export declare const AssistantMessageContent$outboundSchema: z.ZodType<Assistant
 export declare function assistantMessageContentToJSON(assistantMessageContent: AssistantMessageContent): string;
 export declare function assistantMessageContentFromJSON(jsonString: string): SafeParseResult<AssistantMessageContent, SDKValidationError>;
 /** @internal */
+export declare const AssistantMessageImageUrl$inboundSchema: z.ZodType<AssistantMessageImageUrl, unknown>;
+/** @internal */
+export type AssistantMessageImageUrl$Outbound = {
+    url: string;
+};
+/** @internal */
+export declare const AssistantMessageImageUrl$outboundSchema: z.ZodType<AssistantMessageImageUrl$Outbound, AssistantMessageImageUrl>;
+export declare function assistantMessageImageUrlToJSON(assistantMessageImageUrl: AssistantMessageImageUrl): string;
+export declare function assistantMessageImageUrlFromJSON(jsonString: string): SafeParseResult<AssistantMessageImageUrl, SDKValidationError>;
+/** @internal */
+export declare const Image$inboundSchema: z.ZodType<Image, unknown>;
+/** @internal */
+export type Image$Outbound = {
+    image_url: AssistantMessageImageUrl$Outbound;
+};
+/** @internal */
+export declare const Image$outboundSchema: z.ZodType<Image$Outbound, Image>;
+export declare function imageToJSON(image: Image): string;
+export declare function imageFromJSON(jsonString: string): SafeParseResult<Image, SDKValidationError>;
+/** @internal */
 export declare const AssistantMessage$inboundSchema: z.ZodType<AssistantMessage, unknown>;
 /** @internal */
 export type AssistantMessage$Outbound = {
@@ -30,6 +59,8 @@ export type AssistantMessage$Outbound = {
     tool_calls?: Array<ChatMessageToolCall$Outbound> | undefined;
     refusal?: string | null | undefined;
     reasoning?: string | null | undefined;
+    reasoning_details?: Array<Schema2$Outbound> | undefined;
+    images?: Array<Image$Outbound> | undefined;
 };
 /** @internal */
 export declare const AssistantMessage$outboundSchema: z.ZodType<AssistantMessage$Outbound, AssistantMessage>;

package/esm/models/assistantmessage.js

@@ -7,6 +7,7 @@ import { remap as remap$ } from "../lib/primitives.js";
 import { safeParse } from "../lib/schemas.js";
 import { ChatMessageContentItem$inboundSchema, ChatMessageContentItem$outboundSchema, } from "./chatmessagecontentitem.js";
 import { ChatMessageToolCall$inboundSchema, ChatMessageToolCall$outboundSchema, } from "./chatmessagetoolcall.js";
+import { Schema2$inboundSchema, Schema2$outboundSchema, } from "./schema2.js";
 /** @internal */
 export const AssistantMessageContent$inboundSchema = z.union([z.string(), z.array(ChatMessageContentItem$inboundSchema)]);
 /** @internal */
@@ -18,6 +19,42 @@ export function assistantMessageContentFromJSON(jsonString) {
     return safeParse(jsonString, (x) => AssistantMessageContent$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'AssistantMessageContent' from JSON`);
 }
 /** @internal */
+export const AssistantMessageImageUrl$inboundSchema = z.object({
+    url: z.string(),
+});
+/** @internal */
+export const AssistantMessageImageUrl$outboundSchema = z.object({
+    url: z.string(),
+});
+export function assistantMessageImageUrlToJSON(assistantMessageImageUrl) {
+    return JSON.stringify(AssistantMessageImageUrl$outboundSchema.parse(assistantMessageImageUrl));
+}
+export function assistantMessageImageUrlFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => AssistantMessageImageUrl$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'AssistantMessageImageUrl' from JSON`);
+}
+/** @internal */
+export const Image$inboundSchema = z.object({
+    image_url: z.lazy(() => AssistantMessageImageUrl$inboundSchema),
+}).transform((v) => {
+    return remap$(v, {
+        "image_url": "imageUrl",
+    });
+});
+/** @internal */
+export const Image$outboundSchema = z.object({
+    imageUrl: z.lazy(() => AssistantMessageImageUrl$outboundSchema),
+}).transform((v) => {
+    return remap$(v, {
+        imageUrl: "image_url",
+    });
+});
+export function imageToJSON(image) {
+    return JSON.stringify(Image$outboundSchema.parse(image));
+}
+export function imageFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => Image$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'Image' from JSON`);
+}
+/** @internal */
 export const AssistantMessage$inboundSchema = z.object({
     role: z.literal("assistant"),
     content: z.nullable(z.union([z.string(), z.array(ChatMessageContentItem$inboundSchema)])).optional(),
@@ -25,9 +62,12 @@ export const AssistantMessage$inboundSchema = z.object({
     tool_calls: z.array(ChatMessageToolCall$inboundSchema).optional(),
     refusal: z.nullable(z.string()).optional(),
     reasoning: z.nullable(z.string()).optional(),
+    reasoning_details: z.array(Schema2$inboundSchema).optional(),
+    images: z.array(z.lazy(() => Image$inboundSchema)).optional(),
 }).transform((v) => {
     return remap$(v, {
         "tool_calls": "toolCalls",
+        "reasoning_details": "reasoningDetails",
     });
 });
 /** @internal */
@@ -38,9 +78,12 @@ export const AssistantMessage$outboundSchema = z.object({
     toolCalls: z.array(ChatMessageToolCall$outboundSchema).optional(),
     refusal: z.nullable(z.string()).optional(),
     reasoning: z.nullable(z.string()).optional(),
+    reasoningDetails: z.array(Schema2$outboundSchema).optional(),
+    images: z.array(z.lazy(() => Image$outboundSchema)).optional(),
 }).transform((v) => {
     return remap$(v, {
         toolCalls: "tool_calls",
+        reasoningDetails: "reasoning_details",
     });
 });
 export function assistantMessageToJSON(assistantMessage) {

package/esm/models/chatmessagecontentitemimage.d.ts

@@ -8,35 +8,35 @@ export declare const ChatMessageContentItemImageDetail: {
     readonly High: "high";
 };
 export type ChatMessageContentItemImageDetail = OpenEnum<typeof ChatMessageContentItemImageDetail>;
-export type ImageUrl = {
+export type ChatMessageContentItemImageImageUrl = {
     url: string;
     detail?: ChatMessageContentItemImageDetail | undefined;
 };
 export type ChatMessageContentItemImage = {
     type: "image_url";
-    imageUrl: ImageUrl;
+    imageUrl: ChatMessageContentItemImageImageUrl;
 };
 /** @internal */
 export declare const ChatMessageContentItemImageDetail$inboundSchema: z.ZodType<ChatMessageContentItemImageDetail, unknown>;
 /** @internal */
 export declare const ChatMessageContentItemImageDetail$outboundSchema: z.ZodType<string, ChatMessageContentItemImageDetail>;
 /** @internal */
-export declare const ImageUrl$inboundSchema: z.ZodType<ImageUrl, unknown>;
+export declare const ChatMessageContentItemImageImageUrl$inboundSchema: z.ZodType<ChatMessageContentItemImageImageUrl, unknown>;
 /** @internal */
-export type ImageUrl$Outbound = {
+export type ChatMessageContentItemImageImageUrl$Outbound = {
     url: string;
     detail?: string | undefined;
 };
 /** @internal */
-export declare const ImageUrl$outboundSchema: z.ZodType<ImageUrl$Outbound, ImageUrl>;
-export declare function imageUrlToJSON(imageUrl: ImageUrl): string;
-export declare function imageUrlFromJSON(jsonString: string): SafeParseResult<ImageUrl, SDKValidationError>;
+export declare const ChatMessageContentItemImageImageUrl$outboundSchema: z.ZodType<ChatMessageContentItemImageImageUrl$Outbound, ChatMessageContentItemImageImageUrl>;
+export declare function chatMessageContentItemImageImageUrlToJSON(chatMessageContentItemImageImageUrl: ChatMessageContentItemImageImageUrl): string;
+export declare function chatMessageContentItemImageImageUrlFromJSON(jsonString: string): SafeParseResult<ChatMessageContentItemImageImageUrl, SDKValidationError>;
 /** @internal */
 export declare const ChatMessageContentItemImage$inboundSchema: z.ZodType<ChatMessageContentItemImage, unknown>;
 /** @internal */
 export type ChatMessageContentItemImage$Outbound = {
     type: "image_url";
-    image_url: ImageUrl$Outbound;
+    image_url: ChatMessageContentItemImageImageUrl$Outbound;
 };
 /** @internal */
 export declare const ChatMessageContentItemImage$outboundSchema: z.ZodType<ChatMessageContentItemImage$Outbound, ChatMessageContentItemImage>;

package/esm/models/chatmessagecontentitemimage.js

@@ -16,26 +16,25 @@ export const ChatMessageContentItemImageDetail$inboundSchema = openEnums.inbound
 /** @internal */
 export const ChatMessageContentItemImageDetail$outboundSchema = openEnums.outboundSchema(ChatMessageContentItemImageDetail);
 /** @internal */
-export const ImageUrl$inboundSchema = z.object({
+export const ChatMessageContentItemImageImageUrl$inboundSchema = z.object({
     url: z.string(),
     detail: ChatMessageContentItemImageDetail$inboundSchema.optional(),
 });
 /** @internal */
-export const ImageUrl$outboundSchema = z
-    .object({
+export const ChatMessageContentItemImageImageUrl$outboundSchema = z.object({
     url: z.string(),
     detail: ChatMessageContentItemImageDetail$outboundSchema.optional(),
 });
-export function imageUrlToJSON(imageUrl) {
-    return JSON.stringify(ImageUrl$outboundSchema.parse(imageUrl));
+export function chatMessageContentItemImageImageUrlToJSON(chatMessageContentItemImageImageUrl) {
+    return JSON.stringify(ChatMessageContentItemImageImageUrl$outboundSchema.parse(chatMessageContentItemImageImageUrl));
 }
-export function imageUrlFromJSON(jsonString) {
-    return safeParse(jsonString, (x) => ImageUrl$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'ImageUrl' from JSON`);
+export function chatMessageContentItemImageImageUrlFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => ChatMessageContentItemImageImageUrl$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'ChatMessageContentItemImageImageUrl' from JSON`);
 }
 /** @internal */
 export const ChatMessageContentItemImage$inboundSchema = z.object({
     type: z.literal("image_url"),
-    image_url: z.lazy(() => ImageUrl$inboundSchema),
+    image_url: z.lazy(() => ChatMessageContentItemImageImageUrl$inboundSchema),
 }).transform((v) => {
     return remap$(v, {
         "image_url": "imageUrl",
@@ -44,7 +43,7 @@ export const ChatMessageContentItemImage$inboundSchema = z.object({
 /** @internal */
 export const ChatMessageContentItemImage$outboundSchema = z.object({
     type: z.literal("image_url"),
-    imageUrl: z.lazy(() => ImageUrl$outboundSchema),
+    imageUrl: z.lazy(() => ChatMessageContentItemImageImageUrl$outboundSchema),
 }).transform((v) => {
     return remap$(v, {
         imageUrl: "image_url",

package/esm/models/chatresponsechoice.d.ts

@@ -4,12 +4,10 @@ import { AssistantMessage } from "./assistantmessage.js";
 import { ChatCompletionFinishReason } from "./chatcompletionfinishreason.js";
 import { ChatMessageTokenLogprobs } from "./chatmessagetokenlogprobs.js";
 import { SDKValidationError } from "./errors/sdkvalidationerror.js";
-import { Schema3 } from "./schema3.js";
 export type ChatResponseChoice = {
     finishReason: ChatCompletionFinishReason | null;
     index: number;
     message: AssistantMessage;
-    reasoningDetails?: Array<Schema3> | undefined;
     logprobs?: ChatMessageTokenLogprobs | null | undefined;
 };
 /** @internal */

package/esm/models/chatresponsechoice.js

@@ -8,18 +8,15 @@ import { safeParse } from "../lib/schemas.js";
 import { AssistantMessage$inboundSchema, } from "./assistantmessage.js";
 import { ChatCompletionFinishReason$inboundSchema, } from "./chatcompletionfinishreason.js";
 import { ChatMessageTokenLogprobs$inboundSchema, } from "./chatmessagetokenlogprobs.js";
-import { Schema3$inboundSchema } from "./schema3.js";
 /** @internal */
 export const ChatResponseChoice$inboundSchema = z.object({
     finish_reason: z.nullable(ChatCompletionFinishReason$inboundSchema),
     index: z.number(),
     message: AssistantMessage$inboundSchema,
-    reasoning_details: z.array(Schema3$inboundSchema).optional(),
     logprobs: z.nullable(ChatMessageTokenLogprobs$inboundSchema).optional(),
 }).transform((v) => {
     return remap$(v, {
         "finish_reason": "finishReason",
-        "reasoning_details": "reasoningDetails",
     });
 });
 export function chatResponseChoiceFromJSON(jsonString) {

package/esm/models/chatstreamingmessagechunk.d.ts

@@ -3,7 +3,7 @@ import { ClosedEnum } from "../types/enums.js";
 import { Result as SafeParseResult } from "../types/fp.js";
 import { ChatStreamingMessageToolCall } from "./chatstreamingmessagetoolcall.js";
 import { SDKValidationError } from "./errors/sdkvalidationerror.js";
-import { Schema3 } from "./schema3.js";
+import { Schema2 } from "./schema2.js";
 export declare const ChatStreamingMessageChunkRole: {
     readonly Assistant: "assistant";
 };
@@ -14,7 +14,7 @@ export type ChatStreamingMessageChunk = {
     reasoning?: string | null | undefined;
     refusal?: string | null | undefined;
     toolCalls?: Array<ChatStreamingMessageToolCall> | undefined;
-    reasoningDetails?: Array<Schema3> | undefined;
+    reasoningDetails?: Array<Schema2> | undefined;
 };
 /** @internal */
 export declare const ChatStreamingMessageChunkRole$inboundSchema: z.ZodEnum<typeof ChatStreamingMessageChunkRole>;

package/esm/models/chatstreamingmessagechunk.js

@@ -6,7 +6,7 @@ import * as z from "zod/v4";
 import { remap as remap$ } from "../lib/primitives.js";
 import { safeParse } from "../lib/schemas.js";
 import { ChatStreamingMessageToolCall$inboundSchema, } from "./chatstreamingmessagetoolcall.js";
-import { Schema3$inboundSchema } from "./schema3.js";
+import { Schema2$inboundSchema } from "./schema2.js";
 export const ChatStreamingMessageChunkRole = {
     Assistant: "assistant",
 };
@@ -19,7 +19,7 @@ export const ChatStreamingMessageChunk$inboundSchema = z.object({
     reasoning: z.nullable(z.string()).optional(),
     refusal: z.nullable(z.string()).optional(),
     tool_calls: z.array(ChatStreamingMessageToolCall$inboundSchema).optional(),
-    reasoning_details: z.array(Schema3$inboundSchema).optional(),
+    reasoning_details: z.array(Schema2$inboundSchema).optional(),
 }).transform((v) => {
     return remap$(v, {
         "tool_calls": "toolCalls",

package/esm/models/index.d.ts

@@ -141,7 +141,7 @@ export * from "./responseswebsearchcalloutput.js";
 export * from "./responseswebsearchuserlocation.js";
 export * from "./responsetextconfig.js";
 export * from "./schema0.js";
-export * from "./schema3.js";
+export * from "./schema2.js";
 export * from "./security.js";
 export * from "./serviceunavailableresponseerrordata.js";
 export * from "./systemmessage.js";

package/esm/models/index.js

@@ -145,7 +145,7 @@ export * from "./responseswebsearchcalloutput.js";
 export * from "./responseswebsearchuserlocation.js";
 export * from "./responsetextconfig.js";
 export * from "./schema0.js";
-export * from "./schema3.js";
+export * from "./schema2.js";
 export * from "./security.js";
 export * from "./serviceunavailableresponseerrordata.js";
 export * from "./systemmessage.js";

package/esm/models/model.d.ts

@@ -63,6 +63,10 @@ export type Model = {
      * Default parameters for this model
      */
     defaultParameters: DefaultParameters | null;
+    /**
+     * The date after which the model may be removed. ISO 8601 date string (YYYY-MM-DD) or null if no expiration.
+     */
+    expirationDate?: string | null | undefined;
 };
 /** @internal */
 export declare const Model$inboundSchema: z.ZodType<Model, unknown>;

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),
+    expiration_date: z.nullable(z.string()).optional(),
 }).transform((v) => {
     return remap$(v, {
         "canonical_slug": "canonicalSlug",
@@ -35,6 +36,7 @@ export const Model$inboundSchema = z.object({
         "per_request_limits": "perRequestLimits",
         "supported_parameters": "supportedParameters",
         "default_parameters": "defaultParameters",
+        "expiration_date": "expirationDate",
     });
 });
 export function modelFromJSON(jsonString) {

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

@@ -0,0 +1,44 @@
+import * as z from "zod/v4";
+import { Result as SafeParseResult } from "../../types/fp.js";
+import { SDKValidationError } from "../errors/sdkvalidationerror.js";
+export type BulkAssignKeysToGuardrailRequestBody = {
+    /**
+     * Array of API key hashes to assign to the guardrail
+     */
+    keyHashes: Array<string>;
+};
+export type BulkAssignKeysToGuardrailRequest = {
+    /**
+     * The unique identifier of the guardrail
+     */
+    id: string;
+    requestBody: BulkAssignKeysToGuardrailRequestBody;
+};
+/**
+ * Assignment result
+ */
+export type BulkAssignKeysToGuardrailResponse = {
+    /**
+     * Number of keys successfully assigned
+     */
+    assignedCount: number;
+};
+/** @internal */
+export type BulkAssignKeysToGuardrailRequestBody$Outbound = {
+    key_hashes: Array<string>;
+};
+/** @internal */
+export declare const BulkAssignKeysToGuardrailRequestBody$outboundSchema: z.ZodType<BulkAssignKeysToGuardrailRequestBody$Outbound, BulkAssignKeysToGuardrailRequestBody>;
+export declare function bulkAssignKeysToGuardrailRequestBodyToJSON(bulkAssignKeysToGuardrailRequestBody: BulkAssignKeysToGuardrailRequestBody): string;
+/** @internal */
+export type BulkAssignKeysToGuardrailRequest$Outbound = {
+    id: string;
+    RequestBody: BulkAssignKeysToGuardrailRequestBody$Outbound;
+};
+/** @internal */
+export declare const BulkAssignKeysToGuardrailRequest$outboundSchema: z.ZodType<BulkAssignKeysToGuardrailRequest$Outbound, BulkAssignKeysToGuardrailRequest>;
+export declare function bulkAssignKeysToGuardrailRequestToJSON(bulkAssignKeysToGuardrailRequest: BulkAssignKeysToGuardrailRequest): string;
+/** @internal */
+export declare const BulkAssignKeysToGuardrailResponse$inboundSchema: z.ZodType<BulkAssignKeysToGuardrailResponse, unknown>;
+export declare function bulkAssignKeysToGuardrailResponseFromJSON(jsonString: string): SafeParseResult<BulkAssignKeysToGuardrailResponse, SDKValidationError>;
+//# sourceMappingURL=bulkassignkeystoguardrail.d.ts.map

package/esm/models/operations/bulkassignkeystoguardrail.js

@@ -0,0 +1,42 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ * @generated-id: 4f855e3ea589
+ */
+import * as z from "zod/v4";
+import { remap as remap$ } from "../../lib/primitives.js";
+import { safeParse } from "../../lib/schemas.js";
+/** @internal */
+export const BulkAssignKeysToGuardrailRequestBody$outboundSchema = z.object({
+    keyHashes: z.array(z.string()),
+}).transform((v) => {
+    return remap$(v, {
+        keyHashes: "key_hashes",
+    });
+});
+export function bulkAssignKeysToGuardrailRequestBodyToJSON(bulkAssignKeysToGuardrailRequestBody) {
+    return JSON.stringify(BulkAssignKeysToGuardrailRequestBody$outboundSchema.parse(bulkAssignKeysToGuardrailRequestBody));
+}
+/** @internal */
+export const BulkAssignKeysToGuardrailRequest$outboundSchema = z.object({
+    id: z.string(),
+    requestBody: z.lazy(() => BulkAssignKeysToGuardrailRequestBody$outboundSchema),
+}).transform((v) => {
+    return remap$(v, {
+        requestBody: "RequestBody",
+    });
+});
+export function bulkAssignKeysToGuardrailRequestToJSON(bulkAssignKeysToGuardrailRequest) {
+    return JSON.stringify(BulkAssignKeysToGuardrailRequest$outboundSchema.parse(bulkAssignKeysToGuardrailRequest));
+}
+/** @internal */
+export const BulkAssignKeysToGuardrailResponse$inboundSchema = z.object({
+    assigned_count: z.number(),
+}).transform((v) => {
+    return remap$(v, {
+        "assigned_count": "assignedCount",
+    });
+});
+export function bulkAssignKeysToGuardrailResponseFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => BulkAssignKeysToGuardrailResponse$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'BulkAssignKeysToGuardrailResponse' from JSON`);
+}
+//# sourceMappingURL=bulkassignkeystoguardrail.js.map