@openrouter/sdk 0.8.0 → 0.9.11

package/esm/funcs/chatSend.d.ts

@@ -20,11 +20,11 @@ export declare function chatSend(client: OpenRouterCore, request: operations.Sen
     chatGenerationParams: {
         stream?: false;
     };
-}, options?: RequestOptions): APIPromise<Result<models.ChatResponse, errors.ChatError | OpenRouterError | ResponseValidationError | ConnectionError | RequestAbortedError | RequestTimeoutError | InvalidRequestError | UnexpectedClientError | SDKValidationError>>;
+}, options?: RequestOptions): APIPromise<Result<models.ChatResponse, errors.BadRequestResponseError | errors.UnauthorizedResponseError | errors.PaymentRequiredResponseError | errors.NotFoundResponseError | errors.RequestTimeoutResponseError | errors.PayloadTooLargeResponseError | errors.UnprocessableEntityResponseError | errors.TooManyRequestsResponseError | errors.InternalServerResponseError | errors.BadGatewayResponseError | errors.ServiceUnavailableResponseError | errors.EdgeNetworkTimeoutResponseError | errors.ProviderOverloadedResponseError | OpenRouterError | ResponseValidationError | ConnectionError | RequestAbortedError | RequestTimeoutError | InvalidRequestError | UnexpectedClientError | SDKValidationError>>;
 export declare function chatSend(client: OpenRouterCore, request: operations.SendChatCompletionRequestRequest & {
     chatGenerationParams: {
         stream: true;
     };
-}, options?: RequestOptions): APIPromise<Result<EventStream<models.ChatStreamingResponseChunkData>, errors.ChatError | OpenRouterError | ResponseValidationError | ConnectionError | RequestAbortedError | RequestTimeoutError | InvalidRequestError | UnexpectedClientError | SDKValidationError>>;
-export declare function chatSend(client: OpenRouterCore, request: operations.SendChatCompletionRequestRequest, options?: RequestOptions): APIPromise<Result<operations.SendChatCompletionRequestResponse, errors.ChatError | OpenRouterError | ResponseValidationError | ConnectionError | RequestAbortedError | RequestTimeoutError | InvalidRequestError | UnexpectedClientError | SDKValidationError>>;
+}, options?: RequestOptions): APIPromise<Result<EventStream<models.ChatStreamingResponseChunk>, errors.BadRequestResponseError | errors.UnauthorizedResponseError | errors.PaymentRequiredResponseError | errors.NotFoundResponseError | errors.RequestTimeoutResponseError | errors.PayloadTooLargeResponseError | errors.UnprocessableEntityResponseError | errors.TooManyRequestsResponseError | errors.InternalServerResponseError | errors.BadGatewayResponseError | errors.ServiceUnavailableResponseError | errors.EdgeNetworkTimeoutResponseError | errors.ProviderOverloadedResponseError | OpenRouterError | ResponseValidationError | ConnectionError | RequestAbortedError | RequestTimeoutError | InvalidRequestError | UnexpectedClientError | SDKValidationError>>;
+export declare function chatSend(client: OpenRouterCore, request: operations.SendChatCompletionRequestRequest, options?: RequestOptions): APIPromise<Result<operations.SendChatCompletionRequestResponse, errors.BadRequestResponseError | errors.UnauthorizedResponseError | errors.PaymentRequiredResponseError | errors.NotFoundResponseError | errors.RequestTimeoutResponseError | errors.PayloadTooLargeResponseError | errors.UnprocessableEntityResponseError | errors.TooManyRequestsResponseError | errors.InternalServerResponseError | errors.BadGatewayResponseError | errors.ServiceUnavailableResponseError | errors.EdgeNetworkTimeoutResponseError | errors.ProviderOverloadedResponseError | OpenRouterError | ResponseValidationError | ConnectionError | RequestAbortedError | RequestTimeoutError | InvalidRequestError | UnexpectedClientError | SDKValidationError>>;
 //# sourceMappingURL=chatSend.d.ts.map

package/esm/funcs/chatSend.js

