@openrouter/sdk 0.8.0 → 0.9.11

package/esm/models/chatresponse.d.ts

@@ -1,18 +1,46 @@
 import * as z from "zod/v4";
+import { ClosedEnum } from "../types/enums.js";
 import { Result as SafeParseResult } from "../types/fp.js";
 import { ChatGenerationTokenUsage } from "./chatgenerationtokenusage.js";
 import { ChatResponseChoice } from "./chatresponsechoice.js";
 import { SDKValidationError } from "./errors/sdkvalidationerror.js";
+export declare const ChatResponseObject: {
+    readonly ChatCompletion: "chat.completion";
+};
+export type ChatResponseObject = ClosedEnum<typeof ChatResponseObject>;
+/**
+ * Chat completion response
+ */
 export type ChatResponse = {
+    /**
+     * Unique completion identifier
+     */
     id: string;
+    /**
+     * List of completion choices
+     */
     choices: Array<ChatResponseChoice>;
+    /**
+     * Unix timestamp of creation
+     */
     created: number;
+    /**
+     * Model used for completion
+     */
     model: string;
-    object: "chat.completion";
+    object: ChatResponseObject;
+    /**
+     * System fingerprint
+     */
     systemFingerprint?: string | null | undefined;
+    /**
+     * Token usage statistics
+     */
     usage?: ChatGenerationTokenUsage | undefined;
 };
 /** @internal */
+export declare const ChatResponseObject$inboundSchema: z.ZodEnum<typeof ChatResponseObject>;
+/** @internal */
 export declare const ChatResponse$inboundSchema: z.ZodType<ChatResponse, unknown>;
 export declare function chatResponseFromJSON(jsonString: string): SafeParseResult<ChatResponse, SDKValidationError>;
 //# sourceMappingURL=chatresponse.d.ts.map

package/esm/models/chatresponse.js

@@ -7,6 +7,11 @@ import { remap as remap$ } from "../lib/primitives.js";
 import { safeParse } from "../lib/schemas.js";
 import { ChatGenerationTokenUsage$inboundSchema, } from "./chatgenerationtokenusage.js";
 import { ChatResponseChoice$inboundSchema, } from "./chatresponsechoice.js";
