@openrouter/sdk 0.11.2 → 0.12.1

package/esm/models/outputmessage.js

@@ -4,14 +4,18 @@
  */
 import * as z from "zod/v4";
 import { safeParse } from "../lib/schemas.js";
+import { discriminatedUnion } from "../types/discriminatedUnion.js";
 import { OpenAIResponsesRefusalContent$inboundSchema, } from "./openairesponsesrefusalcontent.js";
 import { ResponseOutputText$inboundSchema, } from "./responseoutputtext.js";
+export const OutputMessagePhaseFinalAnswer = {
+    FinalAnswer: "final_answer",
+};
+export const OutputMessagePhaseCommentary = {
+    Commentary: "commentary",
+};
 export const OutputMessageRole = {
     Assistant: "assistant",
 };
-export const OutputMessageType = {
-    Message: "message",
-};
 export const OutputMessageStatusInProgress = {
     InProgress: "in_progress",
 };
@@ -21,16 +25,32 @@ export const OutputMessageStatusIncomplete = {
 export const OutputMessageStatusCompleted = {
     Completed: "completed",
 };
-export const OutputMessagePhaseFinalAnswer = {
-    FinalAnswer: "final_answer",
-};
-export const OutputMessagePhaseCommentary = {
-    Commentary: "commentary",
+export const OutputMessageType = {
+    Message: "message",
 };
 /** @internal */
-export const OutputMessageRole$inboundSchema = z.enum(OutputMessageRole);
+export const OutputMessageContent$inboundSchema = discriminatedUnion("type", {
+    output_text: ResponseOutputText$inboundSchema,
+    refusal: OpenAIResponsesRefusalContent$inboundSchema,
+});
+export function outputMessageContentFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => OutputMessageContent$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'OutputMessageContent' from JSON`);
+}
 /** @internal */
-export const OutputMessageType$inboundSchema = z.enum(OutputMessageType);
+export const OutputMessagePhaseFinalAnswer$inboundSchema = z.enum(OutputMessagePhaseFinalAnswer);
+/** @internal */
+export const OutputMessagePhaseCommentary$inboundSchema = z.enum(OutputMessagePhaseCommentary);
+/** @internal */
+export const OutputMessagePhaseUnion$inboundSchema = z.union([
+    OutputMessagePhaseCommentary$inboundSchema,
+    OutputMessagePhaseFinalAnswer$inboundSchema,
+    z.any(),
+]);
+export function outputMessagePhaseUnionFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => OutputMessagePhaseUnion$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'OutputMessagePhaseUnion' from JSON`);
+}
+/** @internal */
+export const OutputMessageRole$inboundSchema = z.enum(OutputMessageRole);
 /** @internal */
 export const OutputMessageStatusInProgress$inboundSchema = z.enum(OutputMessageStatusInProgress);
 /** @internal */
