@openrouter/sdk 0.3.12 → 0.3.14

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.12",
+  "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.12",
+  "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": [