@openrouter/sdk 1.2.18 → 1.2.20

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: "1.2.18";
+    readonly sdkVersion: "1.2.20";
     readonly genVersion: "2.914.0";
-    readonly userAgent: "speakeasy-sdk/typescript 1.2.18 2.914.0 1.0.0 @openrouter/sdk";
+    readonly userAgent: "speakeasy-sdk/typescript 1.2.20 2.914.0 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: "1.2.18",
+    sdkVersion: "1.2.20",
     genVersion: "2.914.0",
-    userAgent: "speakeasy-sdk/typescript 1.2.18 2.914.0 1.0.0 @openrouter/sdk",
+    userAgent: "speakeasy-sdk/typescript 1.2.20 2.914.0 1.0.0 @openrouter/sdk",
 };
 //# sourceMappingURL=config.js.map

package/esm/models/autobetarouterplugin.d.ts

@@ -1,7 +1,7 @@
 import * as z from "zod/v4";
 import { OpenEnum } from "../types/enums.js";
 /**
- * Named cost/quality setting. For auto-beta-router, tiers select cost-percentile bands: low = [0, 20), medium = [20, 40), high = [40, 60), xhigh = [60, 80), and max = [80, 100]. Numeric cost_quality_tradeoff takes precedence and retains ceiling behavior.
+ * Named cost/quality setting. For auto-beta-router, tiers select cost-percentile bands: low = [0, 20), medium = [20, 40), high = [40, 60), xhigh = [60, 80), and max = [80, 100]. Takes precedence over the deprecated numeric cost_quality_tradeoff when both are provided.
  */
 export declare const AutoBetaRouterPluginCostTier: {
     readonly Low: "low";
@@ -11,22 +11,22 @@ export declare const AutoBetaRouterPluginCostTier: {
     readonly Max: "max";
 };
 /**
- * Named cost/quality setting. For auto-beta-router, tiers select cost-percentile bands: low = [0, 20), medium = [20, 40), high = [40, 60), xhigh = [60, 80), and max = [80, 100]. Numeric cost_quality_tradeoff takes precedence and retains ceiling behavior.
+ * Named cost/quality setting. For auto-beta-router, tiers select cost-percentile bands: low = [0, 20), medium = [20, 40), high = [40, 60), xhigh = [60, 80), and max = [80, 100]. Takes precedence over the deprecated numeric cost_quality_tradeoff when both are provided.
  */
 export type AutoBetaRouterPluginCostTier = OpenEnum<typeof AutoBetaRouterPluginCostTier>;
 export type AutoBetaRouterPlugin = {
     /**
-     * List of model patterns to filter which models the auto-beta-router can route between. Supports wildcards (e.g., "anthropic/*" matches all Anthropic models). When not specified, uses the default supported models list.
+     * List of model patterns to filter which models the auto-beta-router can route between. Supports wildcards (e.g., "anthropic/*" matches all Anthropic models). When not specified, every model ranked for the classified task type is a candidate, falling back to a default model set when rankings are unavailable.
      */
     allowedModels?: Array<string> | undefined;
     /**
-     * Deprecated: Use cost_tier instead. Balances routing between cost and quality on a 0-10 scale. The auto-beta-router ranks models for the classified task type by community spend share, then filters candidates by their average cost per generation for that task. Higher values favor cheaper models: 10 keeps only models around the cheapest 10th percentile, while 0 permits models up to the 90th percentile for cost. Defaults to 9. Numeric cost_quality_tradeoff remains supported, retains ceiling behavior, and takes precedence over cost_tier when both are provided.
+     * Deprecated: Use cost_tier instead. Balances routing between cost and quality on a 0-10 scale. The auto-beta-router ranks models for the classified task type by community spend share, then filters candidates by their average cost per generation for that task. Higher values favor cheaper models: 10 keeps only models around the cheapest 10th percentile, while 0 permits models up to the 90th percentile for cost. Defaults to 9 when no cost setting is provided. It remains supported and retains ceiling behavior, but cost_tier takes precedence when both are provided.
      *
      * @deprecated field: This will be removed in a future release, please migrate away from it as soon as possible.
      */
     costQualityTradeoff?: number | undefined;
     /**
-     * Named cost/quality setting. For auto-beta-router, tiers select cost-percentile bands: low = [0, 20), medium = [20, 40), high = [40, 60), xhigh = [60, 80), and max = [80, 100]. Numeric cost_quality_tradeoff takes precedence and retains ceiling behavior.
+     * Named cost/quality setting. For auto-beta-router, tiers select cost-percentile bands: low = [0, 20), medium = [20, 40), high = [40, 60), xhigh = [60, 80), and max = [80, 100]. Takes precedence over the deprecated numeric cost_quality_tradeoff when both are provided.
      */
     costTier?: AutoBetaRouterPluginCostTier | undefined;
     /**

package/esm/models/autobetarouterplugin.js

@@ -6,7 +6,7 @@ import * as z from "zod/v4";
 import { remap as remap$ } from "../lib/primitives.js";
 import * as openEnums from "../types/enums.js";
 /**
- * Named cost/quality setting. For auto-beta-router, tiers select cost-percentile bands: low = [0, 20), medium = [20, 40), high = [40, 60), xhigh = [60, 80), and max = [80, 100]. Numeric cost_quality_tradeoff takes precedence and retains ceiling behavior.
+ * Named cost/quality setting. For auto-beta-router, tiers select cost-percentile bands: low = [0, 20), medium = [20, 40), high = [40, 60), xhigh = [60, 80), and max = [80, 100]. Takes precedence over the deprecated numeric cost_quality_tradeoff when both are provided.
  */
 export const AutoBetaRouterPluginCostTier = {
     Low: "low",

package/esm/models/autorouterplugin.d.ts

@@ -1,7 +1,7 @@
 import * as z from "zod/v4";
 import { OpenEnum } from "../types/enums.js";
 /**
- * Shorthand for cost_quality_tradeoff. Higher tiers spend more on better models: low = 9, medium = 7, high = 5, xhigh = 3, and max = 1. Numeric cost_quality_tradeoff takes precedence when both are provided.
+ * Named cost/quality setting. Tiers select cost-percentile bands: low = [0, 20), medium = [20, 40), high = [40, 60), xhigh = [60, 80), and max = [80, 100]. Takes precedence over the deprecated numeric cost_quality_tradeoff when both are provided.
  */
 export declare const AutoRouterPluginCostTier: {
     readonly Low: "low";
@@ -11,22 +11,22 @@ export declare const AutoRouterPluginCostTier: {
     readonly Max: "max";
 };
 /**
- * Shorthand for cost_quality_tradeoff. Higher tiers spend more on better models: low = 9, medium = 7, high = 5, xhigh = 3, and max = 1. Numeric cost_quality_tradeoff takes precedence when both are provided.
+ * Named cost/quality setting. Tiers select cost-percentile bands: low = [0, 20), medium = [20, 40), high = [40, 60), xhigh = [60, 80), and max = [80, 100]. Takes precedence over the deprecated numeric cost_quality_tradeoff when both are provided.
  */
 export type AutoRouterPluginCostTier = OpenEnum<typeof AutoRouterPluginCostTier>;
 export type AutoRouterPlugin = {
     /**
-     * List of model patterns to filter which models the auto-router can route between. Supports wildcards (e.g., "anthropic/*" matches all Anthropic models). When not specified, uses the default supported models list.
+     * List of model patterns to filter which models the auto-router can route between. Supports wildcards (e.g., "anthropic/*" matches all Anthropic models). When not specified, every model ranked for the classified task type is a candidate, falling back to a default model set when rankings are unavailable.
      */
     allowedModels?: Array<string> | undefined;
     /**
-     * Deprecated: Use cost_tier instead. Controls cost vs. quality routing tradeoff (0–10). 0 = pure quality (best model regardless of cost), 10 = maximize for cost (cheapest model wins). Intermediate values blend quality and cost signals continuously. Defaults to 7. Numeric cost_quality_tradeoff remains supported and takes precedence over cost_tier when both are provided.
+     * Deprecated: Use cost_tier instead. Balances routing between cost and quality on a 0-10 scale. The auto-router ranks models for the classified task type by community spend share, then filters candidates by their average cost per generation for that task. Higher values favor cheaper models: 10 keeps only models around the cheapest 10th percentile, while 0 permits models up to the 90th percentile for cost. Defaults to 9 when no cost setting is provided. It remains supported and retains ceiling behavior, but cost_tier takes precedence when both are provided.
      *
      * @deprecated field: This will be removed in a future release, please migrate away from it as soon as possible.
      */
     costQualityTradeoff?: number | undefined;
     /**
-     * Shorthand for cost_quality_tradeoff. Higher tiers spend more on better models: low = 9, medium = 7, high = 5, xhigh = 3, and max = 1. Numeric cost_quality_tradeoff takes precedence when both are provided.
+     * Named cost/quality setting. Tiers select cost-percentile bands: low = [0, 20), medium = [20, 40), high = [40, 60), xhigh = [60, 80), and max = [80, 100]. Takes precedence over the deprecated numeric cost_quality_tradeoff when both are provided.
      */
     costTier?: AutoRouterPluginCostTier | undefined;
     /**

package/esm/models/autorouterplugin.js

@@ -6,7 +6,7 @@ import * as z from "zod/v4";
 import { remap as remap$ } from "../lib/primitives.js";
 import * as openEnums from "../types/enums.js";
 /**
- * Shorthand for cost_quality_tradeoff. Higher tiers spend more on better models: low = 9, medium = 7, high = 5, xhigh = 3, and max = 1. Numeric cost_quality_tradeoff takes precedence when both are provided.
+ * Named cost/quality setting. Tiers select cost-percentile bands: low = [0, 20), medium = [20, 40), high = [40, 60), xhigh = [60, 80), and max = [80, 100]. Takes precedence over the deprecated numeric cost_quality_tradeoff when both are provided.
  */
 export const AutoRouterPluginCostTier = {
     Low: "low",

package/esm/models/codeinterpretercallcodedeltaevent.d.ts

@@ -0,0 +1,17 @@
+import * as z from "zod/v4";
+import { Result as SafeParseResult } from "../types/fp.js";
+import { SDKValidationError } from "./errors/sdkvalidationerror.js";
+/**
+ * Incremental chunk of code being streamed for a `code_interpreter_call`.
+ */
+export type CodeInterpreterCallCodeDeltaEvent = {
+    delta: string;
+    itemId: string;
+    outputIndex: number;
+    sequenceNumber: number;
+    type: "response.code_interpreter_call_code.delta";
+};
+/** @internal */
+export declare const CodeInterpreterCallCodeDeltaEvent$inboundSchema: z.ZodType<CodeInterpreterCallCodeDeltaEvent, unknown>;
+export declare function codeInterpreterCallCodeDeltaEventFromJSON(jsonString: string): SafeParseResult<CodeInterpreterCallCodeDeltaEvent, SDKValidationError>;
+//# sourceMappingURL=codeinterpretercallcodedeltaevent.d.ts.map

package/esm/models/codeinterpretercallcodedeltaevent.js

@@ -0,0 +1,25 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ * @generated-id: 1db134a3edf6
+ */
+import * as z from "zod/v4";
+import { remap as remap$ } from "../lib/primitives.js";
+import { safeParse } from "../lib/schemas.js";
+/** @internal */
+export const CodeInterpreterCallCodeDeltaEvent$inboundSchema = z.object({
+    delta: z.string(),
+    item_id: z.string(),
+    output_index: z.int(),
+    sequence_number: z.int(),
+    type: z.literal("response.code_interpreter_call_code.delta"),
+}).transform((v) => {
+    return remap$(v, {
+        "item_id": "itemId",
+        "output_index": "outputIndex",
+        "sequence_number": "sequenceNumber",
+    });
+});
+export function codeInterpreterCallCodeDeltaEventFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => CodeInterpreterCallCodeDeltaEvent$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'CodeInterpreterCallCodeDeltaEvent' from JSON`);
+}
+//# sourceMappingURL=codeinterpretercallcodedeltaevent.js.map

package/esm/models/codeinterpretercallcodedoneevent.d.ts

@@ -0,0 +1,17 @@
+import * as z from "zod/v4";
+import { Result as SafeParseResult } from "../types/fp.js";
+import { SDKValidationError } from "./errors/sdkvalidationerror.js";
+/**
+ * Emitted when code streaming completes for a `code_interpreter_call`.
+ */
+export type CodeInterpreterCallCodeDoneEvent = {
+    code: string;
+    itemId: string;
+    outputIndex: number;
+    sequenceNumber: number;
+    type: "response.code_interpreter_call_code.done";
+};
+/** @internal */
+export declare const CodeInterpreterCallCodeDoneEvent$inboundSchema: z.ZodType<CodeInterpreterCallCodeDoneEvent, unknown>;
+export declare function codeInterpreterCallCodeDoneEventFromJSON(jsonString: string): SafeParseResult<CodeInterpreterCallCodeDoneEvent, SDKValidationError>;
+//# sourceMappingURL=codeinterpretercallcodedoneevent.d.ts.map

package/esm/models/codeinterpretercallcodedoneevent.js

@@ -0,0 +1,25 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ * @generated-id: cae4088ec7c1
+ */
+import * as z from "zod/v4";
+import { remap as remap$ } from "../lib/primitives.js";
+import { safeParse } from "../lib/schemas.js";
+/** @internal */
+export const CodeInterpreterCallCodeDoneEvent$inboundSchema = z.object({
+    code: z.string(),
+    item_id: z.string(),
+    output_index: z.int(),
+    sequence_number: z.int(),
+    type: z.literal("response.code_interpreter_call_code.done"),
+}).transform((v) => {
+    return remap$(v, {
+        "item_id": "itemId",
+        "output_index": "outputIndex",
+        "sequence_number": "sequenceNumber",
+    });
+});
+export function codeInterpreterCallCodeDoneEventFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => CodeInterpreterCallCodeDoneEvent$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'CodeInterpreterCallCodeDoneEvent' from JSON`);
+}
+//# sourceMappingURL=codeinterpretercallcodedoneevent.js.map

package/esm/models/codeinterpretercallcompletedevent.d.ts

@@ -0,0 +1,16 @@
+import * as z from "zod/v4";
+import { Result as SafeParseResult } from "../types/fp.js";
+import { SDKValidationError } from "./errors/sdkvalidationerror.js";
+/**
+ * Code interpreter call completed
+ */
+export type CodeInterpreterCallCompletedEvent = {
+    itemId: string;
+    outputIndex: number;
+    sequenceNumber: number;
+    type: "response.code_interpreter_call.completed";
+};
+/** @internal */
+export declare const CodeInterpreterCallCompletedEvent$inboundSchema: z.ZodType<CodeInterpreterCallCompletedEvent, unknown>;
+export declare function codeInterpreterCallCompletedEventFromJSON(jsonString: string): SafeParseResult<CodeInterpreterCallCompletedEvent, SDKValidationError>;
+//# sourceMappingURL=codeinterpretercallcompletedevent.d.ts.map

package/esm/models/codeinterpretercallcompletedevent.js

@@ -0,0 +1,24 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ * @generated-id: 267055f103eb
+ */
+import * as z from "zod/v4";
+import { remap as remap$ } from "../lib/primitives.js";
+import { safeParse } from "../lib/schemas.js";
+/** @internal */
+export const CodeInterpreterCallCompletedEvent$inboundSchema = z.object({
+    item_id: z.string(),
+    output_index: z.int(),
+    sequence_number: z.int(),
+    type: z.literal("response.code_interpreter_call.completed"),
+}).transform((v) => {
+    return remap$(v, {
+        "item_id": "itemId",
+        "output_index": "outputIndex",
+        "sequence_number": "sequenceNumber",
+    });
+});
+export function codeInterpreterCallCompletedEventFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => CodeInterpreterCallCompletedEvent$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'CodeInterpreterCallCompletedEvent' from JSON`);
+}
+//# sourceMappingURL=codeinterpretercallcompletedevent.js.map

package/esm/models/codeinterpretercallinprogressevent.d.ts

@@ -0,0 +1,16 @@
+import * as z from "zod/v4";
+import { Result as SafeParseResult } from "../types/fp.js";
+import { SDKValidationError } from "./errors/sdkvalidationerror.js";
+/**
+ * Code interpreter call in progress
+ */
+export type CodeInterpreterCallInProgressEvent = {
+    itemId: string;
+    outputIndex: number;
+    sequenceNumber: number;
+    type: "response.code_interpreter_call.in_progress";
+};
+/** @internal */
+export declare const CodeInterpreterCallInProgressEvent$inboundSchema: z.ZodType<CodeInterpreterCallInProgressEvent, unknown>;
+export declare function codeInterpreterCallInProgressEventFromJSON(jsonString: string): SafeParseResult<CodeInterpreterCallInProgressEvent, SDKValidationError>;
+//# sourceMappingURL=codeinterpretercallinprogressevent.d.ts.map

package/esm/models/codeinterpretercallinprogressevent.js

@@ -0,0 +1,24 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ * @generated-id: 171bc7eda480
+ */
+import * as z from "zod/v4";
+import { remap as remap$ } from "../lib/primitives.js";
+import { safeParse } from "../lib/schemas.js";
+/** @internal */
+export const CodeInterpreterCallInProgressEvent$inboundSchema = z.object({
+    item_id: z.string(),
+    output_index: z.int(),
+    sequence_number: z.int(),
+    type: z.literal("response.code_interpreter_call.in_progress"),
+}).transform((v) => {
+    return remap$(v, {
+        "item_id": "itemId",
+        "output_index": "outputIndex",
+        "sequence_number": "sequenceNumber",
+    });
+});
+export function codeInterpreterCallInProgressEventFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => CodeInterpreterCallInProgressEvent$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'CodeInterpreterCallInProgressEvent' from JSON`);
+}
+//# sourceMappingURL=codeinterpretercallinprogressevent.js.map

package/esm/models/codeinterpretercallinterpretingevent.d.ts

@@ -0,0 +1,16 @@
+import * as z from "zod/v4";
+import { Result as SafeParseResult } from "../types/fp.js";
+import { SDKValidationError } from "./errors/sdkvalidationerror.js";
+/**
+ * Code interpreter is executing the code
+ */
+export type CodeInterpreterCallInterpretingEvent = {
+    itemId: string;
+    outputIndex: number;
+    sequenceNumber: number;
+    type: "response.code_interpreter_call.interpreting";
+};
+/** @internal */
+export declare const CodeInterpreterCallInterpretingEvent$inboundSchema: z.ZodType<CodeInterpreterCallInterpretingEvent, unknown>;
+export declare function codeInterpreterCallInterpretingEventFromJSON(jsonString: string): SafeParseResult<CodeInterpreterCallInterpretingEvent, SDKValidationError>;
+//# sourceMappingURL=codeinterpretercallinterpretingevent.d.ts.map

package/esm/models/codeinterpretercallinterpretingevent.js

@@ -0,0 +1,24 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ * @generated-id: 4ae310e8fd22
+ */
+import * as z from "zod/v4";
+import { remap as remap$ } from "../lib/primitives.js";
+import { safeParse } from "../lib/schemas.js";
+/** @internal */
+export const CodeInterpreterCallInterpretingEvent$inboundSchema = z.object({
+    item_id: z.string(),
+    output_index: z.int(),
+    sequence_number: z.int(),
+    type: z.literal("response.code_interpreter_call.interpreting"),
+}).transform((v) => {
+    return remap$(v, {
+        "item_id": "itemId",
+        "output_index": "outputIndex",
+        "sequence_number": "sequenceNumber",
+    });
+});
+export function codeInterpreterCallInterpretingEventFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => CodeInterpreterCallInterpretingEvent$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'CodeInterpreterCallInterpretingEvent' from JSON`);
+}
+//# sourceMappingURL=codeinterpretercallinterpretingevent.js.map

package/esm/models/codeinterpreterfileoutput.d.ts

@@ -0,0 +1,47 @@
+import * as z from "zod/v4";
+import { Result as SafeParseResult } from "../types/fp.js";
+import { SDKValidationError } from "./errors/sdkvalidationerror.js";
+export type CodeInterpreterFileOutput = {
+    /**
+     * Provider-issued download URL for the generated file. Typically signed and time-limited (see `expires_at`); fetch promptly rather than persisting the URL.
+     */
+    downloadUrl?: string | undefined;
+    /**
+     * Provider error code when generating or persisting the file failed; null or absent on success.
+     */
+    errorCode?: string | null | undefined;
+    /**
+     * When the `download_url` stops working, as an ISO 8601 timestamp. After this time the file must be regenerated.
+     */
+    expiresAt?: string | undefined;
+    filename?: string | undefined;
+    id?: string | undefined;
+    mediaType?: string | undefined;
+    sha256?: string | undefined;
+    sizeBytes?: number | undefined;
+    /**
+     * Provider-reported readiness of the generated file (e.g. `ready`). Values other than `ready` indicate the artifact may not be downloadable.
+     */
+    status?: string | undefined;
+    type: "file";
+};
+/** @internal */
+export declare const CodeInterpreterFileOutput$inboundSchema: z.ZodType<CodeInterpreterFileOutput, unknown>;
+/** @internal */
+export type CodeInterpreterFileOutput$Outbound = {
+    download_url?: string | undefined;
+    error_code?: string | null | undefined;
+    expires_at?: string | undefined;
+    filename?: string | undefined;
+    id?: string | undefined;
+    media_type?: string | undefined;
+    sha256?: string | undefined;
+    size_bytes?: number | undefined;
+    status?: string | undefined;
+    type: "file";
+};
+/** @internal */
+export declare const CodeInterpreterFileOutput$outboundSchema: z.ZodType<CodeInterpreterFileOutput$Outbound, CodeInterpreterFileOutput>;
+export declare function codeInterpreterFileOutputToJSON(codeInterpreterFileOutput: CodeInterpreterFileOutput): string;
+export declare function codeInterpreterFileOutputFromJSON(jsonString: string): SafeParseResult<CodeInterpreterFileOutput, SDKValidationError>;
+//# sourceMappingURL=codeinterpreterfileoutput.d.ts.map

package/esm/models/codeinterpreterfileoutput.js

@@ -0,0 +1,56 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ * @generated-id: a06a3be07341
+ */
+import * as z from "zod/v4";
+import { remap as remap$ } from "../lib/primitives.js";
+import { safeParse } from "../lib/schemas.js";
+/** @internal */
+export const CodeInterpreterFileOutput$inboundSchema = z.object({
+    download_url: z.string().optional(),
+    error_code: z.nullable(z.string()).optional(),
+    expires_at: z.string().optional(),
+    filename: z.string().optional(),
+    id: z.string().optional(),
+    media_type: z.string().optional(),
+    sha256: z.string().optional(),
+    size_bytes: z.int().optional(),
+    status: z.string().optional(),
+    type: z.literal("file"),
+}).transform((v) => {
+    return remap$(v, {
+        "download_url": "downloadUrl",
+        "error_code": "errorCode",
+        "expires_at": "expiresAt",
+        "media_type": "mediaType",
+        "size_bytes": "sizeBytes",
+    });
+});
+/** @internal */
+export const CodeInterpreterFileOutput$outboundSchema = z.object({
+    downloadUrl: z.string().optional(),
+    errorCode: z.nullable(z.string()).optional(),
+    expiresAt: z.string().optional(),
+    filename: z.string().optional(),
+    id: z.string().optional(),
+    mediaType: z.string().optional(),
+    sha256: z.string().optional(),
+    sizeBytes: z.int().optional(),
+    status: z.string().optional(),
+    type: z.literal("file"),
+}).transform((v) => {
+    return remap$(v, {
+        downloadUrl: "download_url",
+        errorCode: "error_code",
+        expiresAt: "expires_at",
+        mediaType: "media_type",
+        sizeBytes: "size_bytes",
+    });
+});
+export function codeInterpreterFileOutputToJSON(codeInterpreterFileOutput) {
+    return JSON.stringify(CodeInterpreterFileOutput$outboundSchema.parse(codeInterpreterFileOutput));
+}
+export function codeInterpreterFileOutputFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => CodeInterpreterFileOutput$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'CodeInterpreterFileOutput' from JSON`);
+}
+//# sourceMappingURL=codeinterpreterfileoutput.js.map

