@openrouter/sdk 0.12.35 → 0.13.7

package/esm/models/outputadvisorservertoolitem.d.ts

@@ -0,0 +1,59 @@
+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 { ToolCallStatus } from "./toolcallstatus.js";
+export declare const OutputAdvisorServerToolItemType: {
+    readonly OpenrouterAdvisor: "openrouter:advisor";
+};
+export type OutputAdvisorServerToolItemType = ClosedEnum<typeof OutputAdvisorServerToolItemType>;
+/**
+ * An openrouter:advisor server tool output item
+ */
+export type OutputAdvisorServerToolItem = {
+    /**
+     * The advisor model's response (the advice text returned to the executor).
+     */
+    advice?: string | undefined;
+    /**
+     * Error message when the advisor call did not produce advice.
+     */
+    error?: string | undefined;
+    id?: string | undefined;
+    /**
+     * Provider-safe function name of the specific advisor instance that produced this item (e.g. `openrouter_advisor__1`). Present only when more than one advisor tool is configured; omitted for the default single advisor. Echo this field back unchanged so the advisor's cross-request memory stays namespaced to the correct instance. This identity is positional: it is derived from the index of the advisor entry in the request `tools` array, so clients must keep the order of advisor tool entries stable across requests in a conversation. Reordering or inserting advisor entries shifts these names and causes each advisor's cross-request memory to be attributed to the wrong instance.
+     */
+    instanceName?: string | undefined;
+    /**
+     * Slug of the advisor model that was consulted.
+     */
+    model?: string | undefined;
+    /**
+     * The prompt the executor sent to the advisor.
+     */
+    prompt?: string | undefined;
+    status: ToolCallStatus;
+    type: OutputAdvisorServerToolItemType;
+};
+/** @internal */
+export declare const OutputAdvisorServerToolItemType$inboundSchema: z.ZodEnum<typeof OutputAdvisorServerToolItemType>;
+/** @internal */
+export declare const OutputAdvisorServerToolItemType$outboundSchema: z.ZodEnum<typeof OutputAdvisorServerToolItemType>;
+/** @internal */
+export declare const OutputAdvisorServerToolItem$inboundSchema: z.ZodType<OutputAdvisorServerToolItem, unknown>;
+/** @internal */
+export type OutputAdvisorServerToolItem$Outbound = {
+    advice?: string | undefined;
+    error?: string | undefined;
+    id?: string | undefined;
+    instance_name?: string | undefined;
+    model?: string | undefined;
+    prompt?: string | undefined;
+    status: string;
+    type: string;
+};
+/** @internal */
+export declare const OutputAdvisorServerToolItem$outboundSchema: z.ZodType<OutputAdvisorServerToolItem$Outbound, OutputAdvisorServerToolItem>;
+export declare function outputAdvisorServerToolItemToJSON(outputAdvisorServerToolItem: OutputAdvisorServerToolItem): string;
+export declare function outputAdvisorServerToolItemFromJSON(jsonString: string): SafeParseResult<OutputAdvisorServerToolItem, SDKValidationError>;
+//# sourceMappingURL=outputadvisorservertoolitem.d.ts.map

package/esm/models/outputadvisorservertoolitem.js