+export const ChatResponseObject = {
+    ChatCompletion: "chat.completion",
+};
+/** @internal */
+export const ChatResponseObject$inboundSchema = z.enum(ChatResponseObject);
 /** @internal */
 export const ChatResponse$inboundSchema = z
     .object({
@@ -14,7 +19,7 @@ export const ChatResponse$inboundSchema = z
     choices: z.array(ChatResponseChoice$inboundSchema),
     created: z.number(),
     model: z.string(),
-    object: z.literal("chat.completion"),
+    object: ChatResponseObject$inboundSchema,
     system_fingerprint: z.nullable(z.string()).optional(),
     usage: ChatGenerationTokenUsage$inboundSchema.optional(),
 }).transform((v) => {

package/esm/models/chatresponsechoice.d.ts

@@ -1,13 +1,24 @@
 import * as z from "zod/v4";
 import { Result as SafeParseResult } from "../types/fp.js";
 import { AssistantMessage } from "./assistantmessage.js";
-import { ChatCompletionFinishReason } from "./chatcompletionfinishreason.js";
 import { ChatMessageTokenLogprobs } from "./chatmessagetokenlogprobs.js";
 import { SDKValidationError } from "./errors/sdkvalidationerror.js";
+/**
+ * Chat completion choice
+ */
 export type ChatResponseChoice = {
-    finishReason: ChatCompletionFinishReason | null;
+    finishReason?: any | null | undefined;
+    /**
+     * Choice index
+     */
     index: number;
+    /**
+     * Assistant message for requests and responses
+     */
     message: AssistantMessage;
+    /**
+     * Log probabilities for the completion
+     */
     logprobs?: ChatMessageTokenLogprobs | null | undefined;
 };
 /** @internal */

package/esm/models/chatresponsechoice.js

@@ -6,11 +6,10 @@ import * as z from "zod/v4";
 import { remap as remap$ } from "../lib/primitives.js";
 import { safeParse } from "../lib/schemas.js";
 import { AssistantMessage$inboundSchema, } from "./assistantmessage.js";
-import { ChatCompletionFinishReason$inboundSchema, } from "./chatcompletionfinishreason.js";
 import { ChatMessageTokenLogprobs$inboundSchema, } from "./chatmessagetokenlogprobs.js";
 /** @internal */
 export const ChatResponseChoice$inboundSchema = z.object({
-    finish_reason: z.nullable(ChatCompletionFinishReason$inboundSchema),
+    finish_reason: z.nullable(z.any()).optional(),
     index: z.number(),
     message: AssistantMessage$inboundSchema,
     logprobs: z.nullable(ChatMessageTokenLogprobs$inboundSchema).optional(),

package/esm/models/chatstreamingchoice.d.ts

@@ -1,13 +1,24 @@
 import * as z from "zod/v4";
 import { Result as SafeParseResult } from "../types/fp.js";
-import { ChatCompletionFinishReason } from "./chatcompletionfinishreason.js";
 import { ChatMessageTokenLogprobs } from "./chatmessagetokenlogprobs.js";
 import { ChatStreamingMessageChunk } from "./chatstreamingmessagechunk.js";
 import { SDKValidationError } from "./errors/sdkvalidationerror.js";
+/**
+ * Streaming completion choice chunk
+ */
 export type ChatStreamingChoice = {
+    /**
+     * Delta changes in streaming response
+     */
     delta: ChatStreamingMessageChunk;
-    finishReason: ChatCompletionFinishReason | null;
+    finishReason?: any | null | undefined;
+    /**
+     * Choice index
+     */
     index: number;
+    /**
+     * Log probabilities for the completion
+     */
     logprobs?: ChatMessageTokenLogprobs | null | undefined;
 };
 /** @internal */

package/esm/models/chatstreamingchoice.js

@@ -5,13 +5,12 @@
 import * as z from "zod/v4";
 import { remap as remap$ } from "../lib/primitives.js";
 import { safeParse } from "../lib/schemas.js";
-import { ChatCompletionFinishReason$inboundSchema, } from "./chatcompletionfinishreason.js";
 import { ChatMessageTokenLogprobs$inboundSchema, } from "./chatmessagetokenlogprobs.js";
 import { ChatStreamingMessageChunk$inboundSchema, } from "./chatstreamingmessagechunk.js";
 /** @internal */
 export const ChatStreamingChoice$inboundSchema = z.object({
     delta: ChatStreamingMessageChunk$inboundSchema,
-    finish_reason: z.nullable(ChatCompletionFinishReason$inboundSchema),
+    finish_reason: z.nullable(z.any()).optional(),
     index: z.number(),
     logprobs: z.nullable(ChatMessageTokenLogprobs$inboundSchema).optional(),
 }).transform((v) => {

package/esm/models/chatstreamingmessagechunk.d.ts

@@ -3,18 +3,45 @@ import { ClosedEnum } from "../types/enums.js";
 import { Result as SafeParseResult } from "../types/fp.js";
 import { ChatStreamingMessageToolCall } from "./chatstreamingmessagetoolcall.js";
 import { SDKValidationError } from "./errors/sdkvalidationerror.js";
-import { Schema19 } from "./schema19.js";
+import { ReasoningDetailUnion } from "./reasoningdetailunion.js";
+/**
+ * The role of the message author
+ */
 export declare const ChatStreamingMessageChunkRole: {
     readonly Assistant: "assistant";
 };
+/**
+ * The role of the message author
+ */
 export type ChatStreamingMessageChunkRole = ClosedEnum<typeof ChatStreamingMessageChunkRole>;
+/**
+ * Delta changes in streaming response
+ */
 export type ChatStreamingMessageChunk = {
+    /**
+     * The role of the message author
+     */
     role?: ChatStreamingMessageChunkRole | undefined;
+    /**
+     * Message content delta
+     */
     content?: string | null | undefined;
+    /**
+     * Reasoning content delta
+     */
     reasoning?: string | null | undefined;
+    /**
+     * Refusal message delta
+     */
     refusal?: string | null | undefined;
+    /**
+     * Tool calls delta
+     */
     toolCalls?: Array<ChatStreamingMessageToolCall> | undefined;
-    reasoningDetails?: Array<Schema19> | undefined;
+    /**
+     * Reasoning details for extended thinking models
+     */
+    reasoningDetails?: Array<ReasoningDetailUnion> | undefined;
 };
 /** @internal */
 export declare const ChatStreamingMessageChunkRole$inboundSchema: z.ZodEnum<typeof ChatStreamingMessageChunkRole>;

package/esm/models/chatstreamingmessagechunk.js

@@ -6,7 +6,10 @@ import * as z from "zod/v4";
 import { remap as remap$ } from "../lib/primitives.js";
 import { safeParse } from "../lib/schemas.js";
 import { ChatStreamingMessageToolCall$inboundSchema, } from "./chatstreamingmessagetoolcall.js";
-import { Schema19$inboundSchema } from "./schema19.js";
+import { ReasoningDetailUnion$inboundSchema, } from "./reasoningdetailunion.js";
+/**
+ * The role of the message author
+ */
 export const ChatStreamingMessageChunkRole = {
     Assistant: "assistant",
 };
@@ -19,7 +22,7 @@ export const ChatStreamingMessageChunk$inboundSchema = z.object({
     reasoning: z.nullable(z.string()).optional(),
     refusal: z.nullable(z.string()).optional(),
     tool_calls: z.array(ChatStreamingMessageToolCall$inboundSchema).optional(),
-    reasoning_details: z.array(Schema19$inboundSchema).optional(),
+    reasoning_details: z.array(ReasoningDetailUnion$inboundSchema).optional(),
 }).transform((v) => {
     return remap$(v, {
         "tool_calls": "toolCalls",

package/esm/models/chatstreamingmessagetoolcall.d.ts

@@ -1,17 +1,54 @@
 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";
+/**
+ * Tool call type
+ */
+export declare const ChatStreamingMessageToolCallType: {
+    readonly Function: "function";
+};
+/**
+ * Tool call type
+ */
+export type ChatStreamingMessageToolCallType = ClosedEnum<typeof ChatStreamingMessageToolCallType>;
+/**
+ * Function call details
+ */
 export type ChatStreamingMessageToolCallFunction = {
+    /**
+     * Function name
+     */
     name?: string | undefined;
+    /**
+     * Function arguments as JSON string
+     */
     arguments?: string | undefined;
 };
+/**
+ * Tool call delta for streaming responses
+ */
 export type ChatStreamingMessageToolCall = {
+    /**
+     * Tool call index in the array
+     */
     index: number;
+    /**
+     * Tool call identifier
+     */
     id?: string | undefined;
-    type?: "function" | undefined;
+    /**
+     * Tool call type
+     */
+    type?: ChatStreamingMessageToolCallType | undefined;
+    /**
+     * Function call details
+     */
     function?: ChatStreamingMessageToolCallFunction | undefined;
 };
 /** @internal */
+export declare const ChatStreamingMessageToolCallType$inboundSchema: z.ZodEnum<typeof ChatStreamingMessageToolCallType>;
+/** @internal */
 export declare const ChatStreamingMessageToolCallFunction$inboundSchema: z.ZodType<ChatStreamingMessageToolCallFunction, unknown>;
 export declare function chatStreamingMessageToolCallFunctionFromJSON(jsonString: string): SafeParseResult<ChatStreamingMessageToolCallFunction, SDKValidationError>;
 /** @internal */

package/esm/models/chatstreamingmessagetoolcall.js

@@ -4,6 +4,14 @@
  */
 import * as z from "zod/v4";
 import { safeParse } from "../lib/schemas.js";
+/**
+ * Tool call type
+ */
+export const ChatStreamingMessageToolCallType = {
+    Function: "function",
+};
+/** @internal */
+export const ChatStreamingMessageToolCallType$inboundSchema = z.enum(ChatStreamingMessageToolCallType);
 /** @internal */
 export const ChatStreamingMessageToolCallFunction$inboundSchema = z.object({
     name: z.string().optional(),
@@ -16,7 +24,7 @@ export function chatStreamingMessageToolCallFunctionFromJSON(jsonString) {
 export const ChatStreamingMessageToolCall$inboundSchema = z.object({
     index: z.number(),
     id: z.string().optional(),
-    type: z.literal("function").optional(),
+    type: ChatStreamingMessageToolCallType$inboundSchema.optional(),
     function: z.lazy(() => ChatStreamingMessageToolCallFunction$inboundSchema)
         .optional(),
 });

package/esm/models/chatstreamingresponsechunk.d.ts

@@ -1,31 +1,65 @@
 import * as z from "zod/v4";
+import { ClosedEnum } from "../types/enums.js";
 import { Result as SafeParseResult } from "../types/fp.js";
 import { ChatGenerationTokenUsage } from "./chatgenerationtokenusage.js";
 import { ChatStreamingChoice } from "./chatstreamingchoice.js";
 import { SDKValidationError } from "./errors/sdkvalidationerror.js";
-export type ChatStreamingResponseChunkError = {
+export declare const ChatStreamingResponseChunkObject: {
+    readonly ChatCompletionChunk: "chat.completion.chunk";
+};
+export type ChatStreamingResponseChunkObject = ClosedEnum<typeof ChatStreamingResponseChunkObject>;
+/**
+ * Error information
+ */
+export type ErrorT = {
+    /**
+     * Error message
+     */
     message: string;
+    /**
+     * Error code
+     */
     code: number;
 };
-export type ChatStreamingResponseChunkData = {
+/**
+ * Streaming chat completion chunk
+ */
+export type ChatStreamingResponseChunk = {
+    /**
+     * Unique chunk identifier
+     */
     id: string;
+    /**
+     * List of streaming chunk choices
+     */
     choices: Array<ChatStreamingChoice>;
+    /**
+     * Unix timestamp of creation
+     */
     created: number;
+    /**
+     * Model used for completion
+     */
     model: string;
-    object: "chat.completion.chunk";
+    object: ChatStreamingResponseChunkObject;
+    /**
+     * System fingerprint
+     */
     systemFingerprint?: string | null | undefined;
-    error?: ChatStreamingResponseChunkError | undefined;
+    /**
+     * Error information
+     */
+    error?: ErrorT | undefined;
+    /**
+     * Token usage statistics
+     */
     usage?: ChatGenerationTokenUsage | undefined;
 };
-export type ChatStreamingResponseChunk = {
-    data: ChatStreamingResponseChunkData;
-};
 /** @internal */
-export declare const ChatStreamingResponseChunkError$inboundSchema: z.ZodType<ChatStreamingResponseChunkError, unknown>;
-export declare function chatStreamingResponseChunkErrorFromJSON(jsonString: string): SafeParseResult<ChatStreamingResponseChunkError, SDKValidationError>;
+export declare const ChatStreamingResponseChunkObject$inboundSchema: z.ZodEnum<typeof ChatStreamingResponseChunkObject>;
 /** @internal */
-export declare const ChatStreamingResponseChunkData$inboundSchema: z.ZodType<ChatStreamingResponseChunkData, unknown>;
-export declare function chatStreamingResponseChunkDataFromJSON(jsonString: string): SafeParseResult<ChatStreamingResponseChunkData, SDKValidationError>;
+export declare const ErrorT$inboundSchema: z.ZodType<ErrorT, unknown>;
+export declare function errorFromJSON(jsonString: string): SafeParseResult<ErrorT, SDKValidationError>;
 /** @internal */
 export declare const ChatStreamingResponseChunk$inboundSchema: z.ZodType<ChatStreamingResponseChunk, unknown>;
 export declare function chatStreamingResponseChunkFromJSON(jsonString: string): SafeParseResult<ChatStreamingResponseChunk, SDKValidationError>;

package/esm/models/chatstreamingresponsechunk.js

@@ -7,48 +7,34 @@ import { remap as remap$ } from "../lib/primitives.js";
 import { safeParse } from "../lib/schemas.js";
 import { ChatGenerationTokenUsage$inboundSchema, } from "./chatgenerationtokenusage.js";
 import { ChatStreamingChoice$inboundSchema, } from "./chatstreamingchoice.js";
+export const ChatStreamingResponseChunkObject = {
+    ChatCompletionChunk: "chat.completion.chunk",
+};
 /** @internal */
-export const ChatStreamingResponseChunkError$inboundSchema = z.object({
+export const ChatStreamingResponseChunkObject$inboundSchema = z.enum(ChatStreamingResponseChunkObject);
+/** @internal */
+export const ErrorT$inboundSchema = z.object({
     message: z.string(),
     code: z.number(),
 });
-export function chatStreamingResponseChunkErrorFromJSON(jsonString) {
-    return safeParse(jsonString, (x) => ChatStreamingResponseChunkError$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'ChatStreamingResponseChunkError' from JSON`);
+export function errorFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => ErrorT$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'ErrorT' from JSON`);
 }
 /** @internal */
-export const ChatStreamingResponseChunkData$inboundSchema = z.object({
+export const ChatStreamingResponseChunk$inboundSchema = z.object({
     id: z.string(),
     choices: z.array(ChatStreamingChoice$inboundSchema),
     created: z.number(),
     model: z.string(),
-    object: z.literal("chat.completion.chunk"),
+    object: ChatStreamingResponseChunkObject$inboundSchema,
     system_fingerprint: z.nullable(z.string()).optional(),
-    error: z.lazy(() => ChatStreamingResponseChunkError$inboundSchema).optional(),
+    error: z.lazy(() => ErrorT$inboundSchema).optional(),
     usage: ChatGenerationTokenUsage$inboundSchema.optional(),
 }).transform((v) => {
     return remap$(v, {
         "system_fingerprint": "systemFingerprint",
     });
 });
-export function chatStreamingResponseChunkDataFromJSON(jsonString) {
-    return safeParse(jsonString, (x) => ChatStreamingResponseChunkData$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'ChatStreamingResponseChunkData' from JSON`);
-}
-/** @internal */
-export const ChatStreamingResponseChunk$inboundSchema = z.object({
-    data: z.string().transform((v, ctx) => {
-        try {
-            return JSON.parse(v);
-        }
-        catch (err) {
-            ctx.addIssue({
-                input: v,
-                code: "custom",
-                message: `malformed json: ${err}`,
-            });
-            return z.NEVER;
-        }
-    }).pipe(z.lazy(() => ChatStreamingResponseChunkData$inboundSchema)),
-});
 export function chatStreamingResponseChunkFromJSON(jsonString) {
     return safeParse(jsonString, (x) => ChatStreamingResponseChunk$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'ChatStreamingResponseChunk' from JSON`);
 }

package/esm/models/chatstreamoptions.d.ts

@@ -1,5 +1,13 @@
 import * as z from "zod/v4";
+/**
+ * Streaming configuration options
+ */
 export type ChatStreamOptions = {
+    /**
+     * Deprecated: This field has no effect. Full usage details are always included.
+     *
+     * @deprecated field: This will be removed in a future release, please migrate away from it as soon as possible.
+     */
     includeUsage?: boolean | undefined;
 };
 /** @internal */

package/esm/models/debugoptions.d.ts

@@ -0,0 +1,18 @@
+import * as z from "zod/v4";
+/**
+ * Debug options for inspecting request transformations (streaming only)
+ */
+export type DebugOptions = {
+    /**
+     * If true, includes the transformed upstream request body in a debug chunk at the start of the stream. Only works with streaming mode.
+     */
+    echoUpstreamBody?: boolean | undefined;
+};
+/** @internal */
+export type DebugOptions$Outbound = {
+    echo_upstream_body?: boolean | undefined;
+};
+/** @internal */
+export declare const DebugOptions$outboundSchema: z.ZodType<DebugOptions$Outbound, DebugOptions>;
+export declare function debugOptionsToJSON(debugOptions: DebugOptions): string;
+//# sourceMappingURL=debugoptions.d.ts.map

package/esm/models/debugoptions.js

@@ -0,0 +1,18 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ * @generated-id: 12d8bc710ea7
+ */
+import * as z from "zod/v4";
+import { remap as remap$ } from "../lib/primitives.js";
+/** @internal */
+export const DebugOptions$outboundSchema = z.object({
+    echoUpstreamBody: z.boolean().optional(),
+}).transform((v) => {
+    return remap$(v, {
+        echoUpstreamBody: "echo_upstream_body",
+    });
+});
+export function debugOptionsToJSON(debugOptions) {
+    return JSON.stringify(DebugOptions$outboundSchema.parse(debugOptions));
+}
+//# sourceMappingURL=debugoptions.js.map

package/esm/models/developermessage.d.ts

@@ -1,9 +1,21 @@
 import * as z from "zod/v4";
 import { ChatMessageContentItemText, ChatMessageContentItemText$Outbound } from "./chatmessagecontentitemtext.js";
+/**
+ * Developer message content
+ */
 export type DeveloperMessageContent = string | Array<ChatMessageContentItemText>;
+/**
+ * Developer message
+ */
 export type DeveloperMessage = {
     role: "developer";
+    /**
+     * Developer message content
+     */
     content: string | Array<ChatMessageContentItemText>;
+    /**
+     * Optional name for the developer message
+     */
     name?: string | undefined;
 };
 /** @internal */

package/esm/models/errors/index.d.ts

@@ -1,6 +1,5 @@
 export * from "./badgatewayresponseerror.js";
 export * from "./badrequestresponseerror.js";
-export * from "./chaterror.js";
 export * from "./edgenetworktimeoutresponseerror.js";
 export * from "./forbiddenresponseerror.js";
 export * from "./httpclienterrors.js";

package/esm/models/errors/index.js

@@ -4,7 +4,6 @@
  */
 export * from "./badgatewayresponseerror.js";
 export * from "./badrequestresponseerror.js";
-export * from "./chaterror.js";
 export * from "./edgenetworktimeoutresponseerror.js";
 export * from "./forbiddenresponseerror.js";
 export * from "./httpclienterrors.js";

package/esm/models/index.d.ts

@@ -1,9 +1,9 @@
 export * from "./activityitem.js";
 export * from "./assistantmessage.js";
+export * from "./assistantmessageimages.js";
 export * from "./badgatewayresponseerrordata.js";
 export * from "./badrequestresponseerrordata.js";
 export * from "./chatcompletionfinishreason.js";
-export * from "./chaterror.js";
 export * from "./chatgenerationparams.js";
 export * from "./chatgenerationtokenusage.js";
 export * from "./chatmessagecontentitem.js";
@@ -12,6 +12,7 @@ export * from "./chatmessagecontentitemcachecontrol.js";
 export * from "./chatmessagecontentitemimage.js";
 export * from "./chatmessagecontentitemtext.js";
 export * from "./chatmessagecontentitemvideo.js";
+export * from "./chatmessagecontentitemvideolegacy.js";
 export * from "./chatmessagetokenlogprob.js";
 export * from "./chatmessagetokenlogprobs.js";
 export * from "./chatmessagetoolcall.js";
@@ -24,6 +25,7 @@ export * from "./chatstreamingresponsechunk.js";
 export * from "./chatstreamoptions.js";
 export * from "./createchargerequest.js";
 export * from "./datacollection.js";
+export * from "./debugoptions.js";
 export * from "./defaultparameters.js";
 export * from "./developermessage.js";
 export * from "./edgenetworktimeoutresponseerrordata.js";
@@ -104,17 +106,23 @@ export * from "./provideroverloadedresponseerrordata.js";
 export * from "./providerpreferences.js";
 export * from "./providersort.js";
 export * from "./providersortconfig.js";
-export * from "./providersortunion.js";
 export * from "./publicendpoint.js";
 export * from "./publicpricing.js";
 export * from "./quantization.js";
+export * from "./reasoningdetailencrypted.js";
+export * from "./reasoningdetailsummary.js";
+export * from "./reasoningdetailtext.js";
+export * from "./reasoningdetailunion.js";
 export * from "./reasoningsummarytext.js";
 export * from "./reasoningsummaryverbosity.js";
 export * from "./reasoningtextcontent.js";
 export * from "./requesttimeoutresponseerrordata.js";
+export * from "./responseformatjsonobject.js";
 export * from "./responseformatjsonschema.js";
+export * from "./responseformattext.js";
 export * from "./responseformattextconfig.js";
 export * from "./responseformattextgrammar.js";
+export * from "./responseformattextpython.js";
 export * from "./responseinputaudio.js";
 export * from "./responseinputfile.js";
 export * from "./responseinputimage.js";
@@ -122,7 +130,6 @@ export * from "./responseinputtext.js";
 export * from "./responseinputvideo.js";
 export * from "./responseoutputtext.js";
 export * from "./responseserrorfield.js";
-export * from "./responsesformatjsonobject.js";
 export * from "./responsesformattext.js";
 export * from "./responsesformattextjsonschemaconfig.js";
 export * from "./responsesimagegenerationcall.js";
@@ -136,15 +143,11 @@ export * from "./responsessearchcontextsize.js";
 export * from "./responseswebsearchcalloutput.js";
 export * from "./responseswebsearchuserlocation.js";
 export * from "./responsetextconfig.js";
-export * from "./schema10.js";
-export * from "./schema14.js";
-export * from "./schema17.js";
-export * from "./schema19.js";
-export * from "./schema5.js";
 export * from "./security.js";
 export * from "./serviceunavailableresponseerrordata.js";
 export * from "./systemmessage.js";
 export * from "./toolcallstatus.js";
+export * from "./toolchoiceoption.js";
 export * from "./tooldefinitionjson.js";
 export * from "./toolresponsemessage.js";
 export * from "./toomanyrequestsresponseerrordata.js";
@@ -153,6 +156,7 @@ export * from "./unauthorizedresponseerrordata.js";
 export * from "./unprocessableentityresponseerrordata.js";
 export * from "./urlcitation.js";
 export * from "./usermessage.js";
+export * from "./videoinput.js";
 export * from "./websearchengine.js";
 export * from "./websearchpreviewtooluserlocation.js";
 export * from "./websearchstatus.js";