package/esm/models/codeinterpreterimageoutput.d.ts

@@ -0,0 +1,19 @@
+import * as z from "zod/v4";
+import { Result as SafeParseResult } from "../types/fp.js";
+import { SDKValidationError } from "./errors/sdkvalidationerror.js";
+export type CodeInterpreterImageOutput = {
+    type: "image";
+    url: string;
+};
+/** @internal */
+export declare const CodeInterpreterImageOutput$inboundSchema: z.ZodType<CodeInterpreterImageOutput, unknown>;
+/** @internal */
+export type CodeInterpreterImageOutput$Outbound = {
+    type: "image";
+    url: string;
+};
+/** @internal */
+export declare const CodeInterpreterImageOutput$outboundSchema: z.ZodType<CodeInterpreterImageOutput$Outbound, CodeInterpreterImageOutput>;
+export declare function codeInterpreterImageOutputToJSON(codeInterpreterImageOutput: CodeInterpreterImageOutput): string;
+export declare function codeInterpreterImageOutputFromJSON(jsonString: string): SafeParseResult<CodeInterpreterImageOutput, SDKValidationError>;
+//# sourceMappingURL=codeinterpreterimageoutput.d.ts.map

package/esm/models/codeinterpreterimageoutput.js

@@ -0,0 +1,23 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ * @generated-id: 30383bd386a1
+ */
+import * as z from "zod/v4";
+import { safeParse } from "../lib/schemas.js";
+/** @internal */
+export const CodeInterpreterImageOutput$inboundSchema = z.object({
+    type: z.literal("image"),
+    url: z.string(),
+});
+/** @internal */
+export const CodeInterpreterImageOutput$outboundSchema = z.object({
+    type: z.literal("image"),
+    url: z.string(),
+});
+export function codeInterpreterImageOutputToJSON(codeInterpreterImageOutput) {
+    return JSON.stringify(CodeInterpreterImageOutput$outboundSchema.parse(codeInterpreterImageOutput));
+}
+export function codeInterpreterImageOutputFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => CodeInterpreterImageOutput$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'CodeInterpreterImageOutput' from JSON`);
+}
+//# sourceMappingURL=codeinterpreterimageoutput.js.map

package/esm/models/codeinterpreterlogsoutput.d.ts

@@ -0,0 +1,19 @@
+import * as z from "zod/v4";
+import { Result as SafeParseResult } from "../types/fp.js";
+import { SDKValidationError } from "./errors/sdkvalidationerror.js";
+export type CodeInterpreterLogsOutput = {
+    logs: string;
+    type: "logs";
+};
+/** @internal */
+export declare const CodeInterpreterLogsOutput$inboundSchema: z.ZodType<CodeInterpreterLogsOutput, unknown>;
+/** @internal */
+export type CodeInterpreterLogsOutput$Outbound = {
+    logs: string;
+    type: "logs";
+};
+/** @internal */
+export declare const CodeInterpreterLogsOutput$outboundSchema: z.ZodType<CodeInterpreterLogsOutput$Outbound, CodeInterpreterLogsOutput>;
+export declare function codeInterpreterLogsOutputToJSON(codeInterpreterLogsOutput: CodeInterpreterLogsOutput): string;
+export declare function codeInterpreterLogsOutputFromJSON(jsonString: string): SafeParseResult<CodeInterpreterLogsOutput, SDKValidationError>;
+//# sourceMappingURL=codeinterpreterlogsoutput.d.ts.map

package/esm/models/codeinterpreterlogsoutput.js

@@ -0,0 +1,23 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ * @generated-id: d91c0ced3c74
+ */
+import * as z from "zod/v4";
+import { safeParse } from "../lib/schemas.js";
+/** @internal */
+export const CodeInterpreterLogsOutput$inboundSchema = z.object({
+    logs: z.string(),
+    type: z.literal("logs"),
+});
+/** @internal */
+export const CodeInterpreterLogsOutput$outboundSchema = z.object({
+    logs: z.string(),
+    type: z.literal("logs"),
+});
+export function codeInterpreterLogsOutputToJSON(codeInterpreterLogsOutput) {
+    return JSON.stringify(CodeInterpreterLogsOutput$outboundSchema.parse(codeInterpreterLogsOutput));
+}
+export function codeInterpreterLogsOutputFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => CodeInterpreterLogsOutput$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'CodeInterpreterLogsOutput' from JSON`);
+}
+//# sourceMappingURL=codeinterpreterlogsoutput.js.map

