@openrouter/sdk 0.3.12 → 0.3.15

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: 4f6019babb94
+ */
+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/schema2.d.ts

@@ -0,0 +1,92 @@
+import * as z from "zod/v4";
+import { OpenEnum } from "../types/enums.js";
+import { Result as SafeParseResult } from "../types/fp.js";
+import { SDKValidationError } from "./errors/sdkvalidationerror.js";
+export declare const Schema4: {
+    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";
+};
+export type Schema4 = OpenEnum<typeof Schema4>;
+export type Schema2ReasoningText = {
+    type: "reasoning.text";
+    text?: string | null | undefined;
+    signature?: string | null | undefined;
+    id?: string | null | undefined;
+    format?: Schema4 | null | undefined;
+    index?: number | undefined;
+};
+export type Schema2ReasoningEncrypted = {
+    type: "reasoning.encrypted";
+    data: string;
+    id?: string | null | undefined;
+    format?: Schema4 | null | undefined;
+    index?: number | undefined;
+};
+export type Schema2ReasoningSummary = {
+    type: "reasoning.summary";
+    summary: string;
+    id?: string | null | undefined;
+    format?: Schema4 | null | undefined;
+    index?: number | undefined;
+};
+export type Schema2 = Schema2ReasoningSummary | Schema2ReasoningEncrypted | Schema2ReasoningText;
+/** @internal */
+export declare const Schema4$inboundSchema: z.ZodType<Schema4, unknown>;
+/** @internal */
+export declare const Schema4$outboundSchema: z.ZodType<string, Schema4>;
+/** @internal */
+export declare const Schema2ReasoningText$inboundSchema: z.ZodType<Schema2ReasoningText, unknown>;
+/** @internal */
+export type Schema2ReasoningText$Outbound = {
+    type: "reasoning.text";
+    text?: string | null | undefined;
+    signature?: string | null | undefined;
+    id?: string | null | undefined;
+    format?: string | null | undefined;
+    index?: number | undefined;
+};
+/** @internal */
+export declare const Schema2ReasoningText$outboundSchema: z.ZodType<Schema2ReasoningText$Outbound, Schema2ReasoningText>;
+export declare function schema2ReasoningTextToJSON(schema2ReasoningText: Schema2ReasoningText): string;
+export declare function schema2ReasoningTextFromJSON(jsonString: string): SafeParseResult<Schema2ReasoningText, SDKValidationError>;
+/** @internal */
+export declare const Schema2ReasoningEncrypted$inboundSchema: z.ZodType<Schema2ReasoningEncrypted, unknown>;
+/** @internal */
+export type Schema2ReasoningEncrypted$Outbound = {
+    type: "reasoning.encrypted";
+    data: string;
+    id?: string | null | undefined;
+    format?: string | null | undefined;
+    index?: number | undefined;
+};
+/** @internal */
+export declare const Schema2ReasoningEncrypted$outboundSchema: z.ZodType<Schema2ReasoningEncrypted$Outbound, Schema2ReasoningEncrypted>;
+export declare function schema2ReasoningEncryptedToJSON(schema2ReasoningEncrypted: Schema2ReasoningEncrypted): string;
+export declare function schema2ReasoningEncryptedFromJSON(jsonString: string): SafeParseResult<Schema2ReasoningEncrypted, SDKValidationError>;
+/** @internal */
+export declare const Schema2ReasoningSummary$inboundSchema: z.ZodType<Schema2ReasoningSummary, unknown>;
+/** @internal */
+export type Schema2ReasoningSummary$Outbound = {
+    type: "reasoning.summary";
+    summary: string;
+    id?: string | null | undefined;
+    format?: string | null | undefined;
+    index?: number | undefined;
+};
+/** @internal */
+export declare const Schema2ReasoningSummary$outboundSchema: z.ZodType<Schema2ReasoningSummary$Outbound, Schema2ReasoningSummary>;
+export declare function schema2ReasoningSummaryToJSON(schema2ReasoningSummary: Schema2ReasoningSummary): string;
+export declare function schema2ReasoningSummaryFromJSON(jsonString: string): SafeParseResult<Schema2ReasoningSummary, SDKValidationError>;
+/** @internal */
+export declare const Schema2$inboundSchema: z.ZodType<Schema2, unknown>;
+/** @internal */
+export type Schema2$Outbound = Schema2ReasoningSummary$Outbound | Schema2ReasoningEncrypted$Outbound | Schema2ReasoningText$Outbound;
+/** @internal */
+export declare const Schema2$outboundSchema: z.ZodType<Schema2$Outbound, Schema2>;
+export declare function schema2ToJSON(schema2: Schema2): string;
+export declare function schema2FromJSON(jsonString: string): SafeParseResult<Schema2, SDKValidationError>;
+//# sourceMappingURL=schema2.d.ts.map

package/esm/models/schema2.js