@@ -0,0 +1,52 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ * @generated-id: 0c9d6ff77975
+ */
+import * as z from "zod/v4";
+import { remap as remap$ } from "../lib/primitives.js";
+import { safeParse } from "../lib/schemas.js";
+import { ToolCallStatus$inboundSchema, ToolCallStatus$outboundSchema, } from "./toolcallstatus.js";
+export const OutputAdvisorServerToolItemType = {
+    OpenrouterAdvisor: "openrouter:advisor",
+};
+/** @internal */
+export const OutputAdvisorServerToolItemType$inboundSchema = z.enum(OutputAdvisorServerToolItemType);
+/** @internal */
+export const OutputAdvisorServerToolItemType$outboundSchema = OutputAdvisorServerToolItemType$inboundSchema;
+/** @internal */
+export const OutputAdvisorServerToolItem$inboundSchema = z.object({
+    advice: z.string().optional(),
+    error: z.string().optional(),
+    id: z.string().optional(),
+    instance_name: z.string().optional(),
+    model: z.string().optional(),
+    prompt: z.string().optional(),
+    status: ToolCallStatus$inboundSchema,
+    type: OutputAdvisorServerToolItemType$inboundSchema,
+}).transform((v) => {
+    return remap$(v, {
+        "instance_name": "instanceName",
+    });
+});
+/** @internal */
+export const OutputAdvisorServerToolItem$outboundSchema = z.object({
+    advice: z.string().optional(),
+    error: z.string().optional(),
+    id: z.string().optional(),
+    instanceName: z.string().optional(),
+    model: z.string().optional(),
+    prompt: z.string().optional(),
+    status: ToolCallStatus$outboundSchema,
+    type: OutputAdvisorServerToolItemType$outboundSchema,
+}).transform((v) => {
+    return remap$(v, {
+        instanceName: "instance_name",
+    });
+});
+export function outputAdvisorServerToolItemToJSON(outputAdvisorServerToolItem) {
+    return JSON.stringify(OutputAdvisorServerToolItem$outboundSchema.parse(outputAdvisorServerToolItem));
+}
+export function outputAdvisorServerToolItemFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => OutputAdvisorServerToolItem$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'OutputAdvisorServerToolItem' from JSON`);
+}
+//# sourceMappingURL=outputadvisorservertoolitem.js.map

package/esm/models/outputapplypatchcallitem.d.ts

@@ -0,0 +1,25 @@
+import * as z from "zod/v4";
+import { Result as SafeParseResult } from "../types/fp.js";
+import { ApplyPatchCallOperation } from "./applypatchcalloperation.js";
+import { ApplyPatchCallStatus } from "./applypatchcallstatus.js";
+import { SDKValidationError } from "./errors/sdkvalidationerror.js";
+/**
+ * A native `apply_patch_call` output item matching OpenAI's Responses API shape. Emitted when the client requested the `apply_patch` shorthand.
+ */
+export type OutputApplyPatchCallItem = {
+    callId: string;
+    id: string;
+    /**
+     * The patch operation requested by an `apply_patch_call`. `create_file` and `update_file` carry a V4A diff; `delete_file` omits it.
+     */
+    operation: ApplyPatchCallOperation;
+    /**
+     * Lifecycle state of an `apply_patch_call` output item.
+     */
+    status: ApplyPatchCallStatus;
+    type: "apply_patch_call";
+};
+/** @internal */
+export declare const OutputApplyPatchCallItem$inboundSchema: z.ZodType<OutputApplyPatchCallItem, unknown>;
+export declare function outputApplyPatchCallItemFromJSON(jsonString: string): SafeParseResult<OutputApplyPatchCallItem, SDKValidationError>;
+//# sourceMappingURL=outputapplypatchcallitem.d.ts.map

package/esm/models/outputapplypatchcallitem.js

@@ -0,0 +1,25 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ * @generated-id: 9cfff773cd37
+ */
+import * as z from "zod/v4";
+import { remap as remap$ } from "../lib/primitives.js";
+import { safeParse } from "../lib/schemas.js";
+import { ApplyPatchCallOperation$inboundSchema, } from "./applypatchcalloperation.js";
+import { ApplyPatchCallStatus$inboundSchema, } from "./applypatchcallstatus.js";
+/** @internal */
+export const OutputApplyPatchCallItem$inboundSchema = z.object({
+    call_id: z.string(),
+    id: z.string(),
+    operation: ApplyPatchCallOperation$inboundSchema,
+    status: ApplyPatchCallStatus$inboundSchema,
+    type: z.literal("apply_patch_call"),
+}).transform((v) => {
+    return remap$(v, {
+        "call_id": "callId",
+    });
+});
+export function outputApplyPatchCallItemFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => OutputApplyPatchCallItem$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'OutputApplyPatchCallItem' from JSON`);
+}
+//# sourceMappingURL=outputapplypatchcallitem.js.map

package/esm/models/outputapplypatchservertoolitem.d.ts

@@ -1,6 +1,7 @@
 import * as z from "zod/v4";
 import { ClosedEnum } from "../types/enums.js";
 import { Result as SafeParseResult } from "../types/fp.js";