@@ -47,46 +67,27 @@ export function outputMessageStatusUnionFromJSON(jsonString) {
     return safeParse(jsonString, (x) => OutputMessageStatusUnion$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'OutputMessageStatusUnion' from JSON`);
 }
 /** @internal */
-export const OutputMessageContent$inboundSchema = z.union([
-    ResponseOutputText$inboundSchema,
-    OpenAIResponsesRefusalContent$inboundSchema,
-]);
-export function outputMessageContentFromJSON(jsonString) {
-    return safeParse(jsonString, (x) => OutputMessageContent$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'OutputMessageContent' from JSON`);
-}
-/** @internal */
-export const OutputMessagePhaseFinalAnswer$inboundSchema = z.enum(OutputMessagePhaseFinalAnswer);
-/** @internal */
-export const OutputMessagePhaseCommentary$inboundSchema = z.enum(OutputMessagePhaseCommentary);
-/** @internal */
-export const OutputMessagePhaseUnion$inboundSchema = z.union([
-    OutputMessagePhaseCommentary$inboundSchema,
-    OutputMessagePhaseFinalAnswer$inboundSchema,
-    z.any(),
-]);
-export function outputMessagePhaseUnionFromJSON(jsonString) {
-    return safeParse(jsonString, (x) => OutputMessagePhaseUnion$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'OutputMessagePhaseUnion' from JSON`);
-}
+export const OutputMessageType$inboundSchema = z.enum(OutputMessageType);
 /** @internal */
 export const OutputMessage$inboundSchema = z
     .object({
+    content: z.array(discriminatedUnion("type", {
+        output_text: ResponseOutputText$inboundSchema,
+        refusal: OpenAIResponsesRefusalContent$inboundSchema,
+    })),
     id: z.string(),
+    phase: z.nullable(z.union([
+        OutputMessagePhaseCommentary$inboundSchema,
+        OutputMessagePhaseFinalAnswer$inboundSchema,
+        z.any(),
+    ])).optional(),
     role: OutputMessageRole$inboundSchema,
-    type: OutputMessageType$inboundSchema,
     status: z.union([
         OutputMessageStatusCompleted$inboundSchema,
         OutputMessageStatusIncomplete$inboundSchema,
         OutputMessageStatusInProgress$inboundSchema,
     ]).optional(),
-    content: z.array(z.union([
-        ResponseOutputText$inboundSchema,
-        OpenAIResponsesRefusalContent$inboundSchema,
-    ])),
-    phase: z.nullable(z.union([
-        OutputMessagePhaseCommentary$inboundSchema,
-        OutputMessagePhaseFinalAnswer$inboundSchema,
-        z.any(),
-    ])).optional(),
+    type: OutputMessageType$inboundSchema,
 });
 export function outputMessageFromJSON(jsonString) {
     return safeParse(jsonString, (x) => OutputMessage$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'OutputMessage' from JSON`);

package/esm/models/outputmessageitem.d.ts

@@ -1,17 +1,27 @@
 import * as z from "zod/v4";
+import * as discriminatedUnionTypes from "../types/discriminatedUnion.js";
 import { ClosedEnum } from "../types/enums.js";
 import { Result as SafeParseResult } from "../types/fp.js";
 import { SDKValidationError } from "./errors/sdkvalidationerror.js";
 import { OpenAIResponsesRefusalContent } from "./openairesponsesrefusalcontent.js";
 import { ResponseOutputText } from "./responseoutputtext.js";
+export type OutputMessageItemContent = ResponseOutputText | OpenAIResponsesRefusalContent | discriminatedUnionTypes.Unknown<"type">;
+export declare const OutputMessageItemPhaseFinalAnswer: {
+    readonly FinalAnswer: "final_answer";
+};
+export type OutputMessageItemPhaseFinalAnswer = ClosedEnum<typeof OutputMessageItemPhaseFinalAnswer>;
+export declare const OutputMessageItemPhaseCommentary: {
+    readonly Commentary: "commentary";
+};
+export type OutputMessageItemPhaseCommentary = ClosedEnum<typeof OutputMessageItemPhaseCommentary>;
+/**
+ * The phase of an assistant message. Use `commentary` for an intermediate assistant message and `final_answer` for the final assistant message. For follow-up requests with models like `gpt-5.3-codex` and later, preserve and resend phase on all assistant messages. Omitting it can degrade performance. Not used for user messages.
+ */
+export type OutputMessageItemPhaseUnion = OutputMessageItemPhaseCommentary | OutputMessageItemPhaseFinalAnswer | any;
 export declare const OutputMessageItemRole: {
     readonly Assistant: "assistant";
 };
 export type OutputMessageItemRole = ClosedEnum<typeof OutputMessageItemRole>;
-export declare const OutputMessageItemType: {
-    readonly Message: "message";
-};
-export type OutputMessageItemType = ClosedEnum<typeof OutputMessageItemType>;
 export declare const OutputMessageItemStatusInProgress: {
     readonly InProgress: "in_progress";
 };
@@ -25,37 +35,32 @@ export declare const OutputMessageItemStatusCompleted: {
 };
 export type OutputMessageItemStatusCompleted = ClosedEnum<typeof OutputMessageItemStatusCompleted>;
 export type OutputMessageItemStatusUnion = OutputMessageItemStatusCompleted | OutputMessageItemStatusIncomplete | OutputMessageItemStatusInProgress;
-export type OutputMessageItemContent = ResponseOutputText | OpenAIResponsesRefusalContent;
-export declare const OutputMessageItemPhaseFinalAnswer: {
-    readonly FinalAnswer: "final_answer";
-};
-export type OutputMessageItemPhaseFinalAnswer = ClosedEnum<typeof OutputMessageItemPhaseFinalAnswer>;
-export declare const OutputMessageItemPhaseCommentary: {
-    readonly Commentary: "commentary";
-};
-export type OutputMessageItemPhaseCommentary = ClosedEnum<typeof OutputMessageItemPhaseCommentary>;
-/**
- * The phase of an assistant message. Use `commentary` for an intermediate assistant message and `final_answer` for the final assistant message. For follow-up requests with models like `gpt-5.3-codex` and later, preserve and resend phase on all assistant messages. Omitting it can degrade performance. Not used for user messages.
- */
-export type OutputMessageItemPhaseUnion = OutputMessageItemPhaseCommentary | OutputMessageItemPhaseFinalAnswer | any;
 /**
  * An output message item
  */
 export type OutputMessageItem = {
+    content: Array<ResponseOutputText | OpenAIResponsesRefusalContent | discriminatedUnionTypes.Unknown<"type">>;
     id: string;
-    role: OutputMessageItemRole;
-    type: OutputMessageItemType;
-    status?: OutputMessageItemStatusCompleted | OutputMessageItemStatusIncomplete | OutputMessageItemStatusInProgress | undefined;
-    content: Array<ResponseOutputText | OpenAIResponsesRefusalContent>;
     /**
      * The phase of an assistant message. Use `commentary` for an intermediate assistant message and `final_answer` for the final assistant message. For follow-up requests with models like `gpt-5.3-codex` and later, preserve and resend phase on all assistant messages. Omitting it can degrade performance. Not used for user messages.
      */
     phase?: OutputMessageItemPhaseCommentary | OutputMessageItemPhaseFinalAnswer | any | null | undefined;
+    role: OutputMessageItemRole;
+    status?: OutputMessageItemStatusCompleted | OutputMessageItemStatusIncomplete | OutputMessageItemStatusInProgress | undefined;
+    type: "message";
 };
 /** @internal */
-export declare const OutputMessageItemRole$inboundSchema: z.ZodEnum<typeof OutputMessageItemRole>;
+export declare const OutputMessageItemContent$inboundSchema: z.ZodType<OutputMessageItemContent, unknown>;
+export declare function outputMessageItemContentFromJSON(jsonString: string): SafeParseResult<OutputMessageItemContent, SDKValidationError>;
 /** @internal */
-export declare const OutputMessageItemType$inboundSchema: z.ZodEnum<typeof OutputMessageItemType>;
+export declare const OutputMessageItemPhaseFinalAnswer$inboundSchema: z.ZodEnum<typeof OutputMessageItemPhaseFinalAnswer>;
+/** @internal */
+export declare const OutputMessageItemPhaseCommentary$inboundSchema: z.ZodEnum<typeof OutputMessageItemPhaseCommentary>;
+/** @internal */
+export declare const OutputMessageItemPhaseUnion$inboundSchema: z.ZodType<OutputMessageItemPhaseUnion, unknown>;
+export declare function outputMessageItemPhaseUnionFromJSON(jsonString: string): SafeParseResult<OutputMessageItemPhaseUnion, SDKValidationError>;
+/** @internal */
+export declare const OutputMessageItemRole$inboundSchema: z.ZodEnum<typeof OutputMessageItemRole>;
 /** @internal */
 export declare const OutputMessageItemStatusInProgress$inboundSchema: z.ZodEnum<typeof OutputMessageItemStatusInProgress>;
 /** @internal */
@@ -66,16 +71,6 @@ export declare const OutputMessageItemStatusCompleted$inboundSchema: z.ZodEnum<t
 export declare const OutputMessageItemStatusUnion$inboundSchema: z.ZodType<OutputMessageItemStatusUnion, unknown>;
 export declare function outputMessageItemStatusUnionFromJSON(jsonString: string): SafeParseResult<OutputMessageItemStatusUnion, SDKValidationError>;
 /** @internal */
-export declare const OutputMessageItemContent$inboundSchema: z.ZodType<OutputMessageItemContent, unknown>;
-export declare function outputMessageItemContentFromJSON(jsonString: string): SafeParseResult<OutputMessageItemContent, SDKValidationError>;
-/** @internal */
-export declare const OutputMessageItemPhaseFinalAnswer$inboundSchema: z.ZodEnum<typeof OutputMessageItemPhaseFinalAnswer>;
-/** @internal */
-export declare const OutputMessageItemPhaseCommentary$inboundSchema: z.ZodEnum<typeof OutputMessageItemPhaseCommentary>;
-/** @internal */
-export declare const OutputMessageItemPhaseUnion$inboundSchema: z.ZodType<OutputMessageItemPhaseUnion, unknown>;
-export declare function outputMessageItemPhaseUnionFromJSON(jsonString: string): SafeParseResult<OutputMessageItemPhaseUnion, SDKValidationError>;
-/** @internal */
 export declare const OutputMessageItem$inboundSchema: z.ZodType<OutputMessageItem, unknown>;
 export declare function outputMessageItemFromJSON(jsonString: string): SafeParseResult<OutputMessageItem, SDKValidationError>;
 //# sourceMappingURL=outputmessageitem.d.ts.map

package/esm/models/outputmessageitem.js

@@ -4,14 +4,18 @@
  */
 import * as z from "zod/v4";
 import { safeParse } from "../lib/schemas.js";
+import { discriminatedUnion } from "../types/discriminatedUnion.js";
 import { OpenAIResponsesRefusalContent$inboundSchema, } from "./openairesponsesrefusalcontent.js";
 import { ResponseOutputText$inboundSchema, } from "./responseoutputtext.js";
+export const OutputMessageItemPhaseFinalAnswer = {
+    FinalAnswer: "final_answer",
+};
+export const OutputMessageItemPhaseCommentary = {
+    Commentary: "commentary",
+};
 export const OutputMessageItemRole = {
     Assistant: "assistant",
 };
-export const OutputMessageItemType = {
-    Message: "message",
-};
 export const OutputMessageItemStatusInProgress = {
     InProgress: "in_progress",
 };
@@ -21,36 +25,11 @@ export const OutputMessageItemStatusIncomplete = {
 export const OutputMessageItemStatusCompleted = {
     Completed: "completed",
 };
-export const OutputMessageItemPhaseFinalAnswer = {
-    FinalAnswer: "final_answer",
-};
-export const OutputMessageItemPhaseCommentary = {
-    Commentary: "commentary",
-};
-/** @internal */
-export const OutputMessageItemRole$inboundSchema = z.enum(OutputMessageItemRole);
-/** @internal */
-export const OutputMessageItemType$inboundSchema = z.enum(OutputMessageItemType);
-/** @internal */
-export const OutputMessageItemStatusInProgress$inboundSchema = z.enum(OutputMessageItemStatusInProgress);
-/** @internal */
-export const OutputMessageItemStatusIncomplete$inboundSchema = z.enum(OutputMessageItemStatusIncomplete);
-/** @internal */
-export const OutputMessageItemStatusCompleted$inboundSchema = z.enum(OutputMessageItemStatusCompleted);
-/** @internal */
-export const OutputMessageItemStatusUnion$inboundSchema = z.union([
-    OutputMessageItemStatusCompleted$inboundSchema,
-    OutputMessageItemStatusIncomplete$inboundSchema,
-    OutputMessageItemStatusInProgress$inboundSchema,
-]);
-export function outputMessageItemStatusUnionFromJSON(jsonString) {
-    return safeParse(jsonString, (x) => OutputMessageItemStatusUnion$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'OutputMessageItemStatusUnion' from JSON`);
-}
 /** @internal */
-export const OutputMessageItemContent$inboundSchema = z.union([
-    ResponseOutputText$inboundSchema,
-    OpenAIResponsesRefusalContent$inboundSchema,
-]);
+export const OutputMessageItemContent$inboundSchema = discriminatedUnion("type", {
+    output_text: ResponseOutputText$inboundSchema,
+    refusal: OpenAIResponsesRefusalContent$inboundSchema,
+});
 export function outputMessageItemContentFromJSON(jsonString) {
     return safeParse(jsonString, (x) => OutputMessageItemContent$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'OutputMessageItemContent' from JSON`);
 }
@@ -68,24 +47,41 @@ export function outputMessageItemPhaseUnionFromJSON(jsonString) {
     return safeParse(jsonString, (x) => OutputMessageItemPhaseUnion$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'OutputMessageItemPhaseUnion' from JSON`);
 }
 /** @internal */
+export const OutputMessageItemRole$inboundSchema = z.enum(OutputMessageItemRole);
+/** @internal */
+export const OutputMessageItemStatusInProgress$inboundSchema = z.enum(OutputMessageItemStatusInProgress);
+/** @internal */
+export const OutputMessageItemStatusIncomplete$inboundSchema = z.enum(OutputMessageItemStatusIncomplete);
+/** @internal */
+export const OutputMessageItemStatusCompleted$inboundSchema = z.enum(OutputMessageItemStatusCompleted);
+/** @internal */
+export const OutputMessageItemStatusUnion$inboundSchema = z.union([
+    OutputMessageItemStatusCompleted$inboundSchema,
+    OutputMessageItemStatusIncomplete$inboundSchema,
+    OutputMessageItemStatusInProgress$inboundSchema,
+]);
+export function outputMessageItemStatusUnionFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => OutputMessageItemStatusUnion$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'OutputMessageItemStatusUnion' from JSON`);
+}
+/** @internal */
 export const OutputMessageItem$inboundSchema = z.object({
+    content: z.array(discriminatedUnion("type", {
+        output_text: ResponseOutputText$inboundSchema,
+        refusal: OpenAIResponsesRefusalContent$inboundSchema,
+    })),
     id: z.string(),
+    phase: z.nullable(z.union([
+        OutputMessageItemPhaseCommentary$inboundSchema,
+        OutputMessageItemPhaseFinalAnswer$inboundSchema,
+        z.any(),
+    ])).optional(),
     role: OutputMessageItemRole$inboundSchema,
-    type: OutputMessageItemType$inboundSchema,
     status: z.union([
         OutputMessageItemStatusCompleted$inboundSchema,
         OutputMessageItemStatusIncomplete$inboundSchema,
         OutputMessageItemStatusInProgress$inboundSchema,
     ]).optional(),
-    content: z.array(z.union([
-        ResponseOutputText$inboundSchema,
-        OpenAIResponsesRefusalContent$inboundSchema,
-    ])),
-    phase: z.nullable(z.union([
-        OutputMessageItemPhaseCommentary$inboundSchema,
-        OutputMessageItemPhaseFinalAnswer$inboundSchema,
-        z.any(),
-    ])).optional(),
+    type: z.literal("message"),
 });
 export function outputMessageItemFromJSON(jsonString) {
     return safeParse(jsonString, (x) => OutputMessageItem$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'OutputMessageItem' from JSON`);

package/esm/models/outputmodality.d.ts

@@ -6,6 +6,7 @@ export declare const OutputModality: {
     readonly Embeddings: "embeddings";
     readonly Audio: "audio";
     readonly Video: "video";
+    readonly Rerank: "rerank";
 };
 export type OutputModality = OpenEnum<typeof OutputModality>;
 /** @internal */

package/esm/models/outputmodality.js

@@ -9,6 +9,7 @@ export const OutputModality = {
     Embeddings: "embeddings",
     Audio: "audio",
     Video: "video",
+    Rerank: "rerank",
 };
 /** @internal */
 export const OutputModality$inboundSchema = openEnums.inboundSchema(OutputModality);

package/esm/models/outputreasoningitem.d.ts

@@ -1,13 +1,10 @@
 import * as z from "zod/v4";
-import { ClosedEnum, OpenEnum } from "../types/enums.js";
+import { ClosedEnum } from "../types/enums.js";
 import { Result as SafeParseResult } from "../types/fp.js";
 import { SDKValidationError } from "./errors/sdkvalidationerror.js";
+import { ReasoningFormat } from "./reasoningformat.js";
 import { ReasoningSummaryText } from "./reasoningsummarytext.js";
 import { ReasoningTextContent } from "./reasoningtextcontent.js";
-export declare const OutputReasoningItemType: {
-    readonly Reasoning: "reasoning";
-};
-export type OutputReasoningItemType = ClosedEnum<typeof OutputReasoningItemType>;
 export declare const OutputReasoningItemStatusInProgress: {
     readonly InProgress: "in_progress";
 };
@@ -21,43 +18,23 @@ export declare const OutputReasoningItemStatusCompleted: {
 };
 export type OutputReasoningItemStatusCompleted = ClosedEnum<typeof OutputReasoningItemStatusCompleted>;
 export type OutputReasoningItemStatusUnion = OutputReasoningItemStatusCompleted | OutputReasoningItemStatusIncomplete | OutputReasoningItemStatusInProgress;
-/**
- * The format of the reasoning content
- */
-export declare const OutputReasoningItemFormat: {
-    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 OutputReasoningItemFormat = OpenEnum<typeof OutputReasoningItemFormat>;
 /**
  * An output item containing reasoning
  */
 export type OutputReasoningItem = {
-    type: OutputReasoningItemType;
-    id: string;
     content?: Array<ReasoningTextContent> | null | undefined;
-    summary: Array<ReasoningSummaryText>;
     encryptedContent?: string | null | undefined;
+    id: string;
     status?: OutputReasoningItemStatusCompleted | OutputReasoningItemStatusIncomplete | OutputReasoningItemStatusInProgress | undefined;
+    summary: Array<ReasoningSummaryText>;
+    type: "reasoning";
+    format?: ReasoningFormat | null | undefined;
     /**
      * A signature for the reasoning content, used for verification
      */
     signature?: string | null | undefined;
-    /**
-     * The format of the reasoning content
-     */
-    format?: OutputReasoningItemFormat | null | undefined;
 };
 /** @internal */
-export declare const OutputReasoningItemType$inboundSchema: z.ZodEnum<typeof OutputReasoningItemType>;
-/** @internal */
 export declare const OutputReasoningItemStatusInProgress$inboundSchema: z.ZodEnum<typeof OutputReasoningItemStatusInProgress>;
 /** @internal */
 export declare const OutputReasoningItemStatusIncomplete$inboundSchema: z.ZodEnum<typeof OutputReasoningItemStatusIncomplete>;
@@ -67,8 +44,6 @@ export declare const OutputReasoningItemStatusCompleted$inboundSchema: z.ZodEnum
 export declare const OutputReasoningItemStatusUnion$inboundSchema: z.ZodType<OutputReasoningItemStatusUnion, unknown>;
 export declare function outputReasoningItemStatusUnionFromJSON(jsonString: string): SafeParseResult<OutputReasoningItemStatusUnion, SDKValidationError>;
 /** @internal */
-export declare const OutputReasoningItemFormat$inboundSchema: z.ZodType<OutputReasoningItemFormat, unknown>;
-/** @internal */
 export declare const OutputReasoningItem$inboundSchema: z.ZodType<OutputReasoningItem, unknown>;
 export declare function outputReasoningItemFromJSON(jsonString: string): SafeParseResult<OutputReasoningItem, SDKValidationError>;
 //# sourceMappingURL=outputreasoningitem.d.ts.map

package/esm/models/outputreasoningitem.js

@@ -5,12 +5,9 @@
 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 { ReasoningFormat$inboundSchema, } from "./reasoningformat.js";
 import { ReasoningSummaryText$inboundSchema, } from "./reasoningsummarytext.js";
 import { ReasoningTextContent$inboundSchema, } from "./reasoningtextcontent.js";
-export const OutputReasoningItemType = {
-    Reasoning: "reasoning",
-};
 export const OutputReasoningItemStatusInProgress = {
     InProgress: "in_progress",
 };
@@ -20,19 +17,6 @@ export const OutputReasoningItemStatusIncomplete = {
 export const OutputReasoningItemStatusCompleted = {
     Completed: "completed",
 };
-/**
- * The format of the reasoning content
- */
-export const OutputReasoningItemFormat = {
-    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 OutputReasoningItemType$inboundSchema = z.enum(OutputReasoningItemType);
 /** @internal */
 export const OutputReasoningItemStatusInProgress$inboundSchema = z.enum(OutputReasoningItemStatusInProgress);
 /** @internal */
@@ -49,21 +33,19 @@ export function outputReasoningItemStatusUnionFromJSON(jsonString) {
     return safeParse(jsonString, (x) => OutputReasoningItemStatusUnion$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'OutputReasoningItemStatusUnion' from JSON`);
 }
 /** @internal */
-export const OutputReasoningItemFormat$inboundSchema = openEnums.inboundSchema(OutputReasoningItemFormat);
-/** @internal */
 export const OutputReasoningItem$inboundSchema = z.object({
-    type: OutputReasoningItemType$inboundSchema,
-    id: z.string(),
     content: z.nullable(z.array(ReasoningTextContent$inboundSchema)).optional(),
-    summary: z.array(ReasoningSummaryText$inboundSchema),
     encrypted_content: z.nullable(z.string()).optional(),
+    id: z.string(),
     status: z.union([
         OutputReasoningItemStatusCompleted$inboundSchema,
         OutputReasoningItemStatusIncomplete$inboundSchema,
         OutputReasoningItemStatusInProgress$inboundSchema,
     ]).optional(),
+    summary: z.array(ReasoningSummaryText$inboundSchema),
+    type: z.literal("reasoning"),
+    format: z.nullable(ReasoningFormat$inboundSchema).optional(),
     signature: z.nullable(z.string()).optional(),
-    format: z.nullable(OutputReasoningItemFormat$inboundSchema).optional(),
 }).transform((v) => {
     return remap$(v, {
         "encrypted_content": "encryptedContent",

package/esm/models/outputtexteditorservertoolitem.d.ts

@@ -0,0 +1,28 @@
+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";
+import { ToolCallStatus } from "./toolcallstatus.js";
+export declare const Command: {
+    readonly View: "view";
+    readonly Create: "create";
+    readonly StrReplace: "str_replace";
+    readonly Insert: "insert";
+};
+export type Command = OpenEnum<typeof Command>;
+/**
+ * An openrouter:text_editor server tool output item
+ */
+export type OutputTextEditorServerToolItem = {
+    command?: Command | undefined;
+    filePath?: string | undefined;
+    id?: string | undefined;
+    status: ToolCallStatus;
+    type: "openrouter:text_editor";
+};
+/** @internal */
+export declare const Command$inboundSchema: z.ZodType<Command, unknown>;
+/** @internal */
+export declare const OutputTextEditorServerToolItem$inboundSchema: z.ZodType<OutputTextEditorServerToolItem, unknown>;
+export declare function outputTextEditorServerToolItemFromJSON(jsonString: string): SafeParseResult<OutputTextEditorServerToolItem, SDKValidationError>;
+//# sourceMappingURL=outputtexteditorservertoolitem.d.ts.map

package/esm/models/outputtexteditorservertoolitem.js

@@ -0,0 +1,29 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ * @generated-id: 6c55837a703d
+ */
+import * as z from "zod/v4";
+import { safeParse } from "../lib/schemas.js";
+import * as openEnums from "../types/enums.js";
+import { ToolCallStatus$inboundSchema, } from "./toolcallstatus.js";
+export const Command = {
+    View: "view",
+    Create: "create",
+    StrReplace: "str_replace",
+    Insert: "insert",
+};
+/** @internal */
+export const Command$inboundSchema = openEnums
+    .inboundSchema(Command);
+/** @internal */
+export const OutputTextEditorServerToolItem$inboundSchema = z.object({
+    command: Command$inboundSchema.optional(),
+    filePath: z.string().optional(),
+    id: z.string().optional(),
+    status: ToolCallStatus$inboundSchema,
+    type: z.literal("openrouter:text_editor"),
+});
+export function outputTextEditorServerToolItemFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => OutputTextEditorServerToolItem$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'OutputTextEditorServerToolItem' from JSON`);
+}
+//# sourceMappingURL=outputtexteditorservertoolitem.js.map

package/esm/models/outputtoolsearchservertoolitem.d.ts

@@ -0,0 +1,17 @@
+import * as z from "zod/v4";
+import { Result as SafeParseResult } from "../types/fp.js";
+import { SDKValidationError } from "./errors/sdkvalidationerror.js";
+import { ToolCallStatus } from "./toolcallstatus.js";
+/**
+ * An openrouter:tool_search server tool output item
+ */
+export type OutputToolSearchServerToolItem = {
+    id?: string | undefined;
+    query?: string | undefined;
+    status: ToolCallStatus;
+    type: "openrouter:tool_search";
+};
+/** @internal */
+export declare const OutputToolSearchServerToolItem$inboundSchema: z.ZodType<OutputToolSearchServerToolItem, unknown>;
+export declare function outputToolSearchServerToolItemFromJSON(jsonString: string): SafeParseResult<OutputToolSearchServerToolItem, SDKValidationError>;
+//# sourceMappingURL=outputtoolsearchservertoolitem.d.ts.map

package/esm/models/outputtoolsearchservertoolitem.js

@@ -0,0 +1,18 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ * @generated-id: 54b4dacceeab
+ */
+import * as z from "zod/v4";
+import { safeParse } from "../lib/schemas.js";
+import { ToolCallStatus$inboundSchema, } from "./toolcallstatus.js";
+/** @internal */
+export const OutputToolSearchServerToolItem$inboundSchema = z.object({
+    id: z.string().optional(),
+    query: z.string().optional(),
+    status: ToolCallStatus$inboundSchema,
+    type: z.literal("openrouter:tool_search"),
+});
+export function outputToolSearchServerToolItemFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => OutputToolSearchServerToolItem$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'OutputToolSearchServerToolItem' from JSON`);
+}
+//# sourceMappingURL=outputtoolsearchservertoolitem.js.map

package/esm/models/outputwebfetchservertoolitem.d.ts

@@ -0,0 +1,19 @@
+import * as z from "zod/v4";
+import { Result as SafeParseResult } from "../types/fp.js";
+import { SDKValidationError } from "./errors/sdkvalidationerror.js";
+import { ToolCallStatus } from "./toolcallstatus.js";
+/**
+ * An openrouter:web_fetch server tool output item
+ */
+export type OutputWebFetchServerToolItem = {
+    content?: string | undefined;
+    id?: string | undefined;
+    status: ToolCallStatus;
+    title?: string | undefined;
+    type: "openrouter:web_fetch";
+    url?: string | undefined;
+};
+/** @internal */
+export declare const OutputWebFetchServerToolItem$inboundSchema: z.ZodType<OutputWebFetchServerToolItem, unknown>;
+export declare function outputWebFetchServerToolItemFromJSON(jsonString: string): SafeParseResult<OutputWebFetchServerToolItem, SDKValidationError>;
+//# sourceMappingURL=outputwebfetchservertoolitem.d.ts.map

package/esm/models/outputwebfetchservertoolitem.js

@@ -0,0 +1,20 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ * @generated-id: a28b106c9b49
+ */
+import * as z from "zod/v4";
+import { safeParse } from "../lib/schemas.js";
+import { ToolCallStatus$inboundSchema, } from "./toolcallstatus.js";
+/** @internal */
+export const OutputWebFetchServerToolItem$inboundSchema = z.object({
+    content: z.string().optional(),
+    id: z.string().optional(),
+    status: ToolCallStatus$inboundSchema,
+    title: z.string().optional(),
+    type: z.literal("openrouter:web_fetch"),
+    url: z.string().optional(),
+});
+export function outputWebFetchServerToolItemFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => OutputWebFetchServerToolItem$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'OutputWebFetchServerToolItem' from JSON`);
+}
+//# sourceMappingURL=outputwebfetchservertoolitem.js.map