@@ -0,0 +1,109 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ * @generated-id: f5d5abd15e27
+ */
+import * as z from "zod/v4";
+import { safeParse } from "../lib/schemas.js";
+import * as openEnums from "../types/enums.js";
+export const Schema4 = {
+    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 Schema4$inboundSchema = openEnums
+    .inboundSchema(Schema4);
+/** @internal */
+export const Schema4$outboundSchema = openEnums
+    .outboundSchema(Schema4);
+/** @internal */
+export const Schema2ReasoningText$inboundSchema = z.object({
+    type: z.literal("reasoning.text"),
+    text: z.nullable(z.string()).optional(),
+    signature: z.nullable(z.string()).optional(),
+    id: z.nullable(z.string()).optional(),
+    format: z.nullable(Schema4$inboundSchema).optional(),
+    index: z.number().optional(),
+});
+/** @internal */
+export const Schema2ReasoningText$outboundSchema = z.object({
+    type: z.literal("reasoning.text"),
+    text: z.nullable(z.string()).optional(),
+    signature: z.nullable(z.string()).optional(),
+    id: z.nullable(z.string()).optional(),
+    format: z.nullable(Schema4$outboundSchema).optional(),
+    index: z.number().optional(),
+});
+export function schema2ReasoningTextToJSON(schema2ReasoningText) {
+    return JSON.stringify(Schema2ReasoningText$outboundSchema.parse(schema2ReasoningText));
+}
+export function schema2ReasoningTextFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => Schema2ReasoningText$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'Schema2ReasoningText' from JSON`);
+}
+/** @internal */
+export const Schema2ReasoningEncrypted$inboundSchema = z.object({
+    type: z.literal("reasoning.encrypted"),
+    data: z.string(),
+    id: z.nullable(z.string()).optional(),
+    format: z.nullable(Schema4$inboundSchema).optional(),
+    index: z.number().optional(),
+});
+/** @internal */
+export const Schema2ReasoningEncrypted$outboundSchema = z.object({
+    type: z.literal("reasoning.encrypted"),
+    data: z.string(),
+    id: z.nullable(z.string()).optional(),
+    format: z.nullable(Schema4$outboundSchema).optional(),
+    index: z.number().optional(),
+});
+export function schema2ReasoningEncryptedToJSON(schema2ReasoningEncrypted) {
+    return JSON.stringify(Schema2ReasoningEncrypted$outboundSchema.parse(schema2ReasoningEncrypted));
+}
+export function schema2ReasoningEncryptedFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => Schema2ReasoningEncrypted$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'Schema2ReasoningEncrypted' from JSON`);
+}
+/** @internal */
+export const Schema2ReasoningSummary$inboundSchema = z.object({
+    type: z.literal("reasoning.summary"),
+    summary: z.string(),
+    id: z.nullable(z.string()).optional(),
+    format: z.nullable(Schema4$inboundSchema).optional(),
+    index: z.number().optional(),
+});
+/** @internal */
+export const Schema2ReasoningSummary$outboundSchema = z.object({
+    type: z.literal("reasoning.summary"),
+    summary: z.string(),
+    id: z.nullable(z.string()).optional(),
+    format: z.nullable(Schema4$outboundSchema).optional(),
+    index: z.number().optional(),
+});
+export function schema2ReasoningSummaryToJSON(schema2ReasoningSummary) {
+    return JSON.stringify(Schema2ReasoningSummary$outboundSchema.parse(schema2ReasoningSummary));
+}
+export function schema2ReasoningSummaryFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => Schema2ReasoningSummary$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'Schema2ReasoningSummary' from JSON`);
+}
+/** @internal */
+export const Schema2$inboundSchema = z.union([
+    z.lazy(() => Schema2ReasoningSummary$inboundSchema),
+    z.lazy(() => Schema2ReasoningEncrypted$inboundSchema),
+    z.lazy(() => Schema2ReasoningText$inboundSchema),
+]);
+/** @internal */
+export const Schema2$outboundSchema = z
+    .union([
+    z.lazy(() => Schema2ReasoningSummary$outboundSchema),
+    z.lazy(() => Schema2ReasoningEncrypted$outboundSchema),
+    z.lazy(() => Schema2ReasoningText$outboundSchema),
+]);
+export function schema2ToJSON(schema2) {
+    return JSON.stringify(Schema2$outboundSchema.parse(schema2));
+}
+export function schema2FromJSON(jsonString) {
+    return safeParse(jsonString, (x) => Schema2$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'Schema2' from JSON`);
+}
+//# sourceMappingURL=schema2.js.map

package/esm/sdk/analytics.d.ts

@@ -5,7 +5,7 @@ export declare class Analytics extends ClientSDK {
      * Get user activity grouped by endpoint
      *
      * @remarks
-     * Returns user activity data grouped by endpoint for the last 30 (completed) UTC days
+     * Returns user activity data grouped by endpoint for the last 30 (completed) UTC days. [Provisioning key](/docs/guides/overview/auth/provisioning-api-keys) required.
      */
     getUserActivity(request?: operations.GetUserActivityRequest | undefined, options?: RequestOptions): Promise<operations.GetUserActivityResponse>;
 }

