@openrouter/sdk 0.9.11 → 0.11.2

package/esm/models/codeinterpreterservertool.d.ts

@@ -0,0 +1,68 @@
+import * as z from "zod/v4";
+import { ClosedEnum, OpenEnum } from "../types/enums.js";
+import { Result as SafeParseResult } from "../types/fp.js";
+import { SDKValidationError } from "./errors/sdkvalidationerror.js";
+export declare const ContainerType: {
+    readonly Auto: "auto";
+};
+export type ContainerType = ClosedEnum<typeof ContainerType>;
+export declare const MemoryLimit: {
+    readonly Oneg: "1g";
+    readonly Fourg: "4g";
+    readonly Sixteeng: "16g";
+    readonly SixtyFourg: "64g";
+};
+export type MemoryLimit = OpenEnum<typeof MemoryLimit>;
+export type ContainerAuto = {
+    type: ContainerType;
+    fileIds?: Array<string> | undefined;
+    memoryLimit?: MemoryLimit | null | undefined;
+};
+export type Container = ContainerAuto | string;
+/**
+ * Code interpreter tool configuration
+ */
+export type CodeInterpreterServerTool = {
+    type: "code_interpreter";
+    container: ContainerAuto | string;
+};
+/** @internal */
+export declare const ContainerType$inboundSchema: z.ZodEnum<typeof ContainerType>;
+/** @internal */
+export declare const ContainerType$outboundSchema: z.ZodEnum<typeof ContainerType>;
+/** @internal */
+export declare const MemoryLimit$inboundSchema: z.ZodType<MemoryLimit, unknown>;
+/** @internal */
+export declare const MemoryLimit$outboundSchema: z.ZodType<string, MemoryLimit>;
+/** @internal */
+export declare const ContainerAuto$inboundSchema: z.ZodType<ContainerAuto, unknown>;
+/** @internal */
+export type ContainerAuto$Outbound = {
+    type: string;
+    file_ids?: Array<string> | undefined;
+    memory_limit?: string | null | undefined;
+};
+/** @internal */
+export declare const ContainerAuto$outboundSchema: z.ZodType<ContainerAuto$Outbound, ContainerAuto>;
+export declare function containerAutoToJSON(containerAuto: ContainerAuto): string;
+export declare function containerAutoFromJSON(jsonString: string): SafeParseResult<ContainerAuto, SDKValidationError>;
+/** @internal */
+export declare const Container$inboundSchema: z.ZodType<Container, unknown>;
+/** @internal */
+export type Container$Outbound = ContainerAuto$Outbound | string;
+/** @internal */
+export declare const Container$outboundSchema: z.ZodType<Container$Outbound, Container>;
+export declare function containerToJSON(container: Container): string;
+export declare function containerFromJSON(jsonString: string): SafeParseResult<Container, SDKValidationError>;
+/** @internal */
+export declare const CodeInterpreterServerTool$inboundSchema: z.ZodType<CodeInterpreterServerTool, unknown>;
+/** @internal */
+export type CodeInterpreterServerTool$Outbound = {
+    type: "code_interpreter";
+    container: ContainerAuto$Outbound | string;
+};
+/** @internal */
+export declare const CodeInterpreterServerTool$outboundSchema: z.ZodType<CodeInterpreterServerTool$Outbound, CodeInterpreterServerTool>;
+export declare function codeInterpreterServerToolToJSON(codeInterpreterServerTool: CodeInterpreterServerTool): string;
+export declare function codeInterpreterServerToolFromJSON(jsonString: string): SafeParseResult<CodeInterpreterServerTool, SDKValidationError>;
+//# sourceMappingURL=codeinterpreterservertool.d.ts.map

package/esm/models/codeinterpreterservertool.js

