@openrouter/sdk 0.10.2 → 0.12.0

package/esm/models/chattoolchoice.js

@@ -0,0 +1,32 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ * @generated-id: f553e5b216ba
+ */
+import * as z from "zod/v4";
+import { ChatNamedToolChoice$outboundSchema, } from "./chatnamedtoolchoice.js";
+export const ChatToolChoiceRequired = {
+    Required: "required",
+};
+export const ChatToolChoiceAuto = {
+    Auto: "auto",
+};
+export const ChatToolChoiceNone = {
+    None: "none",
+};
+/** @internal */
+export const ChatToolChoiceRequired$outboundSchema = z.enum(ChatToolChoiceRequired);
+/** @internal */
+export const ChatToolChoiceAuto$outboundSchema = z.enum(ChatToolChoiceAuto);
+/** @internal */
+export const ChatToolChoiceNone$outboundSchema = z.enum(ChatToolChoiceNone);
+/** @internal */
+export const ChatToolChoice$outboundSchema = z.union([
+    ChatNamedToolChoice$outboundSchema,
+    ChatToolChoiceNone$outboundSchema,
+    ChatToolChoiceAuto$outboundSchema,
+    ChatToolChoiceRequired$outboundSchema,
+]);
+export function chatToolChoiceToJSON(chatToolChoice) {
+    return JSON.stringify(ChatToolChoice$outboundSchema.parse(chatToolChoice));
+}
+//# sourceMappingURL=chattoolchoice.js.map

package/esm/models/chattoolmessage.d.ts

@@ -0,0 +1,35 @@
+import * as z from "zod/v4";
+import { ChatContentItems, ChatContentItems$Outbound } from "./chatcontentitems.js";
+/**
+ * Tool response content
+ */
+export type ChatToolMessageContent = string | Array<ChatContentItems>;
+/**
+ * Tool response message
+ */
+export type ChatToolMessage = {
+    /**
+     * Tool response content
+     */
+    content: string | Array<ChatContentItems>;
+    role: "tool";
+    /**
+     * ID of the assistant message tool call this message responds to
+     */
+    toolCallId: string;
+};
+/** @internal */
+export type ChatToolMessageContent$Outbound = string | Array<ChatContentItems$Outbound>;
+/** @internal */
+export declare const ChatToolMessageContent$outboundSchema: z.ZodType<ChatToolMessageContent$Outbound, ChatToolMessageContent>;
+export declare function chatToolMessageContentToJSON(chatToolMessageContent: ChatToolMessageContent): string;
+/** @internal */
+export type ChatToolMessage$Outbound = {
+    content: string | Array<ChatContentItems$Outbound>;
+    role: "tool";
+    tool_call_id: string;
+};
+/** @internal */
+export declare const ChatToolMessage$outboundSchema: z.ZodType<ChatToolMessage$Outbound, ChatToolMessage>;
+export declare function chatToolMessageToJSON(chatToolMessage: ChatToolMessage): string;
+//# sourceMappingURL=chattoolmessage.d.ts.map

package/esm/models/chattoolmessage.js

@@ -0,0 +1,26 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ * @generated-id: 446b465db30a
+ */
+import * as z from "zod/v4";
+import { remap as remap$ } from "../lib/primitives.js";
+import { ChatContentItems$outboundSchema, } from "./chatcontentitems.js";
+/** @internal */
+export const ChatToolMessageContent$outboundSchema = z.union([z.string(), z.array(ChatContentItems$outboundSchema)]);
+export function chatToolMessageContentToJSON(chatToolMessageContent) {
+    return JSON.stringify(ChatToolMessageContent$outboundSchema.parse(chatToolMessageContent));
+}
+/** @internal */
+export const ChatToolMessage$outboundSchema = z.object({
+    content: z.union([z.string(), z.array(ChatContentItems$outboundSchema)]),
+    role: z.literal("tool"),
+    toolCallId: z.string(),
+}).transform((v) => {
+    return remap$(v, {
+        toolCallId: "tool_call_id",
+    });
+});
+export function chatToolMessageToJSON(chatToolMessage) {
+    return JSON.stringify(ChatToolMessage$outboundSchema.parse(chatToolMessage));
+}
+//# sourceMappingURL=chattoolmessage.js.map