package/esm/sdk/analytics.js

@@ -10,7 +10,7 @@ export class Analytics extends ClientSDK {
      * Get user activity grouped by endpoint
      *
      * @remarks
-     * Returns user activity data grouped by endpoint for the last 30 (completed) UTC days
+     * Returns user activity data grouped by endpoint for the last 30 (completed) UTC days. [Provisioning key](/docs/guides/overview/auth/provisioning-api-keys) required.
      */
     async getUserActivity(request, options) {
         return unwrapAsync(analyticsGetUserActivity(this, request, options));

package/esm/sdk/apikeys.d.ts

@@ -3,22 +3,37 @@ import * as operations from "../models/operations/index.js";
 export declare class APIKeys extends ClientSDK {
     /**
      * List API keys
+     *
+     * @remarks
+     * List all API keys for the authenticated user. [Provisioning key](/docs/guides/overview/auth/provisioning-api-keys) required.
      */
     list(request?: operations.ListRequest | undefined, options?: RequestOptions): Promise<operations.ListResponse>;
     /**
      * Create a new API key
+     *
+     * @remarks
+     * Create a new API key for the authenticated user. [Provisioning key](/docs/guides/overview/auth/provisioning-api-keys) required.
      */
     create(request: operations.CreateKeysRequest, options?: RequestOptions): Promise<operations.CreateKeysResponse>;
     /**
      * Update an API key
+     *
+     * @remarks
+     * Update an existing API key. [Provisioning key](/docs/guides/overview/auth/provisioning-api-keys) required.
      */
     update(request: operations.UpdateKeysRequest, options?: RequestOptions): Promise<operations.UpdateKeysResponse>;
     /**
      * Delete an API key
+     *
+     * @remarks
+     * Delete an existing API key. [Provisioning key](/docs/guides/overview/auth/provisioning-api-keys) required.
      */
     delete(request: operations.DeleteKeysRequest, options?: RequestOptions): Promise<operations.DeleteKeysResponse>;
     /**
      * Get a single API key
+     *
+     * @remarks
+     * Get a single API key by hash. [Provisioning key](/docs/guides/overview/auth/provisioning-api-keys) required.
      */
     get(request: operations.GetKeyRequest, options?: RequestOptions): Promise<operations.GetKeyResponse>;
     /**

package/esm/sdk/apikeys.js

@@ -13,30 +13,45 @@ import { unwrapAsync } from "../types/fp.js";
 export class APIKeys extends ClientSDK {
     /**
      * List API keys
+     *
+     * @remarks
+     * List all API keys for the authenticated user. [Provisioning key](/docs/guides/overview/auth/provisioning-api-keys) required.
      */
     async list(request, options) {
         return unwrapAsync(apiKeysList(this, request, options));
     }
     /**
      * Create a new API key
+     *
+     * @remarks
+     * Create a new API key for the authenticated user. [Provisioning key](/docs/guides/overview/auth/provisioning-api-keys) required.
      */
     async create(request, options) {
         return unwrapAsync(apiKeysCreate(this, request, options));
     }
     /**
      * Update an API key
+     *
+     * @remarks
+     * Update an existing API key. [Provisioning key](/docs/guides/overview/auth/provisioning-api-keys) required.
      */
     async update(request, options) {
         return unwrapAsync(apiKeysUpdate(this, request, options));
     }
     /**
      * Delete an API key
+     *
+     * @remarks
+     * Delete an existing API key. [Provisioning key](/docs/guides/overview/auth/provisioning-api-keys) required.
      */
     async delete(request, options) {
         return unwrapAsync(apiKeysDelete(this, request, options));
     }
     /**
      * Get a single API key
+     *
+     * @remarks
+     * Get a single API key by hash. [Provisioning key](/docs/guides/overview/auth/provisioning-api-keys) required.
      */
     async get(request, options) {
         return unwrapAsync(apiKeysGet(this, request, options));

package/esm/sdk/credits.d.ts

@@ -6,7 +6,7 @@ export declare class Credits extends ClientSDK {
      * Get remaining credits
      *
      * @remarks
-     * Get total credits purchased and used for the authenticated user
+     * Get total credits purchased and used for the authenticated user. [Provisioning key](/docs/guides/overview/auth/provisioning-api-keys) required.
      */
     getCredits(options?: RequestOptions): Promise<operations.GetCreditsResponse>;
     /**

package/esm/sdk/credits.js

@@ -11,7 +11,7 @@ export class Credits extends ClientSDK {
      * Get remaining credits
      *
      * @remarks
-     * Get total credits purchased and used for the authenticated user
+     * Get total credits purchased and used for the authenticated user. [Provisioning key](/docs/guides/overview/auth/provisioning-api-keys) required.
      */
     async getCredits(options) {
         return unwrapAsync(creditsGetCredits(this, options));