@openrouter/sdk 0.0.1-beta.9 → 0.1.0

package/esm/models/responseserrorfield.js

@@ -4,41 +4,56 @@
 import * as z from "zod/v4";
 import { safeParse } from "../lib/schemas.js";
 import { catchUnrecognizedEnum, } from "../types/enums.js";
-export const ResponsesErrorFieldCode = {
+export const CodeEnum = {
     ServerError: "server_error",
     RateLimitExceeded: "rate_limit_exceeded",
     InvalidPrompt: "invalid_prompt",
+    VectorStoreTimeout: "vector_store_timeout",
+    InvalidImage: "invalid_image",
+    InvalidImageFormat: "invalid_image_format",
+    InvalidBase64Image: "invalid_base64_image",
+    InvalidImageUrl: "invalid_image_url",
+    ImageTooLarge: "image_too_large",
+    ImageTooSmall: "image_too_small",
+    ImageParseError: "image_parse_error",
+    ImageContentPolicyViolation: "image_content_policy_violation",
+    InvalidImageMode: "invalid_image_mode",
+    ImageFileTooLarge: "image_file_too_large",
+    UnsupportedImageMediaType: "unsupported_image_media_type",
+    EmptyImageFile: "empty_image_file",
+    FailedToDownloadImage: "failed_to_download_image",
+    ImageFileNotFound: "image_file_not_found",
 };
 /** @internal */
-export const ResponsesErrorFieldCode$inboundSchema = z
+export const CodeEnum$inboundSchema = z
     .union([
-    z.enum(ResponsesErrorFieldCode),
+    z.enum(CodeEnum),
     z.string().transform(catchUnrecognizedEnum),
 ]);
 /** @internal */
-export const ResponsesErrorFieldCode$outboundSchema = z.union([
-    z.enum(ResponsesErrorFieldCode),
+export const CodeEnum$outboundSchema = z.union([
+    z.enum(CodeEnum),
     z.string().and(z.custom()),
 ]);
 /**
  * @internal
  * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
  */
-export var ResponsesErrorFieldCode$;
-(function (ResponsesErrorFieldCode$) {
-    /** @deprecated use `ResponsesErrorFieldCode$inboundSchema` instead. */
-    ResponsesErrorFieldCode$.inboundSchema = ResponsesErrorFieldCode$inboundSchema;
-    /** @deprecated use `ResponsesErrorFieldCode$outboundSchema` instead. */
-    ResponsesErrorFieldCode$.outboundSchema = ResponsesErrorFieldCode$outboundSchema;
-})(ResponsesErrorFieldCode$ || (ResponsesErrorFieldCode$ = {}));
+export var CodeEnum$;
+(function (CodeEnum$) {
+    /** @deprecated use `CodeEnum$inboundSchema` instead. */
+    CodeEnum$.inboundSchema = CodeEnum$inboundSchema;
+    /** @deprecated use `CodeEnum$outboundSchema` instead. */
+    CodeEnum$.outboundSchema = CodeEnum$outboundSchema;
+})(CodeEnum$ || (CodeEnum$ = {}));
 /** @internal */
 export const ResponsesErrorField$inboundSchema = z.object({
-    code: ResponsesErrorFieldCode$inboundSchema,
+    code: CodeEnum$inboundSchema,
     message: z.string(),
 });
 /** @internal */
 export const ResponsesErrorField$outboundSchema = z.object({
-    code: ResponsesErrorFieldCode$outboundSchema,
+    code: CodeEnum$outboundSchema,
     message: z.string(),
 });
 /**

package/esm/models/responsesformatjsonobject.d.ts

@@ -0,0 +1,55 @@
+import * as z from "zod/v4";
+import { ClosedEnum } from "../types/enums.js";
+import { Result as SafeParseResult } from "../types/fp.js";
+import { SDKValidationError } from "./errors/sdkvalidationerror.js";
+export declare const ResponsesFormatJSONObjectType: {
+    readonly JsonObject: "json_object";
+};
+export type ResponsesFormatJSONObjectType = ClosedEnum<typeof ResponsesFormatJSONObjectType>;
+/**
+ * JSON object response format
+ */
+export type ResponsesFormatJSONObject = {
+    type: ResponsesFormatJSONObjectType;
+};
+/** @internal */
+export declare const ResponsesFormatJSONObjectType$inboundSchema: z.ZodEnum<typeof ResponsesFormatJSONObjectType>;
+/** @internal */
+export declare const ResponsesFormatJSONObjectType$outboundSchema: z.ZodEnum<typeof ResponsesFormatJSONObjectType>;
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export declare namespace ResponsesFormatJSONObjectType$ {
+    /** @deprecated use `ResponsesFormatJSONObjectType$inboundSchema` instead. */
+    const inboundSchema: z.ZodEnum<{
+        readonly JsonObject: "json_object";
+    }>;
+    /** @deprecated use `ResponsesFormatJSONObjectType$outboundSchema` instead. */
+    const outboundSchema: z.ZodEnum<{
+        readonly JsonObject: "json_object";
+    }>;
+}
+/** @internal */
+export declare const ResponsesFormatJSONObject$inboundSchema: z.ZodType<ResponsesFormatJSONObject, unknown>;
+/** @internal */
+export type ResponsesFormatJSONObject$Outbound = {
+    type: string;
+};
+/** @internal */
+export declare const ResponsesFormatJSONObject$outboundSchema: z.ZodType<ResponsesFormatJSONObject$Outbound, ResponsesFormatJSONObject>;
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export declare namespace ResponsesFormatJSONObject$ {
+    /** @deprecated use `ResponsesFormatJSONObject$inboundSchema` instead. */
+    const inboundSchema: z.ZodType<ResponsesFormatJSONObject, unknown, z.core.$ZodTypeInternals<ResponsesFormatJSONObject, unknown>>;
+    /** @deprecated use `ResponsesFormatJSONObject$outboundSchema` instead. */
+    const outboundSchema: z.ZodType<ResponsesFormatJSONObject$Outbound, ResponsesFormatJSONObject, z.core.$ZodTypeInternals<ResponsesFormatJSONObject$Outbound, ResponsesFormatJSONObject>>;
+    /** @deprecated use `ResponsesFormatJSONObject$Outbound` instead. */
+    type Outbound = ResponsesFormatJSONObject$Outbound;
+}
+export declare function responsesFormatJSONObjectToJSON(responsesFormatJSONObject: ResponsesFormatJSONObject): string;
+export declare function responsesFormatJSONObjectFromJSON(jsonString: string): SafeParseResult<ResponsesFormatJSONObject, SDKValidationError>;
+//# sourceMappingURL=responsesformatjsonobject.d.ts.map

package/esm/models/responsesformatjsonobject.js

@@ -0,0 +1,49 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+import * as z from "zod/v4";
+import { safeParse } from "../lib/schemas.js";
+export const ResponsesFormatJSONObjectType = {
+    JsonObject: "json_object",
+};
+/** @internal */
+export const ResponsesFormatJSONObjectType$inboundSchema = z.enum(ResponsesFormatJSONObjectType);
+/** @internal */
+export const ResponsesFormatJSONObjectType$outboundSchema = ResponsesFormatJSONObjectType$inboundSchema;
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export var ResponsesFormatJSONObjectType$;
+(function (ResponsesFormatJSONObjectType$) {
+    /** @deprecated use `ResponsesFormatJSONObjectType$inboundSchema` instead. */
+    ResponsesFormatJSONObjectType$.inboundSchema = ResponsesFormatJSONObjectType$inboundSchema;
+    /** @deprecated use `ResponsesFormatJSONObjectType$outboundSchema` instead. */
+    ResponsesFormatJSONObjectType$.outboundSchema = ResponsesFormatJSONObjectType$outboundSchema;
+})(ResponsesFormatJSONObjectType$ || (ResponsesFormatJSONObjectType$ = {}));
+/** @internal */
+export const ResponsesFormatJSONObject$inboundSchema = z.object({
+    type: ResponsesFormatJSONObjectType$inboundSchema,
+});
+/** @internal */
+export const ResponsesFormatJSONObject$outboundSchema = z.object({
+    type: ResponsesFormatJSONObjectType$outboundSchema,
+});
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export var ResponsesFormatJSONObject$;
+(function (ResponsesFormatJSONObject$) {
+    /** @deprecated use `ResponsesFormatJSONObject$inboundSchema` instead. */
+    ResponsesFormatJSONObject$.inboundSchema = ResponsesFormatJSONObject$inboundSchema;
+    /** @deprecated use `ResponsesFormatJSONObject$outboundSchema` instead. */
+    ResponsesFormatJSONObject$.outboundSchema = ResponsesFormatJSONObject$outboundSchema;
+})(ResponsesFormatJSONObject$ || (ResponsesFormatJSONObject$ = {}));
+export function responsesFormatJSONObjectToJSON(responsesFormatJSONObject) {
+    return JSON.stringify(ResponsesFormatJSONObject$outboundSchema.parse(responsesFormatJSONObject));
+}
+export function responsesFormatJSONObjectFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => ResponsesFormatJSONObject$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'ResponsesFormatJSONObject' from JSON`);
+}
+//# sourceMappingURL=responsesformatjsonobject.js.map

package/esm/models/responsesformattext.d.ts

@@ -0,0 +1,55 @@
+import * as z from "zod/v4";
+import { ClosedEnum } from "../types/enums.js";
+import { Result as SafeParseResult } from "../types/fp.js";
+import { SDKValidationError } from "./errors/sdkvalidationerror.js";
+export declare const ResponsesFormatTextType: {
+    readonly Text: "text";
+};
+export type ResponsesFormatTextType = ClosedEnum<typeof ResponsesFormatTextType>;
+/**
+ * Plain text response format
+ */
+export type ResponsesFormatText = {
+    type: ResponsesFormatTextType;
+};
+/** @internal */
+export declare const ResponsesFormatTextType$inboundSchema: z.ZodEnum<typeof ResponsesFormatTextType>;
+/** @internal */
+export declare const ResponsesFormatTextType$outboundSchema: z.ZodEnum<typeof ResponsesFormatTextType>;
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export declare namespace ResponsesFormatTextType$ {
+    /** @deprecated use `ResponsesFormatTextType$inboundSchema` instead. */
+    const inboundSchema: z.ZodEnum<{
+        readonly Text: "text";
+    }>;
+    /** @deprecated use `ResponsesFormatTextType$outboundSchema` instead. */
+    const outboundSchema: z.ZodEnum<{
+        readonly Text: "text";
+    }>;
+}
+/** @internal */
+export declare const ResponsesFormatText$inboundSchema: z.ZodType<ResponsesFormatText, unknown>;
+/** @internal */
+export type ResponsesFormatText$Outbound = {
+    type: string;
+};
+/** @internal */
+export declare const ResponsesFormatText$outboundSchema: z.ZodType<ResponsesFormatText$Outbound, ResponsesFormatText>;
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export declare namespace ResponsesFormatText$ {
+    /** @deprecated use `ResponsesFormatText$inboundSchema` instead. */
+    const inboundSchema: z.ZodType<ResponsesFormatText, unknown, z.core.$ZodTypeInternals<ResponsesFormatText, unknown>>;
+    /** @deprecated use `ResponsesFormatText$outboundSchema` instead. */
+    const outboundSchema: z.ZodType<ResponsesFormatText$Outbound, ResponsesFormatText, z.core.$ZodTypeInternals<ResponsesFormatText$Outbound, ResponsesFormatText>>;
+    /** @deprecated use `ResponsesFormatText$Outbound` instead. */
+    type Outbound = ResponsesFormatText$Outbound;
+}
+export declare function responsesFormatTextToJSON(responsesFormatText: ResponsesFormatText): string;
+export declare function responsesFormatTextFromJSON(jsonString: string): SafeParseResult<ResponsesFormatText, SDKValidationError>;
+//# sourceMappingURL=responsesformattext.d.ts.map

package/esm/models/responsesformattext.js

@@ -0,0 +1,49 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+import * as z from "zod/v4";
+import { safeParse } from "../lib/schemas.js";
+export const ResponsesFormatTextType = {
+    Text: "text",
+};
+/** @internal */
+export const ResponsesFormatTextType$inboundSchema = z.enum(ResponsesFormatTextType);
+/** @internal */
+export const ResponsesFormatTextType$outboundSchema = ResponsesFormatTextType$inboundSchema;
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export var ResponsesFormatTextType$;
+(function (ResponsesFormatTextType$) {
+    /** @deprecated use `ResponsesFormatTextType$inboundSchema` instead. */
+    ResponsesFormatTextType$.inboundSchema = ResponsesFormatTextType$inboundSchema;
+    /** @deprecated use `ResponsesFormatTextType$outboundSchema` instead. */
+    ResponsesFormatTextType$.outboundSchema = ResponsesFormatTextType$outboundSchema;
+})(ResponsesFormatTextType$ || (ResponsesFormatTextType$ = {}));
+/** @internal */
+export const ResponsesFormatText$inboundSchema = z.object({
+    type: ResponsesFormatTextType$inboundSchema,
+});
+/** @internal */
+export const ResponsesFormatText$outboundSchema = z.object({
+    type: ResponsesFormatTextType$outboundSchema,
+});
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export var ResponsesFormatText$;
+(function (ResponsesFormatText$) {
+    /** @deprecated use `ResponsesFormatText$inboundSchema` instead. */
+    ResponsesFormatText$.inboundSchema = ResponsesFormatText$inboundSchema;
+    /** @deprecated use `ResponsesFormatText$outboundSchema` instead. */
+    ResponsesFormatText$.outboundSchema = ResponsesFormatText$outboundSchema;
+})(ResponsesFormatText$ || (ResponsesFormatText$ = {}));
+export function responsesFormatTextToJSON(responsesFormatText) {
+    return JSON.stringify(ResponsesFormatText$outboundSchema.parse(responsesFormatText));
+}
+export function responsesFormatTextFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => ResponsesFormatText$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'ResponsesFormatText' from JSON`);
+}
+//# sourceMappingURL=responsesformattext.js.map

package/esm/models/responsesformattextjsonschemaconfig.d.ts

@@ -0,0 +1,67 @@
+import * as z from "zod/v4";
+import { ClosedEnum } from "../types/enums.js";
+import { Result as SafeParseResult } from "../types/fp.js";
+import { SDKValidationError } from "./errors/sdkvalidationerror.js";
+export declare const ResponsesFormatTextJSONSchemaConfigType: {
+    readonly JsonSchema: "json_schema";
+};
+export type ResponsesFormatTextJSONSchemaConfigType = ClosedEnum<typeof ResponsesFormatTextJSONSchemaConfigType>;
+/**
+ * JSON schema constrained response format
+ */
+export type ResponsesFormatTextJSONSchemaConfig = {
+    type: ResponsesFormatTextJSONSchemaConfigType;
+    name: string;
+    description?: string | undefined;
+    strict?: boolean | null | undefined;
+    schema: {
+        [k: string]: any | null;
+    };
+};
+/** @internal */
+export declare const ResponsesFormatTextJSONSchemaConfigType$inboundSchema: z.ZodEnum<typeof ResponsesFormatTextJSONSchemaConfigType>;
+/** @internal */
+export declare const ResponsesFormatTextJSONSchemaConfigType$outboundSchema: z.ZodEnum<typeof ResponsesFormatTextJSONSchemaConfigType>;
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export declare namespace ResponsesFormatTextJSONSchemaConfigType$ {
+    /** @deprecated use `ResponsesFormatTextJSONSchemaConfigType$inboundSchema` instead. */
+    const inboundSchema: z.ZodEnum<{
+        readonly JsonSchema: "json_schema";
+    }>;
+    /** @deprecated use `ResponsesFormatTextJSONSchemaConfigType$outboundSchema` instead. */
+    const outboundSchema: z.ZodEnum<{
+        readonly JsonSchema: "json_schema";
+    }>;
+}
+/** @internal */
+export declare const ResponsesFormatTextJSONSchemaConfig$inboundSchema: z.ZodType<ResponsesFormatTextJSONSchemaConfig, unknown>;
+/** @internal */
+export type ResponsesFormatTextJSONSchemaConfig$Outbound = {
+    type: string;
+    name: string;
+    description?: string | undefined;
+    strict?: boolean | null | undefined;
+    schema: {
+        [k: string]: any | null;
+    };
+};
+/** @internal */
+export declare const ResponsesFormatTextJSONSchemaConfig$outboundSchema: z.ZodType<ResponsesFormatTextJSONSchemaConfig$Outbound, ResponsesFormatTextJSONSchemaConfig>;
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export declare namespace ResponsesFormatTextJSONSchemaConfig$ {
+    /** @deprecated use `ResponsesFormatTextJSONSchemaConfig$inboundSchema` instead. */
+    const inboundSchema: z.ZodType<ResponsesFormatTextJSONSchemaConfig, unknown, z.core.$ZodTypeInternals<ResponsesFormatTextJSONSchemaConfig, unknown>>;
+    /** @deprecated use `ResponsesFormatTextJSONSchemaConfig$outboundSchema` instead. */
+    const outboundSchema: z.ZodType<ResponsesFormatTextJSONSchemaConfig$Outbound, ResponsesFormatTextJSONSchemaConfig, z.core.$ZodTypeInternals<ResponsesFormatTextJSONSchemaConfig$Outbound, ResponsesFormatTextJSONSchemaConfig>>;
+    /** @deprecated use `ResponsesFormatTextJSONSchemaConfig$Outbound` instead. */
+    type Outbound = ResponsesFormatTextJSONSchemaConfig$Outbound;
+}
+export declare function responsesFormatTextJSONSchemaConfigToJSON(responsesFormatTextJSONSchemaConfig: ResponsesFormatTextJSONSchemaConfig): string;
+export declare function responsesFormatTextJSONSchemaConfigFromJSON(jsonString: string): SafeParseResult<ResponsesFormatTextJSONSchemaConfig, SDKValidationError>;
+//# sourceMappingURL=responsesformattextjsonschemaconfig.d.ts.map

package/esm/models/responsesformattextjsonschemaconfig.js

@@ -0,0 +1,57 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+import * as z from "zod/v4";
+import { safeParse } from "../lib/schemas.js";
+export const ResponsesFormatTextJSONSchemaConfigType = {
+    JsonSchema: "json_schema",
+};
+/** @internal */
+export const ResponsesFormatTextJSONSchemaConfigType$inboundSchema = z.enum(ResponsesFormatTextJSONSchemaConfigType);
+/** @internal */
+export const ResponsesFormatTextJSONSchemaConfigType$outboundSchema = ResponsesFormatTextJSONSchemaConfigType$inboundSchema;
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export var ResponsesFormatTextJSONSchemaConfigType$;
+(function (ResponsesFormatTextJSONSchemaConfigType$) {
+    /** @deprecated use `ResponsesFormatTextJSONSchemaConfigType$inboundSchema` instead. */
+    ResponsesFormatTextJSONSchemaConfigType$.inboundSchema = ResponsesFormatTextJSONSchemaConfigType$inboundSchema;
+    /** @deprecated use `ResponsesFormatTextJSONSchemaConfigType$outboundSchema` instead. */
+    ResponsesFormatTextJSONSchemaConfigType$.outboundSchema = ResponsesFormatTextJSONSchemaConfigType$outboundSchema;
+})(ResponsesFormatTextJSONSchemaConfigType$ || (ResponsesFormatTextJSONSchemaConfigType$ = {}));
+/** @internal */
+export const ResponsesFormatTextJSONSchemaConfig$inboundSchema = z.object({
+    type: ResponsesFormatTextJSONSchemaConfigType$inboundSchema,
+    name: z.string(),
+    description: z.string().optional(),
+    strict: z.nullable(z.boolean()).optional(),
+    schema: z.record(z.string(), z.nullable(z.any())),
+});
+/** @internal */
+export const ResponsesFormatTextJSONSchemaConfig$outboundSchema = z.object({
+    type: ResponsesFormatTextJSONSchemaConfigType$outboundSchema,
+    name: z.string(),
+    description: z.string().optional(),
+    strict: z.nullable(z.boolean()).optional(),
+    schema: z.record(z.string(), z.nullable(z.any())),
+});
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export var ResponsesFormatTextJSONSchemaConfig$;
+(function (ResponsesFormatTextJSONSchemaConfig$) {
+    /** @deprecated use `ResponsesFormatTextJSONSchemaConfig$inboundSchema` instead. */
+    ResponsesFormatTextJSONSchemaConfig$.inboundSchema = ResponsesFormatTextJSONSchemaConfig$inboundSchema;
+    /** @deprecated use `ResponsesFormatTextJSONSchemaConfig$outboundSchema` instead. */
+    ResponsesFormatTextJSONSchemaConfig$.outboundSchema = ResponsesFormatTextJSONSchemaConfig$outboundSchema;
+})(ResponsesFormatTextJSONSchemaConfig$ || (ResponsesFormatTextJSONSchemaConfig$ = {}));
+export function responsesFormatTextJSONSchemaConfigToJSON(responsesFormatTextJSONSchemaConfig) {
+    return JSON.stringify(ResponsesFormatTextJSONSchemaConfig$outboundSchema.parse(responsesFormatTextJSONSchemaConfig));
+}
+export function responsesFormatTextJSONSchemaConfigFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => ResponsesFormatTextJSONSchemaConfig$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'ResponsesFormatTextJSONSchemaConfig' from JSON`);
+}
+//# sourceMappingURL=responsesformattextjsonschemaconfig.js.map

package/esm/models/responsesoutputitemfunctioncall.d.ts

@@ -6,12 +6,26 @@ export declare const ResponsesOutputItemFunctionCallType: {
     readonly FunctionCall: "function_call";
 };
 export type ResponsesOutputItemFunctionCallType = ClosedEnum<typeof ResponsesOutputItemFunctionCallType>;
+export declare const ResponsesOutputItemFunctionCallStatusInProgress: {
+    readonly InProgress: "in_progress";
+};
+export type ResponsesOutputItemFunctionCallStatusInProgress = ClosedEnum<typeof ResponsesOutputItemFunctionCallStatusInProgress>;
+export declare const ResponsesOutputItemFunctionCallStatusIncomplete: {
+    readonly Incomplete: "incomplete";
+};
+export type ResponsesOutputItemFunctionCallStatusIncomplete = ClosedEnum<typeof ResponsesOutputItemFunctionCallStatusIncomplete>;
+export declare const ResponsesOutputItemFunctionCallStatusCompleted: {
+    readonly Completed: "completed";
+};
+export type ResponsesOutputItemFunctionCallStatusCompleted = ClosedEnum<typeof ResponsesOutputItemFunctionCallStatusCompleted>;
+export type ResponsesOutputItemFunctionCallStatusUnion = ResponsesOutputItemFunctionCallStatusCompleted | ResponsesOutputItemFunctionCallStatusIncomplete | ResponsesOutputItemFunctionCallStatusInProgress;
 export type ResponsesOutputItemFunctionCall = {
     type: ResponsesOutputItemFunctionCallType;
     id?: string | undefined;
     name: string;
     arguments: string;
     callId: string;
+    status?: ResponsesOutputItemFunctionCallStatusCompleted | ResponsesOutputItemFunctionCallStatusIncomplete | ResponsesOutputItemFunctionCallStatusInProgress | undefined;
 };
 /** @internal */
 export declare const ResponsesOutputItemFunctionCallType$inboundSchema: z.ZodEnum<typeof ResponsesOutputItemFunctionCallType>;
@@ -32,6 +46,80 @@ export declare namespace ResponsesOutputItemFunctionCallType$ {
     }>;
 }
 /** @internal */
+export declare const ResponsesOutputItemFunctionCallStatusInProgress$inboundSchema: z.ZodEnum<typeof ResponsesOutputItemFunctionCallStatusInProgress>;
+/** @internal */
+export declare const ResponsesOutputItemFunctionCallStatusInProgress$outboundSchema: z.ZodEnum<typeof ResponsesOutputItemFunctionCallStatusInProgress>;
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export declare namespace ResponsesOutputItemFunctionCallStatusInProgress$ {
+    /** @deprecated use `ResponsesOutputItemFunctionCallStatusInProgress$inboundSchema` instead. */
+    const inboundSchema: z.ZodEnum<{
+        readonly InProgress: "in_progress";
+    }>;
+    /** @deprecated use `ResponsesOutputItemFunctionCallStatusInProgress$outboundSchema` instead. */
+    const outboundSchema: z.ZodEnum<{
+        readonly InProgress: "in_progress";
+    }>;
+}
+/** @internal */
+export declare const ResponsesOutputItemFunctionCallStatusIncomplete$inboundSchema: z.ZodEnum<typeof ResponsesOutputItemFunctionCallStatusIncomplete>;
+/** @internal */
+export declare const ResponsesOutputItemFunctionCallStatusIncomplete$outboundSchema: z.ZodEnum<typeof ResponsesOutputItemFunctionCallStatusIncomplete>;
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export declare namespace ResponsesOutputItemFunctionCallStatusIncomplete$ {
+    /** @deprecated use `ResponsesOutputItemFunctionCallStatusIncomplete$inboundSchema` instead. */
+    const inboundSchema: z.ZodEnum<{
+        readonly Incomplete: "incomplete";
+    }>;
+    /** @deprecated use `ResponsesOutputItemFunctionCallStatusIncomplete$outboundSchema` instead. */
+    const outboundSchema: z.ZodEnum<{
+        readonly Incomplete: "incomplete";
+    }>;
+}
+/** @internal */
+export declare const ResponsesOutputItemFunctionCallStatusCompleted$inboundSchema: z.ZodEnum<typeof ResponsesOutputItemFunctionCallStatusCompleted>;
+/** @internal */
+export declare const ResponsesOutputItemFunctionCallStatusCompleted$outboundSchema: z.ZodEnum<typeof ResponsesOutputItemFunctionCallStatusCompleted>;
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export declare namespace ResponsesOutputItemFunctionCallStatusCompleted$ {
+    /** @deprecated use `ResponsesOutputItemFunctionCallStatusCompleted$inboundSchema` instead. */
+    const inboundSchema: z.ZodEnum<{
+        readonly Completed: "completed";
+    }>;
+    /** @deprecated use `ResponsesOutputItemFunctionCallStatusCompleted$outboundSchema` instead. */
+    const outboundSchema: z.ZodEnum<{
+        readonly Completed: "completed";
+    }>;
+}
+/** @internal */
+export declare const ResponsesOutputItemFunctionCallStatusUnion$inboundSchema: z.ZodType<ResponsesOutputItemFunctionCallStatusUnion, unknown>;
+/** @internal */
+export type ResponsesOutputItemFunctionCallStatusUnion$Outbound = string | string | string;
+/** @internal */
+export declare const ResponsesOutputItemFunctionCallStatusUnion$outboundSchema: z.ZodType<ResponsesOutputItemFunctionCallStatusUnion$Outbound, ResponsesOutputItemFunctionCallStatusUnion>;
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export declare namespace ResponsesOutputItemFunctionCallStatusUnion$ {
+    /** @deprecated use `ResponsesOutputItemFunctionCallStatusUnion$inboundSchema` instead. */
+    const inboundSchema: z.ZodType<ResponsesOutputItemFunctionCallStatusUnion, unknown, z.core.$ZodTypeInternals<ResponsesOutputItemFunctionCallStatusUnion, unknown>>;
+    /** @deprecated use `ResponsesOutputItemFunctionCallStatusUnion$outboundSchema` instead. */
+    const outboundSchema: z.ZodType<string, ResponsesOutputItemFunctionCallStatusUnion, z.core.$ZodTypeInternals<string, ResponsesOutputItemFunctionCallStatusUnion>>;
+    /** @deprecated use `ResponsesOutputItemFunctionCallStatusUnion$Outbound` instead. */
+    type Outbound = ResponsesOutputItemFunctionCallStatusUnion$Outbound;
+}
+export declare function responsesOutputItemFunctionCallStatusUnionToJSON(responsesOutputItemFunctionCallStatusUnion: ResponsesOutputItemFunctionCallStatusUnion): string;
+export declare function responsesOutputItemFunctionCallStatusUnionFromJSON(jsonString: string): SafeParseResult<ResponsesOutputItemFunctionCallStatusUnion, SDKValidationError>;
+/** @internal */
 export declare const ResponsesOutputItemFunctionCall$inboundSchema: z.ZodType<ResponsesOutputItemFunctionCall, unknown>;
 /** @internal */
 export type ResponsesOutputItemFunctionCall$Outbound = {
@@ -40,6 +128,7 @@ export type ResponsesOutputItemFunctionCall$Outbound = {
     name: string;
     arguments: string;
     call_id: string;
+    status?: string | string | string | undefined;
 };
 /** @internal */
 export declare const ResponsesOutputItemFunctionCall$outboundSchema: z.ZodType<ResponsesOutputItemFunctionCall$Outbound, ResponsesOutputItemFunctionCall>;

package/esm/models/responsesoutputitemfunctioncall.js

@@ -7,6 +7,15 @@ import { safeParse } from "../lib/schemas.js";
 export const ResponsesOutputItemFunctionCallType = {
     FunctionCall: "function_call",
 };
+export const ResponsesOutputItemFunctionCallStatusInProgress = {
+    InProgress: "in_progress",
+};
+export const ResponsesOutputItemFunctionCallStatusIncomplete = {
+    Incomplete: "incomplete",
+};
+export const ResponsesOutputItemFunctionCallStatusCompleted = {
+    Completed: "completed",
+};
 /** @internal */
 export const ResponsesOutputItemFunctionCallType$inboundSchema = z.enum(ResponsesOutputItemFunctionCallType);
 /** @internal */
@@ -23,12 +32,91 @@ export var ResponsesOutputItemFunctionCallType$;
     ResponsesOutputItemFunctionCallType$.outboundSchema = ResponsesOutputItemFunctionCallType$outboundSchema;
 })(ResponsesOutputItemFunctionCallType$ || (ResponsesOutputItemFunctionCallType$ = {}));
 /** @internal */
+export const ResponsesOutputItemFunctionCallStatusInProgress$inboundSchema = z.enum(ResponsesOutputItemFunctionCallStatusInProgress);
+/** @internal */
+export const ResponsesOutputItemFunctionCallStatusInProgress$outboundSchema = ResponsesOutputItemFunctionCallStatusInProgress$inboundSchema;
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export var ResponsesOutputItemFunctionCallStatusInProgress$;
+(function (ResponsesOutputItemFunctionCallStatusInProgress$) {
+    /** @deprecated use `ResponsesOutputItemFunctionCallStatusInProgress$inboundSchema` instead. */
+    ResponsesOutputItemFunctionCallStatusInProgress$.inboundSchema = ResponsesOutputItemFunctionCallStatusInProgress$inboundSchema;
+    /** @deprecated use `ResponsesOutputItemFunctionCallStatusInProgress$outboundSchema` instead. */
+    ResponsesOutputItemFunctionCallStatusInProgress$.outboundSchema = ResponsesOutputItemFunctionCallStatusInProgress$outboundSchema;
+})(ResponsesOutputItemFunctionCallStatusInProgress$ || (ResponsesOutputItemFunctionCallStatusInProgress$ = {}));
+/** @internal */
+export const ResponsesOutputItemFunctionCallStatusIncomplete$inboundSchema = z.enum(ResponsesOutputItemFunctionCallStatusIncomplete);
+/** @internal */
+export const ResponsesOutputItemFunctionCallStatusIncomplete$outboundSchema = ResponsesOutputItemFunctionCallStatusIncomplete$inboundSchema;
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export var ResponsesOutputItemFunctionCallStatusIncomplete$;
+(function (ResponsesOutputItemFunctionCallStatusIncomplete$) {
+    /** @deprecated use `ResponsesOutputItemFunctionCallStatusIncomplete$inboundSchema` instead. */
+    ResponsesOutputItemFunctionCallStatusIncomplete$.inboundSchema = ResponsesOutputItemFunctionCallStatusIncomplete$inboundSchema;
+    /** @deprecated use `ResponsesOutputItemFunctionCallStatusIncomplete$outboundSchema` instead. */
+    ResponsesOutputItemFunctionCallStatusIncomplete$.outboundSchema = ResponsesOutputItemFunctionCallStatusIncomplete$outboundSchema;
+})(ResponsesOutputItemFunctionCallStatusIncomplete$ || (ResponsesOutputItemFunctionCallStatusIncomplete$ = {}));
+/** @internal */
+export const ResponsesOutputItemFunctionCallStatusCompleted$inboundSchema = z.enum(ResponsesOutputItemFunctionCallStatusCompleted);
+/** @internal */
+export const ResponsesOutputItemFunctionCallStatusCompleted$outboundSchema = ResponsesOutputItemFunctionCallStatusCompleted$inboundSchema;
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export var ResponsesOutputItemFunctionCallStatusCompleted$;
+(function (ResponsesOutputItemFunctionCallStatusCompleted$) {
+    /** @deprecated use `ResponsesOutputItemFunctionCallStatusCompleted$inboundSchema` instead. */
+    ResponsesOutputItemFunctionCallStatusCompleted$.inboundSchema = ResponsesOutputItemFunctionCallStatusCompleted$inboundSchema;
+    /** @deprecated use `ResponsesOutputItemFunctionCallStatusCompleted$outboundSchema` instead. */
+    ResponsesOutputItemFunctionCallStatusCompleted$.outboundSchema = ResponsesOutputItemFunctionCallStatusCompleted$outboundSchema;
+})(ResponsesOutputItemFunctionCallStatusCompleted$ || (ResponsesOutputItemFunctionCallStatusCompleted$ = {}));
+/** @internal */
+export const ResponsesOutputItemFunctionCallStatusUnion$inboundSchema = z.union([
+    ResponsesOutputItemFunctionCallStatusCompleted$inboundSchema,
+    ResponsesOutputItemFunctionCallStatusIncomplete$inboundSchema,
+    ResponsesOutputItemFunctionCallStatusInProgress$inboundSchema,
+]);
+/** @internal */
+export const ResponsesOutputItemFunctionCallStatusUnion$outboundSchema = z.union([
+    ResponsesOutputItemFunctionCallStatusCompleted$outboundSchema,
+    ResponsesOutputItemFunctionCallStatusIncomplete$outboundSchema,
+    ResponsesOutputItemFunctionCallStatusInProgress$outboundSchema,
+]);
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export var ResponsesOutputItemFunctionCallStatusUnion$;
+(function (ResponsesOutputItemFunctionCallStatusUnion$) {
+    /** @deprecated use `ResponsesOutputItemFunctionCallStatusUnion$inboundSchema` instead. */
+    ResponsesOutputItemFunctionCallStatusUnion$.inboundSchema = ResponsesOutputItemFunctionCallStatusUnion$inboundSchema;
+    /** @deprecated use `ResponsesOutputItemFunctionCallStatusUnion$outboundSchema` instead. */
+    ResponsesOutputItemFunctionCallStatusUnion$.outboundSchema = ResponsesOutputItemFunctionCallStatusUnion$outboundSchema;
+})(ResponsesOutputItemFunctionCallStatusUnion$ || (ResponsesOutputItemFunctionCallStatusUnion$ = {}));
+export function responsesOutputItemFunctionCallStatusUnionToJSON(responsesOutputItemFunctionCallStatusUnion) {
+    return JSON.stringify(ResponsesOutputItemFunctionCallStatusUnion$outboundSchema.parse(responsesOutputItemFunctionCallStatusUnion));
+}
+export function responsesOutputItemFunctionCallStatusUnionFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => ResponsesOutputItemFunctionCallStatusUnion$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'ResponsesOutputItemFunctionCallStatusUnion' from JSON`);
+}
+/** @internal */
 export const ResponsesOutputItemFunctionCall$inboundSchema = z.object({
     type: ResponsesOutputItemFunctionCallType$inboundSchema,
     id: z.string().optional(),
     name: z.string(),
     arguments: z.string(),
     call_id: z.string(),
+    status: z.union([
+        ResponsesOutputItemFunctionCallStatusCompleted$inboundSchema,
+        ResponsesOutputItemFunctionCallStatusIncomplete$inboundSchema,
+        ResponsesOutputItemFunctionCallStatusInProgress$inboundSchema,
+    ]).optional(),
 }).transform((v) => {
     return remap$(v, {
         "call_id": "callId",
@@ -41,6 +129,11 @@ export const ResponsesOutputItemFunctionCall$outboundSchema = z.object({
     name: z.string(),
     arguments: z.string(),
     callId: z.string(),
+    status: z.union([
+        ResponsesOutputItemFunctionCallStatusCompleted$outboundSchema,
+        ResponsesOutputItemFunctionCallStatusIncomplete$outboundSchema,
+        ResponsesOutputItemFunctionCallStatusInProgress$outboundSchema,
+    ]).optional(),
 }).transform((v) => {
     return remap$(v, {
         callId: "call_id",