@@ -0,0 +1,85 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ * @generated-id: 493e614d6c34
+ */
+import * as z from "zod/v4";
+import { remap as remap$ } from "../lib/primitives.js";
+import { safeParse } from "../lib/schemas.js";
+import * as openEnums from "../types/enums.js";
+export const ContainerType = {
+    Auto: "auto",
+};
+export const MemoryLimit = {
+    Oneg: "1g",
+    Fourg: "4g",
+    Sixteeng: "16g",
+    SixtyFourg: "64g",
+};
+/** @internal */
+export const ContainerType$inboundSchema = z
+    .enum(ContainerType);
+/** @internal */
+export const ContainerType$outboundSchema = ContainerType$inboundSchema;
+/** @internal */
+export const MemoryLimit$inboundSchema = openEnums.inboundSchema(MemoryLimit);
+/** @internal */
+export const MemoryLimit$outboundSchema = openEnums.outboundSchema(MemoryLimit);
+/** @internal */
+export const ContainerAuto$inboundSchema = z
+    .object({
+    type: ContainerType$inboundSchema,
+    file_ids: z.array(z.string()).optional(),
+    memory_limit: z.nullable(MemoryLimit$inboundSchema).optional(),
+}).transform((v) => {
+    return remap$(v, {
+        "file_ids": "fileIds",
+        "memory_limit": "memoryLimit",
+    });
+});
+/** @internal */
+export const ContainerAuto$outboundSchema = z.object({
+    type: ContainerType$outboundSchema,
+    fileIds: z.array(z.string()).optional(),
+    memoryLimit: z.nullable(MemoryLimit$outboundSchema).optional(),
+}).transform((v) => {
+    return remap$(v, {
+        fileIds: "file_ids",
+        memoryLimit: "memory_limit",
+    });
+});
+export function containerAutoToJSON(containerAuto) {
+    return JSON.stringify(ContainerAuto$outboundSchema.parse(containerAuto));
+}
+export function containerAutoFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => ContainerAuto$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'ContainerAuto' from JSON`);
+}
+/** @internal */
+export const Container$inboundSchema = z.union([
+    z.lazy(() => ContainerAuto$inboundSchema),
+    z.string(),
+]);
+/** @internal */
+export const Container$outboundSchema = z.union([z.lazy(() => ContainerAuto$outboundSchema), z.string()]);
+export function containerToJSON(container) {
+    return JSON.stringify(Container$outboundSchema.parse(container));
+}
+export function containerFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => Container$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'Container' from JSON`);
+}
+/** @internal */
+export const CodeInterpreterServerTool$inboundSchema = z.object({
+    type: z.literal("code_interpreter"),
+    container: z.union([z.lazy(() => ContainerAuto$inboundSchema), z.string()]),
+});
+/** @internal */
+export const CodeInterpreterServerTool$outboundSchema = z.object({
+    type: z.literal("code_interpreter"),
+    container: z.union([z.lazy(() => ContainerAuto$outboundSchema), z.string()]),
+});
+export function codeInterpreterServerToolToJSON(codeInterpreterServerTool) {
+    return JSON.stringify(CodeInterpreterServerTool$outboundSchema.parse(codeInterpreterServerTool));
+}
+export function codeInterpreterServerToolFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => CodeInterpreterServerTool$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'CodeInterpreterServerTool' from JSON`);
+}
+//# sourceMappingURL=codeinterpreterservertool.js.map

package/esm/models/codexlocalshelltool.d.ts

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

package/esm/models/codexlocalshelltool.js

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

package/esm/models/compoundfilter.d.ts

@@ -0,0 +1,36 @@
+import * as z from "zod/v4";
+import { OpenEnum } from "../types/enums.js";
+import { Result as SafeParseResult } from "../types/fp.js";
+import { SDKValidationError } from "./errors/sdkvalidationerror.js";
+export declare const CompoundFilterType: {
+    readonly And: "and";
+    readonly Or: "or";
+};
+export type CompoundFilterType = OpenEnum<typeof CompoundFilterType>;
+/**
+ * A compound filter that combines multiple comparison or compound filters
+ */
+export type CompoundFilter = {
+    type: CompoundFilterType;
+    filters: Array<{
+        [k: string]: any | null;
+    }>;
+};
+/** @internal */
+export declare const CompoundFilterType$inboundSchema: z.ZodType<CompoundFilterType, unknown>;
+/** @internal */
+export declare const CompoundFilterType$outboundSchema: z.ZodType<string, CompoundFilterType>;
+/** @internal */
+export declare const CompoundFilter$inboundSchema: z.ZodType<CompoundFilter, unknown>;
+/** @internal */
+export type CompoundFilter$Outbound = {
+    type: string;
+    filters: Array<{
+        [k: string]: any | null;
+    }>;
+};
+/** @internal */
+export declare const CompoundFilter$outboundSchema: z.ZodType<CompoundFilter$Outbound, CompoundFilter>;
+export declare function compoundFilterToJSON(compoundFilter: CompoundFilter): string;
+export declare function compoundFilterFromJSON(jsonString: string): SafeParseResult<CompoundFilter, SDKValidationError>;
+//# sourceMappingURL=compoundfilter.d.ts.map

package/esm/models/compoundfilter.js

@@ -0,0 +1,32 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ * @generated-id: beca2c6f6a75
+ */
+import * as z from "zod/v4";
+import { safeParse } from "../lib/schemas.js";
+import * as openEnums from "../types/enums.js";
+export const CompoundFilterType = {
+    And: "and",
+    Or: "or",
+};
+/** @internal */
+export const CompoundFilterType$inboundSchema = openEnums.inboundSchema(CompoundFilterType);
+/** @internal */
+export const CompoundFilterType$outboundSchema = openEnums.outboundSchema(CompoundFilterType);
+/** @internal */
+export const CompoundFilter$inboundSchema = z.object({
+    type: CompoundFilterType$inboundSchema,
+    filters: z.array(z.record(z.string(), z.nullable(z.any()))),
+});
+/** @internal */
+export const CompoundFilter$outboundSchema = z.object({
+    type: CompoundFilterType$outboundSchema,
+    filters: z.array(z.record(z.string(), z.nullable(z.any()))),
+});
+export function compoundFilterToJSON(compoundFilter) {
+    return JSON.stringify(CompoundFilter$outboundSchema.parse(compoundFilter));
+}
+export function compoundFilterFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => CompoundFilter$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'CompoundFilter' from JSON`);
+}
+//# sourceMappingURL=compoundfilter.js.map

