@openrouter/sdk 0.12.19 → 0.12.21

package/esm/lib/config.d.ts

@@ -49,8 +49,8 @@ export declare function serverURLFromOptions(options: SDKOptions): URL | null;
 export declare const SDK_METADATA: {
     readonly language: "typescript";
     readonly openapiDocVersion: "1.0.0";
-    readonly sdkVersion: "0.12.19";
+    readonly sdkVersion: "0.12.21";
     readonly genVersion: "2.879.1";
-    readonly userAgent: "speakeasy-sdk/typescript 0.12.19 2.879.1 1.0.0 @openrouter/sdk";
+    readonly userAgent: "speakeasy-sdk/typescript 0.12.21 2.879.1 1.0.0 @openrouter/sdk";
 };
 //# sourceMappingURL=config.d.ts.map

package/esm/lib/config.js

@@ -26,8 +26,8 @@ export function serverURLFromOptions(options) {
 export const SDK_METADATA = {
     language: "typescript",
     openapiDocVersion: "1.0.0",
-    sdkVersion: "0.12.19",
+    sdkVersion: "0.12.21",
     genVersion: "2.879.1",
-    userAgent: "speakeasy-sdk/typescript 0.12.19 2.879.1 1.0.0 @openrouter/sdk",
+    userAgent: "speakeasy-sdk/typescript 0.12.21 2.879.1 1.0.0 @openrouter/sdk",
 };
 //# sourceMappingURL=config.js.map

package/esm/models/chatwebsearchshorthand.d.ts

@@ -37,7 +37,7 @@ export type ChatWebSearchShorthand = {
     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.
+     * How much context to retrieve per result. Defaults to medium (15000 chars). Applies to Exa and Parallel engines; ignored with native provider search and Firecrawl.
      */
     searchContextSize?: SearchQualityLevel | undefined;
     type: ChatWebSearchShorthandType;

package/esm/models/createworkspacerequest.d.ts

@@ -16,6 +16,14 @@ export type CreateWorkspaceRequest = {
      * Description of the workspace
      */
     description?: string | null | undefined;
+    /**
+     * Optional array of API key IDs to filter I/O logging
+     */
+    ioLoggingApiKeyIds?: Array<number> | null | undefined;
+    /**
+     * Sampling rate for I/O logging (0.0001-1)
+     */
+    ioLoggingSamplingRate?: number | undefined;
     /**
      * Whether data discount logging is enabled
      */
@@ -43,6 +51,8 @@ export type CreateWorkspaceRequest$Outbound = {
     default_provider_sort?: string | null | undefined;
     default_text_model?: string | null | undefined;
     description?: string | null | undefined;
+    io_logging_api_key_ids?: Array<number> | null | undefined;
+    io_logging_sampling_rate?: number | undefined;
     is_data_discount_logging_enabled?: boolean | undefined;
     is_observability_broadcast_enabled?: boolean | undefined;
     is_observability_io_logging_enabled?: boolean | undefined;

package/esm/models/createworkspacerequest.js

@@ -10,6 +10,8 @@ export const CreateWorkspaceRequest$outboundSchema = z.object({
     defaultProviderSort: z.nullable(z.string()).optional(),
     defaultTextModel: z.nullable(z.string()).optional(),
     description: z.nullable(z.string()).optional(),
+    ioLoggingApiKeyIds: z.nullable(z.array(z.int())).optional(),
+    ioLoggingSamplingRate: z.number().optional(),
     isDataDiscountLoggingEnabled: z.boolean().optional(),
     isObservabilityBroadcastEnabled: z.boolean().optional(),
     isObservabilityIoLoggingEnabled: z.boolean().optional(),
@@ -20,6 +22,8 @@ export const CreateWorkspaceRequest$outboundSchema = z.object({
         defaultImageModel: "default_image_model",
         defaultProviderSort: "default_provider_sort",
         defaultTextModel: "default_text_model",
+        ioLoggingApiKeyIds: "io_logging_api_key_ids",
+        ioLoggingSamplingRate: "io_logging_sampling_rate",
         isDataDiscountLoggingEnabled: "is_data_discount_logging_enabled",
         isObservabilityBroadcastEnabled: "is_observability_broadcast_enabled",
         isObservabilityIoLoggingEnabled: "is_observability_io_logging_enabled",

package/esm/models/generationresponse.d.ts

@@ -137,6 +137,10 @@ export type GenerationResponseData = {
      * Unique identifier grouping all generations from a single API request
      */
     requestId?: string | null | undefined;
+    /**
+     * If this generation was served from response cache, contains the original generation ID. Null otherwise.
+     */
+    responseCacheSourceId?: string | null | undefined;
     /**
      * Router used for the request (e.g., openrouter/auto)
      */

package/esm/models/generationresponse.js

@@ -51,6 +51,7 @@ export const GenerationResponseData$inboundSchema = z.object({
     provider_name: z.nullable(z.string()),
     provider_responses: z.nullable(z.array(ProviderResponse$inboundSchema)),
     request_id: z.nullable(z.string()).optional(),
+    response_cache_source_id: z.nullable(z.string()).optional(),
     router: z.nullable(z.string()),
     session_id: z.nullable(z.string()).optional(),
     streamed: z.nullable(z.boolean()),
@@ -88,6 +89,7 @@ export const GenerationResponseData$inboundSchema = z.object({
         "provider_name": "providerName",
         "provider_responses": "providerResponses",
         "request_id": "requestId",
+        "response_cache_source_id": "responseCacheSourceId",
         "session_id": "sessionId",
         "tokens_completion": "tokensCompletion",
         "tokens_prompt": "tokensPrompt",

package/esm/models/inputsunion.d.ts

@@ -5,10 +5,24 @@ import { FunctionCallItem, FunctionCallItem$Outbound } from "./functioncallitem.
 import { FunctionCallOutputItem, FunctionCallOutputItem$Outbound } from "./functioncalloutputitem.js";
 import { InputMessageItem, InputMessageItem$Outbound } from "./inputmessageitem.js";
 import { OpenAIResponsesRefusalContent, OpenAIResponsesRefusalContent$Outbound } from "./openairesponsesrefusalcontent.js";
+import { OutputApplyPatchServerToolItem, OutputApplyPatchServerToolItem$Outbound } from "./outputapplypatchservertoolitem.js";
+import { OutputBashServerToolItem, OutputBashServerToolItem$Outbound } from "./outputbashservertoolitem.js";
+import { OutputBrowserUseServerToolItem, OutputBrowserUseServerToolItem$Outbound } from "./outputbrowseruseservertoolitem.js";
+import { OutputCodeInterpreterCallItem, OutputCodeInterpreterCallItem$Outbound } from "./outputcodeinterpretercallitem.js";
+import { OutputCodeInterpreterServerToolItem, OutputCodeInterpreterServerToolItem$Outbound } from "./outputcodeinterpreterservertoolitem.js";
+import { OutputComputerCallItem, OutputComputerCallItem$Outbound } from "./outputcomputercallitem.js";
 import { OutputDatetimeItem, OutputDatetimeItem$Outbound } from "./outputdatetimeitem.js";
 import { OutputFileSearchCallItem, OutputFileSearchCallItem$Outbound } from "./outputfilesearchcallitem.js";
+import { OutputFileSearchServerToolItem, OutputFileSearchServerToolItem$Outbound } from "./outputfilesearchservertoolitem.js";
 import { OutputFunctionCallItem, OutputFunctionCallItem$Outbound } from "./outputfunctioncallitem.js";
 import { OutputImageGenerationCallItem, OutputImageGenerationCallItem$Outbound } from "./outputimagegenerationcallitem.js";
+import { OutputImageGenerationServerToolItem, OutputImageGenerationServerToolItem$Outbound } from "./outputimagegenerationservertoolitem.js";
+import { OutputMcpServerToolItem, OutputMcpServerToolItem$Outbound } from "./outputmcpservertoolitem.js";
+import { OutputMemoryServerToolItem, OutputMemoryServerToolItem$Outbound } from "./outputmemoryservertoolitem.js";
+import { OutputSearchModelsServerToolItem, OutputSearchModelsServerToolItem$Outbound } from "./outputsearchmodelsservertoolitem.js";
+import { OutputTextEditorServerToolItem, OutputTextEditorServerToolItem$Outbound } from "./outputtexteditorservertoolitem.js";
+import { OutputToolSearchServerToolItem, OutputToolSearchServerToolItem$Outbound } from "./outputtoolsearchservertoolitem.js";
+import { OutputWebFetchServerToolItem, OutputWebFetchServerToolItem$Outbound } from "./outputwebfetchservertoolitem.js";
 import { OutputWebSearchCallItem, OutputWebSearchCallItem$Outbound } from "./outputwebsearchcallitem.js";
 import { OutputWebSearchServerToolItem, OutputWebSearchServerToolItem$Outbound } from "./outputwebsearchservertoolitem.js";
 import { ReasoningFormat } from "./reasoningformat.js";
@@ -98,11 +112,11 @@ export type InputsMessage = {
     status?: InputsStatusCompleted1 | InputsStatusIncomplete1 | InputsStatusInProgress1 | undefined;
     type: InputsTypeMessage;
 };
-export type InputsUnion1 = FunctionCallItem | InputsMessage | OutputFunctionCallItem | OutputWebSearchCallItem | OutputFileSearchCallItem | OutputDatetimeItem | ReasoningItem | FunctionCallOutputItem | InputsReasoning | OutputImageGenerationCallItem | OutputWebSearchServerToolItem | EasyInputMessage | InputMessageItem;
+export type InputsUnion1 = OutputCodeInterpreterCallItem | FunctionCallItem | InputsMessage | OutputFunctionCallItem | OutputWebSearchCallItem | OutputFileSearchCallItem | OutputComputerCallItem | OutputDatetimeItem | ReasoningItem | FunctionCallOutputItem | InputsReasoning | OutputImageGenerationCallItem | OutputWebSearchServerToolItem | OutputCodeInterpreterServerToolItem | OutputFileSearchServerToolItem | OutputImageGenerationServerToolItem | OutputBrowserUseServerToolItem | OutputBashServerToolItem | OutputTextEditorServerToolItem | OutputApplyPatchServerToolItem | OutputWebFetchServerToolItem | OutputToolSearchServerToolItem | OutputMemoryServerToolItem | OutputMcpServerToolItem | OutputSearchModelsServerToolItem | EasyInputMessage | InputMessageItem;
 /**
  * Input for a response request - can be a string or array of items
  */
-export type InputsUnion = string | Array<FunctionCallItem | InputsMessage | OutputFunctionCallItem | OutputWebSearchCallItem | OutputFileSearchCallItem | OutputDatetimeItem | ReasoningItem | FunctionCallOutputItem | InputsReasoning | OutputImageGenerationCallItem | OutputWebSearchServerToolItem | EasyInputMessage | InputMessageItem>;
+export type InputsUnion = string | Array<OutputCodeInterpreterCallItem | FunctionCallItem | InputsMessage | OutputFunctionCallItem | OutputWebSearchCallItem | OutputFileSearchCallItem | OutputComputerCallItem | OutputDatetimeItem | ReasoningItem | FunctionCallOutputItem | InputsReasoning | OutputImageGenerationCallItem | OutputWebSearchServerToolItem | OutputCodeInterpreterServerToolItem | OutputFileSearchServerToolItem | OutputImageGenerationServerToolItem | OutputBrowserUseServerToolItem | OutputBashServerToolItem | OutputTextEditorServerToolItem | OutputApplyPatchServerToolItem | OutputWebFetchServerToolItem | OutputToolSearchServerToolItem | OutputMemoryServerToolItem | OutputMcpServerToolItem | OutputSearchModelsServerToolItem | EasyInputMessage | InputMessageItem>;
 /** @internal */
 export declare const InputsStatusInProgress2$outboundSchema: z.ZodEnum<typeof InputsStatusInProgress2>;
 /** @internal */
@@ -177,12 +191,12 @@ export type InputsMessage$Outbound = {
 export declare const InputsMessage$outboundSchema: z.ZodType<InputsMessage$Outbound, InputsMessage>;
 export declare function inputsMessageToJSON(inputsMessage: InputsMessage): string;
 /** @internal */
-export type InputsUnion1$Outbound = FunctionCallItem$Outbound | InputsMessage$Outbound | OutputFunctionCallItem$Outbound | OutputWebSearchCallItem$Outbound | OutputFileSearchCallItem$Outbound | OutputDatetimeItem$Outbound | ReasoningItem$Outbound | FunctionCallOutputItem$Outbound | InputsReasoning$Outbound | OutputImageGenerationCallItem$Outbound | OutputWebSearchServerToolItem$Outbound | EasyInputMessage$Outbound | InputMessageItem$Outbound;
+export type InputsUnion1$Outbound = OutputCodeInterpreterCallItem$Outbound | FunctionCallItem$Outbound | InputsMessage$Outbound | OutputFunctionCallItem$Outbound | OutputWebSearchCallItem$Outbound | OutputFileSearchCallItem$Outbound | OutputComputerCallItem$Outbound | OutputDatetimeItem$Outbound | ReasoningItem$Outbound | FunctionCallOutputItem$Outbound | InputsReasoning$Outbound | OutputImageGenerationCallItem$Outbound | OutputWebSearchServerToolItem$Outbound | OutputCodeInterpreterServerToolItem$Outbound | OutputFileSearchServerToolItem$Outbound | OutputImageGenerationServerToolItem$Outbound | OutputBrowserUseServerToolItem$Outbound | OutputBashServerToolItem$Outbound | OutputTextEditorServerToolItem$Outbound | OutputApplyPatchServerToolItem$Outbound | OutputWebFetchServerToolItem$Outbound | OutputToolSearchServerToolItem$Outbound | OutputMemoryServerToolItem$Outbound | OutputMcpServerToolItem$Outbound | OutputSearchModelsServerToolItem$Outbound | EasyInputMessage$Outbound | InputMessageItem$Outbound;
 /** @internal */
 export declare const InputsUnion1$outboundSchema: z.ZodType<InputsUnion1$Outbound, InputsUnion1>;
 export declare function inputsUnion1ToJSON(inputsUnion1: InputsUnion1): string;
 /** @internal */
-export type InputsUnion$Outbound = string | Array<FunctionCallItem$Outbound | InputsMessage$Outbound | OutputFunctionCallItem$Outbound | OutputWebSearchCallItem$Outbound | OutputFileSearchCallItem$Outbound | OutputDatetimeItem$Outbound | ReasoningItem$Outbound | FunctionCallOutputItem$Outbound | InputsReasoning$Outbound | OutputImageGenerationCallItem$Outbound | OutputWebSearchServerToolItem$Outbound | EasyInputMessage$Outbound | InputMessageItem$Outbound>;
+export type InputsUnion$Outbound = string | Array<OutputCodeInterpreterCallItem$Outbound | FunctionCallItem$Outbound | InputsMessage$Outbound | OutputFunctionCallItem$Outbound | OutputWebSearchCallItem$Outbound | OutputFileSearchCallItem$Outbound | OutputComputerCallItem$Outbound | OutputDatetimeItem$Outbound | ReasoningItem$Outbound | FunctionCallOutputItem$Outbound | InputsReasoning$Outbound | OutputImageGenerationCallItem$Outbound | OutputWebSearchServerToolItem$Outbound | OutputCodeInterpreterServerToolItem$Outbound | OutputFileSearchServerToolItem$Outbound | OutputImageGenerationServerToolItem$Outbound | OutputBrowserUseServerToolItem$Outbound | OutputBashServerToolItem$Outbound | OutputTextEditorServerToolItem$Outbound | OutputApplyPatchServerToolItem$Outbound | OutputWebFetchServerToolItem$Outbound | OutputToolSearchServerToolItem$Outbound | OutputMemoryServerToolItem$Outbound | OutputMcpServerToolItem$Outbound | OutputSearchModelsServerToolItem$Outbound | EasyInputMessage$Outbound | InputMessageItem$Outbound>;
 /** @internal */
 export declare const InputsUnion$outboundSchema: z.ZodType<InputsUnion$Outbound, InputsUnion>;
 export declare function inputsUnionToJSON(inputsUnion: InputsUnion): string;

package/esm/models/inputsunion.js

@@ -9,10 +9,24 @@ import { FunctionCallItem$outboundSchema, } from "./functioncallitem.js";
 import { FunctionCallOutputItem$outboundSchema, } from "./functioncalloutputitem.js";
 import { InputMessageItem$outboundSchema, } from "./inputmessageitem.js";
 import { OpenAIResponsesRefusalContent$outboundSchema, } from "./openairesponsesrefusalcontent.js";
+import { OutputApplyPatchServerToolItem$outboundSchema, } from "./outputapplypatchservertoolitem.js";
+import { OutputBashServerToolItem$outboundSchema, } from "./outputbashservertoolitem.js";
+import { OutputBrowserUseServerToolItem$outboundSchema, } from "./outputbrowseruseservertoolitem.js";
+import { OutputCodeInterpreterCallItem$outboundSchema, } from "./outputcodeinterpretercallitem.js";
+import { OutputCodeInterpreterServerToolItem$outboundSchema, } from "./outputcodeinterpreterservertoolitem.js";
+import { OutputComputerCallItem$outboundSchema, } from "./outputcomputercallitem.js";
 import { OutputDatetimeItem$outboundSchema, } from "./outputdatetimeitem.js";
 import { OutputFileSearchCallItem$outboundSchema, } from "./outputfilesearchcallitem.js";
+import { OutputFileSearchServerToolItem$outboundSchema, } from "./outputfilesearchservertoolitem.js";
 import { OutputFunctionCallItem$outboundSchema, } from "./outputfunctioncallitem.js";
 import { OutputImageGenerationCallItem$outboundSchema, } from "./outputimagegenerationcallitem.js";
+import { OutputImageGenerationServerToolItem$outboundSchema, } from "./outputimagegenerationservertoolitem.js";
+import { OutputMcpServerToolItem$outboundSchema, } from "./outputmcpservertoolitem.js";
+import { OutputMemoryServerToolItem$outboundSchema, } from "./outputmemoryservertoolitem.js";
+import { OutputSearchModelsServerToolItem$outboundSchema, } from "./outputsearchmodelsservertoolitem.js";
+import { OutputTextEditorServerToolItem$outboundSchema, } from "./outputtexteditorservertoolitem.js";
+import { OutputToolSearchServerToolItem$outboundSchema, } from "./outputtoolsearchservertoolitem.js";
+import { OutputWebFetchServerToolItem$outboundSchema, } from "./outputwebfetchservertoolitem.js";
 import { OutputWebSearchCallItem$outboundSchema, } from "./outputwebsearchcallitem.js";
 import { OutputWebSearchServerToolItem$outboundSchema, } from "./outputwebsearchservertoolitem.js";
 import { ReasoningFormat$outboundSchema, } from "./reasoningformat.js";
@@ -173,17 +187,31 @@ export function inputsMessageToJSON(inputsMessage) {
 }
 /** @internal */
 export const InputsUnion1$outboundSchema = z.union([
+    OutputCodeInterpreterCallItem$outboundSchema,
     FunctionCallItem$outboundSchema,
     z.lazy(() => InputsMessage$outboundSchema),
     OutputFunctionCallItem$outboundSchema,
     OutputWebSearchCallItem$outboundSchema,
     OutputFileSearchCallItem$outboundSchema,
+    OutputComputerCallItem$outboundSchema,
     OutputDatetimeItem$outboundSchema,
     ReasoningItem$outboundSchema,
     FunctionCallOutputItem$outboundSchema,
     z.lazy(() => InputsReasoning$outboundSchema),
     OutputImageGenerationCallItem$outboundSchema,
     OutputWebSearchServerToolItem$outboundSchema,
+    OutputCodeInterpreterServerToolItem$outboundSchema,
+    OutputFileSearchServerToolItem$outboundSchema,
+    OutputImageGenerationServerToolItem$outboundSchema,
+    OutputBrowserUseServerToolItem$outboundSchema,
+    OutputBashServerToolItem$outboundSchema,
+    OutputTextEditorServerToolItem$outboundSchema,
+    OutputApplyPatchServerToolItem$outboundSchema,
+    OutputWebFetchServerToolItem$outboundSchema,
+    OutputToolSearchServerToolItem$outboundSchema,
+    OutputMemoryServerToolItem$outboundSchema,
+    OutputMcpServerToolItem$outboundSchema,
+    OutputSearchModelsServerToolItem$outboundSchema,
     EasyInputMessage$outboundSchema,
     InputMessageItem$outboundSchema,
 ]);
@@ -194,17 +222,31 @@ export function inputsUnion1ToJSON(inputsUnion1) {
 export const InputsUnion$outboundSchema = z.union([
     z.string(),
     z.array(z.union([
+        OutputCodeInterpreterCallItem$outboundSchema,
         FunctionCallItem$outboundSchema,
         z.lazy(() => InputsMessage$outboundSchema),
         OutputFunctionCallItem$outboundSchema,
         OutputWebSearchCallItem$outboundSchema,
         OutputFileSearchCallItem$outboundSchema,
+        OutputComputerCallItem$outboundSchema,
         OutputDatetimeItem$outboundSchema,
         ReasoningItem$outboundSchema,
         FunctionCallOutputItem$outboundSchema,
         z.lazy(() => InputsReasoning$outboundSchema),
         OutputImageGenerationCallItem$outboundSchema,
         OutputWebSearchServerToolItem$outboundSchema,
+        OutputCodeInterpreterServerToolItem$outboundSchema,
+        OutputFileSearchServerToolItem$outboundSchema,
+        OutputImageGenerationServerToolItem$outboundSchema,
+        OutputBrowserUseServerToolItem$outboundSchema,
+        OutputBashServerToolItem$outboundSchema,
+        OutputTextEditorServerToolItem$outboundSchema,
+        OutputApplyPatchServerToolItem$outboundSchema,
+        OutputWebFetchServerToolItem$outboundSchema,
+        OutputToolSearchServerToolItem$outboundSchema,
+        OutputMemoryServerToolItem$outboundSchema,
+        OutputMcpServerToolItem$outboundSchema,
+        OutputSearchModelsServerToolItem$outboundSchema,
         EasyInputMessage$outboundSchema,
         InputMessageItem$outboundSchema,
     ])),

package/esm/models/outputapplypatchservertoolitem.d.ts

@@ -1,7 +1,12 @@
 import * as z from "zod/v4";
+import { ClosedEnum } from "../types/enums.js";
 import { Result as SafeParseResult } from "../types/fp.js";
 import { SDKValidationError } from "./errors/sdkvalidationerror.js";
 import { ToolCallStatus } from "./toolcallstatus.js";
+export declare const OutputApplyPatchServerToolItemType: {
+    readonly OpenrouterApplyPatch: "openrouter:apply_patch";
+};
+export type OutputApplyPatchServerToolItemType = ClosedEnum<typeof OutputApplyPatchServerToolItemType>;
 /**
  * An openrouter:apply_patch server tool output item
  */
@@ -10,9 +15,24 @@ export type OutputApplyPatchServerToolItem = {
     id?: string | undefined;
     patch?: string | undefined;
     status: ToolCallStatus;
-    type: "openrouter:apply_patch";
+    type: OutputApplyPatchServerToolItemType;
 };
 /** @internal */
+export declare const OutputApplyPatchServerToolItemType$inboundSchema: z.ZodEnum<typeof OutputApplyPatchServerToolItemType>;
+/** @internal */
+export declare const OutputApplyPatchServerToolItemType$outboundSchema: z.ZodEnum<typeof OutputApplyPatchServerToolItemType>;
+/** @internal */
 export declare const OutputApplyPatchServerToolItem$inboundSchema: z.ZodType<OutputApplyPatchServerToolItem, unknown>;
+/** @internal */
+export type OutputApplyPatchServerToolItem$Outbound = {
+    filePath?: string | undefined;
+    id?: string | undefined;
+    patch?: string | undefined;
+    status: string;
+    type: string;
+};
+/** @internal */
+export declare const OutputApplyPatchServerToolItem$outboundSchema: z.ZodType<OutputApplyPatchServerToolItem$Outbound, OutputApplyPatchServerToolItem>;
+export declare function outputApplyPatchServerToolItemToJSON(outputApplyPatchServerToolItem: OutputApplyPatchServerToolItem): string;
 export declare function outputApplyPatchServerToolItemFromJSON(jsonString: string): SafeParseResult<OutputApplyPatchServerToolItem, SDKValidationError>;
 //# sourceMappingURL=outputapplypatchservertoolitem.d.ts.map

package/esm/models/outputapplypatchservertoolitem.js

@@ -4,15 +4,33 @@
  */
 import * as z from "zod/v4";
 import { safeParse } from "../lib/schemas.js";
-import { ToolCallStatus$inboundSchema, } from "./toolcallstatus.js";
+import { ToolCallStatus$inboundSchema, ToolCallStatus$outboundSchema, } from "./toolcallstatus.js";
+export const OutputApplyPatchServerToolItemType = {
+    OpenrouterApplyPatch: "openrouter:apply_patch",
+};
+/** @internal */
+export const OutputApplyPatchServerToolItemType$inboundSchema = z.enum(OutputApplyPatchServerToolItemType);
+/** @internal */
+export const OutputApplyPatchServerToolItemType$outboundSchema = OutputApplyPatchServerToolItemType$inboundSchema;
 /** @internal */
 export const OutputApplyPatchServerToolItem$inboundSchema = z.object({
     filePath: z.string().optional(),
     id: z.string().optional(),
     patch: z.string().optional(),
     status: ToolCallStatus$inboundSchema,
-    type: z.literal("openrouter:apply_patch"),
+    type: OutputApplyPatchServerToolItemType$inboundSchema,
+});
+/** @internal */
+export const OutputApplyPatchServerToolItem$outboundSchema = z.object({
+    filePath: z.string().optional(),
+    id: z.string().optional(),
+    patch: z.string().optional(),
+    status: ToolCallStatus$outboundSchema,
+    type: OutputApplyPatchServerToolItemType$outboundSchema,
 });
+export function outputApplyPatchServerToolItemToJSON(outputApplyPatchServerToolItem) {
+    return JSON.stringify(OutputApplyPatchServerToolItem$outboundSchema.parse(outputApplyPatchServerToolItem));
+}
 export function outputApplyPatchServerToolItemFromJSON(jsonString) {
     return safeParse(jsonString, (x) => OutputApplyPatchServerToolItem$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'OutputApplyPatchServerToolItem' from JSON`);
 }

package/esm/models/outputbashservertoolitem.d.ts

@@ -1,7 +1,12 @@
 import * as z from "zod/v4";
+import { ClosedEnum } from "../types/enums.js";
 import { Result as SafeParseResult } from "../types/fp.js";
 import { SDKValidationError } from "./errors/sdkvalidationerror.js";
 import { ToolCallStatus } from "./toolcallstatus.js";
+export declare const OutputBashServerToolItemType: {
+    readonly OpenrouterBash: "openrouter:bash";
+};
+export type OutputBashServerToolItemType = ClosedEnum<typeof OutputBashServerToolItemType>;
 /**
  * An openrouter:bash server tool output item
  */
@@ -12,9 +17,26 @@ export type OutputBashServerToolItem = {
     status: ToolCallStatus;
     stderr?: string | undefined;
     stdout?: string | undefined;
-    type: "openrouter:bash";
+    type: OutputBashServerToolItemType;
 };
 /** @internal */
+export declare const OutputBashServerToolItemType$inboundSchema: z.ZodEnum<typeof OutputBashServerToolItemType>;
+/** @internal */
+export declare const OutputBashServerToolItemType$outboundSchema: z.ZodEnum<typeof OutputBashServerToolItemType>;
+/** @internal */
 export declare const OutputBashServerToolItem$inboundSchema: z.ZodType<OutputBashServerToolItem, unknown>;
+/** @internal */
+export type OutputBashServerToolItem$Outbound = {
+    command?: string | undefined;
+    exitCode?: number | undefined;
+    id?: string | undefined;
+    status: string;
+    stderr?: string | undefined;
+    stdout?: string | undefined;
+    type: string;
+};
+/** @internal */
+export declare const OutputBashServerToolItem$outboundSchema: z.ZodType<OutputBashServerToolItem$Outbound, OutputBashServerToolItem>;
+export declare function outputBashServerToolItemToJSON(outputBashServerToolItem: OutputBashServerToolItem): string;
 export declare function outputBashServerToolItemFromJSON(jsonString: string): SafeParseResult<OutputBashServerToolItem, SDKValidationError>;
 //# sourceMappingURL=outputbashservertoolitem.d.ts.map

package/esm/models/outputbashservertoolitem.js

@@ -4,7 +4,14 @@
  */
 import * as z from "zod/v4";
 import { safeParse } from "../lib/schemas.js";
-import { ToolCallStatus$inboundSchema, } from "./toolcallstatus.js";
+import { ToolCallStatus$inboundSchema, ToolCallStatus$outboundSchema, } from "./toolcallstatus.js";
+export const OutputBashServerToolItemType = {
+    OpenrouterBash: "openrouter:bash",
+};
+/** @internal */
+export const OutputBashServerToolItemType$inboundSchema = z.enum(OutputBashServerToolItemType);
+/** @internal */
+export const OutputBashServerToolItemType$outboundSchema = OutputBashServerToolItemType$inboundSchema;
 /** @internal */
 export const OutputBashServerToolItem$inboundSchema = z.object({
     command: z.string().optional(),
@@ -13,8 +20,21 @@ export const OutputBashServerToolItem$inboundSchema = z.object({
     status: ToolCallStatus$inboundSchema,
     stderr: z.string().optional(),
     stdout: z.string().optional(),
-    type: z.literal("openrouter:bash"),
+    type: OutputBashServerToolItemType$inboundSchema,
+});
+/** @internal */
+export const OutputBashServerToolItem$outboundSchema = z.object({
+    command: z.string().optional(),
+    exitCode: z.int().optional(),
+    id: z.string().optional(),
+    status: ToolCallStatus$outboundSchema,
+    stderr: z.string().optional(),
+    stdout: z.string().optional(),
+    type: OutputBashServerToolItemType$outboundSchema,
 });
+export function outputBashServerToolItemToJSON(outputBashServerToolItem) {
+    return JSON.stringify(OutputBashServerToolItem$outboundSchema.parse(outputBashServerToolItem));
+}
 export function outputBashServerToolItemFromJSON(jsonString) {
     return safeParse(jsonString, (x) => OutputBashServerToolItem$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'OutputBashServerToolItem' from JSON`);
 }

package/esm/models/outputbrowseruseservertoolitem.d.ts

@@ -1,7 +1,12 @@
 import * as z from "zod/v4";
+import { ClosedEnum } from "../types/enums.js";
 import { Result as SafeParseResult } from "../types/fp.js";
 import { SDKValidationError } from "./errors/sdkvalidationerror.js";
 import { ToolCallStatus } from "./toolcallstatus.js";
+export declare const OutputBrowserUseServerToolItemType: {
+    readonly OpenrouterBrowserUse: "openrouter:browser_use";
+};
+export type OutputBrowserUseServerToolItemType = ClosedEnum<typeof OutputBrowserUseServerToolItemType>;
 /**
  * An openrouter:browser_use server tool output item
  */
@@ -10,9 +15,24 @@ export type OutputBrowserUseServerToolItem = {
     id?: string | undefined;
     screenshotB64?: string | undefined;
     status: ToolCallStatus;
-    type: "openrouter:browser_use";
+    type: OutputBrowserUseServerToolItemType;
 };
 /** @internal */
+export declare const OutputBrowserUseServerToolItemType$inboundSchema: z.ZodEnum<typeof OutputBrowserUseServerToolItemType>;
+/** @internal */
+export declare const OutputBrowserUseServerToolItemType$outboundSchema: z.ZodEnum<typeof OutputBrowserUseServerToolItemType>;
+/** @internal */
 export declare const OutputBrowserUseServerToolItem$inboundSchema: z.ZodType<OutputBrowserUseServerToolItem, unknown>;
+/** @internal */
+export type OutputBrowserUseServerToolItem$Outbound = {
+    action?: string | undefined;
+    id?: string | undefined;
+    screenshotB64?: string | undefined;
+    status: string;
+    type: string;
+};
+/** @internal */
+export declare const OutputBrowserUseServerToolItem$outboundSchema: z.ZodType<OutputBrowserUseServerToolItem$Outbound, OutputBrowserUseServerToolItem>;
+export declare function outputBrowserUseServerToolItemToJSON(outputBrowserUseServerToolItem: OutputBrowserUseServerToolItem): string;
 export declare function outputBrowserUseServerToolItemFromJSON(jsonString: string): SafeParseResult<OutputBrowserUseServerToolItem, SDKValidationError>;
 //# sourceMappingURL=outputbrowseruseservertoolitem.d.ts.map

package/esm/models/outputbrowseruseservertoolitem.js

@@ -4,15 +4,33 @@
  */
 import * as z from "zod/v4";
 import { safeParse } from "../lib/schemas.js";
-import { ToolCallStatus$inboundSchema, } from "./toolcallstatus.js";
+import { ToolCallStatus$inboundSchema, ToolCallStatus$outboundSchema, } from "./toolcallstatus.js";
+export const OutputBrowserUseServerToolItemType = {
+    OpenrouterBrowserUse: "openrouter:browser_use",
+};
+/** @internal */
+export const OutputBrowserUseServerToolItemType$inboundSchema = z.enum(OutputBrowserUseServerToolItemType);
+/** @internal */
+export const OutputBrowserUseServerToolItemType$outboundSchema = OutputBrowserUseServerToolItemType$inboundSchema;
 /** @internal */
 export const OutputBrowserUseServerToolItem$inboundSchema = z.object({
     action: z.string().optional(),
     id: z.string().optional(),
     screenshotB64: z.string().optional(),
     status: ToolCallStatus$inboundSchema,
-    type: z.literal("openrouter:browser_use"),
+    type: OutputBrowserUseServerToolItemType$inboundSchema,
+});
+/** @internal */
+export const OutputBrowserUseServerToolItem$outboundSchema = z.object({
+    action: z.string().optional(),
+    id: z.string().optional(),
+    screenshotB64: z.string().optional(),
+    status: ToolCallStatus$outboundSchema,
+    type: OutputBrowserUseServerToolItemType$outboundSchema,
 });
+export function outputBrowserUseServerToolItemToJSON(outputBrowserUseServerToolItem) {
+    return JSON.stringify(OutputBrowserUseServerToolItem$outboundSchema.parse(outputBrowserUseServerToolItem));
+}
 export function outputBrowserUseServerToolItemFromJSON(jsonString) {
     return safeParse(jsonString, (x) => OutputBrowserUseServerToolItem$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'OutputBrowserUseServerToolItem' from JSON`);
 }

package/esm/models/outputcodeinterpretercallitem.d.ts

@@ -1,5 +1,6 @@
 import * as z from "zod/v4";
 import * as discriminatedUnionTypes from "../types/discriminatedUnion.js";
+import { ClosedEnum } from "../types/enums.js";
 import { Result as SafeParseResult } from "../types/fp.js";
 import { SDKValidationError } from "./errors/sdkvalidationerror.js";
 import { ToolCallStatus } from "./toolcallstatus.js";
@@ -12,6 +13,10 @@ export type OutputImage = {
     url: string;
 };
 export type OutputCodeInterpreterCallItemOutputUnion = OutputImage | OutputLogs | discriminatedUnionTypes.Unknown<"type">;
+export declare const TypeCodeInterpreterCall: {
+    readonly CodeInterpreterCall: "code_interpreter_call";
+};
+export type TypeCodeInterpreterCall = ClosedEnum<typeof TypeCodeInterpreterCall>;
 /**
  * A code interpreter execution call with outputs
  */
@@ -21,18 +26,55 @@ export type OutputCodeInterpreterCallItem = {
     id: string;
     outputs: Array<OutputImage | OutputLogs | discriminatedUnionTypes.Unknown<"type">> | null;
     status: ToolCallStatus;
-    type: "code_interpreter_call";
+    type: TypeCodeInterpreterCall;
 };
 /** @internal */
 export declare const OutputLogs$inboundSchema: z.ZodType<OutputLogs, unknown>;
+/** @internal */
+export type OutputLogs$Outbound = {
+    logs: string;
+    type: "logs";
+};
+/** @internal */
+export declare const OutputLogs$outboundSchema: z.ZodType<OutputLogs$Outbound, OutputLogs>;
+export declare function outputLogsToJSON(outputLogs: OutputLogs): string;
 export declare function outputLogsFromJSON(jsonString: string): SafeParseResult<OutputLogs, SDKValidationError>;
 /** @internal */
 export declare const OutputImage$inboundSchema: z.ZodType<OutputImage, unknown>;
+/** @internal */
+export type OutputImage$Outbound = {
+    type: "image";
+    url: string;
+};
+/** @internal */
+export declare const OutputImage$outboundSchema: z.ZodType<OutputImage$Outbound, OutputImage>;
+export declare function outputImageToJSON(outputImage: OutputImage): string;
 export declare function outputImageFromJSON(jsonString: string): SafeParseResult<OutputImage, SDKValidationError>;
 /** @internal */
 export declare const OutputCodeInterpreterCallItemOutputUnion$inboundSchema: z.ZodType<OutputCodeInterpreterCallItemOutputUnion, unknown>;
+/** @internal */
+export type OutputCodeInterpreterCallItemOutputUnion$Outbound = OutputImage$Outbound | OutputLogs$Outbound;
+/** @internal */
+export declare const OutputCodeInterpreterCallItemOutputUnion$outboundSchema: z.ZodType<OutputCodeInterpreterCallItemOutputUnion$Outbound, OutputCodeInterpreterCallItemOutputUnion>;
+export declare function outputCodeInterpreterCallItemOutputUnionToJSON(outputCodeInterpreterCallItemOutputUnion: OutputCodeInterpreterCallItemOutputUnion): string;
 export declare function outputCodeInterpreterCallItemOutputUnionFromJSON(jsonString: string): SafeParseResult<OutputCodeInterpreterCallItemOutputUnion, SDKValidationError>;
 /** @internal */
+export declare const TypeCodeInterpreterCall$inboundSchema: z.ZodEnum<typeof TypeCodeInterpreterCall>;
+/** @internal */
+export declare const TypeCodeInterpreterCall$outboundSchema: z.ZodEnum<typeof TypeCodeInterpreterCall>;
+/** @internal */
 export declare const OutputCodeInterpreterCallItem$inboundSchema: z.ZodType<OutputCodeInterpreterCallItem, unknown>;
+/** @internal */
+export type OutputCodeInterpreterCallItem$Outbound = {
+    code: string | null;
+    container_id: string;
+    id: string;
+    outputs: Array<OutputImage$Outbound | OutputLogs$Outbound> | null;
+    status: string;
+    type: string;
+};
+/** @internal */
+export declare const OutputCodeInterpreterCallItem$outboundSchema: z.ZodType<OutputCodeInterpreterCallItem$Outbound, OutputCodeInterpreterCallItem>;
+export declare function outputCodeInterpreterCallItemToJSON(outputCodeInterpreterCallItem: OutputCodeInterpreterCallItem): string;
 export declare function outputCodeInterpreterCallItemFromJSON(jsonString: string): SafeParseResult<OutputCodeInterpreterCallItem, SDKValidationError>;
 //# sourceMappingURL=outputcodeinterpretercallitem.d.ts.map