+import { ApplyPatchCallOperation, ApplyPatchCallOperation$Outbound } from "./applypatchcalloperation.js";
 import { SDKValidationError } from "./errors/sdkvalidationerror.js";
 import { ToolCallStatus } from "./toolcallstatus.js";
 export declare const OutputApplyPatchServerToolItemType: {
@@ -8,12 +9,15 @@ export declare const OutputApplyPatchServerToolItemType: {
 };
 export type OutputApplyPatchServerToolItemType = ClosedEnum<typeof OutputApplyPatchServerToolItemType>;
 /**
- * An openrouter:apply_patch server tool output item
+ * An openrouter:apply_patch server tool output item. The turn halts when validation succeeds so the client can apply the patch and echo an `apply_patch_call_output` on the next turn.
  */
 export type OutputApplyPatchServerToolItem = {
-    filePath?: string | undefined;
+    callId?: string | undefined;
     id?: string | undefined;
-    patch?: string | undefined;
+    /**
+     * The patch operation requested by an `apply_patch_call`. `create_file` and `update_file` carry a V4A diff; `delete_file` omits it.
+     */
+    operation?: ApplyPatchCallOperation | undefined;
     status: ToolCallStatus;
     type: OutputApplyPatchServerToolItemType;
 };
@@ -25,9 +29,9 @@ export declare const OutputApplyPatchServerToolItemType$outboundSchema: z.ZodEnu
 export declare const OutputApplyPatchServerToolItem$inboundSchema: z.ZodType<OutputApplyPatchServerToolItem, unknown>;
 /** @internal */
 export type OutputApplyPatchServerToolItem$Outbound = {
-    filePath?: string | undefined;
+    call_id?: string | undefined;
     id?: string | undefined;
-    patch?: string | undefined;
+    operation?: ApplyPatchCallOperation$Outbound | undefined;
     status: string;
     type: string;
 };

package/esm/models/outputapplypatchservertoolitem.js

@@ -3,7 +3,9 @@
  * @generated-id: 761046712899
  */
 import * as z from "zod/v4";
+import { remap as remap$ } from "../lib/primitives.js";
 import { safeParse } from "../lib/schemas.js";
+import { ApplyPatchCallOperation$inboundSchema, ApplyPatchCallOperation$outboundSchema, } from "./applypatchcalloperation.js";
 import { ToolCallStatus$inboundSchema, ToolCallStatus$outboundSchema, } from "./toolcallstatus.js";
 export const OutputApplyPatchServerToolItemType = {
     OpenrouterApplyPatch: "openrouter:apply_patch",
@@ -14,19 +16,27 @@ export const OutputApplyPatchServerToolItemType$inboundSchema = z.enum(OutputApp
 export const OutputApplyPatchServerToolItemType$outboundSchema = OutputApplyPatchServerToolItemType$inboundSchema;
 /** @internal */
 export const OutputApplyPatchServerToolItem$inboundSchema = z.object({
-    filePath: z.string().optional(),
+    call_id: z.string().optional(),
     id: z.string().optional(),
-    patch: z.string().optional(),
+    operation: ApplyPatchCallOperation$inboundSchema.optional(),
     status: ToolCallStatus$inboundSchema,
     type: OutputApplyPatchServerToolItemType$inboundSchema,
+}).transform((v) => {
+    return remap$(v, {
+        "call_id": "callId",
+    });
 });
 /** @internal */
 export const OutputApplyPatchServerToolItem$outboundSchema = z.object({
-    filePath: z.string().optional(),
+    callId: z.string().optional(),
     id: z.string().optional(),
-    patch: z.string().optional(),
+    operation: ApplyPatchCallOperation$outboundSchema.optional(),
     status: ToolCallStatus$outboundSchema,
     type: OutputApplyPatchServerToolItemType$outboundSchema,
+}).transform((v) => {
+    return remap$(v, {
+        callId: "call_id",
+    });
 });
 export function outputApplyPatchServerToolItemToJSON(outputApplyPatchServerToolItem) {
     return JSON.stringify(OutputApplyPatchServerToolItem$outboundSchema.parse(outputApplyPatchServerToolItem));

package/esm/models/outputcustomtoolcallitem.d.ts

@@ -0,0 +1,42 @@
+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 OutputCustomToolCallItemType: {
+    readonly CustomToolCall: "custom_tool_call";
+};
+export type OutputCustomToolCallItemType = ClosedEnum<typeof OutputCustomToolCallItemType>;
+/**
+ * A call to a custom (freeform-grammar) tool created by the model — distinct from `function_call`. Used for tools like Codex CLI's `apply_patch` whose payload is opaque text rather than JSON arguments.
+ */
+export type OutputCustomToolCallItem = {
+    callId: string;
+    id?: string | undefined;
+    input: string;
+    name: string;
+    /**
+     * Namespace qualifier for tools registered as part of a namespace tool group (e.g. an MCP server)
+     */
+    namespace?: string | undefined;
+    type: OutputCustomToolCallItemType;
+};
+/** @internal */
+export declare const OutputCustomToolCallItemType$inboundSchema: z.ZodEnum<typeof OutputCustomToolCallItemType>;
+/** @internal */
+export declare const OutputCustomToolCallItemType$outboundSchema: z.ZodEnum<typeof OutputCustomToolCallItemType>;
+/** @internal */
+export declare const OutputCustomToolCallItem$inboundSchema: z.ZodType<OutputCustomToolCallItem, unknown>;
+/** @internal */
+export type OutputCustomToolCallItem$Outbound = {
+    call_id: string;
+    id?: string | undefined;
+    input: string;
+    name: string;
+    namespace?: string | undefined;
+    type: string;
+};
+/** @internal */
+export declare const OutputCustomToolCallItem$outboundSchema: z.ZodType<OutputCustomToolCallItem$Outbound, OutputCustomToolCallItem>;
+export declare function outputCustomToolCallItemToJSON(outputCustomToolCallItem: OutputCustomToolCallItem): string;
+export declare function outputCustomToolCallItemFromJSON(jsonString: string): SafeParseResult<OutputCustomToolCallItem, SDKValidationError>;
+//# sourceMappingURL=outputcustomtoolcallitem.d.ts.map

package/esm/models/outputcustomtoolcallitem.js

@@ -0,0 +1,47 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ * @generated-id: 71596c10c79b
+ */
+import * as z from "zod/v4";
+import { remap as remap$ } from "../lib/primitives.js";
+import { safeParse } from "../lib/schemas.js";
+export const OutputCustomToolCallItemType = {
+    CustomToolCall: "custom_tool_call",
+};
+/** @internal */
+export const OutputCustomToolCallItemType$inboundSchema = z.enum(OutputCustomToolCallItemType);
+/** @internal */
+export const OutputCustomToolCallItemType$outboundSchema = OutputCustomToolCallItemType$inboundSchema;
+/** @internal */
+export const OutputCustomToolCallItem$inboundSchema = z.object({
+    call_id: z.string(),
+    id: z.string().optional(),
+    input: z.string(),
+    name: z.string(),
+    namespace: z.string().optional(),
+    type: OutputCustomToolCallItemType$inboundSchema,
+}).transform((v) => {
+    return remap$(v, {
+        "call_id": "callId",
+    });
+});
+/** @internal */
+export const OutputCustomToolCallItem$outboundSchema = z.object({
+    callId: z.string(),
+    id: z.string().optional(),
+    input: z.string(),
+    name: z.string(),
+    namespace: z.string().optional(),
+    type: OutputCustomToolCallItemType$outboundSchema,
+}).transform((v) => {
+    return remap$(v, {
+        callId: "call_id",
+    });
+});
+export function outputCustomToolCallItemToJSON(outputCustomToolCallItem) {
+    return JSON.stringify(OutputCustomToolCallItem$outboundSchema.parse(outputCustomToolCallItem));
+}
+export function outputCustomToolCallItemFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => OutputCustomToolCallItem$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'OutputCustomToolCallItem' from JSON`);
+}
+//# sourceMappingURL=outputcustomtoolcallitem.js.map

package/esm/models/outputfusionservertoolitem.d.ts

@@ -0,0 +1,101 @@
+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 { FusionAnalysisResult, FusionAnalysisResult$Outbound } from "./fusionanalysisresult.js";
+import { ToolCallStatus } from "./toolcallstatus.js";
+export type FailedModel = {
+    /**
+     * Error message describing why the model failed.
+     */
+    error: string;
+    /**
+     * Slug of the analysis model that failed.
+     */
+    model: string;
+    /**
+     * HTTP status code from the upstream response, when available (e.g. 402, 429).
+     */
+    statusCode?: number | undefined;
+};
+export type ResponseT = {
+    content?: string | undefined;
+    model: string;
+};
+export declare const OutputFusionServerToolItemType: {
+    readonly OpenrouterFusion: "openrouter:fusion";
+};
+export type OutputFusionServerToolItemType = ClosedEnum<typeof OutputFusionServerToolItemType>;
+/**
+ * An openrouter:fusion server tool output item
+ */
+export type OutputFusionServerToolItem = {
+    /**
+     * Structured analysis produced by the fusion judge model.
+     */
+    analysis?: FusionAnalysisResult | undefined;
+    /**
+     * Error message when the fusion run did not produce an analysis result.
+     */
+    error?: string | undefined;
+    /**
+     * Models that were requested as part of the analysis panel but did not produce a response. Present when at least one requested analysis model failed. The fusion result is still usable but was produced from a degraded panel.
+     */
+    failedModels?: Array<FailedModel> | undefined;
+    /**
+     * Typed failure reason when the fusion run failed. Possible values include: all_panels_failed, insufficient_credits, rate_limited, judge_not_valid_json, judge_schema_mismatch, judge_upstream_error, judge_empty_completion.
+     */
+    failureReason?: string | undefined;
+    id?: string | undefined;
+    /**
+     * Analysis models that produced a response in this fusion run, with each model's full panel content.
+     */
+    responses?: Array<ResponseT> | undefined;
+    status: ToolCallStatus;
+    type: OutputFusionServerToolItemType;
+};
+/** @internal */
+export declare const FailedModel$inboundSchema: z.ZodType<FailedModel, unknown>;
+/** @internal */
+export type FailedModel$Outbound = {
+    error: string;
+    model: string;
+    status_code?: number | undefined;
+};
+/** @internal */
+export declare const FailedModel$outboundSchema: z.ZodType<FailedModel$Outbound, FailedModel>;
+export declare function failedModelToJSON(failedModel: FailedModel): string;
+export declare function failedModelFromJSON(jsonString: string): SafeParseResult<FailedModel, SDKValidationError>;
+/** @internal */
+export declare const ResponseT$inboundSchema: z.ZodType<ResponseT, unknown>;
+/** @internal */
+export type ResponseT$Outbound = {
+    content?: string | undefined;
+    model: string;
+};
+/** @internal */
+export declare const ResponseT$outboundSchema: z.ZodType<ResponseT$Outbound, ResponseT>;
+export declare function responseToJSON(responseT: ResponseT): string;
+export declare function responseFromJSON(jsonString: string): SafeParseResult<ResponseT, SDKValidationError>;
+/** @internal */
+export declare const OutputFusionServerToolItemType$inboundSchema: z.ZodEnum<typeof OutputFusionServerToolItemType>;
+/** @internal */
+export declare const OutputFusionServerToolItemType$outboundSchema: z.ZodEnum<typeof OutputFusionServerToolItemType>;
+/** @internal */
+export declare const OutputFusionServerToolItem$inboundSchema: z.ZodType<OutputFusionServerToolItem, unknown>;
+/** @internal */
+export type OutputFusionServerToolItem$Outbound = {
+    analysis?: FusionAnalysisResult$Outbound | undefined;
+    error?: string | undefined;
+    failed_models?: Array<FailedModel$Outbound> | undefined;
+    failure_reason?: string | undefined;
+    id?: string | undefined;
+    responses?: Array<ResponseT$Outbound> | undefined;
+    status: string;
+    type: string;
+};
+/** @internal */
+export declare const OutputFusionServerToolItem$outboundSchema: z.ZodType<OutputFusionServerToolItem$Outbound, OutputFusionServerToolItem>;
+export declare function outputFusionServerToolItemToJSON(outputFusionServerToolItem: OutputFusionServerToolItem): string;
+export declare function outputFusionServerToolItemFromJSON(jsonString: string): SafeParseResult<OutputFusionServerToolItem, SDKValidationError>;
+//# sourceMappingURL=outputfusionservertoolitem.d.ts.map

package/esm/models/outputfusionservertoolitem.js

@@ -0,0 +1,98 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ * @generated-id: 30bcfe965217
+ */
+import * as z from "zod/v4";
+import { remap as remap$ } from "../lib/primitives.js";
+import { safeParse } from "../lib/schemas.js";
+import { FusionAnalysisResult$inboundSchema, FusionAnalysisResult$outboundSchema, } from "./fusionanalysisresult.js";
+import { ToolCallStatus$inboundSchema, ToolCallStatus$outboundSchema, } from "./toolcallstatus.js";
+export const OutputFusionServerToolItemType = {
+    OpenrouterFusion: "openrouter:fusion",
+};
+/** @internal */
+export const FailedModel$inboundSchema = z
+    .object({
+    error: z.string(),
+    model: z.string(),
+    status_code: z.int().optional(),
+}).transform((v) => {
+    return remap$(v, {
+        "status_code": "statusCode",
+    });
+});
+/** @internal */
+export const FailedModel$outboundSchema = z.object({
+    error: z.string(),
+    model: z.string(),
+    statusCode: z.int().optional(),
+}).transform((v) => {
+    return remap$(v, {
+        statusCode: "status_code",
+    });
+});
+export function failedModelToJSON(failedModel) {
+    return JSON.stringify(FailedModel$outboundSchema.parse(failedModel));
+}
+export function failedModelFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => FailedModel$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'FailedModel' from JSON`);
+}
+/** @internal */
+export const ResponseT$inboundSchema = z.object({
+    content: z.string().optional(),
+    model: z.string(),
+});
+/** @internal */
+export const ResponseT$outboundSchema = z.object({
+    content: z.string().optional(),
+    model: z.string(),
+});
+export function responseToJSON(responseT) {
+    return JSON.stringify(ResponseT$outboundSchema.parse(responseT));
+}
+export function responseFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => ResponseT$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'ResponseT' from JSON`);
+}
+/** @internal */
+export const OutputFusionServerToolItemType$inboundSchema = z.enum(OutputFusionServerToolItemType);
+/** @internal */
+export const OutputFusionServerToolItemType$outboundSchema = OutputFusionServerToolItemType$inboundSchema;
+/** @internal */
+export const OutputFusionServerToolItem$inboundSchema = z.object({
+    analysis: FusionAnalysisResult$inboundSchema.optional(),
+    error: z.string().optional(),
+    failed_models: z.array(z.lazy(() => FailedModel$inboundSchema)).optional(),
+    failure_reason: z.string().optional(),
+    id: z.string().optional(),
+    responses: z.array(z.lazy(() => ResponseT$inboundSchema)).optional(),
+    status: ToolCallStatus$inboundSchema,
+    type: OutputFusionServerToolItemType$inboundSchema,
+}).transform((v) => {
+    return remap$(v, {
+        "failed_models": "failedModels",
+        "failure_reason": "failureReason",
+    });
+});
+/** @internal */
+export const OutputFusionServerToolItem$outboundSchema = z.object({
+    analysis: FusionAnalysisResult$outboundSchema.optional(),
+    error: z.string().optional(),
+    failedModels: z.array(z.lazy(() => FailedModel$outboundSchema)).optional(),
+    failureReason: z.string().optional(),
+    id: z.string().optional(),
+    responses: z.array(z.lazy(() => ResponseT$outboundSchema)).optional(),
+    status: ToolCallStatus$outboundSchema,
+    type: OutputFusionServerToolItemType$outboundSchema,
+}).transform((v) => {
+    return remap$(v, {
+        failedModels: "failed_models",
+        failureReason: "failure_reason",
+    });
+});
+export function outputFusionServerToolItemToJSON(outputFusionServerToolItem) {
+    return JSON.stringify(OutputFusionServerToolItem$outboundSchema.parse(outputFusionServerToolItem));
+}
+export function outputFusionServerToolItemFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => OutputFusionServerToolItem$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'OutputFusionServerToolItem' from JSON`);
+}
+//# sourceMappingURL=outputfusionservertoolitem.js.map