package/esm/models/computeruseservertool.d.ts

@@ -0,0 +1,39 @@
+import * as z from "zod/v4";
+import { OpenEnum } from "../types/enums.js";
+import { Result as SafeParseResult } from "../types/fp.js";
+import { SDKValidationError } from "./errors/sdkvalidationerror.js";
+export declare const Environment: {
+    readonly Windows: "windows";
+    readonly Mac: "mac";
+    readonly Linux: "linux";
+    readonly Ubuntu: "ubuntu";
+    readonly Browser: "browser";
+};
+export type Environment = OpenEnum<typeof Environment>;
+/**
+ * Computer use preview tool configuration
+ */
+export type ComputerUseServerTool = {
+    type: "computer_use_preview";
+    displayHeight: number;
+    displayWidth: number;
+    environment: Environment;
+};
+/** @internal */
+export declare const Environment$inboundSchema: z.ZodType<Environment, unknown>;
+/** @internal */
+export declare const Environment$outboundSchema: z.ZodType<string, Environment>;
+/** @internal */
+export declare const ComputerUseServerTool$inboundSchema: z.ZodType<ComputerUseServerTool, unknown>;
+/** @internal */
+export type ComputerUseServerTool$Outbound = {
+    type: "computer_use_preview";
+    display_height: number;
+    display_width: number;
+    environment: string;
+};
+/** @internal */
+export declare const ComputerUseServerTool$outboundSchema: z.ZodType<ComputerUseServerTool$Outbound, ComputerUseServerTool>;
+export declare function computerUseServerToolToJSON(computerUseServerTool: ComputerUseServerTool): string;
+export declare function computerUseServerToolFromJSON(jsonString: string): SafeParseResult<ComputerUseServerTool, SDKValidationError>;
+//# sourceMappingURL=computeruseservertool.d.ts.map

