@openrouter/sdk 0.11.2 → 0.12.1

package/esm/models/outputfunctioncallitem.d.ts

@@ -2,10 +2,6 @@ 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";
-export declare const OutputFunctionCallItemType: {
-    readonly FunctionCall: "function_call";
-};
-export type OutputFunctionCallItemType = ClosedEnum<typeof OutputFunctionCallItemType>;
 export declare const OutputFunctionCallItemStatusInProgress: {
     readonly InProgress: "in_progress";
 };
@@ -19,19 +15,19 @@ export declare const OutputFunctionCallItemStatusCompleted: {
 };
 export type OutputFunctionCallItemStatusCompleted = ClosedEnum<typeof OutputFunctionCallItemStatusCompleted>;
 export type OutputFunctionCallItemStatusUnion = OutputFunctionCallItemStatusCompleted | OutputFunctionCallItemStatusIncomplete | OutputFunctionCallItemStatusInProgress;
+export declare const OutputFunctionCallItemType: {
+    readonly FunctionCall: "function_call";
+};
+export type OutputFunctionCallItemType = ClosedEnum<typeof OutputFunctionCallItemType>;
 export type OutputFunctionCallItem = {
-    type: OutputFunctionCallItemType;
-    id?: string | undefined;
-    name: string;
     arguments: string;
     callId: string;
+    id?: string | undefined;
+    name: string;
     status?: OutputFunctionCallItemStatusCompleted | OutputFunctionCallItemStatusIncomplete | OutputFunctionCallItemStatusInProgress | undefined;
+    type: OutputFunctionCallItemType;
 };
 /** @internal */
-export declare const OutputFunctionCallItemType$inboundSchema: z.ZodEnum<typeof OutputFunctionCallItemType>;
-/** @internal */
-export declare const OutputFunctionCallItemType$outboundSchema: z.ZodEnum<typeof OutputFunctionCallItemType>;
-/** @internal */
 export declare const OutputFunctionCallItemStatusInProgress$inboundSchema: z.ZodEnum<typeof OutputFunctionCallItemStatusInProgress>;
 /** @internal */
 export declare const OutputFunctionCallItemStatusInProgress$outboundSchema: z.ZodEnum<typeof OutputFunctionCallItemStatusInProgress>;
@@ -52,15 +48,19 @@ export declare const OutputFunctionCallItemStatusUnion$outboundSchema: z.ZodType
 export declare function outputFunctionCallItemStatusUnionToJSON(outputFunctionCallItemStatusUnion: OutputFunctionCallItemStatusUnion): string;
 export declare function outputFunctionCallItemStatusUnionFromJSON(jsonString: string): SafeParseResult<OutputFunctionCallItemStatusUnion, SDKValidationError>;
 /** @internal */
+export declare const OutputFunctionCallItemType$inboundSchema: z.ZodEnum<typeof OutputFunctionCallItemType>;
+/** @internal */
+export declare const OutputFunctionCallItemType$outboundSchema: z.ZodEnum<typeof OutputFunctionCallItemType>;
+/** @internal */
 export declare const OutputFunctionCallItem$inboundSchema: z.ZodType<OutputFunctionCallItem, unknown>;
 /** @internal */
 export type OutputFunctionCallItem$Outbound = {
-    type: string;
-    id?: string | undefined;
-    name: string;
     arguments: string;
     call_id: string;
+    id?: string | undefined;
+    name: string;
     status?: string | string | string | undefined;
+    type: string;
 };
 /** @internal */
 export declare const OutputFunctionCallItem$outboundSchema: z.ZodType<OutputFunctionCallItem$Outbound, OutputFunctionCallItem>;

package/esm/models/outputfunctioncallitem.js

@@ -5,9 +5,6 @@
 import * as z from "zod/v4";
 import { remap as remap$ } from "../lib/primitives.js";
 import { safeParse } from "../lib/schemas.js";
-export const OutputFunctionCallItemType = {
-    FunctionCall: "function_call",
-};
 export const OutputFunctionCallItemStatusInProgress = {
     InProgress: "in_progress",
 };