package/esm/models/index.d.ts

@@ -134,6 +134,14 @@ export * from "./chattoolmessage.js";
 export * from "./chatusage.js";
 export * from "./chatusermessage.js";
 export * from "./chatwebsearchshorthand.js";
+export * from "./codeinterpretercallcodedeltaevent.js";
+export * from "./codeinterpretercallcodedoneevent.js";
+export * from "./codeinterpretercallcompletedevent.js";
+export * from "./codeinterpretercallinprogressevent.js";
+export * from "./codeinterpretercallinterpretingevent.js";
+export * from "./codeinterpreterfileoutput.js";
+export * from "./codeinterpreterimageoutput.js";
+export * from "./codeinterpreterlogsoutput.js";
 export * from "./codeinterpreterservertool.js";
 export * from "./codexlocalshelltool.js";
 export * from "./compactionitem.js";

package/esm/models/index.js

@@ -138,6 +138,14 @@ export * from "./chattoolmessage.js";
 export * from "./chatusage.js";
 export * from "./chatusermessage.js";
 export * from "./chatwebsearchshorthand.js";
+export * from "./codeinterpretercallcodedeltaevent.js";
+export * from "./codeinterpretercallcodedoneevent.js";
+export * from "./codeinterpretercallcompletedevent.js";
+export * from "./codeinterpretercallinprogressevent.js";
+export * from "./codeinterpretercallinterpretingevent.js";
+export * from "./codeinterpreterfileoutput.js";
+export * from "./codeinterpreterimageoutput.js";
+export * from "./codeinterpreterlogsoutput.js";
 export * from "./codeinterpreterservertool.js";
 export * from "./codexlocalshelltool.js";
 export * from "./compactionitem.js";