package/esm/models/computeruseservertool.js

@@ -0,0 +1,50 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ * @generated-id: e6059da59a69
+ */
+import * as z from "zod/v4";
+import { remap as remap$ } from "../lib/primitives.js";
+import { safeParse } from "../lib/schemas.js";
+import * as openEnums from "../types/enums.js";
+export const Environment = {
+    Windows: "windows",
+    Mac: "mac",
+    Linux: "linux",
+    Ubuntu: "ubuntu",
+    Browser: "browser",
+};
+/** @internal */
+export const Environment$inboundSchema = openEnums.inboundSchema(Environment);
+/** @internal */
+export const Environment$outboundSchema = openEnums.outboundSchema(Environment);
+/** @internal */
+export const ComputerUseServerTool$inboundSchema = z.object({
+    type: z.literal("computer_use_preview"),
+    display_height: z.number(),
+    display_width: z.number(),
+    environment: Environment$inboundSchema,
+}).transform((v) => {
+    return remap$(v, {
+        "display_height": "displayHeight",
+        "display_width": "displayWidth",
+    });
+});
+/** @internal */
+export const ComputerUseServerTool$outboundSchema = z.object({
+    type: z.literal("computer_use_preview"),
+    displayHeight: z.number(),
+    displayWidth: z.number(),
+    environment: Environment$outboundSchema,
+}).transform((v) => {
+    return remap$(v, {
+        displayHeight: "display_height",
+        displayWidth: "display_width",
+    });
+});
+export function computerUseServerToolToJSON(computerUseServerTool) {
+    return JSON.stringify(ComputerUseServerTool$outboundSchema.parse(computerUseServerTool));
+}
+export function computerUseServerToolFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => ComputerUseServerTool$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'ComputerUseServerTool' from JSON`);
+}
+//# sourceMappingURL=computeruseservertool.js.map

package/esm/models/conflictresponseerrordata.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";
+/**
+ * Error data for ConflictResponse
+ */
+export type ConflictResponseErrorData = {
+    code: number;
+    message: string;
+    metadata?: {
+        [k: string]: any | null;
+    } | null | undefined;
+};
+/** @internal */
+export declare const ConflictResponseErrorData$inboundSchema: z.ZodType<ConflictResponseErrorData, unknown>;
+export declare function conflictResponseErrorDataFromJSON(jsonString: string): SafeParseResult<ConflictResponseErrorData, SDKValidationError>;
+//# sourceMappingURL=conflictresponseerrordata.d.ts.map

package/esm/models/conflictresponseerrordata.js

@@ -0,0 +1,16 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ * @generated-id: 6c8ea4c00fd1
+ */
+import * as z from "zod/v4";
+import { safeParse } from "../lib/schemas.js";
+/** @internal */
+export const ConflictResponseErrorData$inboundSchema = z.object({
+    code: z.int(),
+    message: z.string(),
+    metadata: z.nullable(z.record(z.string(), z.nullable(z.any()))).optional(),
+});
+export function conflictResponseErrorDataFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => ConflictResponseErrorData$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'ConflictResponseErrorData' from JSON`);
+}
+//# sourceMappingURL=conflictresponseerrordata.js.map

package/esm/models/contentpartaddedevent.d.ts

