@openrouter/sdk 0.8.0 → 0.10.2

package/esm/models/responsesoutputitemreasoning.d.ts

@@ -2,8 +2,8 @@ import * as z from "zod/v4";
 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";
-import { ReasoningTextContent, ReasoningTextContent$Outbound } from "./reasoningtextcontent.js";
+import { ReasoningSummaryText } from "./reasoningsummarytext.js";
+import { ReasoningTextContent } from "./reasoningtextcontent.js";
 export declare const ResponsesOutputItemReasoningType: {
     readonly Reasoning: "reasoning";
 };
@@ -42,7 +42,7 @@ export type ResponsesOutputItemReasoningFormat = OpenEnum<typeof ResponsesOutput
 export type ResponsesOutputItemReasoning = {
     type: ResponsesOutputItemReasoningType;
     id: string;
-    content?: Array<ReasoningTextContent> | undefined;
+    content?: Array<ReasoningTextContent> | null | undefined;
     summary: Array<ReasoningSummaryText>;
     encryptedContent?: string | null | undefined;
     status?: ResponsesOutputItemReasoningStatusCompleted | ResponsesOutputItemReasoningStatusIncomplete | ResponsesOutputItemReasoningStatusInProgress | undefined;
@@ -58,46 +58,17 @@ export type ResponsesOutputItemReasoning = {
 /** @internal */
 export declare const ResponsesOutputItemReasoningType$inboundSchema: z.ZodEnum<typeof ResponsesOutputItemReasoningType>;
 /** @internal */
-export declare const ResponsesOutputItemReasoningType$outboundSchema: z.ZodEnum<typeof ResponsesOutputItemReasoningType>;
-/** @internal */
 export declare const ResponsesOutputItemReasoningStatusInProgress$inboundSchema: z.ZodEnum<typeof ResponsesOutputItemReasoningStatusInProgress>;
 /** @internal */
-export declare const ResponsesOutputItemReasoningStatusInProgress$outboundSchema: z.ZodEnum<typeof ResponsesOutputItemReasoningStatusInProgress>;
-/** @internal */
 export declare const ResponsesOutputItemReasoningStatusIncomplete$inboundSchema: z.ZodEnum<typeof ResponsesOutputItemReasoningStatusIncomplete>;
 /** @internal */
-export declare const ResponsesOutputItemReasoningStatusIncomplete$outboundSchema: z.ZodEnum<typeof ResponsesOutputItemReasoningStatusIncomplete>;
-/** @internal */
 export declare const ResponsesOutputItemReasoningStatusCompleted$inboundSchema: z.ZodEnum<typeof ResponsesOutputItemReasoningStatusCompleted>;
 /** @internal */
-export declare const ResponsesOutputItemReasoningStatusCompleted$outboundSchema: z.ZodEnum<typeof ResponsesOutputItemReasoningStatusCompleted>;
-/** @internal */
 export declare const ResponsesOutputItemReasoningStatusUnion$inboundSchema: z.ZodType<ResponsesOutputItemReasoningStatusUnion, unknown>;
-/** @internal */
-export type ResponsesOutputItemReasoningStatusUnion$Outbound = string | string | string;
-/** @internal */
-export declare const ResponsesOutputItemReasoningStatusUnion$outboundSchema: z.ZodType<ResponsesOutputItemReasoningStatusUnion$Outbound, ResponsesOutputItemReasoningStatusUnion>;
-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 = {
-    type: string;
-    id: string;
-    content?: Array<ReasoningTextContent$Outbound> | undefined;
-    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>;
-export declare function responsesOutputItemReasoningToJSON(responsesOutputItemReasoning: ResponsesOutputItemReasoning): string;
 export declare function responsesOutputItemReasoningFromJSON(jsonString: string): SafeParseResult<ResponsesOutputItemReasoning, SDKValidationError>;
 //# sourceMappingURL=responsesoutputitemreasoning.d.ts.map

package/esm/models/responsesoutputitemreasoning.js

@@ -6,8 +6,8 @@ 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";
+import { ReasoningSummaryText$inboundSchema, } from "./reasoningsummarytext.js";
+import { ReasoningTextContent$inboundSchema, } from "./reasoningtextcontent.js";
 export const ResponsesOutputItemReasoningType = {
     Reasoning: "reasoning",
 };
@@ -34,46 +34,27 @@ export const ResponsesOutputItemReasoningFormat = {
 /** @internal */
 export const ResponsesOutputItemReasoningType$inboundSchema = z.enum(ResponsesOutputItemReasoningType);
 /** @internal */
-export const ResponsesOutputItemReasoningType$outboundSchema = ResponsesOutputItemReasoningType$inboundSchema;
-/** @internal */
 export const ResponsesOutputItemReasoningStatusInProgress$inboundSchema = z.enum(ResponsesOutputItemReasoningStatusInProgress);
 /** @internal */
-export const ResponsesOutputItemReasoningStatusInProgress$outboundSchema = ResponsesOutputItemReasoningStatusInProgress$inboundSchema;
-/** @internal */
 export const ResponsesOutputItemReasoningStatusIncomplete$inboundSchema = z.enum(ResponsesOutputItemReasoningStatusIncomplete);
 /** @internal */
-export const ResponsesOutputItemReasoningStatusIncomplete$outboundSchema = ResponsesOutputItemReasoningStatusIncomplete$inboundSchema;
-/** @internal */
 export const ResponsesOutputItemReasoningStatusCompleted$inboundSchema = z.enum(ResponsesOutputItemReasoningStatusCompleted);
 /** @internal */
-export const ResponsesOutputItemReasoningStatusCompleted$outboundSchema = ResponsesOutputItemReasoningStatusCompleted$inboundSchema;
-/** @internal */
 export const ResponsesOutputItemReasoningStatusUnion$inboundSchema = z.union([
     ResponsesOutputItemReasoningStatusCompleted$inboundSchema,
     ResponsesOutputItemReasoningStatusIncomplete$inboundSchema,
     ResponsesOutputItemReasoningStatusInProgress$inboundSchema,
 ]);
-/** @internal */
-export const ResponsesOutputItemReasoningStatusUnion$outboundSchema = z.union([
-    ResponsesOutputItemReasoningStatusCompleted$outboundSchema,
-    ResponsesOutputItemReasoningStatusIncomplete$outboundSchema,
-    ResponsesOutputItemReasoningStatusInProgress$outboundSchema,
-]);
-export function responsesOutputItemReasoningStatusUnionToJSON(responsesOutputItemReasoningStatusUnion) {
-    return JSON.stringify(ResponsesOutputItemReasoningStatusUnion$outboundSchema.parse(responsesOutputItemReasoningStatusUnion));
-}
 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(),
-    content: z.array(ReasoningTextContent$inboundSchema).optional(),
+    content: z.nullable(z.array(ReasoningTextContent$inboundSchema)).optional(),
     summary: z.array(ReasoningSummaryText$inboundSchema),
     encrypted_content: z.nullable(z.string()).optional(),
     status: z.union([
@@ -89,29 +70,6 @@ export const ResponsesOutputItemReasoning$inboundSchema = z.object({
         "encrypted_content": "encryptedContent",
     });
 });
-/** @internal */
-export const ResponsesOutputItemReasoning$outboundSchema = z.object({
-    type: ResponsesOutputItemReasoningType$outboundSchema,
-    id: z.string(),
-    content: z.array(ReasoningTextContent$outboundSchema).optional(),
-    summary: z.array(ReasoningSummaryText$outboundSchema),
-    encryptedContent: z.nullable(z.string()).optional(),
-    status: z.union([
-        ResponsesOutputItemReasoningStatusCompleted$outboundSchema,
-        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",
-    });
-});
-export function responsesOutputItemReasoningToJSON(responsesOutputItemReasoning) {
-    return JSON.stringify(ResponsesOutputItemReasoning$outboundSchema.parse(responsesOutputItemReasoning));
-}
 export function responsesOutputItemReasoningFromJSON(jsonString) {
     return safeParse(jsonString, (x) => ResponsesOutputItemReasoning$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'ResponsesOutputItemReasoning' from JSON`);
 }

package/esm/models/responsesoutputmessage.d.ts

@@ -2,8 +2,8 @@ import * as z from "zod/v4";
 import { ClosedEnum } from "../types/enums.js";
 import { Result as SafeParseResult } from "../types/fp.js";
 import { SDKValidationError } from "./errors/sdkvalidationerror.js";
-import { OpenAIResponsesRefusalContent, OpenAIResponsesRefusalContent$Outbound } from "./openairesponsesrefusalcontent.js";
-import { ResponseOutputText, ResponseOutputText$Outbound } from "./responseoutputtext.js";
+import { OpenAIResponsesRefusalContent } from "./openairesponsesrefusalcontent.js";
+import { ResponseOutputText } from "./responseoutputtext.js";
 export declare const ResponsesOutputMessageRole: {
     readonly Assistant: "assistant";
 };
@@ -26,6 +26,18 @@ export declare const ResponsesOutputMessageStatusCompleted: {
 export type ResponsesOutputMessageStatusCompleted = ClosedEnum<typeof ResponsesOutputMessageStatusCompleted>;
 export type ResponsesOutputMessageStatusUnion = ResponsesOutputMessageStatusCompleted | ResponsesOutputMessageStatusIncomplete | ResponsesOutputMessageStatusInProgress;
 export type ResponsesOutputMessageContent = ResponseOutputText | OpenAIResponsesRefusalContent;
+export declare const ResponsesOutputMessagePhaseFinalAnswer: {
+    readonly FinalAnswer: "final_answer";
+};
+export type ResponsesOutputMessagePhaseFinalAnswer = ClosedEnum<typeof ResponsesOutputMessagePhaseFinalAnswer>;
+export declare const ResponsesOutputMessagePhaseCommentary: {
+    readonly Commentary: "commentary";
+};
+export type ResponsesOutputMessagePhaseCommentary = ClosedEnum<typeof ResponsesOutputMessagePhaseCommentary>;
+/**
+ * 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 ResponsesOutputMessagePhaseUnion = ResponsesOutputMessagePhaseCommentary | ResponsesOutputMessagePhaseFinalAnswer | any;
 /**
  * An output message item
  */
@@ -35,55 +47,35 @@ export type ResponsesOutputMessage = {
     type: ResponsesOutputMessageType;
     status?: ResponsesOutputMessageStatusCompleted | ResponsesOutputMessageStatusIncomplete | ResponsesOutputMessageStatusInProgress | 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?: ResponsesOutputMessagePhaseCommentary | ResponsesOutputMessagePhaseFinalAnswer | any | null | undefined;
 };
 /** @internal */
 export declare const ResponsesOutputMessageRole$inboundSchema: z.ZodEnum<typeof ResponsesOutputMessageRole>;
 /** @internal */
-export declare const ResponsesOutputMessageRole$outboundSchema: z.ZodEnum<typeof ResponsesOutputMessageRole>;
-/** @internal */
 export declare const ResponsesOutputMessageType$inboundSchema: z.ZodEnum<typeof ResponsesOutputMessageType>;
 /** @internal */
-export declare const ResponsesOutputMessageType$outboundSchema: z.ZodEnum<typeof ResponsesOutputMessageType>;
-/** @internal */
 export declare const ResponsesOutputMessageStatusInProgress$inboundSchema: z.ZodEnum<typeof ResponsesOutputMessageStatusInProgress>;
 /** @internal */
-export declare const ResponsesOutputMessageStatusInProgress$outboundSchema: z.ZodEnum<typeof ResponsesOutputMessageStatusInProgress>;
-/** @internal */
 export declare const ResponsesOutputMessageStatusIncomplete$inboundSchema: z.ZodEnum<typeof ResponsesOutputMessageStatusIncomplete>;
 /** @internal */
-export declare const ResponsesOutputMessageStatusIncomplete$outboundSchema: z.ZodEnum<typeof ResponsesOutputMessageStatusIncomplete>;
-/** @internal */
 export declare const ResponsesOutputMessageStatusCompleted$inboundSchema: z.ZodEnum<typeof ResponsesOutputMessageStatusCompleted>;
 /** @internal */
-export declare const ResponsesOutputMessageStatusCompleted$outboundSchema: z.ZodEnum<typeof ResponsesOutputMessageStatusCompleted>;
-/** @internal */
 export declare const ResponsesOutputMessageStatusUnion$inboundSchema: z.ZodType<ResponsesOutputMessageStatusUnion, unknown>;
-/** @internal */
-export type ResponsesOutputMessageStatusUnion$Outbound = string | string | string;
-/** @internal */
-export declare const ResponsesOutputMessageStatusUnion$outboundSchema: z.ZodType<ResponsesOutputMessageStatusUnion$Outbound, ResponsesOutputMessageStatusUnion>;
-export declare function responsesOutputMessageStatusUnionToJSON(responsesOutputMessageStatusUnion: ResponsesOutputMessageStatusUnion): string;
 export declare function responsesOutputMessageStatusUnionFromJSON(jsonString: string): SafeParseResult<ResponsesOutputMessageStatusUnion, SDKValidationError>;
 /** @internal */
 export declare const ResponsesOutputMessageContent$inboundSchema: z.ZodType<ResponsesOutputMessageContent, unknown>;
-/** @internal */
-export type ResponsesOutputMessageContent$Outbound = ResponseOutputText$Outbound | OpenAIResponsesRefusalContent$Outbound;
-/** @internal */
-export declare const ResponsesOutputMessageContent$outboundSchema: z.ZodType<ResponsesOutputMessageContent$Outbound, ResponsesOutputMessageContent>;
-export declare function responsesOutputMessageContentToJSON(responsesOutputMessageContent: ResponsesOutputMessageContent): string;
 export declare function responsesOutputMessageContentFromJSON(jsonString: string): SafeParseResult<ResponsesOutputMessageContent, SDKValidationError>;
 /** @internal */
-export declare const ResponsesOutputMessage$inboundSchema: z.ZodType<ResponsesOutputMessage, unknown>;
+export declare const ResponsesOutputMessagePhaseFinalAnswer$inboundSchema: z.ZodEnum<typeof ResponsesOutputMessagePhaseFinalAnswer>;
 /** @internal */
-export type ResponsesOutputMessage$Outbound = {
-    id: string;
-    role: string;
-    type: string;
-    status?: string | string | string | undefined;
-    content: Array<ResponseOutputText$Outbound | OpenAIResponsesRefusalContent$Outbound>;
-};
+export declare const ResponsesOutputMessagePhaseCommentary$inboundSchema: z.ZodEnum<typeof ResponsesOutputMessagePhaseCommentary>;
 /** @internal */
-export declare const ResponsesOutputMessage$outboundSchema: z.ZodType<ResponsesOutputMessage$Outbound, ResponsesOutputMessage>;
-export declare function responsesOutputMessageToJSON(responsesOutputMessage: ResponsesOutputMessage): string;
+export declare const ResponsesOutputMessagePhaseUnion$inboundSchema: z.ZodType<ResponsesOutputMessagePhaseUnion, unknown>;
+export declare function responsesOutputMessagePhaseUnionFromJSON(jsonString: string): SafeParseResult<ResponsesOutputMessagePhaseUnion, SDKValidationError>;
+/** @internal */
+export declare const ResponsesOutputMessage$inboundSchema: z.ZodType<ResponsesOutputMessage, unknown>;
 export declare function responsesOutputMessageFromJSON(jsonString: string): SafeParseResult<ResponsesOutputMessage, SDKValidationError>;
 //# sourceMappingURL=responsesoutputmessage.d.ts.map

package/esm/models/responsesoutputmessage.js

@@ -4,8 +4,8 @@
  */
 import * as z from "zod/v4";
 import { safeParse } from "../lib/schemas.js";
-import { OpenAIResponsesRefusalContent$inboundSchema, OpenAIResponsesRefusalContent$outboundSchema, } from "./openairesponsesrefusalcontent.js";
-import { ResponseOutputText$inboundSchema, ResponseOutputText$outboundSchema, } from "./responseoutputtext.js";
+import { OpenAIResponsesRefusalContent$inboundSchema, } from "./openairesponsesrefusalcontent.js";
+import { ResponseOutputText$inboundSchema, } from "./responseoutputtext.js";
 export const ResponsesOutputMessageRole = {
     Assistant: "assistant",
 };
@@ -21,41 +21,28 @@ export const ResponsesOutputMessageStatusIncomplete = {
 export const ResponsesOutputMessageStatusCompleted = {
     Completed: "completed",
 };
+export const ResponsesOutputMessagePhaseFinalAnswer = {
+    FinalAnswer: "final_answer",
+};
+export const ResponsesOutputMessagePhaseCommentary = {
+    Commentary: "commentary",
+};
 /** @internal */
 export const ResponsesOutputMessageRole$inboundSchema = z.enum(ResponsesOutputMessageRole);
 /** @internal */
-export const ResponsesOutputMessageRole$outboundSchema = ResponsesOutputMessageRole$inboundSchema;
-/** @internal */
 export const ResponsesOutputMessageType$inboundSchema = z.enum(ResponsesOutputMessageType);
 /** @internal */
-export const ResponsesOutputMessageType$outboundSchema = ResponsesOutputMessageType$inboundSchema;
-/** @internal */
 export const ResponsesOutputMessageStatusInProgress$inboundSchema = z.enum(ResponsesOutputMessageStatusInProgress);
 /** @internal */
-export const ResponsesOutputMessageStatusInProgress$outboundSchema = ResponsesOutputMessageStatusInProgress$inboundSchema;
-/** @internal */
 export const ResponsesOutputMessageStatusIncomplete$inboundSchema = z.enum(ResponsesOutputMessageStatusIncomplete);
 /** @internal */
-export const ResponsesOutputMessageStatusIncomplete$outboundSchema = ResponsesOutputMessageStatusIncomplete$inboundSchema;
-/** @internal */
 export const ResponsesOutputMessageStatusCompleted$inboundSchema = z.enum(ResponsesOutputMessageStatusCompleted);
 /** @internal */
-export const ResponsesOutputMessageStatusCompleted$outboundSchema = ResponsesOutputMessageStatusCompleted$inboundSchema;
-/** @internal */
 export const ResponsesOutputMessageStatusUnion$inboundSchema = z.union([
     ResponsesOutputMessageStatusCompleted$inboundSchema,
     ResponsesOutputMessageStatusIncomplete$inboundSchema,
     ResponsesOutputMessageStatusInProgress$inboundSchema,
 ]);
-/** @internal */
-export const ResponsesOutputMessageStatusUnion$outboundSchema = z.union([
-    ResponsesOutputMessageStatusCompleted$outboundSchema,
-    ResponsesOutputMessageStatusIncomplete$outboundSchema,
-    ResponsesOutputMessageStatusInProgress$outboundSchema,
-]);
-export function responsesOutputMessageStatusUnionToJSON(responsesOutputMessageStatusUnion) {
-    return JSON.stringify(ResponsesOutputMessageStatusUnion$outboundSchema.parse(responsesOutputMessageStatusUnion));
-}
 export function responsesOutputMessageStatusUnionFromJSON(jsonString) {
     return safeParse(jsonString, (x) => ResponsesOutputMessageStatusUnion$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'ResponsesOutputMessageStatusUnion' from JSON`);
 }
@@ -64,18 +51,23 @@ export const ResponsesOutputMessageContent$inboundSchema = z.union([
     ResponseOutputText$inboundSchema,
     OpenAIResponsesRefusalContent$inboundSchema,
 ]);
-/** @internal */
-export const ResponsesOutputMessageContent$outboundSchema = z.union([
-    ResponseOutputText$outboundSchema,
-    OpenAIResponsesRefusalContent$outboundSchema,
-]);
-export function responsesOutputMessageContentToJSON(responsesOutputMessageContent) {
-    return JSON.stringify(ResponsesOutputMessageContent$outboundSchema.parse(responsesOutputMessageContent));
-}
 export function responsesOutputMessageContentFromJSON(jsonString) {
     return safeParse(jsonString, (x) => ResponsesOutputMessageContent$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'ResponsesOutputMessageContent' from JSON`);
 }
 /** @internal */
+export const ResponsesOutputMessagePhaseFinalAnswer$inboundSchema = z.enum(ResponsesOutputMessagePhaseFinalAnswer);
+/** @internal */
+export const ResponsesOutputMessagePhaseCommentary$inboundSchema = z.enum(ResponsesOutputMessagePhaseCommentary);
+/** @internal */
+export const ResponsesOutputMessagePhaseUnion$inboundSchema = z.union([
+    ResponsesOutputMessagePhaseCommentary$inboundSchema,
+    ResponsesOutputMessagePhaseFinalAnswer$inboundSchema,
+    z.any(),
+]);
+export function responsesOutputMessagePhaseUnionFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => ResponsesOutputMessagePhaseUnion$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'ResponsesOutputMessagePhaseUnion' from JSON`);
+}
+/** @internal */
 export const ResponsesOutputMessage$inboundSchema = z.object({
     id: z.string(),
     role: ResponsesOutputMessageRole$inboundSchema,
@@ -89,25 +81,12 @@ export const ResponsesOutputMessage$inboundSchema = z.object({
         ResponseOutputText$inboundSchema,
         OpenAIResponsesRefusalContent$inboundSchema,
     ])),
+    phase: z.nullable(z.union([
+        ResponsesOutputMessagePhaseCommentary$inboundSchema,
+        ResponsesOutputMessagePhaseFinalAnswer$inboundSchema,
+        z.any(),
+    ])).optional(),
 });
-/** @internal */
-export const ResponsesOutputMessage$outboundSchema = z.object({
-    id: z.string(),
-    role: ResponsesOutputMessageRole$outboundSchema,
-    type: ResponsesOutputMessageType$outboundSchema,
-    status: z.union([
-        ResponsesOutputMessageStatusCompleted$outboundSchema,
-        ResponsesOutputMessageStatusIncomplete$outboundSchema,
-        ResponsesOutputMessageStatusInProgress$outboundSchema,
-    ]).optional(),
-    content: z.array(z.union([
-        ResponseOutputText$outboundSchema,
-        OpenAIResponsesRefusalContent$outboundSchema,
-    ])),
-});
-export function responsesOutputMessageToJSON(responsesOutputMessage) {
-    return JSON.stringify(ResponsesOutputMessage$outboundSchema.parse(responsesOutputMessage));
-}
 export function responsesOutputMessageFromJSON(jsonString) {
     return safeParse(jsonString, (x) => ResponsesOutputMessage$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'ResponsesOutputMessage' from JSON`);
 }

package/esm/models/responsesservertooloutput.d.ts

@@ -0,0 +1,42 @@
+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 ResponsesServerToolOutputStatus: {
+    readonly Completed: "completed";
+    readonly InProgress: "in_progress";
+    readonly Incomplete: "incomplete";
+};
+export type ResponsesServerToolOutputStatus = OpenEnum<typeof ResponsesServerToolOutputStatus>;
+/**
+ * A generic OpenRouter server tool output item
+ */
+export type ResponsesServerToolOutput = {
+    /**
+     * Server tool type (e.g. openrouter:datetime, openrouter:web_search)
+     */
+    type: string;
+    id?: string | undefined;
+    status: ResponsesServerToolOutputStatus;
+    additionalProperties?: {
+        [k: string]: any | null;
+    } | undefined;
+};
+/** @internal */
+export declare const ResponsesServerToolOutputStatus$inboundSchema: z.ZodType<ResponsesServerToolOutputStatus, unknown>;
+/** @internal */
+export declare const ResponsesServerToolOutputStatus$outboundSchema: z.ZodType<string, ResponsesServerToolOutputStatus>;
+/** @internal */
+export declare const ResponsesServerToolOutput$inboundSchema: z.ZodType<ResponsesServerToolOutput, unknown>;
+/** @internal */
+export type ResponsesServerToolOutput$Outbound = {
+    type: string;
+    id?: string | undefined;
+    status: string;
+    [additionalProperties: string]: unknown;
+};
+/** @internal */
+export declare const ResponsesServerToolOutput$outboundSchema: z.ZodType<ResponsesServerToolOutput$Outbound, ResponsesServerToolOutput>;
+export declare function responsesServerToolOutputToJSON(responsesServerToolOutput: ResponsesServerToolOutput): string;
+export declare function responsesServerToolOutputFromJSON(jsonString: string): SafeParseResult<ResponsesServerToolOutput, SDKValidationError>;
+//# sourceMappingURL=responsesservertooloutput.d.ts.map

package/esm/models/responsesservertooloutput.js

@@ -0,0 +1,44 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ * @generated-id: 40768491f00e
+ */
+import * as z from "zod/v4";
+import { remap as remap$ } from "../lib/primitives.js";
+import { collectExtraKeys as collectExtraKeys$, safeParse, } from "../lib/schemas.js";
+import * as openEnums from "../types/enums.js";
+export const ResponsesServerToolOutputStatus = {
+    Completed: "completed",
+    InProgress: "in_progress",
+    Incomplete: "incomplete",
+};
+/** @internal */
+export const ResponsesServerToolOutputStatus$inboundSchema = openEnums.inboundSchema(ResponsesServerToolOutputStatus);
+/** @internal */
+export const ResponsesServerToolOutputStatus$outboundSchema = openEnums.outboundSchema(ResponsesServerToolOutputStatus);
+/** @internal */
+export const ResponsesServerToolOutput$inboundSchema = collectExtraKeys$(z.object({
+    type: z.string(),
+    id: z.string().optional(),
+    status: ResponsesServerToolOutputStatus$inboundSchema,
+}).catchall(z.any()), "additionalProperties", true);
+/** @internal */
+export const ResponsesServerToolOutput$outboundSchema = z.object({
+    type: z.string(),
+    id: z.string().optional(),
+    status: ResponsesServerToolOutputStatus$outboundSchema,
+    additionalProperties: z.record(z.string(), z.nullable(z.any())).optional(),
+}).transform((v) => {
+    return {
+        ...v.additionalProperties,
+        ...remap$(v, {
+            additionalProperties: null,
+        }),
+    };
+});
+export function responsesServerToolOutputToJSON(responsesServerToolOutput) {
+    return JSON.stringify(ResponsesServerToolOutput$outboundSchema.parse(responsesServerToolOutput));
+}
+export function responsesServerToolOutputFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => ResponsesServerToolOutput$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'ResponsesServerToolOutput' from JSON`);
+}
+//# sourceMappingURL=responsesservertooloutput.js.map

package/esm/models/responseswebsearchcalloutput.d.ts

@@ -3,25 +3,110 @@ import { ClosedEnum } from "../types/enums.js";
 import { Result as SafeParseResult } from "../types/fp.js";
 import { SDKValidationError } from "./errors/sdkvalidationerror.js";
 import { WebSearchStatus } from "./websearchstatus.js";
-export declare const ResponsesWebSearchCallOutputType: {
+export declare const TypeWebSearchCall: {
     readonly WebSearchCall: "web_search_call";
 };
-export type ResponsesWebSearchCallOutputType = ClosedEnum<typeof ResponsesWebSearchCallOutputType>;
+export type TypeWebSearchCall = ClosedEnum<typeof TypeWebSearchCall>;
+export type ActionFindInPage = {
+    type: "find_in_page";
+    pattern: string;
+    url: string;
+};
+export type ActionOpenPage = {
+    type: "open_page";
+    url?: string | null | undefined;
+};
+export declare const TypeURL: {
+    readonly Url: "url";
+};
+export type TypeURL = ClosedEnum<typeof TypeURL>;
+export type Source = {
+    type: TypeURL;
+    url: string;
+};
+export type ActionSearch = {
+    type: "search";
+    query: string;
+    queries?: Array<string> | undefined;
+    sources?: Array<Source> | undefined;
+};
+export type Action = ActionSearch | ActionOpenPage | ActionFindInPage;
 export type ResponsesWebSearchCallOutput = {
-    type: ResponsesWebSearchCallOutputType;
+    type: TypeWebSearchCall;
     id: string;
+    action: ActionSearch | ActionOpenPage | ActionFindInPage;
     status: WebSearchStatus;
 };
 /** @internal */
-export declare const ResponsesWebSearchCallOutputType$inboundSchema: z.ZodEnum<typeof ResponsesWebSearchCallOutputType>;
+export declare const TypeWebSearchCall$inboundSchema: z.ZodEnum<typeof TypeWebSearchCall>;
+/** @internal */
+export declare const TypeWebSearchCall$outboundSchema: z.ZodEnum<typeof TypeWebSearchCall>;
+/** @internal */
+export declare const ActionFindInPage$inboundSchema: z.ZodType<ActionFindInPage, unknown>;
+/** @internal */
+export type ActionFindInPage$Outbound = {
+    type: "find_in_page";
+    pattern: string;
+    url: string;
+};
+/** @internal */
+export declare const ActionFindInPage$outboundSchema: z.ZodType<ActionFindInPage$Outbound, ActionFindInPage>;
+export declare function actionFindInPageToJSON(actionFindInPage: ActionFindInPage): string;
+export declare function actionFindInPageFromJSON(jsonString: string): SafeParseResult<ActionFindInPage, SDKValidationError>;
+/** @internal */
+export declare const ActionOpenPage$inboundSchema: z.ZodType<ActionOpenPage, unknown>;
+/** @internal */
+export type ActionOpenPage$Outbound = {
+    type: "open_page";
+    url?: string | null | undefined;
+};
+/** @internal */
+export declare const ActionOpenPage$outboundSchema: z.ZodType<ActionOpenPage$Outbound, ActionOpenPage>;
+export declare function actionOpenPageToJSON(actionOpenPage: ActionOpenPage): string;
+export declare function actionOpenPageFromJSON(jsonString: string): SafeParseResult<ActionOpenPage, SDKValidationError>;
+/** @internal */
+export declare const TypeURL$inboundSchema: z.ZodEnum<typeof TypeURL>;
+/** @internal */
+export declare const TypeURL$outboundSchema: z.ZodEnum<typeof TypeURL>;
+/** @internal */
+export declare const Source$inboundSchema: z.ZodType<Source, unknown>;
+/** @internal */
+export type Source$Outbound = {
+    type: string;
+    url: string;
+};
+/** @internal */
+export declare const Source$outboundSchema: z.ZodType<Source$Outbound, Source>;
+export declare function sourceToJSON(source: Source): string;
+export declare function sourceFromJSON(jsonString: string): SafeParseResult<Source, SDKValidationError>;
+/** @internal */
+export declare const ActionSearch$inboundSchema: z.ZodType<ActionSearch, unknown>;
+/** @internal */
+export type ActionSearch$Outbound = {
+    type: "search";
+    query: string;
+    queries?: Array<string> | undefined;
+    sources?: Array<Source$Outbound> | undefined;
+};
+/** @internal */
+export declare const ActionSearch$outboundSchema: z.ZodType<ActionSearch$Outbound, ActionSearch>;
+export declare function actionSearchToJSON(actionSearch: ActionSearch): string;
+export declare function actionSearchFromJSON(jsonString: string): SafeParseResult<ActionSearch, SDKValidationError>;
+/** @internal */
+export declare const Action$inboundSchema: z.ZodType<Action, unknown>;
+/** @internal */
+export type Action$Outbound = ActionSearch$Outbound | ActionOpenPage$Outbound | ActionFindInPage$Outbound;
 /** @internal */
-export declare const ResponsesWebSearchCallOutputType$outboundSchema: z.ZodEnum<typeof ResponsesWebSearchCallOutputType>;
+export declare const Action$outboundSchema: z.ZodType<Action$Outbound, Action>;
+export declare function actionToJSON(action: Action): string;
+export declare function actionFromJSON(jsonString: string): SafeParseResult<Action, SDKValidationError>;
 /** @internal */
 export declare const ResponsesWebSearchCallOutput$inboundSchema: z.ZodType<ResponsesWebSearchCallOutput, unknown>;
 /** @internal */
 export type ResponsesWebSearchCallOutput$Outbound = {
     type: string;
     id: string;
+    action: ActionSearch$Outbound | ActionOpenPage$Outbound | ActionFindInPage$Outbound;
     status: string;
 };
 /** @internal */