@@ -63,7 +63,23 @@ async function $do(client, request, options) {
     const req = requestRes.value;
     const doResult = await client._do(req, {
         context,
-        errorCodes: ["400", "401", "429", "4XX", "500", "5XX"],
+        errorCodes: [
+            "400",
+            "401",
+            "402",
+            "404",
+            "408",
+            "413",
+            "422",
+            "429",
+            "4XX",
+            "500",
+            "502",
+            "503",
+            "524",
+            "529",
+            "5XX",
+        ],
         retryConfig: context.retryConfig,
         retryCodes: context.retryCodes,
     });
@@ -74,7 +90,7 @@ async function $do(client, request, options) {
     const responseFields = {
         HttpMeta: { Response: response, Request: req },
     };
-    const [result] = await M.match(M.json(200, operations.SendChatCompletionRequestResponse$inboundSchema), M.sse(200, operations.SendChatCompletionRequestResponse$inboundSchema), M.jsonErr([400, 401, 429], errors.ChatError$inboundSchema), M.jsonErr(500, errors.ChatError$inboundSchema), M.fail("4XX"), M.fail("5XX"))(response, req, { extraFields: responseFields });
+    const [result] = await M.match(M.json(200, operations.SendChatCompletionRequestResponse$inboundSchema), M.sse(200, operations.SendChatCompletionRequestResponse$inboundSchema), 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(408, errors.RequestTimeoutResponseError$inboundSchema), M.jsonErr(413, errors.PayloadTooLargeResponseError$inboundSchema), M.jsonErr(422, errors.UnprocessableEntityResponseError$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 }];
     }

package/esm/lib/config.d.ts

@@ -51,8 +51,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.8.0";
+    readonly sdkVersion: "0.9.11";
     readonly genVersion: "2.788.4";
-    readonly userAgent: "speakeasy-sdk/typescript 0.8.0 2.788.4 1.0.0 @openrouter/sdk";
+    readonly userAgent: "speakeasy-sdk/typescript 0.9.11 2.788.4 1.0.0 @openrouter/sdk";
 };
 //# sourceMappingURL=config.d.ts.map

package/esm/lib/config.js

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

package/esm/models/assistantmessage.d.ts

@@ -1,66 +1,77 @@
 import * as z from "zod/v4";
+import { ClosedEnum } from "../types/enums.js";
 import { Result as SafeParseResult } from "../types/fp.js";
+import { AssistantMessageImages, AssistantMessageImages$Outbound } from "./assistantmessageimages.js";
 import { ChatMessageContentItem, ChatMessageContentItem$Outbound } from "./chatmessagecontentitem.js";
 import { ChatMessageToolCall, ChatMessageToolCall$Outbound } from "./chatmessagetoolcall.js";
 import { SDKValidationError } from "./errors/sdkvalidationerror.js";