@@ -17,10 +14,9 @@ export const OutputFunctionCallItemStatusIncomplete = {
 export const OutputFunctionCallItemStatusCompleted = {
     Completed: "completed",
 };
-/** @internal */
-export const OutputFunctionCallItemType$inboundSchema = z.enum(OutputFunctionCallItemType);
-/** @internal */
-export const OutputFunctionCallItemType$outboundSchema = OutputFunctionCallItemType$inboundSchema;
+export const OutputFunctionCallItemType = {
+    FunctionCall: "function_call",
+};
 /** @internal */
 export const OutputFunctionCallItemStatusInProgress$inboundSchema = z.enum(OutputFunctionCallItemStatusInProgress);
 /** @internal */
@@ -52,17 +48,21 @@ export function outputFunctionCallItemStatusUnionFromJSON(jsonString) {
     return safeParse(jsonString, (x) => OutputFunctionCallItemStatusUnion$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'OutputFunctionCallItemStatusUnion' from JSON`);
 }
 /** @internal */
+export const OutputFunctionCallItemType$inboundSchema = z.enum(OutputFunctionCallItemType);
+/** @internal */
+export const OutputFunctionCallItemType$outboundSchema = OutputFunctionCallItemType$inboundSchema;
+/** @internal */
 export const OutputFunctionCallItem$inboundSchema = z.object({
-    type: OutputFunctionCallItemType$inboundSchema,
-    id: z.string().optional(),
-    name: z.string(),
     arguments: z.string(),
     call_id: z.string(),
+    id: z.string().optional(),
+    name: z.string(),
     status: z.union([
         OutputFunctionCallItemStatusCompleted$inboundSchema,
         OutputFunctionCallItemStatusIncomplete$inboundSchema,
         OutputFunctionCallItemStatusInProgress$inboundSchema,
     ]).optional(),
+    type: OutputFunctionCallItemType$inboundSchema,
 }).transform((v) => {
     return remap$(v, {
         "call_id": "callId",
@@ -70,16 +70,16 @@ export const OutputFunctionCallItem$inboundSchema = z.object({
 });
 /** @internal */
 export const OutputFunctionCallItem$outboundSchema = z.object({
-    type: OutputFunctionCallItemType$outboundSchema,
-    id: z.string().optional(),
-    name: z.string(),
     arguments: z.string(),
     callId: z.string(),
+    id: z.string().optional(),
+    name: z.string(),
     status: z.union([
         OutputFunctionCallItemStatusCompleted$outboundSchema,
         OutputFunctionCallItemStatusIncomplete$outboundSchema,
         OutputFunctionCallItemStatusInProgress$outboundSchema,
     ]).optional(),
+    type: OutputFunctionCallItemType$outboundSchema,
 }).transform((v) => {
     return remap$(v, {
         callId: "call_id",

package/esm/models/outputimagegenerationcallitem.d.ts

@@ -8,10 +8,10 @@ export declare const OutputImageGenerationCallItemType: {
 };
 export type OutputImageGenerationCallItemType = ClosedEnum<typeof OutputImageGenerationCallItemType>;
 export type OutputImageGenerationCallItem = {
-    type: OutputImageGenerationCallItemType;
     id: string;
     result?: string | null | undefined;
     status: ImageGenerationStatus;
+    type: OutputImageGenerationCallItemType;
 };
 /** @internal */
 export declare const OutputImageGenerationCallItemType$inboundSchema: z.ZodEnum<typeof OutputImageGenerationCallItemType>;
@@ -21,10 +21,10 @@ export declare const OutputImageGenerationCallItemType$outboundSchema: z.ZodEnum
 export declare const OutputImageGenerationCallItem$inboundSchema: z.ZodType<OutputImageGenerationCallItem, unknown>;
 /** @internal */
 export type OutputImageGenerationCallItem$Outbound = {
-    type: string;
     id: string;
     result: string | null;
     status: string;
+    type: string;
 };
 /** @internal */
 export declare const OutputImageGenerationCallItem$outboundSchema: z.ZodType<OutputImageGenerationCallItem$Outbound, OutputImageGenerationCallItem>;

package/esm/models/outputimagegenerationcallitem.js

@@ -14,17 +14,17 @@ export const OutputImageGenerationCallItemType$inboundSchema = z.enum(OutputImag
 export const OutputImageGenerationCallItemType$outboundSchema = OutputImageGenerationCallItemType$inboundSchema;
 /** @internal */
 export const OutputImageGenerationCallItem$inboundSchema = z.object({
-    type: OutputImageGenerationCallItemType$inboundSchema,
     id: z.string(),
     result: z.nullable(z.string()).default(null),
     status: ImageGenerationStatus$inboundSchema,
+    type: OutputImageGenerationCallItemType$inboundSchema,
 });
 /** @internal */
 export const OutputImageGenerationCallItem$outboundSchema = z.object({
-    type: OutputImageGenerationCallItemType$outboundSchema,
     id: z.string(),
     result: z.nullable(z.string()).default(null),
     status: ImageGenerationStatus$outboundSchema,
+    type: OutputImageGenerationCallItemType$outboundSchema,
 });
 export function outputImageGenerationCallItemToJSON(outputImageGenerationCallItem) {
     return JSON.stringify(OutputImageGenerationCallItem$outboundSchema.parse(outputImageGenerationCallItem));

package/esm/models/outputimagegenerationservertoolitem.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:image_generation server tool output item
+ */
+export type OutputImageGenerationServerToolItem = {
+    id?: string | undefined;
+    imageB64?: string | undefined;
+    imageUrl?: string | undefined;
+    revisedPrompt?: string | undefined;
+    status: ToolCallStatus;
+    type: "openrouter:image_generation";
+};
+/** @internal */
+export declare const OutputImageGenerationServerToolItem$inboundSchema: z.ZodType<OutputImageGenerationServerToolItem, unknown>;
+export declare function outputImageGenerationServerToolItemFromJSON(jsonString: string): SafeParseResult<OutputImageGenerationServerToolItem, SDKValidationError>;
+//# sourceMappingURL=outputimagegenerationservertoolitem.d.ts.map

package/esm/models/outputimagegenerationservertoolitem.js

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

package/esm/models/outputitemimagegenerationcall.d.ts

@@ -8,10 +8,10 @@ export declare const OutputItemImageGenerationCallType: {
 };
 export type OutputItemImageGenerationCallType = ClosedEnum<typeof OutputItemImageGenerationCallType>;
 export type OutputItemImageGenerationCall = {
-    type: OutputItemImageGenerationCallType;
     id: string;
     result: string | null;
     status: ImageGenerationStatus;
+    type: OutputItemImageGenerationCallType;
 };
 /** @internal */
 export declare const OutputItemImageGenerationCallType$inboundSchema: z.ZodEnum<typeof OutputItemImageGenerationCallType>;

package/esm/models/outputitemimagegenerationcall.js

@@ -12,10 +12,10 @@ export const OutputItemImageGenerationCallType = {
 export const OutputItemImageGenerationCallType$inboundSchema = z.enum(OutputItemImageGenerationCallType);
 /** @internal */
 export const OutputItemImageGenerationCall$inboundSchema = z.object({
-    type: OutputItemImageGenerationCallType$inboundSchema,
     id: z.string(),
     result: z.nullable(z.string()).default(null),
     status: ImageGenerationStatus$inboundSchema,
+    type: OutputItemImageGenerationCallType$inboundSchema,
 });
 export function outputItemImageGenerationCallFromJSON(jsonString) {
     return safeParse(jsonString, (x) => OutputItemImageGenerationCall$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'OutputItemImageGenerationCall' from JSON`);

package/esm/models/outputitems.d.ts

@@ -1,17 +1,44 @@
 import * as z from "zod/v4";
+import * as discriminatedUnionTypes from "../types/discriminatedUnion.js";
 import { Result as SafeParseResult } from "../types/fp.js";
 import { SDKValidationError } from "./errors/sdkvalidationerror.js";
+import { OutputApplyPatchServerToolItem } from "./outputapplypatchservertoolitem.js";
+import { OutputBashServerToolItem } from "./outputbashservertoolitem.js";
+import { OutputBrowserUseServerToolItem } from "./outputbrowseruseservertoolitem.js";
+import { OutputCodeInterpreterCallItem } from "./outputcodeinterpretercallitem.js";
+import { OutputCodeInterpreterServerToolItem } from "./outputcodeinterpreterservertoolitem.js";
+import { OutputComputerCallItem } from "./outputcomputercallitem.js";
+import { OutputDatetimeItem } from "./outputdatetimeitem.js";
 import { OutputFileSearchCallItem } from "./outputfilesearchcallitem.js";
+import { OutputFileSearchServerToolItem } from "./outputfilesearchservertoolitem.js";
 import { OutputFunctionCallItem } from "./outputfunctioncallitem.js";
 import { OutputImageGenerationCallItem } from "./outputimagegenerationcallitem.js";
+import { OutputImageGenerationServerToolItem } from "./outputimagegenerationservertoolitem.js";
+import { OutputMcpServerToolItem } from "./outputmcpservertoolitem.js";
+import { OutputMemoryServerToolItem } from "./outputmemoryservertoolitem.js";
 import { OutputMessageItem } from "./outputmessageitem.js";
 import { OutputReasoningItem } from "./outputreasoningitem.js";
-import { OutputServerToolItem } from "./outputservertoolitem.js";
+import { OutputTextEditorServerToolItem } from "./outputtexteditorservertoolitem.js";
+import { OutputToolSearchServerToolItem } from "./outputtoolsearchservertoolitem.js";
+import { OutputWebFetchServerToolItem } from "./outputwebfetchservertoolitem.js";
 import { OutputWebSearchCallItem } from "./outputwebsearchcallitem.js";
+import { OutputWebSearchServerToolItem } from "./outputwebsearchservertoolitem.js";
 /**
  * An output item from the response
  */
-export type OutputItems = OutputMessageItem | OutputFunctionCallItem | OutputWebSearchCallItem | OutputFileSearchCallItem | OutputReasoningItem | OutputImageGenerationCallItem | OutputServerToolItem;
+export type OutputItems = OutputCodeInterpreterCallItem | OutputComputerCallItem | (OutputFileSearchCallItem & {
+    type: "file_search_call";
+}) | (OutputFunctionCallItem & {
+    type: "function_call";
+}) | (OutputImageGenerationCallItem & {
+    type: "image_generation_call";
+}) | OutputMessageItem | OutputApplyPatchServerToolItem | OutputBashServerToolItem | OutputBrowserUseServerToolItem | OutputCodeInterpreterServerToolItem | (OutputDatetimeItem & {
+    type: "openrouter:datetime";
+}) | OutputFileSearchServerToolItem | OutputImageGenerationServerToolItem | OutputMcpServerToolItem | OutputMemoryServerToolItem | OutputTextEditorServerToolItem | OutputToolSearchServerToolItem | OutputWebFetchServerToolItem | (OutputWebSearchServerToolItem & {
+    type: "openrouter:web_search";
+}) | OutputReasoningItem | (OutputWebSearchCallItem & {
+    type: "web_search_call";
+}) | discriminatedUnionTypes.Unknown<"type">;
 /** @internal */
 export declare const OutputItems$inboundSchema: z.ZodType<OutputItems, unknown>;
 export declare function outputItemsFromJSON(jsonString: string): SafeParseResult<OutputItems, SDKValidationError>;

package/esm/models/outputitems.js

@@ -4,24 +4,52 @@
  */
 import * as z from "zod/v4";
 import { safeParse } from "../lib/schemas.js";
+import { discriminatedUnion } from "../types/discriminatedUnion.js";
+import { OutputApplyPatchServerToolItem$inboundSchema, } from "./outputapplypatchservertoolitem.js";
+import { OutputBashServerToolItem$inboundSchema, } from "./outputbashservertoolitem.js";
+import { OutputBrowserUseServerToolItem$inboundSchema, } from "./outputbrowseruseservertoolitem.js";
+import { OutputCodeInterpreterCallItem$inboundSchema, } from "./outputcodeinterpretercallitem.js";
+import { OutputCodeInterpreterServerToolItem$inboundSchema, } from "./outputcodeinterpreterservertoolitem.js";
+import { OutputComputerCallItem$inboundSchema, } from "./outputcomputercallitem.js";
+import { OutputDatetimeItem$inboundSchema, } from "./outputdatetimeitem.js";
 import { OutputFileSearchCallItem$inboundSchema, } from "./outputfilesearchcallitem.js";
+import { OutputFileSearchServerToolItem$inboundSchema, } from "./outputfilesearchservertoolitem.js";
 import { OutputFunctionCallItem$inboundSchema, } from "./outputfunctioncallitem.js";
 import { OutputImageGenerationCallItem$inboundSchema, } from "./outputimagegenerationcallitem.js";
+import { OutputImageGenerationServerToolItem$inboundSchema, } from "./outputimagegenerationservertoolitem.js";
+import { OutputMcpServerToolItem$inboundSchema, } from "./outputmcpservertoolitem.js";
+import { OutputMemoryServerToolItem$inboundSchema, } from "./outputmemoryservertoolitem.js";
 import { OutputMessageItem$inboundSchema, } from "./outputmessageitem.js";
 import { OutputReasoningItem$inboundSchema, } from "./outputreasoningitem.js";
-import { OutputServerToolItem$inboundSchema, } from "./outputservertoolitem.js";
+import { OutputTextEditorServerToolItem$inboundSchema, } from "./outputtexteditorservertoolitem.js";
+import { OutputToolSearchServerToolItem$inboundSchema, } from "./outputtoolsearchservertoolitem.js";
+import { OutputWebFetchServerToolItem$inboundSchema, } from "./outputwebfetchservertoolitem.js";
 import { OutputWebSearchCallItem$inboundSchema, } from "./outputwebsearchcallitem.js";
+import { OutputWebSearchServerToolItem$inboundSchema, } from "./outputwebsearchservertoolitem.js";
 /** @internal */
-export const OutputItems$inboundSchema = z
-    .union([
-    OutputMessageItem$inboundSchema,
-    OutputFunctionCallItem$inboundSchema,
-    OutputWebSearchCallItem$inboundSchema,
-    OutputFileSearchCallItem$inboundSchema,
-    OutputReasoningItem$inboundSchema,
-    OutputImageGenerationCallItem$inboundSchema,
-    OutputServerToolItem$inboundSchema,
-]);
+export const OutputItems$inboundSchema = discriminatedUnion("type", {
+    code_interpreter_call: OutputCodeInterpreterCallItem$inboundSchema,
+    computer_call: OutputComputerCallItem$inboundSchema,
+    file_search_call: OutputFileSearchCallItem$inboundSchema.and(z.object({ type: z.literal("file_search_call") })),
+    function_call: OutputFunctionCallItem$inboundSchema.and(z.object({ type: z.literal("function_call") })),
+    image_generation_call: OutputImageGenerationCallItem$inboundSchema.and(z.object({ type: z.literal("image_generation_call") })),
+    message: OutputMessageItem$inboundSchema,
+    ["openrouter:apply_patch"]: OutputApplyPatchServerToolItem$inboundSchema,
+    ["openrouter:bash"]: OutputBashServerToolItem$inboundSchema,
+    ["openrouter:browser_use"]: OutputBrowserUseServerToolItem$inboundSchema,
+    ["openrouter:code_interpreter"]: OutputCodeInterpreterServerToolItem$inboundSchema,
+    ["openrouter:datetime"]: OutputDatetimeItem$inboundSchema.and(z.object({ type: z.literal("openrouter:datetime") })),
+    ["openrouter:file_search"]: OutputFileSearchServerToolItem$inboundSchema,
+    ["openrouter:image_generation"]: OutputImageGenerationServerToolItem$inboundSchema,
+    ["openrouter:mcp"]: OutputMcpServerToolItem$inboundSchema,
+    ["openrouter:memory"]: OutputMemoryServerToolItem$inboundSchema,
+    ["openrouter:text_editor"]: OutputTextEditorServerToolItem$inboundSchema,
+    ["openrouter:tool_search"]: OutputToolSearchServerToolItem$inboundSchema,
+    ["openrouter:web_fetch"]: OutputWebFetchServerToolItem$inboundSchema,
+    ["openrouter:web_search"]: OutputWebSearchServerToolItem$inboundSchema.and(z.object({ type: z.literal("openrouter:web_search") })),
+    reasoning: OutputReasoningItem$inboundSchema,
+    web_search_call: OutputWebSearchCallItem$inboundSchema.and(z.object({ type: z.literal("web_search_call") })),
+});
 export function outputItemsFromJSON(jsonString) {
     return safeParse(jsonString, (x) => OutputItems$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'OutputItems' from JSON`);
 }

package/esm/models/outputmcpservertoolitem.d.ts

@@ -0,0 +1,18 @@
+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:mcp server tool output item
+ */
+export type OutputMcpServerToolItem = {
+    id?: string | undefined;
+    serverLabel?: string | undefined;
+    status: ToolCallStatus;
+    toolName?: string | undefined;
+    type: "openrouter:mcp";
+};
+/** @internal */
+export declare const OutputMcpServerToolItem$inboundSchema: z.ZodType<OutputMcpServerToolItem, unknown>;
+export declare function outputMcpServerToolItemFromJSON(jsonString: string): SafeParseResult<OutputMcpServerToolItem, SDKValidationError>;
+//# sourceMappingURL=outputmcpservertoolitem.d.ts.map

package/esm/models/outputmcpservertoolitem.js

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

package/esm/models/outputmemoryservertoolitem.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 ActionEnum: {
+    readonly Read: "read";
+    readonly Write: "write";
+    readonly Delete: "delete";
+};
+export type ActionEnum = OpenEnum<typeof ActionEnum>;
+/**
+ * An openrouter:memory server tool output item
+ */
+export type OutputMemoryServerToolItem = {
+    action?: ActionEnum | undefined;
+    id?: string | undefined;
+    key?: string | undefined;
+    status: ToolCallStatus;
+    type: "openrouter:memory";
+    value?: any | null | undefined;
+};
+/** @internal */
+export declare const ActionEnum$inboundSchema: z.ZodType<ActionEnum, unknown>;
+/** @internal */
+export declare const OutputMemoryServerToolItem$inboundSchema: z.ZodType<OutputMemoryServerToolItem, unknown>;
+export declare function outputMemoryServerToolItemFromJSON(jsonString: string): SafeParseResult<OutputMemoryServerToolItem, SDKValidationError>;
+//# sourceMappingURL=outputmemoryservertoolitem.d.ts.map

package/esm/models/outputmemoryservertoolitem.js

@@ -0,0 +1,28 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ * @generated-id: 2fb051c8b4e9
+ */
+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 ActionEnum = {
+    Read: "read",
+    Write: "write",
+    Delete: "delete",
+};
+/** @internal */
+export const ActionEnum$inboundSchema = openEnums.inboundSchema(ActionEnum);
+/** @internal */
+export const OutputMemoryServerToolItem$inboundSchema = z.object({
+    action: ActionEnum$inboundSchema.optional(),
+    id: z.string().optional(),
+    key: z.string().optional(),
+    status: ToolCallStatus$inboundSchema,
+    type: z.literal("openrouter:memory"),
+    value: z.nullable(z.any()).optional(),
+});
+export function outputMemoryServerToolItemFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => OutputMemoryServerToolItem$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'OutputMemoryServerToolItem' from JSON`);
+}
+//# sourceMappingURL=outputmemoryservertoolitem.js.map

package/esm/models/outputmessage.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 OutputMessageContent = ResponseOutputText | OpenAIResponsesRefusalContent | discriminatedUnionTypes.Unknown<"type">;
+export declare const OutputMessagePhaseFinalAnswer: {
+    readonly FinalAnswer: "final_answer";
+};
+export type OutputMessagePhaseFinalAnswer = ClosedEnum<typeof OutputMessagePhaseFinalAnswer>;
+export declare const OutputMessagePhaseCommentary: {
+    readonly Commentary: "commentary";
+};
+export type OutputMessagePhaseCommentary = ClosedEnum<typeof OutputMessagePhaseCommentary>;
+/**
+ * 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 OutputMessagePhaseUnion = OutputMessagePhaseCommentary | OutputMessagePhaseFinalAnswer | any;
 export declare const OutputMessageRole: {
     readonly Assistant: "assistant";
 };
 export type OutputMessageRole = ClosedEnum<typeof OutputMessageRole>;
-export declare const OutputMessageType: {
-    readonly Message: "message";
-};
-export type OutputMessageType = ClosedEnum<typeof OutputMessageType>;
 export declare const OutputMessageStatusInProgress: {
     readonly InProgress: "in_progress";
 };
@@ -25,34 +35,33 @@ export declare const OutputMessageStatusCompleted: {
 };
 export type OutputMessageStatusCompleted = ClosedEnum<typeof OutputMessageStatusCompleted>;
 export type OutputMessageStatusUnion = OutputMessageStatusCompleted | OutputMessageStatusIncomplete | OutputMessageStatusInProgress;
-export type OutputMessageContent = ResponseOutputText | OpenAIResponsesRefusalContent;
-export declare const OutputMessagePhaseFinalAnswer: {
-    readonly FinalAnswer: "final_answer";
-};
-export type OutputMessagePhaseFinalAnswer = ClosedEnum<typeof OutputMessagePhaseFinalAnswer>;
-export declare const OutputMessagePhaseCommentary: {
-    readonly Commentary: "commentary";
+export declare const OutputMessageType: {
+    readonly Message: "message";
 };
-export type OutputMessagePhaseCommentary = ClosedEnum<typeof OutputMessagePhaseCommentary>;
-/**
- * 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 OutputMessagePhaseUnion = OutputMessagePhaseCommentary | OutputMessagePhaseFinalAnswer | any;
+export type OutputMessageType = ClosedEnum<typeof OutputMessageType>;
 export type OutputMessage = {
+    content: Array<ResponseOutputText | OpenAIResponsesRefusalContent | discriminatedUnionTypes.Unknown<"type">>;
     id: string;
-    role: OutputMessageRole;
-    type: OutputMessageType;
-    status?: OutputMessageStatusCompleted | OutputMessageStatusIncomplete | OutputMessageStatusInProgress | 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?: OutputMessagePhaseCommentary | OutputMessagePhaseFinalAnswer | any | null | undefined;
+    role: OutputMessageRole;
+    status?: OutputMessageStatusCompleted | OutputMessageStatusIncomplete | OutputMessageStatusInProgress | undefined;
+    type: OutputMessageType;
 };
 /** @internal */
-export declare const OutputMessageRole$inboundSchema: z.ZodEnum<typeof OutputMessageRole>;
+export declare const OutputMessageContent$inboundSchema: z.ZodType<OutputMessageContent, unknown>;
+export declare function outputMessageContentFromJSON(jsonString: string): SafeParseResult<OutputMessageContent, SDKValidationError>;
 /** @internal */
-export declare const OutputMessageType$inboundSchema: z.ZodEnum<typeof OutputMessageType>;
+export declare const OutputMessagePhaseFinalAnswer$inboundSchema: z.ZodEnum<typeof OutputMessagePhaseFinalAnswer>;
+/** @internal */
+export declare const OutputMessagePhaseCommentary$inboundSchema: z.ZodEnum<typeof OutputMessagePhaseCommentary>;
+/** @internal */
+export declare const OutputMessagePhaseUnion$inboundSchema: z.ZodType<OutputMessagePhaseUnion, unknown>;
+export declare function outputMessagePhaseUnionFromJSON(jsonString: string): SafeParseResult<OutputMessagePhaseUnion, SDKValidationError>;
+/** @internal */
+export declare const OutputMessageRole$inboundSchema: z.ZodEnum<typeof OutputMessageRole>;
 /** @internal */
 export declare const OutputMessageStatusInProgress$inboundSchema: z.ZodEnum<typeof OutputMessageStatusInProgress>;
 /** @internal */
@@ -63,15 +72,7 @@ export declare const OutputMessageStatusCompleted$inboundSchema: z.ZodEnum<typeo
 export declare const OutputMessageStatusUnion$inboundSchema: z.ZodType<OutputMessageStatusUnion, unknown>;
 export declare function outputMessageStatusUnionFromJSON(jsonString: string): SafeParseResult<OutputMessageStatusUnion, SDKValidationError>;
 /** @internal */
-export declare const OutputMessageContent$inboundSchema: z.ZodType<OutputMessageContent, unknown>;
-export declare function outputMessageContentFromJSON(jsonString: string): SafeParseResult<OutputMessageContent, SDKValidationError>;
-/** @internal */
-export declare const OutputMessagePhaseFinalAnswer$inboundSchema: z.ZodEnum<typeof OutputMessagePhaseFinalAnswer>;
-/** @internal */
-export declare const OutputMessagePhaseCommentary$inboundSchema: z.ZodEnum<typeof OutputMessagePhaseCommentary>;
-/** @internal */
-export declare const OutputMessagePhaseUnion$inboundSchema: z.ZodType<OutputMessagePhaseUnion, unknown>;
-export declare function outputMessagePhaseUnionFromJSON(jsonString: string): SafeParseResult<OutputMessagePhaseUnion, SDKValidationError>;
+export declare const OutputMessageType$inboundSchema: z.ZodEnum<typeof OutputMessageType>;
 /** @internal */
 export declare const OutputMessage$inboundSchema: z.ZodType<OutputMessage, unknown>;
 export declare function outputMessageFromJSON(jsonString: string): SafeParseResult<OutputMessage, SDKValidationError>;