@@ -0,0 +1,29 @@
+import * as z from "zod/v4";
+import { Result as SafeParseResult } from "../types/fp.js";
+import { SDKValidationError } from "./errors/sdkvalidationerror.js";
+import { OpenAIResponsesRefusalContent } from "./openairesponsesrefusalcontent.js";
+import { ReasoningTextContent } from "./reasoningtextcontent.js";
+import { ResponseOutputText } from "./responseoutputtext.js";
+export type ContentPartAddedEventPart = ResponseOutputText | (ReasoningTextContent & {
+    type: "reasoning_text";
+}) | OpenAIResponsesRefusalContent;
+/**
+ * Event emitted when a new content part is added to an output item
+ */
+export type ContentPartAddedEvent = {
+    type: "response.content_part.added";
+    outputIndex: number;
+    itemId: string;
+    contentIndex: number;
+    part: ResponseOutputText | (ReasoningTextContent & {
+        type: "reasoning_text";
+    }) | OpenAIResponsesRefusalContent;
+    sequenceNumber: number;
+};
+/** @internal */
+export declare const ContentPartAddedEventPart$inboundSchema: z.ZodType<ContentPartAddedEventPart, unknown>;
+export declare function contentPartAddedEventPartFromJSON(jsonString: string): SafeParseResult<ContentPartAddedEventPart, SDKValidationError>;
+/** @internal */
+export declare const ContentPartAddedEvent$inboundSchema: z.ZodType<ContentPartAddedEvent, unknown>;
+export declare function contentPartAddedEventFromJSON(jsonString: string): SafeParseResult<ContentPartAddedEvent, SDKValidationError>;
+//# sourceMappingURL=contentpartaddedevent.d.ts.map

package/esm/models/contentpartaddedevent.js

@@ -0,0 +1,43 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ * @generated-id: 5ba581a076ec
+ */
+import * as z from "zod/v4";
+import { remap as remap$ } from "../lib/primitives.js";
+import { safeParse } from "../lib/schemas.js";
+import { OpenAIResponsesRefusalContent$inboundSchema, } from "./openairesponsesrefusalcontent.js";
+import { ReasoningTextContent$inboundSchema, } from "./reasoningtextcontent.js";
+import { ResponseOutputText$inboundSchema, } from "./responseoutputtext.js";
+/** @internal */
+export const ContentPartAddedEventPart$inboundSchema = z.union([
+    ResponseOutputText$inboundSchema,
+    ReasoningTextContent$inboundSchema.and(z.object({ type: z.literal("reasoning_text") })),
+    OpenAIResponsesRefusalContent$inboundSchema,
+]);
+export function contentPartAddedEventPartFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => ContentPartAddedEventPart$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'ContentPartAddedEventPart' from JSON`);
+}
+/** @internal */
+export const ContentPartAddedEvent$inboundSchema = z.object({
+    type: z.literal("response.content_part.added"),
+    output_index: z.number(),
+    item_id: z.string(),
+    content_index: z.number(),
+    part: z.union([
+        ResponseOutputText$inboundSchema,
+        ReasoningTextContent$inboundSchema.and(z.object({ type: z.literal("reasoning_text") })),
+        OpenAIResponsesRefusalContent$inboundSchema,
+    ]),
+    sequence_number: z.number(),
+}).transform((v) => {
+    return remap$(v, {
+        "output_index": "outputIndex",
+        "item_id": "itemId",
+        "content_index": "contentIndex",
+        "sequence_number": "sequenceNumber",
+    });
+});
+export function contentPartAddedEventFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => ContentPartAddedEvent$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'ContentPartAddedEvent' from JSON`);
+}
+//# sourceMappingURL=contentpartaddedevent.js.map

package/esm/models/contentpartdoneevent.d.ts

