@openrouter/sdk 0.0.0-beta.4 → 0.0.0-beta.7

package/src/models/{chatstreamingmessagechunk.ts → chatcompletionchunkchoicedelta.ts}

@@ -8,11 +8,11 @@ import { safeParse } from "../lib/schemas.js";
 import { ClosedEnum } from "../types/enums.js";
 import { Result as SafeParseResult } from "../types/fp.js";
 import {
-  ChatStreamingMessageToolCall,
-  ChatStreamingMessageToolCall$inboundSchema,
-  ChatStreamingMessageToolCall$Outbound,
-  ChatStreamingMessageToolCall$outboundSchema,
-} from "./chatstreamingmessagetoolcall.js";
+  ChatCompletionChunkChoiceDeltaToolCall,
+  ChatCompletionChunkChoiceDeltaToolCall$inboundSchema,
+  ChatCompletionChunkChoiceDeltaToolCall$Outbound,
+  ChatCompletionChunkChoiceDeltaToolCall$outboundSchema,
+} from "./chatcompletionchunkchoicedeltatoolcall.js";
 import { SDKValidationError } from "./errors/sdkvalidationerror.js";
 
 export const Role = {
@@ -20,12 +20,12 @@ export const Role = {
 } as const;
 export type Role = ClosedEnum<typeof Role>;
 
-export type ChatStreamingMessageChunk = {
+export type ChatCompletionChunkChoiceDelta = {
   role?: Role | undefined;
   content?: string | null | undefined;
   reasoning?: string | null | undefined;
   refusal?: string | null | undefined;
-  toolCalls?: Array<ChatStreamingMessageToolCall> | undefined;
+  toolCalls?: Array<ChatCompletionChunkChoiceDeltaToolCall> | undefined;
 };
 
 /** @internal */
@@ -49,8 +49,8 @@ export namespace Role$ {
 }
 
 /** @internal */
-export const ChatStreamingMessageChunk$inboundSchema: z.ZodType<
-  ChatStreamingMessageChunk,
+export const ChatCompletionChunkChoiceDelta$inboundSchema: z.ZodType<
+  ChatCompletionChunkChoiceDelta,
   z.ZodTypeDef,
   unknown
 > = z.object({
@@ -58,7 +58,8 @@ export const ChatStreamingMessageChunk$inboundSchema: z.ZodType<
   content: z.nullable(z.string()).optional(),
   reasoning: z.nullable(z.string()).optional(),
   refusal: z.nullable(z.string()).optional(),
-  tool_calls: z.array(ChatStreamingMessageToolCall$inboundSchema).optional(),
+  tool_calls: z.array(ChatCompletionChunkChoiceDeltaToolCall$inboundSchema)
+    .optional(),
 }).transform((v) => {
   return remap$(v, {
     "tool_calls": "toolCalls",
@@ -66,25 +67,28 @@ export const ChatStreamingMessageChunk$inboundSchema: z.ZodType<
 });
 
 /** @internal */
-export type ChatStreamingMessageChunk$Outbound = {
+export type ChatCompletionChunkChoiceDelta$Outbound = {
   role?: string | undefined;
   content?: string | null | undefined;
   reasoning?: string | null | undefined;
   refusal?: string | null | undefined;
-  tool_calls?: Array<ChatStreamingMessageToolCall$Outbound> | undefined;
+  tool_calls?:
+    | Array<ChatCompletionChunkChoiceDeltaToolCall$Outbound>
+    | undefined;
 };
 
 /** @internal */
-export const ChatStreamingMessageChunk$outboundSchema: z.ZodType<
-  ChatStreamingMessageChunk$Outbound,
+export const ChatCompletionChunkChoiceDelta$outboundSchema: z.ZodType<
+  ChatCompletionChunkChoiceDelta$Outbound,
   z.ZodTypeDef,
-  ChatStreamingMessageChunk
+  ChatCompletionChunkChoiceDelta
 > = z.object({
   role: Role$outboundSchema.optional(),
   content: z.nullable(z.string()).optional(),
   reasoning: z.nullable(z.string()).optional(),
   refusal: z.nullable(z.string()).optional(),
-  toolCalls: z.array(ChatStreamingMessageToolCall$outboundSchema).optional(),
+  toolCalls: z.array(ChatCompletionChunkChoiceDeltaToolCall$outboundSchema)
+    .optional(),
 }).transform((v) => {
   return remap$(v, {
     toolCalls: "tool_calls",
@@ -95,29 +99,31 @@ export const ChatStreamingMessageChunk$outboundSchema: z.ZodType<
  * @internal
  * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
  */
-export namespace ChatStreamingMessageChunk$ {
-  /** @deprecated use `ChatStreamingMessageChunk$inboundSchema` instead. */
-  export const inboundSchema = ChatStreamingMessageChunk$inboundSchema;
-  /** @deprecated use `ChatStreamingMessageChunk$outboundSchema` instead. */
-  export const outboundSchema = ChatStreamingMessageChunk$outboundSchema;
-  /** @deprecated use `ChatStreamingMessageChunk$Outbound` instead. */
-  export type Outbound = ChatStreamingMessageChunk$Outbound;
+export namespace ChatCompletionChunkChoiceDelta$ {
+  /** @deprecated use `ChatCompletionChunkChoiceDelta$inboundSchema` instead. */
+  export const inboundSchema = ChatCompletionChunkChoiceDelta$inboundSchema;
+  /** @deprecated use `ChatCompletionChunkChoiceDelta$outboundSchema` instead. */
+  export const outboundSchema = ChatCompletionChunkChoiceDelta$outboundSchema;
+  /** @deprecated use `ChatCompletionChunkChoiceDelta$Outbound` instead. */
+  export type Outbound = ChatCompletionChunkChoiceDelta$Outbound;
 }
 
-export function chatStreamingMessageChunkToJSON(
-  chatStreamingMessageChunk: ChatStreamingMessageChunk,
+export function chatCompletionChunkChoiceDeltaToJSON(
+  chatCompletionChunkChoiceDelta: ChatCompletionChunkChoiceDelta,
 ): string {
   return JSON.stringify(
-    ChatStreamingMessageChunk$outboundSchema.parse(chatStreamingMessageChunk),
+    ChatCompletionChunkChoiceDelta$outboundSchema.parse(
+      chatCompletionChunkChoiceDelta,
+    ),
   );
 }
 
-export function chatStreamingMessageChunkFromJSON(
+export function chatCompletionChunkChoiceDeltaFromJSON(
   jsonString: string,
-): SafeParseResult<ChatStreamingMessageChunk, SDKValidationError> {
+): SafeParseResult<ChatCompletionChunkChoiceDelta, SDKValidationError> {
   return safeParse(
     jsonString,
-    (x) => ChatStreamingMessageChunk$inboundSchema.parse(JSON.parse(x)),
-    `Failed to parse 'ChatStreamingMessageChunk' from JSON`,
+    (x) => ChatCompletionChunkChoiceDelta$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'ChatCompletionChunkChoiceDelta' from JSON`,
   );
 }

package/src/models/chatcompletionchunkchoicedeltatoolcall.ts

@@ -0,0 +1,166 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod";
+import { safeParse } from "../lib/schemas.js";
+import { Result as SafeParseResult } from "../types/fp.js";
+import { SDKValidationError } from "./errors/sdkvalidationerror.js";
+
+export type ChatCompletionChunkChoiceDeltaToolCallFunction = {
+  name?: string | undefined;
+  arguments?: string | undefined;
+};
+
+export type ChatCompletionChunkChoiceDeltaToolCall = {
+  index: number;
+  id?: string | undefined;
+  type?: "function" | undefined;
+  function?: ChatCompletionChunkChoiceDeltaToolCallFunction | undefined;
+};
+
+/** @internal */
+export const ChatCompletionChunkChoiceDeltaToolCallFunction$inboundSchema:
+  z.ZodType<
+    ChatCompletionChunkChoiceDeltaToolCallFunction,
+    z.ZodTypeDef,
+    unknown
+  > = z.object({
+    name: z.string().optional(),
+    arguments: z.string().optional(),
+  });
+
+/** @internal */
+export type ChatCompletionChunkChoiceDeltaToolCallFunction$Outbound = {
+  name?: string | undefined;
+  arguments?: string | undefined;
+};
+
+/** @internal */
+export const ChatCompletionChunkChoiceDeltaToolCallFunction$outboundSchema:
+  z.ZodType<
+    ChatCompletionChunkChoiceDeltaToolCallFunction$Outbound,
+    z.ZodTypeDef,
+    ChatCompletionChunkChoiceDeltaToolCallFunction
+  > = z.object({
+    name: z.string().optional(),
+    arguments: z.string().optional(),
+  });
+
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export namespace ChatCompletionChunkChoiceDeltaToolCallFunction$ {
+  /** @deprecated use `ChatCompletionChunkChoiceDeltaToolCallFunction$inboundSchema` instead. */
+  export const inboundSchema =
+    ChatCompletionChunkChoiceDeltaToolCallFunction$inboundSchema;
+  /** @deprecated use `ChatCompletionChunkChoiceDeltaToolCallFunction$outboundSchema` instead. */
+  export const outboundSchema =
+    ChatCompletionChunkChoiceDeltaToolCallFunction$outboundSchema;
+  /** @deprecated use `ChatCompletionChunkChoiceDeltaToolCallFunction$Outbound` instead. */
+  export type Outbound =
+    ChatCompletionChunkChoiceDeltaToolCallFunction$Outbound;
+}
+
+export function chatCompletionChunkChoiceDeltaToolCallFunctionToJSON(
+  chatCompletionChunkChoiceDeltaToolCallFunction:
+    ChatCompletionChunkChoiceDeltaToolCallFunction,
+): string {
+  return JSON.stringify(
+    ChatCompletionChunkChoiceDeltaToolCallFunction$outboundSchema.parse(
+      chatCompletionChunkChoiceDeltaToolCallFunction,
+    ),
+  );
+}
+
+export function chatCompletionChunkChoiceDeltaToolCallFunctionFromJSON(
+  jsonString: string,
+): SafeParseResult<
+  ChatCompletionChunkChoiceDeltaToolCallFunction,
+  SDKValidationError
+> {
+  return safeParse(
+    jsonString,
+    (x) =>
+      ChatCompletionChunkChoiceDeltaToolCallFunction$inboundSchema.parse(
+        JSON.parse(x),
+      ),
+    `Failed to parse 'ChatCompletionChunkChoiceDeltaToolCallFunction' from JSON`,
+  );
+}
+
+/** @internal */
+export const ChatCompletionChunkChoiceDeltaToolCall$inboundSchema: z.ZodType<
+  ChatCompletionChunkChoiceDeltaToolCall,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  index: z.number(),
+  id: z.string().optional(),
+  type: z.literal("function").optional(),
+  function: z.lazy(() =>
+    ChatCompletionChunkChoiceDeltaToolCallFunction$inboundSchema
+  ).optional(),
+});
+
+/** @internal */
+export type ChatCompletionChunkChoiceDeltaToolCall$Outbound = {
+  index: number;
+  id?: string | undefined;
+  type?: "function" | undefined;
+  function?:
+    | ChatCompletionChunkChoiceDeltaToolCallFunction$Outbound
+    | undefined;
+};
+
+/** @internal */
+export const ChatCompletionChunkChoiceDeltaToolCall$outboundSchema: z.ZodType<
+  ChatCompletionChunkChoiceDeltaToolCall$Outbound,
+  z.ZodTypeDef,
+  ChatCompletionChunkChoiceDeltaToolCall
+> = z.object({
+  index: z.number(),
+  id: z.string().optional(),
+  type: z.literal("function").optional(),
+  function: z.lazy(() =>
+    ChatCompletionChunkChoiceDeltaToolCallFunction$outboundSchema
+  ).optional(),
+});
+
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export namespace ChatCompletionChunkChoiceDeltaToolCall$ {
+  /** @deprecated use `ChatCompletionChunkChoiceDeltaToolCall$inboundSchema` instead. */
+  export const inboundSchema =
+    ChatCompletionChunkChoiceDeltaToolCall$inboundSchema;
+  /** @deprecated use `ChatCompletionChunkChoiceDeltaToolCall$outboundSchema` instead. */
+  export const outboundSchema =
+    ChatCompletionChunkChoiceDeltaToolCall$outboundSchema;
+  /** @deprecated use `ChatCompletionChunkChoiceDeltaToolCall$Outbound` instead. */
+  export type Outbound = ChatCompletionChunkChoiceDeltaToolCall$Outbound;
+}
+
+export function chatCompletionChunkChoiceDeltaToolCallToJSON(
+  chatCompletionChunkChoiceDeltaToolCall:
+    ChatCompletionChunkChoiceDeltaToolCall,
+): string {
+  return JSON.stringify(
+    ChatCompletionChunkChoiceDeltaToolCall$outboundSchema.parse(
+      chatCompletionChunkChoiceDeltaToolCall,
+    ),
+  );
+}
+
+export function chatCompletionChunkChoiceDeltaToolCallFromJSON(
+  jsonString: string,
+): SafeParseResult<ChatCompletionChunkChoiceDeltaToolCall, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) =>
+      ChatCompletionChunkChoiceDeltaToolCall$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'ChatCompletionChunkChoiceDeltaToolCall' from JSON`,
+  );
+}

package/src/models/chatcompletionerror.ts

@@ -0,0 +1,78 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod";
+import { safeParse } from "../lib/schemas.js";
+import { Result as SafeParseResult } from "../types/fp.js";
+import { SDKValidationError } from "./errors/sdkvalidationerror.js";
+
+export type ChatCompletionErrorError = {
+  code: string | null;
+  message: string;
+  param: string | null;
+  type: string;
+};
+
+/** @internal */
+export const ChatCompletionErrorError$inboundSchema: z.ZodType<
+  ChatCompletionErrorError,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  code: z.nullable(z.string()),
+  message: z.string(),
+  param: z.nullable(z.string()),
+  type: z.string(),
+});
+
+/** @internal */
+export type ChatCompletionErrorError$Outbound = {
+  code: string | null;
+  message: string;
+  param: string | null;
+  type: string;
+};
+
+/** @internal */
+export const ChatCompletionErrorError$outboundSchema: z.ZodType<
+  ChatCompletionErrorError$Outbound,
+  z.ZodTypeDef,
+  ChatCompletionErrorError
+> = z.object({
+  code: z.nullable(z.string()),
+  message: z.string(),
+  param: z.nullable(z.string()),
+  type: z.string(),
+});
+
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export namespace ChatCompletionErrorError$ {
+  /** @deprecated use `ChatCompletionErrorError$inboundSchema` instead. */
+  export const inboundSchema = ChatCompletionErrorError$inboundSchema;
+  /** @deprecated use `ChatCompletionErrorError$outboundSchema` instead. */
+  export const outboundSchema = ChatCompletionErrorError$outboundSchema;
+  /** @deprecated use `ChatCompletionErrorError$Outbound` instead. */
+  export type Outbound = ChatCompletionErrorError$Outbound;
+}
+
+export function chatCompletionErrorErrorToJSON(
+  chatCompletionErrorError: ChatCompletionErrorError,
+): string {
+  return JSON.stringify(
+    ChatCompletionErrorError$outboundSchema.parse(chatCompletionErrorError),
+  );
+}
+
+export function chatCompletionErrorErrorFromJSON(
+  jsonString: string,
+): SafeParseResult<ChatCompletionErrorError, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => ChatCompletionErrorError$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'ChatCompletionErrorError' from JSON`,
+  );
+}

package/src/models/chatcompletionmessage.ts

@@ -0,0 +1,167 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod";
+import { remap as remap$ } from "../lib/primitives.js";
+import { safeParse } from "../lib/schemas.js";
+import { Result as SafeParseResult } from "../types/fp.js";
+import {
+  ChatMessageContentItem,
+  ChatMessageContentItem$inboundSchema,
+  ChatMessageContentItem$Outbound,
+  ChatMessageContentItem$outboundSchema,
+} from "./chatmessagecontentitem.js";
+import {
+  ChatMessageToolCall,
+  ChatMessageToolCall$inboundSchema,
+  ChatMessageToolCall$Outbound,
+  ChatMessageToolCall$outboundSchema,
+} from "./chatmessagetoolcall.js";
+import { SDKValidationError } from "./errors/sdkvalidationerror.js";
+
+export type ChatCompletionMessageContent =
+  | string
+  | Array<ChatMessageContentItem>;
+
+export type ChatCompletionMessage = {
+  role: "assistant";
+  content?: string | Array<ChatMessageContentItem> | null | undefined;
+  name?: string | undefined;
+  toolCalls?: Array<ChatMessageToolCall> | undefined;
+  refusal?: string | null | undefined;
+  reasoning?: string | null | undefined;
+};
+
+/** @internal */
+export const ChatCompletionMessageContent$inboundSchema: z.ZodType<
+  ChatCompletionMessageContent,
+  z.ZodTypeDef,
+  unknown
+> = z.union([z.string(), z.array(ChatMessageContentItem$inboundSchema)]);
+
+/** @internal */
+export type ChatCompletionMessageContent$Outbound =
+  | string
+  | Array<ChatMessageContentItem$Outbound>;
+
+/** @internal */
+export const ChatCompletionMessageContent$outboundSchema: z.ZodType<
+  ChatCompletionMessageContent$Outbound,
+  z.ZodTypeDef,
+  ChatCompletionMessageContent
+> = z.union([z.string(), z.array(ChatMessageContentItem$outboundSchema)]);
+
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export namespace ChatCompletionMessageContent$ {
+  /** @deprecated use `ChatCompletionMessageContent$inboundSchema` instead. */
+  export const inboundSchema = ChatCompletionMessageContent$inboundSchema;
+  /** @deprecated use `ChatCompletionMessageContent$outboundSchema` instead. */
+  export const outboundSchema = ChatCompletionMessageContent$outboundSchema;
+  /** @deprecated use `ChatCompletionMessageContent$Outbound` instead. */
+  export type Outbound = ChatCompletionMessageContent$Outbound;
+}
+
+export function chatCompletionMessageContentToJSON(
+  chatCompletionMessageContent: ChatCompletionMessageContent,
+): string {
+  return JSON.stringify(
+    ChatCompletionMessageContent$outboundSchema.parse(
+      chatCompletionMessageContent,
+    ),
+  );
+}
+
+export function chatCompletionMessageContentFromJSON(
+  jsonString: string,
+): SafeParseResult<ChatCompletionMessageContent, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => ChatCompletionMessageContent$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'ChatCompletionMessageContent' from JSON`,
+  );
+}
+
+/** @internal */
+export const ChatCompletionMessage$inboundSchema: z.ZodType<
+  ChatCompletionMessage,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  role: z.literal("assistant"),
+  content: z.nullable(
+    z.union([z.string(), z.array(ChatMessageContentItem$inboundSchema)]),
+  ).optional(),
+  name: z.string().optional(),
+  tool_calls: z.array(ChatMessageToolCall$inboundSchema).optional(),
+  refusal: z.nullable(z.string()).optional(),
+  reasoning: z.nullable(z.string()).optional(),
+}).transform((v) => {
+  return remap$(v, {
+    "tool_calls": "toolCalls",
+  });
+});
+
+/** @internal */
+export type ChatCompletionMessage$Outbound = {
+  role: "assistant";
+  content?: string | Array<ChatMessageContentItem$Outbound> | null | undefined;
+  name?: string | undefined;
+  tool_calls?: Array<ChatMessageToolCall$Outbound> | undefined;
+  refusal?: string | null | undefined;
+  reasoning?: string | null | undefined;
+};
+
+/** @internal */
+export const ChatCompletionMessage$outboundSchema: z.ZodType<
+  ChatCompletionMessage$Outbound,
+  z.ZodTypeDef,
+  ChatCompletionMessage
+> = z.object({
+  role: z.literal("assistant"),
+  content: z.nullable(
+    z.union([z.string(), z.array(ChatMessageContentItem$outboundSchema)]),
+  ).optional(),
+  name: z.string().optional(),
+  toolCalls: z.array(ChatMessageToolCall$outboundSchema).optional(),
+  refusal: z.nullable(z.string()).optional(),
+  reasoning: z.nullable(z.string()).optional(),
+}).transform((v) => {
+  return remap$(v, {
+    toolCalls: "tool_calls",
+  });
+});
+
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export namespace ChatCompletionMessage$ {
+  /** @deprecated use `ChatCompletionMessage$inboundSchema` instead. */
+  export const inboundSchema = ChatCompletionMessage$inboundSchema;
+  /** @deprecated use `ChatCompletionMessage$outboundSchema` instead. */
+  export const outboundSchema = ChatCompletionMessage$outboundSchema;
+  /** @deprecated use `ChatCompletionMessage$Outbound` instead. */
+  export type Outbound = ChatCompletionMessage$Outbound;
+}
+
+export function chatCompletionMessageToJSON(
+  chatCompletionMessage: ChatCompletionMessage,
+): string {
+  return JSON.stringify(
+    ChatCompletionMessage$outboundSchema.parse(chatCompletionMessage),
+  );
+}
+
+export function chatCompletionMessageFromJSON(
+  jsonString: string,
+): SafeParseResult<ChatCompletionMessage, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => ChatCompletionMessage$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'ChatCompletionMessage' from JSON`,
+  );
+}

package/src/models/errorresponse.ts

@@ -9,7 +9,7 @@ import { ClosedEnum } from "../types/enums.js";
 import { Result as SafeParseResult } from "../types/fp.js";
 import { SDKValidationError } from "./errors/sdkvalidationerror.js";
 
-export const CodeEnum = {
+export const Code = {
   OneHundred: 100,
   OneHundredAndOne: 101,
   OneHundredAndTwo: 102,
@@ -81,10 +81,10 @@ export const CodeEnum = {
   FiveHundredAndTwentyNine: 529,
   FiveHundredAndThirty: 530,
 } as const;
-export type CodeEnum = ClosedEnum<typeof CodeEnum>;
+export type Code = ClosedEnum<typeof Code>;
 
 export type ErrorResponseError = {
-  code: CodeEnum;
+  code: Code;
   message: string;
   metadata?: { [k: string]: any | null } | null | undefined;
 };
@@ -98,22 +98,23 @@ export type ErrorResponse = {
 };
 
 /** @internal */
-export const CodeEnum$inboundSchema: z.ZodNativeEnum<typeof CodeEnum> = z
-  .nativeEnum(CodeEnum);
+export const Code$inboundSchema: z.ZodNativeEnum<typeof Code> = z.nativeEnum(
+  Code,
+);
 
 /** @internal */
-export const CodeEnum$outboundSchema: z.ZodNativeEnum<typeof CodeEnum> =
-  CodeEnum$inboundSchema;
+export const Code$outboundSchema: z.ZodNativeEnum<typeof Code> =
+  Code$inboundSchema;
 
 /**
  * @internal
  * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
  */
-export namespace CodeEnum$ {
-  /** @deprecated use `CodeEnum$inboundSchema` instead. */
-  export const inboundSchema = CodeEnum$inboundSchema;
-  /** @deprecated use `CodeEnum$outboundSchema` instead. */
-  export const outboundSchema = CodeEnum$outboundSchema;
+export namespace Code$ {
+  /** @deprecated use `Code$inboundSchema` instead. */
+  export const inboundSchema = Code$inboundSchema;
+  /** @deprecated use `Code$outboundSchema` instead. */
+  export const outboundSchema = Code$outboundSchema;
 }
 
 /** @internal */
@@ -122,7 +123,7 @@ export const ErrorResponseError$inboundSchema: z.ZodType<
   z.ZodTypeDef,
   unknown
 > = z.object({
-  code: CodeEnum$inboundSchema,
+  code: Code$inboundSchema,
   message: z.string(),
   metadata: z.nullable(z.record(z.nullable(z.any()))).optional(),
 });
@@ -140,7 +141,7 @@ export const ErrorResponseError$outboundSchema: z.ZodType<
   z.ZodTypeDef,
   ErrorResponseError
 > = z.object({
-  code: CodeEnum$outboundSchema,
+  code: Code$outboundSchema,
   message: z.string(),
   metadata: z.nullable(z.record(z.nullable(z.any()))).optional(),
 });

package/src/models/errors/chatcompletionerror.ts

@@ -0,0 +1,79 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod";
+import * as models from "../index.js";
+import { OpenRouterError } from "./openroutererror.js";
+
+export type ChatCompletionErrorData = {
+  error: models.ChatCompletionErrorError;
+};
+
+export class ChatCompletionError extends OpenRouterError {
+  error: models.ChatCompletionErrorError;
+
+  /** The original data that was passed to this error instance. */
+  data$: ChatCompletionErrorData;
+
+  constructor(
+    err: ChatCompletionErrorData,
+    httpMeta: { response: Response; request: Request; body: string },
+  ) {
+    const message = err.error?.message
+      || `API error occurred: ${JSON.stringify(err)}`;
+    super(message, httpMeta);
+    this.data$ = err;
+    this.error = err.error;
+
+    this.name = "ChatCompletionError";
+  }
+}
+
+/** @internal */
+export const ChatCompletionError$inboundSchema: z.ZodType<
+  ChatCompletionError,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  error: z.lazy(() => models.ChatCompletionErrorError$inboundSchema),
+  request$: z.instanceof(Request),
+  response$: z.instanceof(Response),
+  body$: z.string(),
+})
+  .transform((v) => {
+    return new ChatCompletionError(v, {
+      request: v.request$,
+      response: v.response$,
+      body: v.body$,
+    });
+  });
+
+/** @internal */
+export type ChatCompletionError$Outbound = {
+  error: models.ChatCompletionErrorError$Outbound;
+};
+
+/** @internal */
+export const ChatCompletionError$outboundSchema: z.ZodType<
+  ChatCompletionError$Outbound,
+  z.ZodTypeDef,
+  ChatCompletionError
+> = z.instanceof(ChatCompletionError)
+  .transform(v => v.data$)
+  .pipe(z.object({
+    error: z.lazy(() => models.ChatCompletionErrorError$outboundSchema),
+  }));
+
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export namespace ChatCompletionError$ {
+  /** @deprecated use `ChatCompletionError$inboundSchema` instead. */
+  export const inboundSchema = ChatCompletionError$inboundSchema;
+  /** @deprecated use `ChatCompletionError$outboundSchema` instead. */
+  export const outboundSchema = ChatCompletionError$outboundSchema;
+  /** @deprecated use `ChatCompletionError$Outbound` instead. */
+  export type Outbound = ChatCompletionError$Outbound;
+}