package/esm/models/outputitems.d.ts

@@ -2,16 +2,20 @@ 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 { OutputAdvisorServerToolItem } from "./outputadvisorservertoolitem.js";
+import { OutputApplyPatchCallItem } from "./outputapplypatchcallitem.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 { OutputCustomToolCallItem } from "./outputcustomtoolcallitem.js";
 import { OutputDatetimeItem } from "./outputdatetimeitem.js";
 import { OutputFileSearchCallItem } from "./outputfilesearchcallitem.js";
 import { OutputFileSearchServerToolItem } from "./outputfilesearchservertoolitem.js";
 import { OutputFunctionCallItem } from "./outputfunctioncallitem.js";
+import { OutputFusionServerToolItem } from "./outputfusionservertoolitem.js";
 import { OutputImageGenerationCallItem } from "./outputimagegenerationcallitem.js";
 import { OutputImageGenerationServerToolItem } from "./outputimagegenerationservertoolitem.js";
 import { OutputMcpServerToolItem } from "./outputmcpservertoolitem.js";
@@ -19,6 +23,9 @@ import { OutputMemoryServerToolItem } from "./outputmemoryservertoolitem.js";
 import { OutputMessageItem } from "./outputmessageitem.js";
 import { OutputReasoningItem } from "./outputreasoningitem.js";
 import { OutputSearchModelsServerToolItem } from "./outputsearchmodelsservertoolitem.js";
