@openrouter/sdk 0.0.1 → 0.1.1

package/FUNCTIONS.md

@@ -29,115 +29,7 @@ const openRouter = new OpenRouterCore({
 });
 
 async function run() {
-  const res = await betaResponsesSend(openRouter, {
-    input: [
-      {
-        type: "message",
-        role: "user",
-        content: "Hello, how are you?",
-      },
-    ],
-    instructions: "<value>",
-    metadata: {
-      "user_id": "123",
-      "session_id": "abc-def-ghi",
-    },
-    tools: [
-      {
-        type: "function",
-        name: "get_current_weather",
-        description: "Get the current weather in a given location",
-        strict: true,
-        parameters: {
-          "type": "object",
-          "properties": {
-            "location": {
-              "type": "string",
-            },
-          },
-        },
-      },
-    ],
-    toolChoice: {
-      type: "function",
-      name: "<value>",
-    },
-    parallelToolCalls: true,
-    model: "anthropic/claude-4.5-sonnet-20250929",
-    models: [
-      "<value 1>",
-    ],
-    text: {
-      format: {
-        type: "text",
-      },
-      verbosity: "medium",
-    },
-    reasoning: {
-      effort: "high",
-      summary: "auto",
-      maxTokens: 8661.16,
-      enabled: true,
-    },
-    maxOutputTokens: null,
-    temperature: 0.7,
-    topP: 0.9,
-    topK: 193.77,
-    promptCacheKey: "<value>",
-    previousResponseId: "<id>",
-    prompt: {
-      id: "<id>",
-      variables: {
-        "key": {
-          type: "input_text",
-          text: "Hello, how can I help you?",
-        },
-      },
-    },
-    include: [
-      "reasoning.encrypted_content",
-    ],
-    background: true,
-    safetyIdentifier: "<value>",
-    store: true,
-    serviceTier: "auto",
-    truncation: "auto",
-    provider: {
-      allowFallbacks: null,
-      requireParameters: true,
-      dataCollection: "deny",
-      zdr: true,
-      order: [
-        "OpenAI",
-      ],
-      only: [
-        "OpenAI",
-      ],
-      ignore: null,
-      quantizations: [
-        "fp16",
-      ],
-      sort: "price",
-      maxPrice: {
-        prompt: "1000",
-        completion: 1000,
-        image: 1000,
-        audio: "1000",
-        request: 1000,
-      },
-      experimental: {},
-    },
-    plugins: [
-      {
-        id: "file-parser",
-        maxFiles: 4870.55,
-        pdf: {
-          engine: "mistral-ocr",
-        },
-      },
-    ],
-    user: "Elmer_Yundt72",
-  });
+  const res = await betaResponsesSend(openRouter, {});
   if (res.ok) {
     const { value: result } = res;
     console.log(result);

package/REACT_QUERY.md

@@ -53,9 +53,7 @@ from TanStack Query.
 import { useAnalyticsGetUserActivity } from "@openrouter/sdk/react-query/analyticsGetUserActivity.js";
 
 export function Example() {
-  const { data, error, status } = useAnalyticsGetUserActivity({
-    date: "2025-08-24",
-  });
+  const { data, error, status } = useAnalyticsGetUserActivity();
 
   // Render the UI here...
 }
@@ -73,9 +71,6 @@ import { useAnalyticsGetUserActivity } from "@openrouter/sdk/react-query/analyti
 export function ExampleWithOptions() {
   const [enabled, setEnabled] = useState(true);
   const { data, error, status } = useAnalyticsGetUserActivity(
-    {
-      date: "2025-08-24",
-    },
     {
       // TanStack Query options:
       enabled,
@@ -124,115 +119,7 @@ export function Example() {
 
         // Read form data here...
 
-        mutate({
-          input: [
-            {
-              type: "message",
-              role: "user",
-              content: "Hello, how are you?",
-            },
-          ],
-          instructions: "<value>",
-          metadata: {
-            "user_id": "123",
-            "session_id": "abc-def-ghi",
-          },
-          tools: [
-            {
-              type: "function",
-              name: "get_current_weather",
-              description: "Get the current weather in a given location",
-              strict: true,
-              parameters: {
-                "type": "object",
-                "properties": {
-                  "location": {
-                    "type": "string",
-                  },
-                },
-              },
-            },
-          ],
-          toolChoice: {
-            type: "function",
-            name: "<value>",
-          },
-          parallelToolCalls: true,
-          model: "anthropic/claude-4.5-sonnet-20250929",
-          models: [
-            "<value 1>",
-          ],
-          text: {
-            format: {
-              type: "text",
-            },
-            verbosity: "medium",
-          },
-          reasoning: {
-            effort: "high",
-            summary: "auto",
-            maxTokens: 8661.16,
-            enabled: true,
-          },
-          maxOutputTokens: null,
-          temperature: 0.7,
-          topP: 0.9,
-          topK: 193.77,
-          promptCacheKey: "<value>",
-          previousResponseId: "<id>",
-          prompt: {
-            id: "<id>",
-            variables: {
-              "key": {
-                type: "input_text",
-                text: "Hello, how can I help you?",
-              },
-            },
-          },
-          include: [
-            "reasoning.encrypted_content",
-          ],
-          background: true,
-          safetyIdentifier: "<value>",
-          store: true,
-          serviceTier: "auto",
-          truncation: "auto",
-          provider: {
-            allowFallbacks: null,
-            requireParameters: true,
-            dataCollection: "deny",
-            zdr: true,
-            order: [
-              "OpenAI",
-            ],
-            only: [
-              "OpenAI",
-            ],
-            ignore: null,
-            quantizations: [
-              "fp16",
-            ],
-            sort: "price",
-            maxPrice: {
-              prompt: "1000",
-              completion: 1000,
-              image: 1000,
-              audio: "1000",
-              request: 1000,
-            },
-            experimental: {},
-          },
-          plugins: [
-            {
-              id: "file-parser",
-              maxFiles: 4870.55,
-              pdf: {
-                engine: "mistral-ocr",
-              },
-            },
-          ],
-          user: "Elmer_Yundt72",
-        });
+        mutate({});
       }}
     >
       {/* Form fields go here... */} 
@@ -366,9 +253,7 @@ export function App() {
 }
 
 function Example() {
-  const { data } = useAnalyticsGetUserActivitySuspense({
-    date: "2025-08-24",
-  });
+  const { data } = useAnalyticsGetUserActivitySuspense();
 
   // Render the UI here...
 }
@@ -396,9 +281,7 @@ export default async function Page() {
     apiKey: process.env["OPENROUTER_API_KEY"] ?? "",
   });
 
-  await prefetchAnalyticsGetUserActivity(queryClient, openRouter, {
-    date: "2025-08-24",
-  });
+  await prefetchAnalyticsGetUserActivity(openRouter);
 
   return (
     // HydrationBoundary is a Client Component, so hydration will happen there.

package/esm/funcs/embeddingsGenerate.d.ts

@@ -0,0 +1,18 @@
+import { OpenRouterCore } from "../core.js";
+import { RequestOptions } from "../lib/sdks.js";
+import { ConnectionError, InvalidRequestError, RequestAbortedError, RequestTimeoutError, UnexpectedClientError } from "../models/errors/httpclienterrors.js";
+import * as errors from "../models/errors/index.js";
+import { OpenRouterError } from "../models/errors/openroutererror.js";
+import { ResponseValidationError } from "../models/errors/responsevalidationerror.js";
+import { SDKValidationError } from "../models/errors/sdkvalidationerror.js";
+import * as operations from "../models/operations/index.js";
+import { APIPromise } from "../types/async.js";
+import { Result } from "../types/fp.js";
+/**
+ * Submit an embedding request
+ *
+ * @remarks
+ * Submits an embedding request to the embeddings router
+ */
+export declare function embeddingsGenerate(client: OpenRouterCore, request: operations.CreateEmbeddingsRequest, options?: RequestOptions): APIPromise<Result<operations.CreateEmbeddingsResponse, errors.BadRequestResponseError | errors.UnauthorizedResponseError | errors.PaymentRequiredResponseError | errors.NotFoundResponseError | errors.TooManyRequestsResponseError | errors.InternalServerResponseError | errors.BadGatewayResponseError | errors.ServiceUnavailableResponseError | errors.EdgeNetworkTimeoutResponseError | errors.ProviderOverloadedResponseError | OpenRouterError | ResponseValidationError | ConnectionError | RequestAbortedError | RequestTimeoutError | InvalidRequestError | UnexpectedClientError | SDKValidationError>>;
+//# sourceMappingURL=embeddingsGenerate.d.ts.map

package/esm/funcs/embeddingsGenerate.js

@@ -0,0 +1,97 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+import { encodeJSON } from "../lib/encodings.js";
+import * as M from "../lib/matchers.js";
+import { compactMap } from "../lib/primitives.js";
+import { safeParse } from "../lib/schemas.js";
+import { extractSecurity, resolveGlobalSecurity } from "../lib/security.js";
+import { pathToFunc } from "../lib/url.js";
+import * as errors from "../models/errors/index.js";
+import * as operations from "../models/operations/index.js";
+import { APIPromise } from "../types/async.js";
+/**
+ * Submit an embedding request
+ *
+ * @remarks
+ * Submits an embedding request to the embeddings router
+ */
+export function embeddingsGenerate(client, request, options) {
+    return new APIPromise($do(client, request, options));
+}
+async function $do(client, request, options) {
+    const parsed = safeParse(request, (value) => operations.CreateEmbeddingsRequest$outboundSchema.parse(value), "Input validation failed");
+    if (!parsed.ok) {
+        return [parsed, { status: "invalid" }];
+    }
+    const payload = parsed.value;
+    const body = encodeJSON("body", payload, { explode: true });
+    const path = pathToFunc("/embeddings")();
+    const headers = new Headers(compactMap({
+        "Content-Type": "application/json",
+        Accept: "application/json;q=1, text/event-stream;q=0",
+    }));
+    const secConfig = await extractSecurity(client._options.apiKey);
+    const securityInput = secConfig == null ? {} : { apiKey: secConfig };
+    const requestSecurity = resolveGlobalSecurity(securityInput);
+    const context = {
+        options: client._options,
+        baseURL: options?.serverURL ?? client._baseURL ?? "",
+        operationID: "createEmbeddings",
+        oAuth2Scopes: null,
+        resolvedSecurity: requestSecurity,
+        securitySource: client._options.apiKey,
+        retryConfig: options?.retries
+            || client._options.retryConfig
+            || { strategy: "none" },
+        retryCodes: options?.retryCodes || ["429", "500", "502", "503", "504"],
+    };
+    const requestRes = client._createRequest(context, {
+        security: requestSecurity,
+        method: "POST",
+        baseURL: options?.serverURL,
+        path: path,
+        headers: headers,
+        body: body,
+        userAgent: client._options.userAgent,
+        timeoutMs: options?.timeoutMs || client._options.timeoutMs || -1,
+    }, options);
+    if (!requestRes.ok) {
+        return [requestRes, { status: "invalid" }];
+    }
+    const req = requestRes.value;
+    const doResult = await client._do(req, {
+        context,
+        errorCodes: [
+            "400",
+            "401",
+            "402",
+            "404",
+            "429",
+            "4XX",
+            "500",
+            "502",
+            "503",
+            "524",
+            "529",
+            "5XX",
+        ],
+        retryConfig: context.retryConfig,
+        retryCodes: context.retryCodes,
+    });
+    if (!doResult.ok) {
+        return [doResult, { status: "request-error", request: req }];
+    }
+    const response = doResult.value;
+    const responseFields = {
+        HttpMeta: { Response: response, Request: req },
+    };
+    const [result] = await M.match(M.json(200, operations.CreateEmbeddingsResponse$inboundSchema), M.text(200, operations.CreateEmbeddingsResponse$inboundSchema, {
+        ctype: "text/event-stream",
+    }), M.jsonErr(400, errors.BadRequestResponseError$inboundSchema), M.jsonErr(401, errors.UnauthorizedResponseError$inboundSchema), M.jsonErr(402, errors.PaymentRequiredResponseError$inboundSchema), M.jsonErr(404, errors.NotFoundResponseError$inboundSchema), M.jsonErr(429, errors.TooManyRequestsResponseError$inboundSchema), M.jsonErr(500, errors.InternalServerResponseError$inboundSchema), M.jsonErr(502, errors.BadGatewayResponseError$inboundSchema), M.jsonErr(503, errors.ServiceUnavailableResponseError$inboundSchema), M.jsonErr(524, errors.EdgeNetworkTimeoutResponseError$inboundSchema), M.jsonErr(529, errors.ProviderOverloadedResponseError$inboundSchema), M.fail("4XX"), M.fail("5XX"))(response, req, { extraFields: responseFields });
+    if (!result.ok) {
+        return [result, { status: "complete", request: req, response }];
+    }
+    return [result, { status: "complete", request: req, response }];
+}
+//# sourceMappingURL=embeddingsGenerate.js.map

package/esm/lib/config.d.ts

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

package/esm/lib/config.js

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

package/esm/models/chaterror.d.ts

@@ -5,8 +5,8 @@ export type Code = string | number;
 export type ChatErrorError = {
     code: string | number | null;
     message: string;
-    param: string | null;
-    type: string;
+    param?: string | null | undefined;
+    type?: string | null | undefined;
 };
 /** @internal */
 export declare const Code$inboundSchema: z.ZodType<Code, unknown>;
@@ -34,8 +34,8 @@ export declare const ChatErrorError$inboundSchema: z.ZodType<ChatErrorError, unk
 export type ChatErrorError$Outbound = {
     code: string | number | null;
     message: string;
-    param: string | null;
-    type: string;
+    param?: string | null | undefined;
+    type?: string | null | undefined;
 };
 /** @internal */
 export declare const ChatErrorError$outboundSchema: z.ZodType<ChatErrorError$Outbound, ChatErrorError>;

package/esm/models/chaterror.js

@@ -34,15 +34,15 @@ export function codeFromJSON(jsonString) {
 export const ChatErrorError$inboundSchema = z.object({
     code: z.nullable(z.union([z.string(), z.number()])),
     message: z.string(),
-    param: z.nullable(z.string()),
-    type: z.string(),
+    param: z.nullable(z.string()).optional(),
+    type: z.nullable(z.string()).optional(),
 });
 /** @internal */
 export const ChatErrorError$outboundSchema = z.object({
     code: z.nullable(z.union([z.string(), z.number()])),
     message: z.string(),
-    param: z.nullable(z.string()),
-    type: z.string(),
+    param: z.nullable(z.string()).optional(),
+    type: z.nullable(z.string()).optional(),
 });
 /**
  * @internal

package/esm/models/chatgenerationparams.d.ts

@@ -32,7 +32,8 @@ export type ChatGenerationParamsResponseFormatUnion = ResponseFormatJSONSchema |
 export type ChatGenerationParamsStop = string | Array<string>;
 export type ChatGenerationParams = {
     messages: Array<Message>;
-    model: string;
+    model?: string | undefined;
+    models?: Array<string> | undefined;
     frequencyPenalty?: number | null | undefined;
     logitBias?: {
         [k: string]: number;
@@ -205,7 +206,8 @@ export declare const ChatGenerationParams$inboundSchema: z.ZodType<ChatGeneratio
 /** @internal */
 export type ChatGenerationParams$Outbound = {
     messages: Array<Message$Outbound>;
-    model: string;
+    model?: string | undefined;
+    models?: Array<string> | undefined;
     frequency_penalty?: number | null | undefined;
     logit_bias?: {
         [k: string]: number;

package/esm/models/chatgenerationparams.js

@@ -198,7 +198,8 @@ export function chatGenerationParamsStopFromJSON(jsonString) {
 /** @internal */
 export const ChatGenerationParams$inboundSchema = z.object({
     messages: z.array(Message$inboundSchema),
-    model: z.string(),
+    model: z.string().optional(),
+    models: z.array(z.string()).optional(),
     frequency_penalty: z.nullable(z.number()).optional(),
     logit_bias: z.nullable(z.record(z.string(), z.number())).optional(),
     logprobs: z.nullable(z.boolean()).optional(),
@@ -241,7 +242,8 @@ export const ChatGenerationParams$inboundSchema = z.object({
 /** @internal */
 export const ChatGenerationParams$outboundSchema = z.object({
     messages: z.array(Message$outboundSchema),
-    model: z.string(),
+    model: z.string().optional(),
+    models: z.array(z.string()).optional(),
     frequencyPenalty: z.nullable(z.number()).optional(),
     logitBias: z.nullable(z.record(z.string(), z.number())).optional(),
     logprobs: z.nullable(z.boolean()).optional(),

package/esm/models/chatmessagecontentitemaudio.d.ts

@@ -12,13 +12,13 @@ export declare const ChatMessageContentItemAudioFormat: {
     readonly Pcm24: "pcm24";
 };
 export type ChatMessageContentItemAudioFormat = OpenEnum<typeof ChatMessageContentItemAudioFormat>;
-export type InputAudio = {
+export type ChatMessageContentItemAudioInputAudio = {
     data: string;
     format: ChatMessageContentItemAudioFormat;
 };
 export type ChatMessageContentItemAudio = {
     type: "input_audio";
-    inputAudio: InputAudio;
+    inputAudio: ChatMessageContentItemAudioInputAudio;
 };
 /** @internal */
 export declare const ChatMessageContentItemAudioFormat$inboundSchema: z.ZodType<ChatMessageContentItemAudioFormat, unknown>;
@@ -35,34 +35,34 @@ export declare namespace ChatMessageContentItemAudioFormat$ {
     const outboundSchema: z.ZodType<ChatMessageContentItemAudioFormat, ChatMessageContentItemAudioFormat, z.core.$ZodTypeInternals<ChatMessageContentItemAudioFormat, ChatMessageContentItemAudioFormat>>;
 }
 /** @internal */
-export declare const InputAudio$inboundSchema: z.ZodType<InputAudio, unknown>;
+export declare const ChatMessageContentItemAudioInputAudio$inboundSchema: z.ZodType<ChatMessageContentItemAudioInputAudio, unknown>;
 /** @internal */
-export type InputAudio$Outbound = {
+export type ChatMessageContentItemAudioInputAudio$Outbound = {
     data: string;
     format: string;
 };
 /** @internal */
-export declare const InputAudio$outboundSchema: z.ZodType<InputAudio$Outbound, InputAudio>;
+export declare const ChatMessageContentItemAudioInputAudio$outboundSchema: z.ZodType<ChatMessageContentItemAudioInputAudio$Outbound, ChatMessageContentItemAudioInputAudio>;
 /**
  * @internal
  * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
  */
-export declare namespace InputAudio$ {
-    /** @deprecated use `InputAudio$inboundSchema` instead. */
-    const inboundSchema: z.ZodType<InputAudio, unknown, z.core.$ZodTypeInternals<InputAudio, unknown>>;
-    /** @deprecated use `InputAudio$outboundSchema` instead. */
-    const outboundSchema: z.ZodType<InputAudio$Outbound, InputAudio, z.core.$ZodTypeInternals<InputAudio$Outbound, InputAudio>>;
-    /** @deprecated use `InputAudio$Outbound` instead. */
-    type Outbound = InputAudio$Outbound;
+export declare namespace ChatMessageContentItemAudioInputAudio$ {
+    /** @deprecated use `ChatMessageContentItemAudioInputAudio$inboundSchema` instead. */
+    const inboundSchema: z.ZodType<ChatMessageContentItemAudioInputAudio, unknown, z.core.$ZodTypeInternals<ChatMessageContentItemAudioInputAudio, unknown>>;
+    /** @deprecated use `ChatMessageContentItemAudioInputAudio$outboundSchema` instead. */
+    const outboundSchema: z.ZodType<ChatMessageContentItemAudioInputAudio$Outbound, ChatMessageContentItemAudioInputAudio, z.core.$ZodTypeInternals<ChatMessageContentItemAudioInputAudio$Outbound, ChatMessageContentItemAudioInputAudio>>;
+    /** @deprecated use `ChatMessageContentItemAudioInputAudio$Outbound` instead. */
+    type Outbound = ChatMessageContentItemAudioInputAudio$Outbound;
 }
-export declare function inputAudioToJSON(inputAudio: InputAudio): string;
-export declare function inputAudioFromJSON(jsonString: string): SafeParseResult<InputAudio, SDKValidationError>;
+export declare function chatMessageContentItemAudioInputAudioToJSON(chatMessageContentItemAudioInputAudio: ChatMessageContentItemAudioInputAudio): string;
+export declare function chatMessageContentItemAudioInputAudioFromJSON(jsonString: string): SafeParseResult<ChatMessageContentItemAudioInputAudio, SDKValidationError>;
 /** @internal */
 export declare const ChatMessageContentItemAudio$inboundSchema: z.ZodType<ChatMessageContentItemAudio, unknown>;
 /** @internal */
 export type ChatMessageContentItemAudio$Outbound = {
     type: "input_audio";
-    input_audio: InputAudio$Outbound;
+    input_audio: ChatMessageContentItemAudioInputAudio$Outbound;
 };
 /** @internal */
 export declare const ChatMessageContentItemAudio$outboundSchema: z.ZodType<ChatMessageContentItemAudio$Outbound, ChatMessageContentItemAudio>;

package/esm/models/chatmessagecontentitemaudio.js

@@ -37,13 +37,12 @@ export var ChatMessageContentItemAudioFormat$;
     ChatMessageContentItemAudioFormat$.outboundSchema = ChatMessageContentItemAudioFormat$outboundSchema;
 })(ChatMessageContentItemAudioFormat$ || (ChatMessageContentItemAudioFormat$ = {}));
 /** @internal */
-export const InputAudio$inboundSchema = z
-    .object({
+export const ChatMessageContentItemAudioInputAudio$inboundSchema = z.object({
     data: z.string(),
     format: ChatMessageContentItemAudioFormat$inboundSchema,
 });
 /** @internal */
-export const InputAudio$outboundSchema = z.object({
+export const ChatMessageContentItemAudioInputAudio$outboundSchema = z.object({
     data: z.string(),
     format: ChatMessageContentItemAudioFormat$outboundSchema,
 });
@@ -51,23 +50,23 @@ export const InputAudio$outboundSchema = z.object({
  * @internal
  * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
  */
-export var InputAudio$;
-(function (InputAudio$) {
-    /** @deprecated use `InputAudio$inboundSchema` instead. */
-    InputAudio$.inboundSchema = InputAudio$inboundSchema;
-    /** @deprecated use `InputAudio$outboundSchema` instead. */
-    InputAudio$.outboundSchema = InputAudio$outboundSchema;
-})(InputAudio$ || (InputAudio$ = {}));
-export function inputAudioToJSON(inputAudio) {
-    return JSON.stringify(InputAudio$outboundSchema.parse(inputAudio));
+export var ChatMessageContentItemAudioInputAudio$;
+(function (ChatMessageContentItemAudioInputAudio$) {
+    /** @deprecated use `ChatMessageContentItemAudioInputAudio$inboundSchema` instead. */
+    ChatMessageContentItemAudioInputAudio$.inboundSchema = ChatMessageContentItemAudioInputAudio$inboundSchema;
+    /** @deprecated use `ChatMessageContentItemAudioInputAudio$outboundSchema` instead. */
+    ChatMessageContentItemAudioInputAudio$.outboundSchema = ChatMessageContentItemAudioInputAudio$outboundSchema;
+})(ChatMessageContentItemAudioInputAudio$ || (ChatMessageContentItemAudioInputAudio$ = {}));
+export function chatMessageContentItemAudioInputAudioToJSON(chatMessageContentItemAudioInputAudio) {
+    return JSON.stringify(ChatMessageContentItemAudioInputAudio$outboundSchema.parse(chatMessageContentItemAudioInputAudio));
 }
-export function inputAudioFromJSON(jsonString) {
-    return safeParse(jsonString, (x) => InputAudio$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'InputAudio' from JSON`);
+export function chatMessageContentItemAudioInputAudioFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => ChatMessageContentItemAudioInputAudio$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'ChatMessageContentItemAudioInputAudio' from JSON`);
 }
 /** @internal */
 export const ChatMessageContentItemAudio$inboundSchema = z.object({
     type: z.literal("input_audio"),
-    input_audio: z.lazy(() => InputAudio$inboundSchema),
+    input_audio: z.lazy(() => ChatMessageContentItemAudioInputAudio$inboundSchema),
 }).transform((v) => {
     return remap$(v, {
         "input_audio": "inputAudio",
@@ -76,7 +75,7 @@ export const ChatMessageContentItemAudio$inboundSchema = z.object({
 /** @internal */
 export const ChatMessageContentItemAudio$outboundSchema = z.object({
     type: z.literal("input_audio"),
-    inputAudio: z.lazy(() => InputAudio$outboundSchema),
+    inputAudio: z.lazy(() => ChatMessageContentItemAudioInputAudio$outboundSchema),
 }).transform((v) => {
     return remap$(v, {
         inputAudio: "input_audio",

package/esm/models/completioncreateparams.d.ts

@@ -19,7 +19,8 @@ export type CompletionCreateParamsResponseFormatText = {
 };
 export type CompletionCreateParamsResponseFormatUnion = ResponseFormatJSONSchema | ResponseFormatTextGrammar | CompletionCreateParamsResponseFormatText | CompletionCreateParamsResponseFormatJSONObject | CompletionCreateParamsResponseFormatPython;
 export type CompletionCreateParams = {
-    model: string;
+    model?: string | undefined;
+    models?: Array<string> | undefined;
     prompt: string | Array<string> | Array<number> | Array<Array<number>>;
     bestOf?: number | null | undefined;
     echo?: boolean | null | undefined;
@@ -196,7 +197,8 @@ export declare function completionCreateParamsResponseFormatUnionFromJSON(jsonSt
 export declare const CompletionCreateParams$inboundSchema: z.ZodType<CompletionCreateParams, unknown>;
 /** @internal */
 export type CompletionCreateParams$Outbound = {
-    model: string;
+    model?: string | undefined;
+    models?: Array<string> | undefined;
     prompt: string | Array<string> | Array<number> | Array<Array<number>>;
     best_of?: number | null | undefined;
     echo?: boolean | null | undefined;

package/esm/models/completioncreateparams.js

@@ -203,7 +203,8 @@ export function completionCreateParamsResponseFormatUnionFromJSON(jsonString) {
 }
 /** @internal */
 export const CompletionCreateParams$inboundSchema = z.object({
-    model: z.string(),
+    model: z.string().optional(),
+    models: z.array(z.string()).optional(),
     prompt: z.union([
         z.string(),
         z.array(z.string()),
@@ -249,7 +250,8 @@ export const CompletionCreateParams$inboundSchema = z.object({
 });
 /** @internal */
 export const CompletionCreateParams$outboundSchema = z.object({
-    model: z.string(),
+    model: z.string().optional(),
+    models: z.array(z.string()).optional(),
     prompt: z.union([
         z.string(),
         z.array(z.string()),