@openrouter/sdk 0.3.11 → 0.3.14

package/esm/models/publicendpoint.d.ts

@@ -4,6 +4,7 @@ import { Result as SafeParseResult } from "../types/fp.js";
 import { EndpointStatus } from "./endpointstatus.js";
 import { SDKValidationError } from "./errors/sdkvalidationerror.js";
 import { Parameter } from "./parameter.js";
+import { PercentileStats } from "./percentilestats.js";
 import { ProviderName } from "./providername.js";
 export type Pricing = {
     /**
@@ -85,6 +86,11 @@ export type PublicEndpoint = {
     status?: EndpointStatus | undefined;
     uptimeLast30m: number | null;
     supportsImplicitCaching: boolean;
+    /**
+     * Latency percentiles in milliseconds over the last 30 minutes. Latency measures time to first token. Only visible when authenticated with an API key or cookie; returns null for unauthenticated requests.
+     */
+    latencyLast30m: PercentileStats | null;
+    throughputLast30m: PercentileStats | null;
 };
 /** @internal */
 export declare const Pricing$inboundSchema: z.ZodType<Pricing, unknown>;

package/esm/models/publicendpoint.js

@@ -8,6 +8,7 @@ import { safeParse } from "../lib/schemas.js";
 import * as openEnums from "../types/enums.js";
 import { EndpointStatus$inboundSchema, } from "./endpointstatus.js";
 import { Parameter$inboundSchema } from "./parameter.js";