@@ -0,0 +1,29 @@
+import * as z from "zod/v4";
+import { Result as SafeParseResult } from "../types/fp.js";
+import { SDKValidationError } from "./errors/sdkvalidationerror.js";
+import { OpenAIResponsesRefusalContent } from "./openairesponsesrefusalcontent.js";
+import { ReasoningTextContent } from "./reasoningtextcontent.js";
+import { ResponseOutputText } from "./responseoutputtext.js";
+export type ContentPartDoneEventPart = ResponseOutputText | (ReasoningTextContent & {
+    type: "reasoning_text";
+}) | OpenAIResponsesRefusalContent;
+/**
+ * Event emitted when a content part is complete
+ */
+export type ContentPartDoneEvent = {
+    type: "response.content_part.done";
+    outputIndex: number;
+    itemId: string;
+    contentIndex: number;
+    part: ResponseOutputText | (ReasoningTextContent & {
+        type: "reasoning_text";
+    }) | OpenAIResponsesRefusalContent;
+    sequenceNumber: number;
+};
+/** @internal */
+export declare const ContentPartDoneEventPart$inboundSchema: z.ZodType<ContentPartDoneEventPart, unknown>;
+export declare function contentPartDoneEventPartFromJSON(jsonString: string): SafeParseResult<ContentPartDoneEventPart, SDKValidationError>;
+/** @internal */
+export declare const ContentPartDoneEvent$inboundSchema: z.ZodType<ContentPartDoneEvent, unknown>;
+export declare function contentPartDoneEventFromJSON(jsonString: string): SafeParseResult<ContentPartDoneEvent, SDKValidationError>;
+//# sourceMappingURL=contentpartdoneevent.d.ts.map

package/esm/models/contentpartdoneevent.js

@@ -0,0 +1,43 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ * @generated-id: 943cfab7678a
+ */
+import * as z from "zod/v4";
+import { remap as remap$ } from "../lib/primitives.js";
+import { safeParse } from "../lib/schemas.js";
+import { OpenAIResponsesRefusalContent$inboundSchema, } from "./openairesponsesrefusalcontent.js";
+import { ReasoningTextContent$inboundSchema, } from "./reasoningtextcontent.js";
+import { ResponseOutputText$inboundSchema, } from "./responseoutputtext.js";
+/** @internal */
+export const ContentPartDoneEventPart$inboundSchema = z.union([
+    ResponseOutputText$inboundSchema,
+    ReasoningTextContent$inboundSchema.and(z.object({ type: z.literal("reasoning_text") })),
+    OpenAIResponsesRefusalContent$inboundSchema,
+]);
+export function contentPartDoneEventPartFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => ContentPartDoneEventPart$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'ContentPartDoneEventPart' from JSON`);
+}
+/** @internal */
+export const ContentPartDoneEvent$inboundSchema = z.object({
+    type: z.literal("response.content_part.done"),
+    output_index: z.number(),
+    item_id: z.string(),
+    content_index: z.number(),
+    part: z.union([
+        ResponseOutputText$inboundSchema,
+        ReasoningTextContent$inboundSchema.and(z.object({ type: z.literal("reasoning_text") })),
+        OpenAIResponsesRefusalContent$inboundSchema,
+    ]),
+    sequence_number: z.number(),
+}).transform((v) => {
+    return remap$(v, {
+        "output_index": "outputIndex",
+        "item_id": "itemId",
+        "content_index": "contentIndex",
+        "sequence_number": "sequenceNumber",
+    });
+});
+export function contentPartDoneEventFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => ContentPartDoneEvent$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'ContentPartDoneEvent' from JSON`);
+}
+//# sourceMappingURL=contentpartdoneevent.js.map

package/esm/models/contextcompressionengine.d.ts

@@ -0,0 +1,15 @@
+import * as z from "zod/v4";
+import { ClosedEnum } from "../types/enums.js";
+/**
+ * The compression engine to use. Defaults to "middle-out".
+ */
+export declare const ContextCompressionEngine: {
+    readonly MiddleOut: "middle-out";
+};
+/**
+ * The compression engine to use. Defaults to "middle-out".
+ */
+export type ContextCompressionEngine = ClosedEnum<typeof ContextCompressionEngine>;
+/** @internal */
+export declare const ContextCompressionEngine$outboundSchema: z.ZodEnum<typeof ContextCompressionEngine>;
+//# sourceMappingURL=contextcompressionengine.d.ts.map