package/esm/models/inputsunion.d.ts

@@ -134,11 +134,11 @@ export type InputsMessage = {
     status?: InputsStatusCompleted1 | InputsStatusIncomplete1 | InputsStatusInProgress1 | undefined;
     type?: InputsTypeMessage | undefined;
 };
-export type InputsUnion1 = OutputCodeInterpreterCallItem | FunctionCallItem | LocalShellCallItem | McpApprovalRequestItem | McpCallItem | ApplyPatchCallItem | OutputFunctionCallItem | OutputCustomToolCallItem | OutputFileSearchCallItem | OutputComputerCallItem | OutputDatetimeItem | McpListToolsItem | CustomToolCallItem | AgentMessageItem | ReasoningItem | FunctionCallOutputItem | ApplyPatchCallOutputItem | InputsMessage | InputsReasoning | OutputWebSearchCallItem | OutputImageGenerationCallItem | LocalShellCallOutputItem | ShellCallItem | ShellCallOutputItem | McpApprovalResponseItem | CustomToolCallOutputItem | AdditionalToolsItem | OutputWebSearchServerToolItem | OutputCodeInterpreterServerToolItem | OutputFileSearchServerToolItem | OutputImageGenerationServerToolItem | OutputBrowserUseServerToolItem | OutputBashServerToolItem | OutputTextEditorServerToolItem | OutputApplyPatchServerToolItem | OutputWebFetchServerToolItem | OutputToolSearchServerToolItem | OutputMemoryServerToolItem | OutputMcpServerToolItem | OutputSearchModelsServerToolItem | OutputFusionServerToolItem | OutputAdvisorServerToolItem | OutputSubagentServerToolItem | OutputFilesServerToolItem | CompactionItem | ItemReferenceItem | EasyInputMessage | InputMessageItem | ContextCompactionItem;
+export type InputsUnion1 = FunctionCallItem | LocalShellCallItem | McpApprovalRequestItem | McpCallItem | ApplyPatchCallItem | OutputFunctionCallItem | OutputCustomToolCallItem | OutputFileSearchCallItem | OutputComputerCallItem | OutputDatetimeItem | McpListToolsItem | CustomToolCallItem | AgentMessageItem | ReasoningItem | FunctionCallOutputItem | ApplyPatchCallOutputItem | InputsMessage | InputsReasoning | OutputWebSearchCallItem | OutputImageGenerationCallItem | OutputCodeInterpreterCallItem | LocalShellCallOutputItem | ShellCallItem | ShellCallOutputItem | McpApprovalResponseItem | CustomToolCallOutputItem | AdditionalToolsItem | OutputWebSearchServerToolItem | OutputCodeInterpreterServerToolItem | OutputFileSearchServerToolItem | OutputImageGenerationServerToolItem | OutputBrowserUseServerToolItem | OutputBashServerToolItem | OutputTextEditorServerToolItem | OutputApplyPatchServerToolItem | OutputWebFetchServerToolItem | OutputToolSearchServerToolItem | OutputMemoryServerToolItem | OutputMcpServerToolItem | OutputSearchModelsServerToolItem | OutputFusionServerToolItem | OutputAdvisorServerToolItem | OutputSubagentServerToolItem | OutputFilesServerToolItem | CompactionItem | ItemReferenceItem | EasyInputMessage | InputMessageItem | ContextCompactionItem;
 /**
  * Input for a response request - can be a string or array of items
  */
-export type InputsUnion = string | Array<OutputCodeInterpreterCallItem | FunctionCallItem | LocalShellCallItem | McpApprovalRequestItem | McpCallItem | ApplyPatchCallItem | OutputFunctionCallItem | OutputCustomToolCallItem | OutputFileSearchCallItem | OutputComputerCallItem | OutputDatetimeItem | McpListToolsItem | CustomToolCallItem | AgentMessageItem | ReasoningItem | FunctionCallOutputItem | ApplyPatchCallOutputItem | InputsMessage | InputsReasoning | OutputWebSearchCallItem | OutputImageGenerationCallItem | LocalShellCallOutputItem | ShellCallItem | ShellCallOutputItem | McpApprovalResponseItem | CustomToolCallOutputItem | AdditionalToolsItem | OutputWebSearchServerToolItem | OutputCodeInterpreterServerToolItem | OutputFileSearchServerToolItem | OutputImageGenerationServerToolItem | OutputBrowserUseServerToolItem | OutputBashServerToolItem | OutputTextEditorServerToolItem | OutputApplyPatchServerToolItem | OutputWebFetchServerToolItem | OutputToolSearchServerToolItem | OutputMemoryServerToolItem | OutputMcpServerToolItem | OutputSearchModelsServerToolItem | OutputFusionServerToolItem | OutputAdvisorServerToolItem | OutputSubagentServerToolItem | OutputFilesServerToolItem | CompactionItem | ItemReferenceItem | EasyInputMessage | InputMessageItem | ContextCompactionItem>;
+export type InputsUnion = string | Array<FunctionCallItem | LocalShellCallItem | McpApprovalRequestItem | McpCallItem | ApplyPatchCallItem | OutputFunctionCallItem | OutputCustomToolCallItem | OutputFileSearchCallItem | OutputComputerCallItem | OutputDatetimeItem | McpListToolsItem | CustomToolCallItem | AgentMessageItem | ReasoningItem | FunctionCallOutputItem | ApplyPatchCallOutputItem | InputsMessage | InputsReasoning | OutputWebSearchCallItem | OutputImageGenerationCallItem | OutputCodeInterpreterCallItem | LocalShellCallOutputItem | ShellCallItem | ShellCallOutputItem | McpApprovalResponseItem | CustomToolCallOutputItem | AdditionalToolsItem | OutputWebSearchServerToolItem | OutputCodeInterpreterServerToolItem | OutputFileSearchServerToolItem | OutputImageGenerationServerToolItem | OutputBrowserUseServerToolItem | OutputBashServerToolItem | OutputTextEditorServerToolItem | OutputApplyPatchServerToolItem | OutputWebFetchServerToolItem | OutputToolSearchServerToolItem | OutputMemoryServerToolItem | OutputMcpServerToolItem | OutputSearchModelsServerToolItem | OutputFusionServerToolItem | OutputAdvisorServerToolItem | OutputSubagentServerToolItem | OutputFilesServerToolItem | CompactionItem | ItemReferenceItem | EasyInputMessage | InputMessageItem | ContextCompactionItem>;
 /** @internal */
 export declare const InputsStatusInProgress2$outboundSchema: z.ZodEnum<typeof InputsStatusInProgress2>;
 /** @internal */