-import { Schema19, Schema19$Outbound } from "./schema19.js";
-export type AssistantMessageContent = string | Array<ChatMessageContentItem>;
-export type AssistantMessageImageUrl = {
-    url: string;
-};
-export type Image = {
-    imageUrl: AssistantMessageImageUrl;
+import { ReasoningDetailUnion, ReasoningDetailUnion$Outbound } from "./reasoningdetailunion.js";
+export declare const AssistantMessageRole: {
+    readonly Assistant: "assistant";
 };
+export type AssistantMessageRole = ClosedEnum<typeof AssistantMessageRole>;
+/**
+ * Assistant message content
+ */
+export type AssistantMessageContent = string | Array<ChatMessageContentItem> | any;
+/**
+ * Assistant message for requests and responses
+ */
 export type AssistantMessage = {
-    role: "assistant";
-    content?: string | Array<ChatMessageContentItem> | null | undefined;
+    role: AssistantMessageRole;
+    /**
+     * Assistant message content
+     */
+    content?: string | Array<ChatMessageContentItem> | any | null | undefined;
+    /**
+     * Optional name for the assistant
+     */
     name?: string | undefined;
+    /**
+     * Tool calls made by the assistant
+     */
     toolCalls?: Array<ChatMessageToolCall> | undefined;
+    /**
+     * Refusal message if content was refused
+     */
     refusal?: string | null | undefined;
+    /**
+     * Reasoning output
+     */
     reasoning?: string | null | undefined;
-    reasoningDetails?: Array<Schema19> | undefined;
-    images?: Array<Image> | undefined;
+    /**
+     * Reasoning details for extended thinking models
+     */
+    reasoningDetails?: Array<ReasoningDetailUnion> | undefined;
+    /**
+     * Generated images from image generation models
+     */
+    images?: Array<AssistantMessageImages> | undefined;
 };
 /** @internal */
+export declare const AssistantMessageRole$inboundSchema: z.ZodEnum<typeof AssistantMessageRole>;
+/** @internal */
+export declare const AssistantMessageRole$outboundSchema: z.ZodEnum<typeof AssistantMessageRole>;
+/** @internal */
 export declare const AssistantMessageContent$inboundSchema: z.ZodType<AssistantMessageContent, unknown>;
 /** @internal */
-export type AssistantMessageContent$Outbound = string | Array<ChatMessageContentItem$Outbound>;
+export type AssistantMessageContent$Outbound = string | Array<ChatMessageContentItem$Outbound> | any;
 /** @internal */
 export declare const AssistantMessageContent$outboundSchema: z.ZodType<AssistantMessageContent$Outbound, AssistantMessageContent>;
 export declare function assistantMessageContentToJSON(assistantMessageContent: AssistantMessageContent): string;
 export declare function assistantMessageContentFromJSON(jsonString: string): SafeParseResult<AssistantMessageContent, SDKValidationError>;
 /** @internal */
-export declare const AssistantMessageImageUrl$inboundSchema: z.ZodType<AssistantMessageImageUrl, unknown>;
-/** @internal */
-export type AssistantMessageImageUrl$Outbound = {
-    url: string;
-};
-/** @internal */
-export declare const AssistantMessageImageUrl$outboundSchema: z.ZodType<AssistantMessageImageUrl$Outbound, AssistantMessageImageUrl>;
-export declare function assistantMessageImageUrlToJSON(assistantMessageImageUrl: AssistantMessageImageUrl): string;
-export declare function assistantMessageImageUrlFromJSON(jsonString: string): SafeParseResult<AssistantMessageImageUrl, SDKValidationError>;
-/** @internal */
-export declare const Image$inboundSchema: z.ZodType<Image, unknown>;
-/** @internal */
-export type Image$Outbound = {
-    image_url: AssistantMessageImageUrl$Outbound;
-};
-/** @internal */
-export declare const Image$outboundSchema: z.ZodType<Image$Outbound, Image>;
-export declare function imageToJSON(image: Image): string;
-export declare function imageFromJSON(jsonString: string): SafeParseResult<Image, SDKValidationError>;
-/** @internal */
 export declare const AssistantMessage$inboundSchema: z.ZodType<AssistantMessage, unknown>;
 /** @internal */
 export type AssistantMessage$Outbound = {
-    role: "assistant";
-    content?: string | Array<ChatMessageContentItem$Outbound> | null | undefined;
+    role: string;
+    content?: string | Array<ChatMessageContentItem$Outbound> | any | null | undefined;
     name?: string | undefined;
     tool_calls?: Array<ChatMessageToolCall$Outbound> | undefined;
     refusal?: string | null | undefined;
     reasoning?: string | null | undefined;
-    reasoning_details?: Array<Schema19$Outbound> | undefined;
-    images?: Array<Image$Outbound> | undefined;
+    reasoning_details?: Array<ReasoningDetailUnion$Outbound> | undefined;
+    images?: Array<AssistantMessageImages$Outbound> | undefined;
 };
 /** @internal */
 export declare const AssistantMessage$outboundSchema: z.ZodType<AssistantMessage$Outbound, AssistantMessage>;

package/esm/models/assistantmessage.js

@@ -5,13 +5,29 @@
 import * as z from "zod/v4";
 import { remap as remap$ } from "../lib/primitives.js";
 import { safeParse } from "../lib/schemas.js";
+import { AssistantMessageImages$inboundSchema, AssistantMessageImages$outboundSchema, } from "./assistantmessageimages.js";
 import { ChatMessageContentItem$inboundSchema, ChatMessageContentItem$outboundSchema, } from "./chatmessagecontentitem.js";
 import { ChatMessageToolCall$inboundSchema, ChatMessageToolCall$outboundSchema, } from "./chatmessagetoolcall.js";
-import { Schema19$inboundSchema, Schema19$outboundSchema, } from "./schema19.js";
+import { ReasoningDetailUnion$inboundSchema, ReasoningDetailUnion$outboundSchema, } from "./reasoningdetailunion.js";
+export const AssistantMessageRole = {
+    Assistant: "assistant",
+};
 /** @internal */
-export const AssistantMessageContent$inboundSchema = z.union([z.string(), z.array(ChatMessageContentItem$inboundSchema)]);
+export const AssistantMessageRole$inboundSchema = z.enum(AssistantMessageRole);
 /** @internal */
-export const AssistantMessageContent$outboundSchema = z.union([z.string(), z.array(ChatMessageContentItem$outboundSchema)]);
+export const AssistantMessageRole$outboundSchema = AssistantMessageRole$inboundSchema;
+/** @internal */
+export const AssistantMessageContent$inboundSchema = z.union([
+    z.string(),
+    z.array(ChatMessageContentItem$inboundSchema),
+    z.any(),
+]);
+/** @internal */
+export const AssistantMessageContent$outboundSchema = z.union([
+    z.string(),
+    z.array(ChatMessageContentItem$outboundSchema),
+    z.any(),
+]);
 export function assistantMessageContentToJSON(assistantMessageContent) {
     return JSON.stringify(AssistantMessageContent$outboundSchema.parse(assistantMessageContent));
 }
@@ -19,51 +35,19 @@ export function assistantMessageContentFromJSON(jsonString) {
     return safeParse(jsonString, (x) => AssistantMessageContent$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'AssistantMessageContent' from JSON`);
 }
 /** @internal */
-export const AssistantMessageImageUrl$inboundSchema = z.object({
-    url: z.string(),
-});
-/** @internal */
-export const AssistantMessageImageUrl$outboundSchema = z.object({
-    url: z.string(),
-});
-export function assistantMessageImageUrlToJSON(assistantMessageImageUrl) {
-    return JSON.stringify(AssistantMessageImageUrl$outboundSchema.parse(assistantMessageImageUrl));
-}
-export function assistantMessageImageUrlFromJSON(jsonString) {
-    return safeParse(jsonString, (x) => AssistantMessageImageUrl$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'AssistantMessageImageUrl' from JSON`);
-}
-/** @internal */
-export const Image$inboundSchema = z.object({
-    image_url: z.lazy(() => AssistantMessageImageUrl$inboundSchema),
-}).transform((v) => {
-    return remap$(v, {
-        "image_url": "imageUrl",
-    });
-});
-/** @internal */
-export const Image$outboundSchema = z.object({
-    imageUrl: z.lazy(() => AssistantMessageImageUrl$outboundSchema),
-}).transform((v) => {
-    return remap$(v, {
-        imageUrl: "image_url",
-    });
-});
-export function imageToJSON(image) {
-    return JSON.stringify(Image$outboundSchema.parse(image));
-}
-export function imageFromJSON(jsonString) {
-    return safeParse(jsonString, (x) => Image$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'Image' from JSON`);
-}
-/** @internal */
 export const AssistantMessage$inboundSchema = z.object({
-    role: z.literal("assistant"),
-    content: z.nullable(z.union([z.string(), z.array(ChatMessageContentItem$inboundSchema)])).optional(),
+    role: AssistantMessageRole$inboundSchema,
+    content: z.nullable(z.union([
+        z.string(),
+        z.array(ChatMessageContentItem$inboundSchema),
+        z.any(),
+    ])).optional(),
     name: z.string().optional(),
     tool_calls: z.array(ChatMessageToolCall$inboundSchema).optional(),
     refusal: z.nullable(z.string()).optional(),
     reasoning: z.nullable(z.string()).optional(),
-    reasoning_details: z.array(Schema19$inboundSchema).optional(),
-    images: z.array(z.lazy(() => Image$inboundSchema)).optional(),
+    reasoning_details: z.array(ReasoningDetailUnion$inboundSchema).optional(),
+    images: z.array(AssistantMessageImages$inboundSchema).optional(),
 }).transform((v) => {
     return remap$(v, {
         "tool_calls": "toolCalls",
@@ -72,14 +56,18 @@ export const AssistantMessage$inboundSchema = z.object({
 });
 /** @internal */
 export const AssistantMessage$outboundSchema = z.object({
-    role: z.literal("assistant"),
-    content: z.nullable(z.union([z.string(), z.array(ChatMessageContentItem$outboundSchema)])).optional(),
+    role: AssistantMessageRole$outboundSchema,
+    content: z.nullable(z.union([
+        z.string(),
+        z.array(ChatMessageContentItem$outboundSchema),
+        z.any(),
+    ])).optional(),
     name: z.string().optional(),
     toolCalls: z.array(ChatMessageToolCall$outboundSchema).optional(),
     refusal: z.nullable(z.string()).optional(),
     reasoning: z.nullable(z.string()).optional(),
-    reasoningDetails: z.array(Schema19$outboundSchema).optional(),
-    images: z.array(z.lazy(() => Image$outboundSchema)).optional(),
+    reasoningDetails: z.array(ReasoningDetailUnion$outboundSchema).optional(),
+    images: z.array(AssistantMessageImages$outboundSchema).optional(),
 }).transform((v) => {
     return remap$(v, {
         toolCalls: "tool_calls",

package/esm/models/assistantmessageimages.d.ts

@@ -0,0 +1,33 @@
+import * as z from "zod/v4";
+import { Result as SafeParseResult } from "../types/fp.js";
+import { SDKValidationError } from "./errors/sdkvalidationerror.js";
+export type AssistantMessageImagesImageUrl = {
+    /**
+     * URL or base64-encoded data of the generated image
+     */
+    url: string;
+};
+export type AssistantMessageImages = {
+    imageUrl: AssistantMessageImagesImageUrl;
+};
+/** @internal */
+export declare const AssistantMessageImagesImageUrl$inboundSchema: z.ZodType<AssistantMessageImagesImageUrl, unknown>;
+/** @internal */
+export type AssistantMessageImagesImageUrl$Outbound = {
+    url: string;
+};
+/** @internal */
+export declare const AssistantMessageImagesImageUrl$outboundSchema: z.ZodType<AssistantMessageImagesImageUrl$Outbound, AssistantMessageImagesImageUrl>;
+export declare function assistantMessageImagesImageUrlToJSON(assistantMessageImagesImageUrl: AssistantMessageImagesImageUrl): string;
+export declare function assistantMessageImagesImageUrlFromJSON(jsonString: string): SafeParseResult<AssistantMessageImagesImageUrl, SDKValidationError>;
+/** @internal */
+export declare const AssistantMessageImages$inboundSchema: z.ZodType<AssistantMessageImages, unknown>;
+/** @internal */
+export type AssistantMessageImages$Outbound = {
+    image_url: AssistantMessageImagesImageUrl$Outbound;
+};
+/** @internal */
+export declare const AssistantMessageImages$outboundSchema: z.ZodType<AssistantMessageImages$Outbound, AssistantMessageImages>;
+export declare function assistantMessageImagesToJSON(assistantMessageImages: AssistantMessageImages): string;
+export declare function assistantMessageImagesFromJSON(jsonString: string): SafeParseResult<AssistantMessageImages, SDKValidationError>;
+//# sourceMappingURL=assistantmessageimages.d.ts.map

package/esm/models/assistantmessageimages.js

@@ -0,0 +1,44 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ * @generated-id: 7b893584cc21
+ */
+import * as z from "zod/v4";
+import { remap as remap$ } from "../lib/primitives.js";
+import { safeParse } from "../lib/schemas.js";
+/** @internal */
+export const AssistantMessageImagesImageUrl$inboundSchema = z.object({
+    url: z.string(),
+});
+/** @internal */
+export const AssistantMessageImagesImageUrl$outboundSchema = z.object({
+    url: z.string(),
+});
+export function assistantMessageImagesImageUrlToJSON(assistantMessageImagesImageUrl) {
+    return JSON.stringify(AssistantMessageImagesImageUrl$outboundSchema.parse(assistantMessageImagesImageUrl));
+}
+export function assistantMessageImagesImageUrlFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => AssistantMessageImagesImageUrl$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'AssistantMessageImagesImageUrl' from JSON`);
+}
+/** @internal */
+export const AssistantMessageImages$inboundSchema = z.object({
+    image_url: z.lazy(() => AssistantMessageImagesImageUrl$inboundSchema),
+}).transform((v) => {
+    return remap$(v, {
+        "image_url": "imageUrl",
+    });
+});
+/** @internal */
+export const AssistantMessageImages$outboundSchema = z.object({
+    imageUrl: z.lazy(() => AssistantMessageImagesImageUrl$outboundSchema),
+}).transform((v) => {
+    return remap$(v, {
+        imageUrl: "image_url",
+    });
+});
+export function assistantMessageImagesToJSON(assistantMessageImages) {
+    return JSON.stringify(AssistantMessageImages$outboundSchema.parse(assistantMessageImages));
+}
+export function assistantMessageImagesFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => AssistantMessageImages$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'AssistantMessageImages' from JSON`);
+}
+//# sourceMappingURL=assistantmessageimages.js.map