+import { OutputShellCallItem } from "./outputshellcallitem.js";
+import { OutputShellCallOutputItem } from "./outputshellcalloutputitem.js";
+import { OutputSubagentServerToolItem } from "./outputsubagentservertoolitem.js";
 import { OutputTextEditorServerToolItem } from "./outputtexteditorservertoolitem.js";
 import { OutputToolSearchServerToolItem } from "./outputtoolsearchservertoolitem.js";
 import { OutputWebFetchServerToolItem } from "./outputwebfetchservertoolitem.js";
@@ -27,17 +34,21 @@ import { OutputWebSearchServerToolItem } from "./outputwebsearchservertoolitem.j
 /**
  * An output item from the response
  */
-export type OutputItems = (OutputCodeInterpreterCallItem & {
+export type OutputItems = OutputApplyPatchCallItem | (OutputCodeInterpreterCallItem & {
     type: "code_interpreter_call";
 }) | (OutputComputerCallItem & {
     type: "computer_call";
+}) | (OutputCustomToolCallItem & {
+    type: "custom_tool_call";
 }) | (OutputFileSearchCallItem & {
     type: "file_search_call";
 }) | (OutputFunctionCallItem & {
     type: "function_call";
 }) | (OutputImageGenerationCallItem & {
     type: "image_generation_call";
-}) | OutputMessageItem | (OutputApplyPatchServerToolItem & {
+}) | OutputMessageItem | (OutputAdvisorServerToolItem & {
+    type: "openrouter:advisor";
+}) | (OutputApplyPatchServerToolItem & {
     type: "openrouter:apply_patch";
 }) | (OutputBashServerToolItem & {
     type: "openrouter:bash";
@@ -51,12 +62,16 @@ export type OutputItems = (OutputCodeInterpreterCallItem & {
     type: "openrouter:experimental__search_models";
 }) | (OutputFileSearchServerToolItem & {
     type: "openrouter:file_search";
+}) | (OutputFusionServerToolItem & {
+    type: "openrouter:fusion";
 }) | (OutputImageGenerationServerToolItem & {
     type: "openrouter:image_generation";
 }) | (OutputMcpServerToolItem & {
     type: "openrouter:mcp";
 }) | (OutputMemoryServerToolItem & {
     type: "openrouter:memory";
+}) | (OutputSubagentServerToolItem & {
+    type: "openrouter:subagent";
 }) | (OutputTextEditorServerToolItem & {
     type: "openrouter:text_editor";
 }) | (OutputToolSearchServerToolItem & {
@@ -65,7 +80,7 @@ export type OutputItems = (OutputCodeInterpreterCallItem & {
     type: "openrouter:web_fetch";
 }) | (OutputWebSearchServerToolItem & {
     type: "openrouter:web_search";
-}) | OutputReasoningItem | (OutputWebSearchCallItem & {
+}) | OutputReasoningItem | OutputShellCallItem | OutputShellCallOutputItem | (OutputWebSearchCallItem & {
     type: "web_search_call";
 }) | discriminatedUnionTypes.Unknown<"type">;
 /** @internal */