+import { PercentileStats$inboundSchema, } from "./percentilestats.js";
 import { ProviderName$inboundSchema } from "./providername.js";
 export const PublicEndpointQuantization = {
     Int4: "int4",
@@ -66,6 +67,8 @@ export const PublicEndpoint$inboundSchema = z.object({
     status: EndpointStatus$inboundSchema.optional(),
     uptime_last_30m: z.nullable(z.number()),
     supports_implicit_caching: z.boolean(),
+    latency_last_30m: z.nullable(PercentileStats$inboundSchema),
+    throughput_last_30m: z.nullable(PercentileStats$inboundSchema),
 }).transform((v) => {
     return remap$(v, {
         "model_name": "modelName",
@@ -76,6 +79,8 @@ export const PublicEndpoint$inboundSchema = z.object({
         "supported_parameters": "supportedParameters",
         "uptime_last_30m": "uptimeLast30m",
         "supports_implicit_caching": "supportsImplicitCaching",
+        "latency_last_30m": "latencyLast30m",
+        "throughput_last_30m": "throughputLast30m",
     });
 });
 export function publicEndpointFromJSON(jsonString) {

package/esm/models/responseinputimage.d.ts

@@ -1,7 +1,11 @@
 import * as z from "zod/v4";
-import { OpenEnum } from "../types/enums.js";
+import { ClosedEnum, OpenEnum } from "../types/enums.js";
 import { Result as SafeParseResult } from "../types/fp.js";
 import { SDKValidationError } from "./errors/sdkvalidationerror.js";
+export declare const ResponseInputImageType: {
+    readonly InputImage: "input_image";
+};
+export type ResponseInputImageType = ClosedEnum<typeof ResponseInputImageType>;
 export declare const ResponseInputImageDetail: {
     readonly Auto: "auto";
     readonly High: "high";
@@ -12,11 +16,15 @@ export type ResponseInputImageDetail = OpenEnum<typeof ResponseInputImageDetail>
  * Image input content item
  */
 export type ResponseInputImage = {
-    type: "input_image";
+    type: ResponseInputImageType;
     detail: ResponseInputImageDetail;
     imageUrl?: string | null | undefined;
 };
 /** @internal */
+export declare const ResponseInputImageType$inboundSchema: z.ZodEnum<typeof ResponseInputImageType>;
+/** @internal */
+export declare const ResponseInputImageType$outboundSchema: z.ZodEnum<typeof ResponseInputImageType>;
+/** @internal */
 export declare const ResponseInputImageDetail$inboundSchema: z.ZodType<ResponseInputImageDetail, unknown>;
 /** @internal */
 export declare const ResponseInputImageDetail$outboundSchema: z.ZodType<string, ResponseInputImageDetail>;
@@ -24,7 +32,7 @@ export declare const ResponseInputImageDetail$outboundSchema: z.ZodType<string,
 export declare const ResponseInputImage$inboundSchema: z.ZodType<ResponseInputImage, unknown>;
 /** @internal */
 export type ResponseInputImage$Outbound = {
-    type: "input_image";
+    type: string;
     detail: string;
     image_url?: string | null | undefined;
 };

package/esm/models/responseinputimage.js

@@ -6,18 +6,25 @@ import * as z from "zod/v4";
 import { remap as remap$ } from "../lib/primitives.js";
 import { safeParse } from "../lib/schemas.js";
 import * as openEnums from "../types/enums.js";
+export const ResponseInputImageType = {
+    InputImage: "input_image",
+};
 export const ResponseInputImageDetail = {
     Auto: "auto",
     High: "high",
     Low: "low",
 };
 /** @internal */
+export const ResponseInputImageType$inboundSchema = z.enum(ResponseInputImageType);
+/** @internal */
+export const ResponseInputImageType$outboundSchema = ResponseInputImageType$inboundSchema;
+/** @internal */
 export const ResponseInputImageDetail$inboundSchema = openEnums.inboundSchema(ResponseInputImageDetail);
 /** @internal */
 export const ResponseInputImageDetail$outboundSchema = openEnums.outboundSchema(ResponseInputImageDetail);
 /** @internal */
 export const ResponseInputImage$inboundSchema = z.object({
-    type: z.literal("input_image"),
+    type: ResponseInputImageType$inboundSchema,
     detail: ResponseInputImageDetail$inboundSchema,
     image_url: z.nullable(z.string()).optional(),
 }).transform((v) => {
@@ -27,7 +34,7 @@ export const ResponseInputImage$inboundSchema = z.object({
 });
 /** @internal */
 export const ResponseInputImage$outboundSchema = z.object({
-    type: z.literal("input_image"),
+    type: ResponseInputImageType$outboundSchema,
     detail: ResponseInputImageDetail$outboundSchema,
     imageUrl: z.nullable(z.string()).optional(),
 }).transform((v) => {

package/esm/models/responseinputvideo.d.ts

@@ -0,0 +1,20 @@
+import * as z from "zod/v4";
+/**
+ * Video input content item
+ */
+export type ResponseInputVideo = {
+    type: "input_video";
+    /**
+     * A base64 data URL or remote URL that resolves to a video file
+     */
+    videoUrl: string;
+};
+/** @internal */
+export type ResponseInputVideo$Outbound = {
+    type: "input_video";
+    video_url: string;
+};
+/** @internal */
+export declare const ResponseInputVideo$outboundSchema: z.ZodType<ResponseInputVideo$Outbound, ResponseInputVideo>;
+export declare function responseInputVideoToJSON(responseInputVideo: ResponseInputVideo): string;
+//# sourceMappingURL=responseinputvideo.d.ts.map

package/esm/models/responseinputvideo.js

@@ -0,0 +1,19 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ * @generated-id: 79bef840e448
+ */
+import * as z from "zod/v4";
+import { remap as remap$ } from "../lib/primitives.js";
+/** @internal */
+export const ResponseInputVideo$outboundSchema = z.object({
+    type: z.literal("input_video"),
+    videoUrl: z.string(),
+}).transform((v) => {
+    return remap$(v, {
+        videoUrl: "video_url",
+    });
+});
+export function responseInputVideoToJSON(responseInputVideo) {
+    return JSON.stringify(ResponseInputVideo$outboundSchema.parse(responseInputVideo));
+}
+//# sourceMappingURL=responseinputvideo.js.map

package/esm/models/responseoutputtext.d.ts

@@ -2,18 +2,56 @@ import * as z from "zod/v4";
 import { Result as SafeParseResult } from "../types/fp.js";
 import { SDKValidationError } from "./errors/sdkvalidationerror.js";
 import { OpenAIResponsesAnnotation, OpenAIResponsesAnnotation$Outbound } from "./openairesponsesannotation.js";
+export type ResponseOutputTextTopLogprob = {
+    token: string;
+    bytes: Array<number>;
+    logprob: number;
+};
+export type Logprob = {
+    token: string;
+    bytes: Array<number>;
+    logprob: number;
+    topLogprobs: Array<ResponseOutputTextTopLogprob>;
+};
 export type ResponseOutputText = {
     type: "output_text";
     text: string;
     annotations?: Array<OpenAIResponsesAnnotation> | undefined;
+    logprobs?: Array<Logprob> | undefined;
+};
+/** @internal */
+export declare const ResponseOutputTextTopLogprob$inboundSchema: z.ZodType<ResponseOutputTextTopLogprob, unknown>;
+/** @internal */
+export type ResponseOutputTextTopLogprob$Outbound = {
+    token: string;
+    bytes: Array<number>;
+    logprob: number;
 };
 /** @internal */
+export declare const ResponseOutputTextTopLogprob$outboundSchema: z.ZodType<ResponseOutputTextTopLogprob$Outbound, ResponseOutputTextTopLogprob>;
+export declare function responseOutputTextTopLogprobToJSON(responseOutputTextTopLogprob: ResponseOutputTextTopLogprob): string;
+export declare function responseOutputTextTopLogprobFromJSON(jsonString: string): SafeParseResult<ResponseOutputTextTopLogprob, SDKValidationError>;
+/** @internal */
+export declare const Logprob$inboundSchema: z.ZodType<Logprob, unknown>;
+/** @internal */
+export type Logprob$Outbound = {
+    token: string;
+    bytes: Array<number>;
+    logprob: number;
+    top_logprobs: Array<ResponseOutputTextTopLogprob$Outbound>;
+};
+/** @internal */
+export declare const Logprob$outboundSchema: z.ZodType<Logprob$Outbound, Logprob>;
+export declare function logprobToJSON(logprob: Logprob): string;
+export declare function logprobFromJSON(jsonString: string): SafeParseResult<Logprob, SDKValidationError>;
+/** @internal */
 export declare const ResponseOutputText$inboundSchema: z.ZodType<ResponseOutputText, unknown>;
 /** @internal */
 export type ResponseOutputText$Outbound = {
     type: "output_text";
     text: string;
     annotations?: Array<OpenAIResponsesAnnotation$Outbound> | undefined;
+    logprobs?: Array<Logprob$Outbound> | undefined;
 };
 /** @internal */
 export declare const ResponseOutputText$outboundSchema: z.ZodType<ResponseOutputText$Outbound, ResponseOutputText>;

package/esm/models/responseoutputtext.js

@@ -3,19 +3,69 @@
  * @generated-id: 2d5e61e53c46
  */
 import * as z from "zod/v4";
+import { remap as remap$ } from "../lib/primitives.js";
 import { safeParse } from "../lib/schemas.js";
 import { OpenAIResponsesAnnotation$inboundSchema, OpenAIResponsesAnnotation$outboundSchema, } from "./openairesponsesannotation.js";
 /** @internal */
+export const ResponseOutputTextTopLogprob$inboundSchema = z.object({
+    token: z.string(),
+    bytes: z.array(z.number()),
+    logprob: z.number(),
+});
+/** @internal */
+export const ResponseOutputTextTopLogprob$outboundSchema = z.object({
+    token: z.string(),
+    bytes: z.array(z.number()),
+    logprob: z.number(),
+});
+export function responseOutputTextTopLogprobToJSON(responseOutputTextTopLogprob) {
+    return JSON.stringify(ResponseOutputTextTopLogprob$outboundSchema.parse(responseOutputTextTopLogprob));
+}
+export function responseOutputTextTopLogprobFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => ResponseOutputTextTopLogprob$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'ResponseOutputTextTopLogprob' from JSON`);
+}
+/** @internal */
+export const Logprob$inboundSchema = z.object({
+    token: z.string(),
+    bytes: z.array(z.number()),
+    logprob: z.number(),
+    top_logprobs: z.array(z.lazy(() => ResponseOutputTextTopLogprob$inboundSchema)),
+}).transform((v) => {
+    return remap$(v, {
+        "top_logprobs": "topLogprobs",
+    });
+});
+/** @internal */
+export const Logprob$outboundSchema = z
+    .object({
+    token: z.string(),
+    bytes: z.array(z.number()),
+    logprob: z.number(),
+    topLogprobs: z.array(z.lazy(() => ResponseOutputTextTopLogprob$outboundSchema)),
+}).transform((v) => {
+    return remap$(v, {
+        topLogprobs: "top_logprobs",
+    });
+});
+export function logprobToJSON(logprob) {
+    return JSON.stringify(Logprob$outboundSchema.parse(logprob));
+}
+export function logprobFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => Logprob$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'Logprob' from JSON`);
+}
+/** @internal */
 export const ResponseOutputText$inboundSchema = z.object({
     type: z.literal("output_text"),
     text: z.string(),
     annotations: z.array(OpenAIResponsesAnnotation$inboundSchema).optional(),
+    logprobs: z.array(z.lazy(() => Logprob$inboundSchema)).optional(),
 });
 /** @internal */
 export const ResponseOutputText$outboundSchema = z.object({
     type: z.literal("output_text"),
     text: z.string(),
     annotations: z.array(OpenAIResponsesAnnotation$outboundSchema).optional(),
+    logprobs: z.array(z.lazy(() => Logprob$outboundSchema)).optional(),
 });
 export function responseOutputTextToJSON(responseOutputText) {
     return JSON.stringify(ResponseOutputText$outboundSchema.parse(responseOutputText));

package/esm/models/responsesoutputitemreasoning.d.ts

@@ -1,5 +1,5 @@
 import * as z from "zod/v4";
-import { ClosedEnum } from "../types/enums.js";
+import { ClosedEnum, OpenEnum } from "../types/enums.js";
 import { Result as SafeParseResult } from "../types/fp.js";
 import { SDKValidationError } from "./errors/sdkvalidationerror.js";
 import { ReasoningSummaryText, ReasoningSummaryText$Outbound } from "./reasoningsummarytext.js";
@@ -21,6 +21,21 @@ export declare const ResponsesOutputItemReasoningStatusCompleted: {
 };
 export type ResponsesOutputItemReasoningStatusCompleted = ClosedEnum<typeof ResponsesOutputItemReasoningStatusCompleted>;
 export type ResponsesOutputItemReasoningStatusUnion = ResponsesOutputItemReasoningStatusCompleted | ResponsesOutputItemReasoningStatusIncomplete | ResponsesOutputItemReasoningStatusInProgress;
+/**
+ * The format of the reasoning content
+ */
+export declare const ResponsesOutputItemReasoningFormat: {
+    readonly Unknown: "unknown";
+    readonly OpenaiResponsesV1: "openai-responses-v1";
+    readonly AzureOpenaiResponsesV1: "azure-openai-responses-v1";
+    readonly XaiResponsesV1: "xai-responses-v1";
+    readonly AnthropicClaudeV1: "anthropic-claude-v1";
+    readonly GoogleGeminiV1: "google-gemini-v1";
+};
+/**
+ * The format of the reasoning content
+ */
+export type ResponsesOutputItemReasoningFormat = OpenEnum<typeof ResponsesOutputItemReasoningFormat>;
 /**
  * An output item containing reasoning
  */
@@ -31,6 +46,14 @@ export type ResponsesOutputItemReasoning = {
     summary: Array<ReasoningSummaryText>;
     encryptedContent?: string | null | undefined;
     status?: ResponsesOutputItemReasoningStatusCompleted | ResponsesOutputItemReasoningStatusIncomplete | ResponsesOutputItemReasoningStatusInProgress | undefined;
+    /**
+     * A signature for the reasoning content, used for verification
+     */
+    signature?: string | null | undefined;
+    /**
+     * The format of the reasoning content
+     */
+    format?: ResponsesOutputItemReasoningFormat | null | undefined;
 };
 /** @internal */
 export declare const ResponsesOutputItemReasoningType$inboundSchema: z.ZodEnum<typeof ResponsesOutputItemReasoningType>;
@@ -57,6 +80,10 @@ export declare const ResponsesOutputItemReasoningStatusUnion$outboundSchema: z.Z
 export declare function responsesOutputItemReasoningStatusUnionToJSON(responsesOutputItemReasoningStatusUnion: ResponsesOutputItemReasoningStatusUnion): string;
 export declare function responsesOutputItemReasoningStatusUnionFromJSON(jsonString: string): SafeParseResult<ResponsesOutputItemReasoningStatusUnion, SDKValidationError>;
 /** @internal */
+export declare const ResponsesOutputItemReasoningFormat$inboundSchema: z.ZodType<ResponsesOutputItemReasoningFormat, unknown>;
+/** @internal */
+export declare const ResponsesOutputItemReasoningFormat$outboundSchema: z.ZodType<string, ResponsesOutputItemReasoningFormat>;
+/** @internal */
 export declare const ResponsesOutputItemReasoning$inboundSchema: z.ZodType<ResponsesOutputItemReasoning, unknown>;
 /** @internal */
 export type ResponsesOutputItemReasoning$Outbound = {
@@ -66,6 +93,8 @@ export type ResponsesOutputItemReasoning$Outbound = {
     summary: Array<ReasoningSummaryText$Outbound>;
     encrypted_content?: string | null | undefined;
     status?: string | string | string | undefined;
+    signature?: string | null | undefined;
+    format?: string | null | undefined;
 };
 /** @internal */
 export declare const ResponsesOutputItemReasoning$outboundSchema: z.ZodType<ResponsesOutputItemReasoning$Outbound, ResponsesOutputItemReasoning>;

package/esm/models/responsesoutputitemreasoning.js

@@ -5,6 +5,7 @@
 import * as z from "zod/v4";
 import { remap as remap$ } from "../lib/primitives.js";
 import { safeParse } from "../lib/schemas.js";
+import * as openEnums from "../types/enums.js";
 import { ReasoningSummaryText$inboundSchema, ReasoningSummaryText$outboundSchema, } from "./reasoningsummarytext.js";
 import { ReasoningTextContent$inboundSchema, ReasoningTextContent$outboundSchema, } from "./reasoningtextcontent.js";
 export const ResponsesOutputItemReasoningType = {
@@ -19,6 +20,17 @@ export const ResponsesOutputItemReasoningStatusIncomplete = {
 export const ResponsesOutputItemReasoningStatusCompleted = {
     Completed: "completed",
 };
+/**
+ * The format of the reasoning content
+ */
+export const ResponsesOutputItemReasoningFormat = {
+    Unknown: "unknown",
+    OpenaiResponsesV1: "openai-responses-v1",
+    AzureOpenaiResponsesV1: "azure-openai-responses-v1",
+    XaiResponsesV1: "xai-responses-v1",
+    AnthropicClaudeV1: "anthropic-claude-v1",
+    GoogleGeminiV1: "google-gemini-v1",
+};
 /** @internal */
 export const ResponsesOutputItemReasoningType$inboundSchema = z.enum(ResponsesOutputItemReasoningType);
 /** @internal */
@@ -54,6 +66,10 @@ export function responsesOutputItemReasoningStatusUnionFromJSON(jsonString) {
     return safeParse(jsonString, (x) => ResponsesOutputItemReasoningStatusUnion$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'ResponsesOutputItemReasoningStatusUnion' from JSON`);
 }
 /** @internal */
+export const ResponsesOutputItemReasoningFormat$inboundSchema = openEnums.inboundSchema(ResponsesOutputItemReasoningFormat);
+/** @internal */
+export const ResponsesOutputItemReasoningFormat$outboundSchema = openEnums.outboundSchema(ResponsesOutputItemReasoningFormat);
+/** @internal */
 export const ResponsesOutputItemReasoning$inboundSchema = z.object({
     type: ResponsesOutputItemReasoningType$inboundSchema,
     id: z.string(),
@@ -65,6 +81,9 @@ export const ResponsesOutputItemReasoning$inboundSchema = z.object({
         ResponsesOutputItemReasoningStatusIncomplete$inboundSchema,
         ResponsesOutputItemReasoningStatusInProgress$inboundSchema,
     ]).optional(),
+    signature: z.nullable(z.string()).optional(),
+    format: z.nullable(ResponsesOutputItemReasoningFormat$inboundSchema)
+        .optional(),
 }).transform((v) => {
     return remap$(v, {
         "encrypted_content": "encryptedContent",
@@ -82,6 +101,9 @@ export const ResponsesOutputItemReasoning$outboundSchema = z.object({
         ResponsesOutputItemReasoningStatusIncomplete$outboundSchema,
         ResponsesOutputItemReasoningStatusInProgress$outboundSchema,
     ]).optional(),
+    signature: z.nullable(z.string()).optional(),
+    format: z.nullable(ResponsesOutputItemReasoningFormat$outboundSchema)
+        .optional(),
 }).transform((v) => {
     return remap$(v, {
         encryptedContent: "encrypted_content",

package/esm/models/responsesoutputmodality.d.ts

@@ -0,0 +1,10 @@
+import * as z from "zod/v4";
+import { OpenEnum } from "../types/enums.js";
+export declare const ResponsesOutputModality: {
+    readonly Text: "text";
+    readonly Image: "image";
+};
+export type ResponsesOutputModality = OpenEnum<typeof ResponsesOutputModality>;
+/** @internal */
+export declare const ResponsesOutputModality$outboundSchema: z.ZodType<string, ResponsesOutputModality>;
+//# sourceMappingURL=responsesoutputmodality.d.ts.map

package/esm/models/responsesoutputmodality.js

@@ -0,0 +1,12 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ * @generated-id: c42840bf36d8
+ */
+import * as openEnums from "../types/enums.js";
+export const ResponsesOutputModality = {
+    Text: "text",
+    Image: "image",
+};
+/** @internal */
+export const ResponsesOutputModality$outboundSchema = openEnums.outboundSchema(ResponsesOutputModality);
+//# sourceMappingURL=responsesoutputmodality.js.map

package/esm/models/schema0.d.ts

@@ -27,12 +27,12 @@ export declare const Schema0Enum: {
     readonly Fireworks: "Fireworks";
     readonly Friendli: "Friendli";
     readonly GMICloud: "GMICloud";
-    readonly GoPomelo: "GoPomelo";
     readonly Google: "Google";
     readonly GoogleAIStudio: "Google AI Studio";
     readonly Groq: "Groq";
     readonly Hyperbolic: "Hyperbolic";
     readonly Inception: "Inception";
+    readonly Inceptron: "Inceptron";
     readonly InferenceNet: "InferenceNet";
     readonly Infermatic: "Infermatic";
     readonly Inflection: "Inflection";
@@ -57,13 +57,14 @@ export declare const Schema0Enum: {
     readonly Phala: "Phala";
     readonly Relace: "Relace";
     readonly SambaNova: "SambaNova";
+    readonly Seed: "Seed";
     readonly SiliconFlow: "SiliconFlow";
     readonly Sourceful: "Sourceful";
     readonly Stealth: "Stealth";
     readonly StreamLake: "StreamLake";
     readonly Switchpoint: "Switchpoint";
-    readonly Targon: "Targon";
     readonly Together: "Together";
+    readonly Upstage: "Upstage";
     readonly Venice: "Venice";
     readonly WandB: "WandB";
     readonly Xiaomi: "Xiaomi";

package/esm/models/schema0.js

@@ -31,12 +31,12 @@ export const Schema0Enum = {
     Fireworks: "Fireworks",
     Friendli: "Friendli",
     GMICloud: "GMICloud",
-    GoPomelo: "GoPomelo",
     Google: "Google",
     GoogleAIStudio: "Google AI Studio",
     Groq: "Groq",
     Hyperbolic: "Hyperbolic",
     Inception: "Inception",
+    Inceptron: "Inceptron",
     InferenceNet: "InferenceNet",
     Infermatic: "Infermatic",
     Inflection: "Inflection",
@@ -61,13 +61,14 @@ export const Schema0Enum = {
     Phala: "Phala",
     Relace: "Relace",
     SambaNova: "SambaNova",
+    Seed: "Seed",
     SiliconFlow: "SiliconFlow",
     Sourceful: "Sourceful",
     Stealth: "Stealth",
     StreamLake: "StreamLake",
     Switchpoint: "Switchpoint",
-    Targon: "Targon",
     Together: "Together",
+    Upstage: "Upstage",
     Venice: "Venice",
     WandB: "WandB",
     Xiaomi: "Xiaomi",

package/esm/models/schema3.d.ts

@@ -5,6 +5,7 @@ import { SDKValidationError } from "./errors/sdkvalidationerror.js";
 export declare const Schema5: {
     readonly Unknown: "unknown";
     readonly OpenaiResponsesV1: "openai-responses-v1";
+    readonly AzureOpenaiResponsesV1: "azure-openai-responses-v1";
     readonly XaiResponsesV1: "xai-responses-v1";
     readonly AnthropicClaudeV1: "anthropic-claude-v1";
     readonly GoogleGeminiV1: "google-gemini-v1";

package/esm/models/schema3.js

@@ -8,6 +8,7 @@ import * as openEnums from "../types/enums.js";
 export const Schema5 = {
     Unknown: "unknown",
     OpenaiResponsesV1: "openai-responses-v1",
+    AzureOpenaiResponsesV1: "azure-openai-responses-v1",
     XaiResponsesV1: "xai-responses-v1",
     AnthropicClaudeV1: "anthropic-claude-v1",
     GoogleGeminiV1: "google-gemini-v1",

package/jsr.json

@@ -2,7 +2,7 @@
 
 {
   "name": "@openrouter/sdk",
-  "version": "0.3.11",
+  "version": "0.3.14",
   "exports": {
     ".": "./src/index.ts",    
     "./models/errors": "./src/models/errors/index.ts",    

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@openrouter/sdk",
-  "version": "0.3.11",
+  "version": "0.3.14",
   "author": "OpenRouter",
   "description": "The OpenRouter TypeScript SDK is a type-safe toolkit for building AI applications with access to 300+ language models through a unified API.",
   "keywords": [
@@ -69,11 +69,9 @@
     "build": "tsc",
     "typecheck": "tsc --noEmit",
     "prepublishOnly": "npm run build",
-    "test": "vitest --run",
-    "test:watch": "vitest"
-  },
-  "peerDependencies": {
-
+    "test": "vitest --run --project unit",
+    "test:e2e": "vitest --run --project e2e",
+    "test:watch": "vitest --watch --project unit"
   },
   "devDependencies": {
     "@eslint/js": "^9.19.0",
@@ -87,5 +85,6 @@
   },
   "dependencies": {
     "zod": "^3.25.0 || ^4.0.0"
-  }
+  },
+  "packageManager": "pnpm@10.22.0"
 }

package/vitest.config.ts

@@ -1,36 +1,45 @@
-import { dirname, join } from 'node:path';
-import { fileURLToPath } from 'node:url';
 import { config } from 'dotenv';
 import { defineConfig } from 'vitest/config';
 
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = dirname(__filename);
-
 // Load environment variables from .env file if it exists
 // This will not override existing environment variables
 config({
-  path: join(__dirname, '.env'),
+  path: new URL('.env', import.meta.url),
 });
 
 export default defineConfig({
   test: {
     globals: true,
     environment: 'node',
-    // Don't override env vars - just let them pass through from the system
-    // The env object here will be merged with process.env
     env: {
       OPENROUTER_API_KEY: process.env.OPENROUTER_API_KEY,
     },
-    include: [
-      'tests/**/*.test.ts',
-    ],
-    hookTimeout: 30000,
-    testTimeout: 30000,
     typecheck: {
       enabled: true,
-      include: [
-        'tests/**/*.test.ts',
-      ],
     },
+    projects: [
+      {
+        extends: true,
+        test: {
+          name: 'unit',
+          include: [
+            'tests/unit/**/*.test.ts', 
+            'tests/funcs/**/*.test.ts', 
+            'tests/sdk/**/*.test.ts'
+          ],
+          testTimeout: 10000,
+          hookTimeout: 10000,
+        },
+      },
+      {
+        extends: true,
+        test: {
+          name: 'e2e',
+          include: ['tests/e2e/**/*.test.ts'],
+          testTimeout: 30000,
+          hookTimeout: 30000,
+        },
+      },
+    ],
   },
 });

package/.zed/settings.json

@@ -1,10 +0,0 @@
-{
-  "tab_size": 2,
-  "project_name": "@openrouter/sdk",
-  "formatter": {
-    "language_server": {
-      "name": "eslint"
-    }
-  },
-  "language_servers": ["!biome", "..."]
-}