package/esm/models/{chatgenerationtokenusage.d.ts → chatusage.d.ts}

@@ -6,38 +6,38 @@ import { SDKValidationError } from "./errors/sdkvalidationerror.js";
  */
 export type CompletionTokensDetails = {
     /**
-     * Tokens used for reasoning
+     * Accepted prediction tokens
      */
-    reasoningTokens?: number | null | undefined;
+    acceptedPredictionTokens?: number | undefined;
     /**
      * Tokens used for audio output
      */
-    audioTokens?: number | null | undefined;
+    audioTokens?: number | undefined;
     /**
-     * Accepted prediction tokens
+     * Tokens used for reasoning
      */
-    acceptedPredictionTokens?: number | null | undefined;
+    reasoningTokens?: number | undefined;
     /**
      * Rejected prediction tokens
      */
-    rejectedPredictionTokens?: number | null | undefined;
+    rejectedPredictionTokens?: number | undefined;
 };
 /**
  * Detailed prompt token usage
  */
 export type PromptTokensDetails = {
     /**
-     * Cached prompt tokens
+     * Audio input tokens
      */
-    cachedTokens?: number | undefined;
+    audioTokens?: number | undefined;
     /**
      * Tokens written to cache. Only returned for models with explicit caching and cache write pricing.
      */
     cacheWriteTokens?: number | undefined;
     /**
-     * Audio input tokens
+     * Cached prompt tokens
      */
-    audioTokens?: number | undefined;
+    cachedTokens?: number | undefined;
     /**
      * Video input tokens
      */
@@ -46,27 +46,27 @@ export type PromptTokensDetails = {
 /**
  * Token usage statistics
  */
-export type ChatGenerationTokenUsage = {
+export type ChatUsage = {
     /**
      * Number of tokens in the completion
      */
     completionTokens: number;
-    /**
-     * Number of tokens in the prompt
-     */
-    promptTokens: number;
-    /**
-     * Total number of tokens
-     */
-    totalTokens: number;
     /**
      * Detailed completion token usage
      */
     completionTokensDetails?: CompletionTokensDetails | null | undefined;
+    /**
+     * Number of tokens in the prompt
+     */
+    promptTokens: number;
     /**
      * Detailed prompt token usage
      */
     promptTokensDetails?: PromptTokensDetails | null | undefined;
+    /**
+     * Total number of tokens
+     */
+    totalTokens: number;
 };
 /** @internal */
 export declare const CompletionTokensDetails$inboundSchema: z.ZodType<CompletionTokensDetails, unknown>;
@@ -75,6 +75,6 @@ export declare function completionTokensDetailsFromJSON(jsonString: string): Saf
 export declare const PromptTokensDetails$inboundSchema: z.ZodType<PromptTokensDetails, unknown>;
 export declare function promptTokensDetailsFromJSON(jsonString: string): SafeParseResult<PromptTokensDetails, SDKValidationError>;
 /** @internal */
-export declare const ChatGenerationTokenUsage$inboundSchema: z.ZodType<ChatGenerationTokenUsage, unknown>;
-export declare function chatGenerationTokenUsageFromJSON(jsonString: string): SafeParseResult<ChatGenerationTokenUsage, SDKValidationError>;
-//# sourceMappingURL=chatgenerationtokenusage.d.ts.map
+export declare const ChatUsage$inboundSchema: z.ZodType<ChatUsage, unknown>;
+export declare function chatUsageFromJSON(jsonString: string): SafeParseResult<ChatUsage, SDKValidationError>;
+//# sourceMappingURL=chatusage.d.ts.map

package/esm/models/{chatgenerationtokenusage.js → chatusage.js}

@@ -1,21 +1,21 @@
 /*
  * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
- * @generated-id: 1d57b0d238b8
+ * @generated-id: 1e677d1ed4fc
  */
 import * as z from "zod/v4";
 import { remap as remap$ } from "../lib/primitives.js";
 import { safeParse } from "../lib/schemas.js";
 /** @internal */
 export const CompletionTokensDetails$inboundSchema = z.object({
-    reasoning_tokens: z.nullable(z.number()).optional(),
-    audio_tokens: z.nullable(z.number()).optional(),
-    accepted_prediction_tokens: z.nullable(z.number()).optional(),
-    rejected_prediction_tokens: z.nullable(z.number()).optional(),
+    accepted_prediction_tokens: z.int().optional(),
+    audio_tokens: z.int().optional(),
+    reasoning_tokens: z.int().optional(),
+    rejected_prediction_tokens: z.int().optional(),
 }).transform((v) => {
     return remap$(v, {
-        "reasoning_tokens": "reasoningTokens",
-        "audio_tokens": "audioTokens",
         "accepted_prediction_tokens": "acceptedPredictionTokens",
+        "audio_tokens": "audioTokens",
+        "reasoning_tokens": "reasoningTokens",
         "rejected_prediction_tokens": "rejectedPredictionTokens",
     });
 });
@@ -24,15 +24,15 @@ export function completionTokensDetailsFromJSON(jsonString) {
 }
 /** @internal */
 export const PromptTokensDetails$inboundSchema = z.object({
-    cached_tokens: z.number().optional(),
-    cache_write_tokens: z.number().optional(),
-    audio_tokens: z.number().optional(),
-    video_tokens: z.number().optional(),
+    audio_tokens: z.int().optional(),
+    cache_write_tokens: z.int().optional(),
+    cached_tokens: z.int().optional(),
+    video_tokens: z.int().optional(),
 }).transform((v) => {
     return remap$(v, {
-        "cached_tokens": "cachedTokens",
-        "cache_write_tokens": "cacheWriteTokens",
         "audio_tokens": "audioTokens",
+        "cache_write_tokens": "cacheWriteTokens",
+        "cached_tokens": "cachedTokens",
         "video_tokens": "videoTokens",
     });
 });
@@ -40,22 +40,22 @@ export function promptTokensDetailsFromJSON(jsonString) {
     return safeParse(jsonString, (x) => PromptTokensDetails$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'PromptTokensDetails' from JSON`);
 }
 /** @internal */
-export const ChatGenerationTokenUsage$inboundSchema = z.object({
-    completion_tokens: z.number(),
-    prompt_tokens: z.number(),
-    total_tokens: z.number(),
+export const ChatUsage$inboundSchema = z.object({
+    completion_tokens: z.int(),
     completion_tokens_details: z.nullable(z.lazy(() => CompletionTokensDetails$inboundSchema)).optional(),
+    prompt_tokens: z.int(),
     prompt_tokens_details: z.nullable(z.lazy(() => PromptTokensDetails$inboundSchema)).optional(),
+    total_tokens: z.int(),
 }).transform((v) => {
     return remap$(v, {
         "completion_tokens": "completionTokens",
-        "prompt_tokens": "promptTokens",
-        "total_tokens": "totalTokens",
         "completion_tokens_details": "completionTokensDetails",
+        "prompt_tokens": "promptTokens",
         "prompt_tokens_details": "promptTokensDetails",
+        "total_tokens": "totalTokens",
     });
 });
-export function chatGenerationTokenUsageFromJSON(jsonString) {
-    return safeParse(jsonString, (x) => ChatGenerationTokenUsage$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'ChatGenerationTokenUsage' from JSON`);
+export function chatUsageFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => ChatUsage$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'ChatUsage' from JSON`);
 }
-//# sourceMappingURL=chatgenerationtokenusage.js.map
+//# sourceMappingURL=chatusage.js.map

package/esm/models/chatusermessage.d.ts

@@ -0,0 +1,35 @@
+import * as z from "zod/v4";
+import { ChatContentItems, ChatContentItems$Outbound } from "./chatcontentitems.js";
+/**
+ * User message content
+ */
+export type ChatUserMessageContent = string | Array<ChatContentItems>;
+/**
+ * User message
+ */
+export type ChatUserMessage = {
+    /**
+     * User message content
+     */
+    content: string | Array<ChatContentItems>;
+    /**
+     * Optional name for the user
+     */
+    name?: string | undefined;
+    role: "user";
+};
+/** @internal */
+export type ChatUserMessageContent$Outbound = string | Array<ChatContentItems$Outbound>;
+/** @internal */
+export declare const ChatUserMessageContent$outboundSchema: z.ZodType<ChatUserMessageContent$Outbound, ChatUserMessageContent>;
+export declare function chatUserMessageContentToJSON(chatUserMessageContent: ChatUserMessageContent): string;
+/** @internal */
+export type ChatUserMessage$Outbound = {
+    content: string | Array<ChatContentItems$Outbound>;
+    name?: string | undefined;
+    role: "user";
+};
+/** @internal */
+export declare const ChatUserMessage$outboundSchema: z.ZodType<ChatUserMessage$Outbound, ChatUserMessage>;
+export declare function chatUserMessageToJSON(chatUserMessage: ChatUserMessage): string;
+//# sourceMappingURL=chatusermessage.d.ts.map

package/esm/models/chatusermessage.js

@@ -0,0 +1,21 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ * @generated-id: bc892e4ebadf
+ */
+import * as z from "zod/v4";
+import { ChatContentItems$outboundSchema, } from "./chatcontentitems.js";
+/** @internal */
+export const ChatUserMessageContent$outboundSchema = z.union([z.string(), z.array(ChatContentItems$outboundSchema)]);
+export function chatUserMessageContentToJSON(chatUserMessageContent) {
+    return JSON.stringify(ChatUserMessageContent$outboundSchema.parse(chatUserMessageContent));
+}
+/** @internal */
+export const ChatUserMessage$outboundSchema = z.object({
+    content: z.union([z.string(), z.array(ChatContentItems$outboundSchema)]),
+    name: z.string().optional(),
+    role: z.literal("user"),
+});
+export function chatUserMessageToJSON(chatUserMessage) {
+    return JSON.stringify(ChatUserMessage$outboundSchema.parse(chatUserMessage));
+}
+//# sourceMappingURL=chatusermessage.js.map

package/esm/models/chatwebsearchshorthand.d.ts

@@ -0,0 +1,66 @@
+import * as z from "zod/v4";
+import { OpenEnum } from "../types/enums.js";
+import { SearchQualityLevel } from "./searchqualitylevel.js";
+import { WebSearchConfig, WebSearchConfig$Outbound } from "./websearchconfig.js";
+import { WebSearchEngineEnum } from "./websearchengineenum.js";
+import { WebSearchUserLocationServerTool, WebSearchUserLocationServerTool$Outbound } from "./websearchuserlocationservertool.js";
+export declare const ChatWebSearchShorthandType: {
+    readonly WebSearch: "web_search";
+    readonly WebSearchPreview: "web_search_preview";
+    readonly WebSearchPreview20250311: "web_search_preview_2025_03_11";
+    readonly WebSearch20250826: "web_search_2025_08_26";
+};
+export type ChatWebSearchShorthandType = OpenEnum<typeof ChatWebSearchShorthandType>;
+/**
+ * Web search tool using OpenAI Responses API syntax. Automatically converted to openrouter:web_search.
+ */
+export type ChatWebSearchShorthand = {
+    /**
+     * Limit search results to these domains. Supported by Exa, Parallel, and most native providers (Anthropic, OpenAI, xAI). Not supported with Firecrawl or Perplexity.
+     */
+    allowedDomains?: Array<string> | undefined;
+    /**
+     * Which search engine to use. "auto" (default) uses native if the provider supports it, otherwise Exa. "native" forces the provider's built-in search. "exa" forces the Exa search API. "firecrawl" uses Firecrawl (requires BYOK). "parallel" uses the Parallel search API.
+     */
+    engine?: WebSearchEngineEnum | undefined;
+    /**
+     * Exclude search results from these domains. Supported by Exa, Parallel, Anthropic, and xAI. Not supported with Firecrawl, OpenAI (silently ignored), or Perplexity.
+     */
+    excludedDomains?: Array<string> | undefined;
+    /**
+     * Maximum number of search results to return per search call. Defaults to 5. Applies to Exa, Firecrawl, and Parallel engines; ignored with native provider search.
+     */
+    maxResults?: number | undefined;
+    /**
+     * Maximum total number of search results across all search calls in a single request. Once this limit is reached, the tool will stop returning new results. Useful for controlling cost and context size in agentic loops.
+     */
+    maxTotalResults?: number | undefined;
+    parameters?: WebSearchConfig | undefined;
+    /**
+     * How much context to retrieve per result. Defaults to medium (15000 chars). Only applies when using the Exa engine; ignored with native provider search.
+     */
+    searchContextSize?: SearchQualityLevel | undefined;
+    type: ChatWebSearchShorthandType;
+    /**
+     * Approximate user location for location-biased results.
+     */
+    userLocation?: WebSearchUserLocationServerTool | undefined;
+};
+/** @internal */
+export declare const ChatWebSearchShorthandType$outboundSchema: z.ZodType<string, ChatWebSearchShorthandType>;
+/** @internal */
+export type ChatWebSearchShorthand$Outbound = {
+    allowed_domains?: Array<string> | undefined;
+    engine?: string | undefined;
+    excluded_domains?: Array<string> | undefined;
+    max_results?: number | undefined;
+    max_total_results?: number | undefined;
+    parameters?: WebSearchConfig$Outbound | undefined;
+    search_context_size?: string | undefined;
+    type: string;
+    user_location?: WebSearchUserLocationServerTool$Outbound | undefined;
+};
+/** @internal */
+export declare const ChatWebSearchShorthand$outboundSchema: z.ZodType<ChatWebSearchShorthand$Outbound, ChatWebSearchShorthand>;
+export declare function chatWebSearchShorthandToJSON(chatWebSearchShorthand: ChatWebSearchShorthand): string;
+//# sourceMappingURL=chatwebsearchshorthand.d.ts.map

package/esm/models/chatwebsearchshorthand.js

@@ -0,0 +1,44 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ * @generated-id: a67d6bbce478
+ */
+import * as z from "zod/v4";
+import { remap as remap$ } from "../lib/primitives.js";
+import * as openEnums from "../types/enums.js";
+import { SearchQualityLevel$outboundSchema, } from "./searchqualitylevel.js";
+import { WebSearchConfig$outboundSchema, } from "./websearchconfig.js";
+import { WebSearchEngineEnum$outboundSchema, } from "./websearchengineenum.js";
+import { WebSearchUserLocationServerTool$outboundSchema, } from "./websearchuserlocationservertool.js";
+export const ChatWebSearchShorthandType = {
+    WebSearch: "web_search",
+    WebSearchPreview: "web_search_preview",
+    WebSearchPreview20250311: "web_search_preview_2025_03_11",
+    WebSearch20250826: "web_search_2025_08_26",
+};
+/** @internal */
+export const ChatWebSearchShorthandType$outboundSchema = openEnums.outboundSchema(ChatWebSearchShorthandType);
+/** @internal */
+export const ChatWebSearchShorthand$outboundSchema = z.object({
+    allowedDomains: z.array(z.string()).optional(),
+    engine: WebSearchEngineEnum$outboundSchema.optional(),
+    excludedDomains: z.array(z.string()).optional(),
+    maxResults: z.int().optional(),
+    maxTotalResults: z.int().optional(),
+    parameters: WebSearchConfig$outboundSchema.optional(),
+    searchContextSize: SearchQualityLevel$outboundSchema.optional(),
+    type: ChatWebSearchShorthandType$outboundSchema,
+    userLocation: WebSearchUserLocationServerTool$outboundSchema.optional(),
+}).transform((v) => {
+    return remap$(v, {
+        allowedDomains: "allowed_domains",
+        excludedDomains: "excluded_domains",
+        maxResults: "max_results",
+        maxTotalResults: "max_total_results",
+        searchContextSize: "search_context_size",
+        userLocation: "user_location",
+    });
+});
+export function chatWebSearchShorthandToJSON(chatWebSearchShorthand) {
+    return JSON.stringify(ChatWebSearchShorthand$outboundSchema.parse(chatWebSearchShorthand));
+}
+//# sourceMappingURL=chatwebsearchshorthand.js.map

package/esm/models/{openresponsescodeinterpretertool.d.ts → codeinterpreterservertool.d.ts}

@@ -2,10 +2,6 @@ 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 declare const ContainerType: {
-    readonly Auto: "auto";
-};
-export type ContainerType = ClosedEnum<typeof ContainerType>;
 export declare const MemoryLimit: {
     readonly Oneg: "1g";
     readonly Fourg: "4g";
@@ -13,34 +9,38 @@ export declare const MemoryLimit: {
     readonly SixtyFourg: "64g";
 };
 export type MemoryLimit = OpenEnum<typeof MemoryLimit>;
+export declare const ContainerType: {
+    readonly Auto: "auto";
+};
+export type ContainerType = ClosedEnum<typeof ContainerType>;
 export type ContainerAuto = {
-    type: ContainerType;
     fileIds?: Array<string> | undefined;
     memoryLimit?: MemoryLimit | null | undefined;
+    type: ContainerType;
 };
 export type Container = ContainerAuto | string;
 /**
  * Code interpreter tool configuration
  */
-export type OpenResponsesCodeInterpreterTool = {
-    type: "code_interpreter";
+export type CodeInterpreterServerTool = {
     container: ContainerAuto | string;
+    type: "code_interpreter";
 };
 /** @internal */
-export declare const ContainerType$inboundSchema: z.ZodEnum<typeof ContainerType>;
-/** @internal */
-export declare const ContainerType$outboundSchema: z.ZodEnum<typeof ContainerType>;
-/** @internal */
 export declare const MemoryLimit$inboundSchema: z.ZodType<MemoryLimit, unknown>;
 /** @internal */
 export declare const MemoryLimit$outboundSchema: z.ZodType<string, MemoryLimit>;
 /** @internal */
+export declare const ContainerType$inboundSchema: z.ZodEnum<typeof ContainerType>;
+/** @internal */
+export declare const ContainerType$outboundSchema: z.ZodEnum<typeof ContainerType>;
+/** @internal */
 export declare const ContainerAuto$inboundSchema: z.ZodType<ContainerAuto, unknown>;
 /** @internal */
 export type ContainerAuto$Outbound = {
-    type: string;
     file_ids?: Array<string> | undefined;
     memory_limit?: string | null | undefined;
+    type: string;
 };
 /** @internal */
 export declare const ContainerAuto$outboundSchema: z.ZodType<ContainerAuto$Outbound, ContainerAuto>;
@@ -55,14 +55,14 @@ export declare const Container$outboundSchema: z.ZodType<Container$Outbound, Con
 export declare function containerToJSON(container: Container): string;
 export declare function containerFromJSON(jsonString: string): SafeParseResult<Container, SDKValidationError>;
 /** @internal */
-export declare const OpenResponsesCodeInterpreterTool$inboundSchema: z.ZodType<OpenResponsesCodeInterpreterTool, unknown>;
+export declare const CodeInterpreterServerTool$inboundSchema: z.ZodType<CodeInterpreterServerTool, unknown>;
 /** @internal */
-export type OpenResponsesCodeInterpreterTool$Outbound = {
-    type: "code_interpreter";
+export type CodeInterpreterServerTool$Outbound = {
     container: ContainerAuto$Outbound | string;
+    type: "code_interpreter";
 };
 /** @internal */
-export declare const OpenResponsesCodeInterpreterTool$outboundSchema: z.ZodType<OpenResponsesCodeInterpreterTool$Outbound, OpenResponsesCodeInterpreterTool>;
-export declare function openResponsesCodeInterpreterToolToJSON(openResponsesCodeInterpreterTool: OpenResponsesCodeInterpreterTool): string;
-export declare function openResponsesCodeInterpreterToolFromJSON(jsonString: string): SafeParseResult<OpenResponsesCodeInterpreterTool, SDKValidationError>;
-//# sourceMappingURL=openresponsescodeinterpretertool.d.ts.map
+export declare const CodeInterpreterServerTool$outboundSchema: z.ZodType<CodeInterpreterServerTool$Outbound, CodeInterpreterServerTool>;
+export declare function codeInterpreterServerToolToJSON(codeInterpreterServerTool: CodeInterpreterServerTool): string;
+export declare function codeInterpreterServerToolFromJSON(jsonString: string): SafeParseResult<CodeInterpreterServerTool, SDKValidationError>;
+//# sourceMappingURL=codeinterpreterservertool.d.ts.map

package/esm/models/{openresponsescodeinterpretertool.js → codeinterpreterservertool.js}

@@ -1,35 +1,35 @@
 /*
  * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
- * @generated-id: 8d6c57413f99
+ * @generated-id: 493e614d6c34
  */
 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 ContainerType = {
-    Auto: "auto",
-};
 export const MemoryLimit = {
     Oneg: "1g",
     Fourg: "4g",
     Sixteeng: "16g",
     SixtyFourg: "64g",
 };
+export const ContainerType = {
+    Auto: "auto",
+};
+/** @internal */
+export const MemoryLimit$inboundSchema = openEnums.inboundSchema(MemoryLimit);
+/** @internal */
+export const MemoryLimit$outboundSchema = openEnums.outboundSchema(MemoryLimit);
 /** @internal */
 export const ContainerType$inboundSchema = z
     .enum(ContainerType);
 /** @internal */
 export const ContainerType$outboundSchema = ContainerType$inboundSchema;
 /** @internal */
-export const MemoryLimit$inboundSchema = openEnums.inboundSchema(MemoryLimit);
-/** @internal */
-export const MemoryLimit$outboundSchema = openEnums.outboundSchema(MemoryLimit);
-/** @internal */
 export const ContainerAuto$inboundSchema = z
     .object({
-    type: ContainerType$inboundSchema,
     file_ids: z.array(z.string()).optional(),
     memory_limit: z.nullable(MemoryLimit$inboundSchema).optional(),
+    type: ContainerType$inboundSchema,
 }).transform((v) => {
     return remap$(v, {
         "file_ids": "fileIds",
@@ -38,9 +38,9 @@ export const ContainerAuto$inboundSchema = z
 });
 /** @internal */
 export const ContainerAuto$outboundSchema = z.object({
-    type: ContainerType$outboundSchema,
     fileIds: z.array(z.string()).optional(),
     memoryLimit: z.nullable(MemoryLimit$outboundSchema).optional(),
+    type: ContainerType$outboundSchema,
 }).transform((v) => {
     return remap$(v, {
         fileIds: "file_ids",
@@ -67,19 +67,19 @@ export function containerFromJSON(jsonString) {
     return safeParse(jsonString, (x) => Container$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'Container' from JSON`);
 }
 /** @internal */
-export const OpenResponsesCodeInterpreterTool$inboundSchema = z.object({
-    type: z.literal("code_interpreter"),
+export const CodeInterpreterServerTool$inboundSchema = z.object({
     container: z.union([z.lazy(() => ContainerAuto$inboundSchema), z.string()]),
+    type: z.literal("code_interpreter"),
 });
 /** @internal */
-export const OpenResponsesCodeInterpreterTool$outboundSchema = z.object({
-    type: z.literal("code_interpreter"),
+export const CodeInterpreterServerTool$outboundSchema = z.object({
     container: z.union([z.lazy(() => ContainerAuto$outboundSchema), z.string()]),
+    type: z.literal("code_interpreter"),
 });
-export function openResponsesCodeInterpreterToolToJSON(openResponsesCodeInterpreterTool) {
-    return JSON.stringify(OpenResponsesCodeInterpreterTool$outboundSchema.parse(openResponsesCodeInterpreterTool));
+export function codeInterpreterServerToolToJSON(codeInterpreterServerTool) {
+    return JSON.stringify(CodeInterpreterServerTool$outboundSchema.parse(codeInterpreterServerTool));
 }
-export function openResponsesCodeInterpreterToolFromJSON(jsonString) {
-    return safeParse(jsonString, (x) => OpenResponsesCodeInterpreterTool$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'OpenResponsesCodeInterpreterTool' from JSON`);
+export function codeInterpreterServerToolFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => CodeInterpreterServerTool$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'CodeInterpreterServerTool' from JSON`);
 }
-//# sourceMappingURL=openresponsescodeinterpretertool.js.map
+//# sourceMappingURL=codeinterpreterservertool.js.map

package/esm/models/codexlocalshelltool.d.ts

@@ -0,0 +1,20 @@
+import * as z from "zod/v4";
+import { Result as SafeParseResult } from "../types/fp.js";
+import { SDKValidationError } from "./errors/sdkvalidationerror.js";
+/**
+ * Local shell tool configuration
+ */
+export type CodexLocalShellTool = {
+    type: "local_shell";
+};
+/** @internal */
+export declare const CodexLocalShellTool$inboundSchema: z.ZodType<CodexLocalShellTool, unknown>;
+/** @internal */
+export type CodexLocalShellTool$Outbound = {
+    type: "local_shell";
+};
+/** @internal */
+export declare const CodexLocalShellTool$outboundSchema: z.ZodType<CodexLocalShellTool$Outbound, CodexLocalShellTool>;
+export declare function codexLocalShellToolToJSON(codexLocalShellTool: CodexLocalShellTool): string;
+export declare function codexLocalShellToolFromJSON(jsonString: string): SafeParseResult<CodexLocalShellTool, SDKValidationError>;
+//# sourceMappingURL=codexlocalshelltool.d.ts.map

package/esm/models/codexlocalshelltool.js

@@ -0,0 +1,21 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ * @generated-id: 5cd3cc003b0b
+ */
+import * as z from "zod/v4";
+import { safeParse } from "../lib/schemas.js";
+/** @internal */
+export const CodexLocalShellTool$inboundSchema = z.object({
+    type: z.literal("local_shell"),
+});
+/** @internal */
+export const CodexLocalShellTool$outboundSchema = z.object({
+    type: z.literal("local_shell"),
+});
+export function codexLocalShellToolToJSON(codexLocalShellTool) {
+    return JSON.stringify(CodexLocalShellTool$outboundSchema.parse(codexLocalShellTool));
+}
+export function codexLocalShellToolFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => CodexLocalShellTool$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'CodexLocalShellTool' from JSON`);
+}
+//# sourceMappingURL=codexlocalshelltool.js.map