@@ -213,12 +213,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 = OutputCodeInterpreterCallItem$Outbound | FunctionCallItem$Outbound | LocalShellCallItem$Outbound | McpApprovalRequestItem$Outbound | McpCallItem$Outbound | ApplyPatchCallItem$Outbound | OutputFunctionCallItem$Outbound | OutputCustomToolCallItem$Outbound | OutputFileSearchCallItem$Outbound | OutputComputerCallItem$Outbound | OutputDatetimeItem$Outbound | McpListToolsItem$Outbound | CustomToolCallItem$Outbound | AgentMessageItem$Outbound | ReasoningItem$Outbound | FunctionCallOutputItem$Outbound | ApplyPatchCallOutputItem$Outbound | InputsMessage$Outbound | InputsReasoning$Outbound | OutputWebSearchCallItem$Outbound | OutputImageGenerationCallItem$Outbound | LocalShellCallOutputItem$Outbound | ShellCallItem$Outbound | ShellCallOutputItem$Outbound | McpApprovalResponseItem$Outbound | CustomToolCallOutputItem$Outbound | AdditionalToolsItem$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 | OutputFusionServerToolItem$Outbound | OutputAdvisorServerToolItem$Outbound | OutputSubagentServerToolItem$Outbound | OutputFilesServerToolItem$Outbound | CompactionItem$Outbound | ItemReferenceItem$Outbound | EasyInputMessage$Outbound | InputMessageItem$Outbound | ContextCompactionItem$Outbound;
+export type InputsUnion1$Outbound = FunctionCallItem$Outbound | LocalShellCallItem$Outbound | McpApprovalRequestItem$Outbound | McpCallItem$Outbound | ApplyPatchCallItem$Outbound | OutputFunctionCallItem$Outbound | OutputCustomToolCallItem$Outbound | OutputFileSearchCallItem$Outbound | OutputComputerCallItem$Outbound | OutputDatetimeItem$Outbound | McpListToolsItem$Outbound | CustomToolCallItem$Outbound | AgentMessageItem$Outbound | ReasoningItem$Outbound | FunctionCallOutputItem$Outbound | ApplyPatchCallOutputItem$Outbound | InputsMessage$Outbound | InputsReasoning$Outbound | OutputWebSearchCallItem$Outbound | OutputImageGenerationCallItem$Outbound | OutputCodeInterpreterCallItem$Outbound | LocalShellCallOutputItem$Outbound | ShellCallItem$Outbound | ShellCallOutputItem$Outbound | McpApprovalResponseItem$Outbound | CustomToolCallOutputItem$Outbound | AdditionalToolsItem$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 | OutputFusionServerToolItem$Outbound | OutputAdvisorServerToolItem$Outbound | OutputSubagentServerToolItem$Outbound | OutputFilesServerToolItem$Outbound | CompactionItem$Outbound | ItemReferenceItem$Outbound | EasyInputMessage$Outbound | InputMessageItem$Outbound | ContextCompactionItem$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<OutputCodeInterpreterCallItem$Outbound | FunctionCallItem$Outbound | LocalShellCallItem$Outbound | McpApprovalRequestItem$Outbound | McpCallItem$Outbound | ApplyPatchCallItem$Outbound | OutputFunctionCallItem$Outbound | OutputCustomToolCallItem$Outbound | OutputFileSearchCallItem$Outbound | OutputComputerCallItem$Outbound | OutputDatetimeItem$Outbound | McpListToolsItem$Outbound | CustomToolCallItem$Outbound | AgentMessageItem$Outbound | ReasoningItem$Outbound | FunctionCallOutputItem$Outbound | ApplyPatchCallOutputItem$Outbound | InputsMessage$Outbound | InputsReasoning$Outbound | OutputWebSearchCallItem$Outbound | OutputImageGenerationCallItem$Outbound | LocalShellCallOutputItem$Outbound | ShellCallItem$Outbound | ShellCallOutputItem$Outbound | McpApprovalResponseItem$Outbound | CustomToolCallOutputItem$Outbound | AdditionalToolsItem$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 | OutputFusionServerToolItem$Outbound | OutputAdvisorServerToolItem$Outbound | OutputSubagentServerToolItem$Outbound | OutputFilesServerToolItem$Outbound | CompactionItem$Outbound | ItemReferenceItem$Outbound | EasyInputMessage$Outbound | InputMessageItem$Outbound | ContextCompactionItem$Outbound>;
+export type InputsUnion$Outbound = string | Array<FunctionCallItem$Outbound | LocalShellCallItem$Outbound | McpApprovalRequestItem$Outbound | McpCallItem$Outbound | ApplyPatchCallItem$Outbound | OutputFunctionCallItem$Outbound | OutputCustomToolCallItem$Outbound | OutputFileSearchCallItem$Outbound | OutputComputerCallItem$Outbound | OutputDatetimeItem$Outbound | McpListToolsItem$Outbound | CustomToolCallItem$Outbound | AgentMessageItem$Outbound | ReasoningItem$Outbound | FunctionCallOutputItem$Outbound | ApplyPatchCallOutputItem$Outbound | InputsMessage$Outbound | InputsReasoning$Outbound | OutputWebSearchCallItem$Outbound | OutputImageGenerationCallItem$Outbound | OutputCodeInterpreterCallItem$Outbound | LocalShellCallOutputItem$Outbound | ShellCallItem$Outbound | ShellCallOutputItem$Outbound | McpApprovalResponseItem$Outbound | CustomToolCallOutputItem$Outbound | AdditionalToolsItem$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 | OutputFusionServerToolItem$Outbound | OutputAdvisorServerToolItem$Outbound | OutputSubagentServerToolItem$Outbound | OutputFilesServerToolItem$Outbound | CompactionItem$Outbound | ItemReferenceItem$Outbound | EasyInputMessage$Outbound | InputMessageItem$Outbound | ContextCompactionItem$Outbound>;
 /** @internal */
 export declare const InputsUnion$outboundSchema: z.ZodType<InputsUnion$Outbound, InputsUnion>;
 export declare function inputsUnionToJSON(inputsUnion: InputsUnion): string;

package/esm/models/inputsunion.js