package/esm/models/contextcompressionengine.js

@@ -0,0 +1,14 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ * @generated-id: c80f6c3a6e09
+ */
+import * as z from "zod/v4";
+/**
+ * The compression engine to use. Defaults to "middle-out".
+ */
+export const ContextCompressionEngine = {
+    MiddleOut: "middle-out",
+};
+/** @internal */
+export const ContextCompressionEngine$outboundSchema = z.enum(ContextCompressionEngine);
+//# sourceMappingURL=contextcompressionengine.js.map

package/esm/models/customtool.d.ts

@@ -0,0 +1,75 @@
+import * as z from "zod/v4";
+import { OpenEnum } from "../types/enums.js";
+import { Result as SafeParseResult } from "../types/fp.js";
+import { SDKValidationError } from "./errors/sdkvalidationerror.js";
+export declare const Syntax: {
+    readonly Lark: "lark";
+    readonly Regex: "regex";
+};
+export type Syntax = OpenEnum<typeof Syntax>;
+export type FormatGrammar = {
+    type: "grammar";
+    definition: string;
+    syntax: Syntax;
+};
+export type FormatText = {
+    type: "text";
+};
+export type Format = FormatText | FormatGrammar;
+/**
+ * Custom tool configuration
+ */
+export type CustomTool = {
+    type: "custom";
+    name: string;
+    description?: string | undefined;
+    format?: FormatText | FormatGrammar | undefined;
+};
+/** @internal */
+export declare const Syntax$inboundSchema: z.ZodType<Syntax, unknown>;
+/** @internal */
+export declare const Syntax$outboundSchema: z.ZodType<string, Syntax>;
+/** @internal */
+export declare const FormatGrammar$inboundSchema: z.ZodType<FormatGrammar, unknown>;
+/** @internal */
+export type FormatGrammar$Outbound = {
+    type: "grammar";
+    definition: string;
+    syntax: string;
+};
+/** @internal */
+export declare const FormatGrammar$outboundSchema: z.ZodType<FormatGrammar$Outbound, FormatGrammar>;
+export declare function formatGrammarToJSON(formatGrammar: FormatGrammar): string;
+export declare function formatGrammarFromJSON(jsonString: string): SafeParseResult<FormatGrammar, SDKValidationError>;
+/** @internal */
+export declare const FormatText$inboundSchema: z.ZodType<FormatText, unknown>;
+/** @internal */
+export type FormatText$Outbound = {
+    type: "text";
+};
+/** @internal */
+export declare const FormatText$outboundSchema: z.ZodType<FormatText$Outbound, FormatText>;
+export declare function formatTextToJSON(formatText: FormatText): string;
+export declare function formatTextFromJSON(jsonString: string): SafeParseResult<FormatText, SDKValidationError>;
+/** @internal */
+export declare const Format$inboundSchema: z.ZodType<Format, unknown>;
+/** @internal */
+export type Format$Outbound = FormatText$Outbound | FormatGrammar$Outbound;
+/** @internal */
+export declare const Format$outboundSchema: z.ZodType<Format$Outbound, Format>;
+export declare function formatToJSON(format: Format): string;
+export declare function formatFromJSON(jsonString: string): SafeParseResult<Format, SDKValidationError>;
+/** @internal */
+export declare const CustomTool$inboundSchema: z.ZodType<CustomTool, unknown>;
+/** @internal */
+export type CustomTool$Outbound = {
+    type: "custom";
+    name: string;
+    description?: string | undefined;
+    format?: FormatText$Outbound | FormatGrammar$Outbound | undefined;
+};
+/** @internal */
+export declare const CustomTool$outboundSchema: z.ZodType<CustomTool$Outbound, CustomTool>;
+export declare function customToolToJSON(customTool: CustomTool): string;
+export declare function customToolFromJSON(jsonString: string): SafeParseResult<CustomTool, SDKValidationError>;
+//# sourceMappingURL=customtool.d.ts.map