@@ -205,7 +205,6 @@ export function inputsMessageToJSON(inputsMessage) {
 }
 /** @internal */
 export const InputsUnion1$outboundSchema = z.union([
-    OutputCodeInterpreterCallItem$outboundSchema,
     FunctionCallItem$outboundSchema,
     LocalShellCallItem$outboundSchema,
     McpApprovalRequestItem$outboundSchema,
@@ -226,6 +225,7 @@ export const InputsUnion1$outboundSchema = z.union([
     z.lazy(() => InputsReasoning$outboundSchema),
     OutputWebSearchCallItem$outboundSchema,
     OutputImageGenerationCallItem$outboundSchema,
+    OutputCodeInterpreterCallItem$outboundSchema,
     LocalShellCallOutputItem$outboundSchema,
     ShellCallItem$outboundSchema,
     ShellCallOutputItem$outboundSchema,
@@ -262,7 +262,6 @@ export function inputsUnion1ToJSON(inputsUnion1) {
 export const InputsUnion$outboundSchema = z.union([
     z.string(),
     z.array(z.union([
-        OutputCodeInterpreterCallItem$outboundSchema,
         FunctionCallItem$outboundSchema,
         LocalShellCallItem$outboundSchema,
         McpApprovalRequestItem$outboundSchema,
@@ -283,6 +282,7 @@ export const InputsUnion$outboundSchema = z.union([
         z.lazy(() => InputsReasoning$outboundSchema),
         OutputWebSearchCallItem$outboundSchema,
         OutputImageGenerationCallItem$outboundSchema,
+        OutputCodeInterpreterCallItem$outboundSchema,
         LocalShellCallOutputItem$outboundSchema,
         ShellCallItem$outboundSchema,
         ShellCallOutputItem$outboundSchema,

package/esm/models/outputcodeinterpretercallitem.d.ts

@@ -1,77 +1,65 @@
 import * as z from "zod/v4";
 import * as discriminatedUnionTypes from "../types/discriminatedUnion.js";
-import { ClosedEnum } from "../types/enums.js";
+import { ClosedEnum, OpenEnum } from "../types/enums.js";
 import { Result as SafeParseResult } from "../types/fp.js";
+import { CodeInterpreterFileOutput, CodeInterpreterFileOutput$Outbound } from "./codeinterpreterfileoutput.js";
+import { CodeInterpreterImageOutput, CodeInterpreterImageOutput$Outbound } from "./codeinterpreterimageoutput.js";
+import { CodeInterpreterLogsOutput, CodeInterpreterLogsOutput$Outbound } from "./codeinterpreterlogsoutput.js";
 import { SDKValidationError } from "./errors/sdkvalidationerror.js";
-import { ToolCallStatus } from "./toolcallstatus.js";
-export type OutputLogs = {
-    logs: string;
-    type: "logs";
+export type OutputCodeInterpreterCallItemOutput = CodeInterpreterFileOutput | CodeInterpreterImageOutput | CodeInterpreterLogsOutput | discriminatedUnionTypes.Unknown<"type">;
+export declare const OutputCodeInterpreterCallItemStatus: {
+    readonly InProgress: "in_progress";
+    readonly Completed: "completed";
+    readonly Incomplete: "incomplete";
+    readonly Interpreting: "interpreting";
+    readonly Failed: "failed";
 };
-export type OutputImage = {
-    type: "image";
-    url: string;
-};
-export type OutputCodeInterpreterCallItemOutputUnion = OutputImage | OutputLogs | discriminatedUnionTypes.Unknown<"type">;
-export declare const TypeCodeInterpreterCall: {
+export type OutputCodeInterpreterCallItemStatus = OpenEnum<typeof OutputCodeInterpreterCallItemStatus>;
+export declare const OutputCodeInterpreterCallItemType: {
     readonly CodeInterpreterCall: "code_interpreter_call";
 };
-export type TypeCodeInterpreterCall = ClosedEnum<typeof TypeCodeInterpreterCall>;
+export type OutputCodeInterpreterCallItemType = ClosedEnum<typeof OutputCodeInterpreterCallItemType>;
 /**
  * A code interpreter execution call with outputs
  */
 export type OutputCodeInterpreterCallItem = {
-    code: string | null;
-    containerId: string;
+    code?: string | null | undefined;
+    containerId?: string | undefined;
     id: string;
-    outputs: Array<OutputImage | OutputLogs | discriminatedUnionTypes.Unknown<"type">> | null;
-    status: ToolCallStatus;
-    type: TypeCodeInterpreterCall;
-};
-/** @internal */
-export declare const OutputLogs$inboundSchema: z.ZodType<OutputLogs, unknown>;
-/** @internal */
-export type OutputLogs$Outbound = {
-    logs: string;
-    type: "logs";
+    outputs?: Array<CodeInterpreterFileOutput | CodeInterpreterImageOutput | CodeInterpreterLogsOutput | discriminatedUnionTypes.Unknown<"type">> | null | undefined;
+    status: OutputCodeInterpreterCallItemStatus;
+    type: OutputCodeInterpreterCallItemType;
+    additionalProperties?: {
+        [k: string]: any;
+    } | undefined;
 };
 /** @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;
-};
+export declare const OutputCodeInterpreterCallItemOutput$inboundSchema: z.ZodType<OutputCodeInterpreterCallItemOutput, unknown>;
 /** @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>;
+export type OutputCodeInterpreterCallItemOutput$Outbound = CodeInterpreterFileOutput$Outbound | CodeInterpreterImageOutput$Outbound | CodeInterpreterLogsOutput$Outbound;
 /** @internal */
-export declare const OutputCodeInterpreterCallItemOutputUnion$inboundSchema: z.ZodType<OutputCodeInterpreterCallItemOutputUnion, unknown>;
+export declare const OutputCodeInterpreterCallItemOutput$outboundSchema: z.ZodType<OutputCodeInterpreterCallItemOutput$Outbound, OutputCodeInterpreterCallItemOutput>;
+export declare function outputCodeInterpreterCallItemOutputToJSON(outputCodeInterpreterCallItemOutput: OutputCodeInterpreterCallItemOutput): string;
+export declare function outputCodeInterpreterCallItemOutputFromJSON(jsonString: string): SafeParseResult<OutputCodeInterpreterCallItemOutput, SDKValidationError>;
 /** @internal */
-export type OutputCodeInterpreterCallItemOutputUnion$Outbound = OutputImage$Outbound | OutputLogs$Outbound;
+export declare const OutputCodeInterpreterCallItemStatus$inboundSchema: z.ZodType<OutputCodeInterpreterCallItemStatus, unknown>;
 /** @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>;
+export declare const OutputCodeInterpreterCallItemStatus$outboundSchema: z.ZodType<string, OutputCodeInterpreterCallItemStatus>;
 /** @internal */
-export declare const TypeCodeInterpreterCall$inboundSchema: z.ZodEnum<typeof TypeCodeInterpreterCall>;
+export declare const OutputCodeInterpreterCallItemType$inboundSchema: z.ZodEnum<typeof OutputCodeInterpreterCallItemType>;
 /** @internal */
-export declare const TypeCodeInterpreterCall$outboundSchema: z.ZodEnum<typeof TypeCodeInterpreterCall>;
+export declare const OutputCodeInterpreterCallItemType$outboundSchema: z.ZodEnum<typeof OutputCodeInterpreterCallItemType>;
 /** @internal */
 export declare const OutputCodeInterpreterCallItem$inboundSchema: z.ZodType<OutputCodeInterpreterCallItem, unknown>;
 /** @internal */
 export type OutputCodeInterpreterCallItem$Outbound = {
-    code: string | null;
-    container_id: string;
+    code?: string | null | undefined;
+    container_id?: string | undefined;
     id: string;
-    outputs: Array<OutputImage$Outbound | OutputLogs$Outbound> | null;
+    outputs?: Array<CodeInterpreterFileOutput$Outbound | CodeInterpreterImageOutput$Outbound | CodeInterpreterLogsOutput$Outbound> | null | undefined;
     status: string;
     type: string;
+    [additionalProperties: string]: unknown;
 };
 /** @internal */
 export declare const OutputCodeInterpreterCallItem$outboundSchema: z.ZodType<OutputCodeInterpreterCallItem$Outbound, OutputCodeInterpreterCallItem>;

package/esm/models/outputcodeinterpretercallitem.js

@@ -4,97 +4,86 @@
  */
 import * as z from "zod/v4";
 import { remap as remap$ } from "../lib/primitives.js";
-import { safeParse } from "../lib/schemas.js";
+import { collectExtraKeys as collectExtraKeys$, safeParse, } from "../lib/schemas.js";
 import { discriminatedUnion } from "../types/discriminatedUnion.js";
-import { ToolCallStatus$inboundSchema, ToolCallStatus$outboundSchema, } from "./toolcallstatus.js";
-export const TypeCodeInterpreterCall = {
+import * as openEnums from "../types/enums.js";
+import { CodeInterpreterFileOutput$inboundSchema, CodeInterpreterFileOutput$outboundSchema, } from "./codeinterpreterfileoutput.js";
+import { CodeInterpreterImageOutput$inboundSchema, CodeInterpreterImageOutput$outboundSchema, } from "./codeinterpreterimageoutput.js";
+import { CodeInterpreterLogsOutput$inboundSchema, CodeInterpreterLogsOutput$outboundSchema, } from "./codeinterpreterlogsoutput.js";
+export const OutputCodeInterpreterCallItemStatus = {
+    InProgress: "in_progress",
+    Completed: "completed",
+    Incomplete: "incomplete",
+    Interpreting: "interpreting",
+    Failed: "failed",
+};
+export const OutputCodeInterpreterCallItemType = {
     CodeInterpreterCall: "code_interpreter_call",
 };
 /** @internal */
-export const OutputLogs$inboundSchema = z
-    .object({
-    logs: z.string(),
-    type: z.literal("logs"),
-});
-/** @internal */
-export const OutputLogs$outboundSchema = z.object({
-    logs: z.string(),
-    type: z.literal("logs"),
-});
-export function outputLogsToJSON(outputLogs) {
-    return JSON.stringify(OutputLogs$outboundSchema.parse(outputLogs));
-}
-export function outputLogsFromJSON(jsonString) {
-    return safeParse(jsonString, (x) => OutputLogs$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'OutputLogs' from JSON`);
-}
-/** @internal */
-export const OutputImage$inboundSchema = z
-    .object({
-    type: z.literal("image"),
-    url: z.string(),
+export const OutputCodeInterpreterCallItemOutput$inboundSchema = discriminatedUnion("type", {
+    file: CodeInterpreterFileOutput$inboundSchema,
+    image: CodeInterpreterImageOutput$inboundSchema,
+    logs: CodeInterpreterLogsOutput$inboundSchema,
 });
 /** @internal */
-export const OutputImage$outboundSchema = z.object({
-    type: z.literal("image"),
-    url: z.string(),
-});
-export function outputImageToJSON(outputImage) {
-    return JSON.stringify(OutputImage$outboundSchema.parse(outputImage));
+export const OutputCodeInterpreterCallItemOutput$outboundSchema = z.union([
+    CodeInterpreterFileOutput$outboundSchema,
+    CodeInterpreterImageOutput$outboundSchema,
+    CodeInterpreterLogsOutput$outboundSchema,
+]);
+export function outputCodeInterpreterCallItemOutputToJSON(outputCodeInterpreterCallItemOutput) {
+    return JSON.stringify(OutputCodeInterpreterCallItemOutput$outboundSchema.parse(outputCodeInterpreterCallItemOutput));
 }
-export function outputImageFromJSON(jsonString) {
-    return safeParse(jsonString, (x) => OutputImage$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'OutputImage' from JSON`);
+export function outputCodeInterpreterCallItemOutputFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => OutputCodeInterpreterCallItemOutput$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'OutputCodeInterpreterCallItemOutput' from JSON`);
 }
 /** @internal */
-export const OutputCodeInterpreterCallItemOutputUnion$inboundSchema = discriminatedUnion("type", {
-    image: z.lazy(() => OutputImage$inboundSchema),
-    logs: z.lazy(() => OutputLogs$inboundSchema),
-});
+export const OutputCodeInterpreterCallItemStatus$inboundSchema = openEnums.inboundSchema(OutputCodeInterpreterCallItemStatus);
 /** @internal */
-export const OutputCodeInterpreterCallItemOutputUnion$outboundSchema = z.union([
-    z.lazy(() => OutputImage$outboundSchema),
-    z.lazy(() => OutputLogs$outboundSchema),
-]);
-export function outputCodeInterpreterCallItemOutputUnionToJSON(outputCodeInterpreterCallItemOutputUnion) {
-    return JSON.stringify(OutputCodeInterpreterCallItemOutputUnion$outboundSchema.parse(outputCodeInterpreterCallItemOutputUnion));
-}
-export function outputCodeInterpreterCallItemOutputUnionFromJSON(jsonString) {
-    return safeParse(jsonString, (x) => OutputCodeInterpreterCallItemOutputUnion$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'OutputCodeInterpreterCallItemOutputUnion' from JSON`);
-}
+export const OutputCodeInterpreterCallItemStatus$outboundSchema = openEnums.outboundSchema(OutputCodeInterpreterCallItemStatus);
 /** @internal */
-export const TypeCodeInterpreterCall$inboundSchema = z.enum(TypeCodeInterpreterCall);
+export const OutputCodeInterpreterCallItemType$inboundSchema = z.enum(OutputCodeInterpreterCallItemType);
 /** @internal */
-export const TypeCodeInterpreterCall$outboundSchema = TypeCodeInterpreterCall$inboundSchema;
+export const OutputCodeInterpreterCallItemType$outboundSchema = OutputCodeInterpreterCallItemType$inboundSchema;
 /** @internal */
-export const OutputCodeInterpreterCallItem$inboundSchema = z.object({
-    code: z.nullable(z.string()),
-    container_id: z.string(),
+export const OutputCodeInterpreterCallItem$inboundSchema = collectExtraKeys$(z.object({
+    code: z.nullable(z.string()).optional(),
+    container_id: z.string().optional(),
     id: z.string(),
     outputs: z.nullable(z.array(discriminatedUnion("type", {
-        image: z.lazy(() => OutputImage$inboundSchema),
-        logs: z.lazy(() => OutputLogs$inboundSchema),
-    }))),
-    status: ToolCallStatus$inboundSchema,
-    type: TypeCodeInterpreterCall$inboundSchema,
-}).transform((v) => {
+        file: CodeInterpreterFileOutput$inboundSchema,
+        image: CodeInterpreterImageOutput$inboundSchema,
+        logs: CodeInterpreterLogsOutput$inboundSchema,
+    }))).optional(),
+    status: OutputCodeInterpreterCallItemStatus$inboundSchema,
+    type: OutputCodeInterpreterCallItemType$inboundSchema,
+}).catchall(z.any()), "additionalProperties", true).transform((v) => {
     return remap$(v, {
         "container_id": "containerId",
     });
 });
 /** @internal */
 export const OutputCodeInterpreterCallItem$outboundSchema = z.object({
-    code: z.nullable(z.string()),
-    containerId: z.string(),
+    code: z.nullable(z.string()).optional(),
+    containerId: z.string().optional(),
     id: z.string(),
     outputs: z.nullable(z.array(z.union([
-        z.lazy(() => OutputImage$outboundSchema),
-        z.lazy(() => OutputLogs$outboundSchema),
-    ]))),
-    status: ToolCallStatus$outboundSchema,
-    type: TypeCodeInterpreterCall$outboundSchema,
+        CodeInterpreterFileOutput$outboundSchema,
+        CodeInterpreterImageOutput$outboundSchema,
+        CodeInterpreterLogsOutput$outboundSchema,
+    ]))).optional(),
+    status: OutputCodeInterpreterCallItemStatus$outboundSchema,
+    type: OutputCodeInterpreterCallItemType$outboundSchema,
+    additionalProperties: z.record(z.string(), z.any()).optional(),
 }).transform((v) => {
-    return remap$(v, {
-        containerId: "container_id",
-    });
+    return {
+        ...v.additionalProperties,
+        ...remap$(v, {
+            containerId: "container_id",
+            additionalProperties: null,
+        }),
+    };
 });
 export function outputCodeInterpreterCallItemToJSON(outputCodeInterpreterCallItem) {
     return JSON.stringify(OutputCodeInterpreterCallItem$outboundSchema.parse(outputCodeInterpreterCallItem));

package/esm/models/outputwebsearchcallitem.d.ts

@@ -30,6 +30,9 @@ export type OutputWebSearchCallItem = {
     id: string;
     status: WebSearchStatus;
     type: TypeWebSearchCall;
+    additionalProperties?: {
+        [k: string]: any;
+    } | undefined;
 };
 /** @internal */
 export declare const ActionFindInPage$inboundSchema: z.ZodType<ActionFindInPage, unknown>;
@@ -87,6 +90,7 @@ export type OutputWebSearchCallItem$Outbound = {
     id: string;
     status: string;
     type: string;
+    [additionalProperties: string]: unknown;
 };
 /** @internal */
 export declare const OutputWebSearchCallItem$outboundSchema: z.ZodType<OutputWebSearchCallItem$Outbound, OutputWebSearchCallItem>;

package/esm/models/outputwebsearchcallitem.js

@@ -3,7 +3,8 @@
  * @generated-id: b4585d176186
  */
 import * as z from "zod/v4";
-import { safeParse } from "../lib/schemas.js";
+import { remap as remap$ } from "../lib/primitives.js";
+import { collectExtraKeys as collectExtraKeys$, safeParse, } from "../lib/schemas.js";
 import { discriminatedUnion } from "../types/discriminatedUnion.js";
 import { WebSearchSource$inboundSchema, WebSearchSource$outboundSchema, } from "./websearchsource.js";
 import { WebSearchStatus$inboundSchema, WebSearchStatus$outboundSchema, } from "./websearchstatus.js";
@@ -88,7 +89,7 @@ export const TypeWebSearchCall$inboundSchema = z.enum(TypeWebSearchCall);
 /** @internal */
 export const TypeWebSearchCall$outboundSchema = TypeWebSearchCall$inboundSchema;
 /** @internal */
-export const OutputWebSearchCallItem$inboundSchema = z.object({
+export const OutputWebSearchCallItem$inboundSchema = collectExtraKeys$(z.object({
     action: discriminatedUnion("type", {
         search: z.lazy(() => OutputWebSearchCallItemActionSearch$inboundSchema),
         open_page: z.lazy(() => ActionOpenPage$inboundSchema),
@@ -97,7 +98,7 @@ export const OutputWebSearchCallItem$inboundSchema = z.object({
     id: z.string(),
     status: WebSearchStatus$inboundSchema,
     type: TypeWebSearchCall$inboundSchema,
-});
+}).catchall(z.any()), "additionalProperties", true);
 /** @internal */
 export const OutputWebSearchCallItem$outboundSchema = z.object({
     action: z.union([
@@ -108,6 +109,14 @@ export const OutputWebSearchCallItem$outboundSchema = z.object({
     id: z.string(),
     status: WebSearchStatus$outboundSchema,
     type: TypeWebSearchCall$outboundSchema,
+    additionalProperties: z.record(z.string(), z.any()).optional(),
+}).transform((v) => {
+    return {
+        ...v.additionalProperties,
+        ...remap$(v, {
+            additionalProperties: null,
+        }),
+    };
 });
 export function outputWebSearchCallItemToJSON(outputWebSearchCallItem) {
     return JSON.stringify(OutputWebSearchCallItem$outboundSchema.parse(outputWebSearchCallItem));

package/esm/models/streamevents.d.ts

@@ -4,6 +4,11 @@ import { Result as SafeParseResult } from "../types/fp.js";
 import { AnnotationAddedEvent } from "./annotationaddedevent.js";
 import { ApplyPatchCallOperationDiffDeltaEvent } from "./applypatchcalloperationdiffdeltaevent.js";
 import { ApplyPatchCallOperationDiffDoneEvent } from "./applypatchcalloperationdiffdoneevent.js";
+import { CodeInterpreterCallCodeDeltaEvent } from "./codeinterpretercallcodedeltaevent.js";
+import { CodeInterpreterCallCodeDoneEvent } from "./codeinterpretercallcodedoneevent.js";
+import { CodeInterpreterCallCompletedEvent } from "./codeinterpretercallcompletedevent.js";
+import { CodeInterpreterCallInProgressEvent } from "./codeinterpretercallinprogressevent.js";
+import { CodeInterpreterCallInterpretingEvent } from "./codeinterpretercallinterpretingevent.js";
 import { ContentPartAddedEvent } from "./contentpartaddedevent.js";
 import { ContentPartDoneEvent } from "./contentpartdoneevent.js";
 import { CustomToolCallInputDeltaEvent } from "./customtoolcallinputdeltaevent.js";
@@ -49,7 +54,7 @@ import { WebSearchCallSearchingEvent } from "./websearchcallsearchingevent.js";
 /**
  * Union of all possible event types emitted during response streaming
  */
-export type StreamEvents = ErrorEvent | ApplyPatchCallOperationDiffDeltaEvent | ApplyPatchCallOperationDiffDoneEvent | StreamEventsResponseCompleted | ContentPartAddedEvent | ContentPartDoneEvent | OpenResponsesCreatedEvent | CustomToolCallInputDeltaEvent | CustomToolCallInputDoneEvent | DebugEvent | StreamEventsResponseFailed | FunctionCallArgsDeltaEvent | FunctionCallArgsDoneEvent | FusionCallAnalysisCompletedEvent | FusionCallAnalysisInProgressEvent | FusionCallCompletedEvent | FusionCallInProgressEvent | FusionCallPanelAddedEvent | FusionCallPanelCompletedEvent | FusionCallPanelDeltaEvent | FusionCallPanelFailedEvent | FusionCallPanelReasoningDeltaEvent | ImageGenCallCompletedEvent | ImageGenCallGeneratingEvent | ImageGenCallInProgressEvent | ImageGenCallPartialImageEvent | OpenResponsesInProgressEvent | StreamEventsResponseIncomplete | StreamEventsResponseOutputItemAdded | StreamEventsResponseOutputItemDone | AnnotationAddedEvent | TextDeltaEvent | TextDoneEvent | ReasoningSummaryPartAddedEvent | ReasoningSummaryPartDoneEvent | ReasoningSummaryTextDeltaEvent | ReasoningSummaryTextDoneEvent | ReasoningDeltaEvent | ReasoningDoneEvent | RefusalDeltaEvent | RefusalDoneEvent | WebSearchCallCompletedEvent | WebSearchCallInProgressEvent | WebSearchCallSearchingEvent | discriminatedUnionTypes.Unknown<"type">;
+export type StreamEvents = ErrorEvent | ApplyPatchCallOperationDiffDeltaEvent | ApplyPatchCallOperationDiffDoneEvent | CodeInterpreterCallCodeDeltaEvent | CodeInterpreterCallCodeDoneEvent | CodeInterpreterCallCompletedEvent | CodeInterpreterCallInProgressEvent | CodeInterpreterCallInterpretingEvent | StreamEventsResponseCompleted | ContentPartAddedEvent | ContentPartDoneEvent | OpenResponsesCreatedEvent | CustomToolCallInputDeltaEvent | CustomToolCallInputDoneEvent | DebugEvent | StreamEventsResponseFailed | FunctionCallArgsDeltaEvent | FunctionCallArgsDoneEvent | FusionCallAnalysisCompletedEvent | FusionCallAnalysisInProgressEvent | FusionCallCompletedEvent | FusionCallInProgressEvent | FusionCallPanelAddedEvent | FusionCallPanelCompletedEvent | FusionCallPanelDeltaEvent | FusionCallPanelFailedEvent | FusionCallPanelReasoningDeltaEvent | ImageGenCallCompletedEvent | ImageGenCallGeneratingEvent | ImageGenCallInProgressEvent | ImageGenCallPartialImageEvent | OpenResponsesInProgressEvent | StreamEventsResponseIncomplete | StreamEventsResponseOutputItemAdded | StreamEventsResponseOutputItemDone | AnnotationAddedEvent | TextDeltaEvent | TextDoneEvent | ReasoningSummaryPartAddedEvent | ReasoningSummaryPartDoneEvent | ReasoningSummaryTextDeltaEvent | ReasoningSummaryTextDoneEvent | ReasoningDeltaEvent | ReasoningDoneEvent | RefusalDeltaEvent | RefusalDoneEvent | WebSearchCallCompletedEvent | WebSearchCallInProgressEvent | WebSearchCallSearchingEvent | discriminatedUnionTypes.Unknown<"type">;
 /** @internal */
 export declare const StreamEvents$inboundSchema: z.ZodType<StreamEvents, unknown>;
 export declare function streamEventsFromJSON(jsonString: string): SafeParseResult<StreamEvents, SDKValidationError>;

package/esm/models/streamevents.js

@@ -7,6 +7,11 @@ import { discriminatedUnion } from "../types/discriminatedUnion.js";
 import { AnnotationAddedEvent$inboundSchema, } from "./annotationaddedevent.js";
 import { ApplyPatchCallOperationDiffDeltaEvent$inboundSchema, } from "./applypatchcalloperationdiffdeltaevent.js";
 import { ApplyPatchCallOperationDiffDoneEvent$inboundSchema, } from "./applypatchcalloperationdiffdoneevent.js";
+import { CodeInterpreterCallCodeDeltaEvent$inboundSchema, } from "./codeinterpretercallcodedeltaevent.js";
+import { CodeInterpreterCallCodeDoneEvent$inboundSchema, } from "./codeinterpretercallcodedoneevent.js";
+import { CodeInterpreterCallCompletedEvent$inboundSchema, } from "./codeinterpretercallcompletedevent.js";
+import { CodeInterpreterCallInProgressEvent$inboundSchema, } from "./codeinterpretercallinprogressevent.js";
+import { CodeInterpreterCallInterpretingEvent$inboundSchema, } from "./codeinterpretercallinterpretingevent.js";
 import { ContentPartAddedEvent$inboundSchema, } from "./contentpartaddedevent.js";
 import { ContentPartDoneEvent$inboundSchema, } from "./contentpartdoneevent.js";
 import { CustomToolCallInputDeltaEvent$inboundSchema, } from "./customtoolcallinputdeltaevent.js";
@@ -53,6 +58,11 @@ export const StreamEvents$inboundSchema = discriminatedUnion("type", {
     error: ErrorEvent$inboundSchema,
     ["response.apply_patch_call_operation_diff.delta"]: ApplyPatchCallOperationDiffDeltaEvent$inboundSchema,
     ["response.apply_patch_call_operation_diff.done"]: ApplyPatchCallOperationDiffDoneEvent$inboundSchema,
+    ["response.code_interpreter_call_code.delta"]: CodeInterpreterCallCodeDeltaEvent$inboundSchema,
+    ["response.code_interpreter_call_code.done"]: CodeInterpreterCallCodeDoneEvent$inboundSchema,
+    ["response.code_interpreter_call.completed"]: CodeInterpreterCallCompletedEvent$inboundSchema,
+    ["response.code_interpreter_call.in_progress"]: CodeInterpreterCallInProgressEvent$inboundSchema,
+    ["response.code_interpreter_call.interpreting"]: CodeInterpreterCallInterpretingEvent$inboundSchema,
     ["response.completed"]: StreamEventsResponseCompleted$inboundSchema,
     ["response.content_part.added"]: ContentPartAddedEvent$inboundSchema,
     ["response.content_part.done"]: ContentPartDoneEvent$inboundSchema,

package/jsr.json

@@ -2,7 +2,7 @@
 
 {
   "name": "@openrouter/sdk",
-  "version": "1.2.18",
+  "version": "1.2.20",
   "exports": {
     ".": "./src/index.ts",    
     "./models/errors": "./src/models/errors/index.ts",    

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@openrouter/sdk",
-  "version": "1.2.18",
+  "version": "1.2.20",
   "author": "OpenRouter",
   "description": "The OpenRouter TypeScript SDK is a type-safe toolkit for building AI applications with access to 400+ language models through a unified API.",
   "keywords": [
@@ -21,8 +21,8 @@
   "license": "Apache-2.0",
   "packageManager": "pnpm@10.22.0",
   "publishConfig": {
-    "access": "public",
-    "provenance": true
+    "provenance": true,
+    "access": "public"
   },
   "type": "module",
   "main": "./esm/index.js",
@@ -73,15 +73,15 @@
     "lint": "eslint --cache --max-warnings=0 src",
     "build": "tsc",
     "prepublishOnly": "npm run build",
+    "typecheck:transit": "exit 0",
     "compile": "tsc",
-    "postinstall": "node scripts/check-types.js || true",
     "prepare": "npm run build",
-    "test:watch": "vitest --watch --project unit",
-    "typecheck": "tsc --noEmit",
-    "typecheck:transit": "exit 0",
     "test": "vitest --run --project unit",
     "test:e2e": "vitest --run --project e2e",
-    "test:transit": "exit 0"
+    "test:transit": "exit 0",
+    "test:watch": "vitest --watch --project unit",
+    "postinstall": "node scripts/check-types.js || true",
+    "typecheck": "tsc --noEmit"
   },
   "peerDependencies": {},
   "devDependencies": {