@openrouter/sdk 1.4.24 → 1.5.0

package/esm/models/outputapplypatchservertoolitem.d.ts

@@ -3,7 +3,7 @@ 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";
+import { FailableToolCallStatus } from "./failabletoolcallstatus.js";
 export declare const OutputApplyPatchServerToolItemType: {
     readonly OpenrouterApplyPatch: "openrouter:apply_patch";
 };
@@ -13,12 +13,16 @@ export type OutputApplyPatchServerToolItemType = ClosedEnum<typeof OutputApplyPa
  */
 export type OutputApplyPatchServerToolItem = {
     callId?: string | undefined;
+    /**
+     * The error message when the tool call failed before producing a result. Set together with `status: 'failed'`; absent on a successful call.
+     */
+    error?: string | undefined;
     id?: 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;
+    status: FailableToolCallStatus;
     type: OutputApplyPatchServerToolItemType;
 };
 /** @internal */
@@ -30,6 +34,7 @@ export declare const OutputApplyPatchServerToolItem$inboundSchema: z.ZodType<Out
 /** @internal */
 export type OutputApplyPatchServerToolItem$Outbound = {
     call_id?: string | undefined;
+    error?: string | undefined;
     id?: string | undefined;
     operation?: ApplyPatchCallOperation$Outbound | undefined;
     status: string;

package/esm/models/outputapplypatchservertoolitem.js

@@ -6,7 +6,7 @@ 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";
+import { FailableToolCallStatus$inboundSchema, FailableToolCallStatus$outboundSchema, } from "./failabletoolcallstatus.js";
 export const OutputApplyPatchServerToolItemType = {
     OpenrouterApplyPatch: "openrouter:apply_patch",
 };
@@ -17,9 +17,10 @@ export const OutputApplyPatchServerToolItemType$outboundSchema = OutputApplyPatc
 /** @internal */
 export const OutputApplyPatchServerToolItem$inboundSchema = z.object({
     call_id: z.string().optional(),
+    error: z.string().optional(),
     id: z.string().optional(),
     operation: ApplyPatchCallOperation$inboundSchema.optional(),
-    status: ToolCallStatus$inboundSchema,
+    status: FailableToolCallStatus$inboundSchema,
     type: OutputApplyPatchServerToolItemType$inboundSchema,
 }).transform((v) => {
     return remap$(v, {
@@ -29,9 +30,10 @@ export const OutputApplyPatchServerToolItem$inboundSchema = z.object({
 /** @internal */
 export const OutputApplyPatchServerToolItem$outboundSchema = z.object({
     callId: z.string().optional(),
+    error: z.string().optional(),
     id: z.string().optional(),
     operation: ApplyPatchCallOperation$outboundSchema.optional(),
-    status: ToolCallStatus$outboundSchema,
+    status: FailableToolCallStatus$outboundSchema,
     type: OutputApplyPatchServerToolItemType$outboundSchema,
 }).transform((v) => {
     return remap$(v, {

package/esm/models/outputarmorblockeditem.d.ts

@@ -0,0 +1,71 @@
+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 OutputArmorBlockedItemStatus: {
+    readonly Completed: "completed";
+};
+export type OutputArmorBlockedItemStatus = ClosedEnum<typeof OutputArmorBlockedItemStatus>;
+export declare const OutputArmorBlockedItemType: {
+    readonly OpenrouterArmorBlocked: "openrouter:armor_blocked";
+};
+export type OutputArmorBlockedItemType = ClosedEnum<typeof OutputArmorBlockedItemType>;
+/**
+ * A client tool call that OpenRouter Armor blocked. Emitted in place of the call when `plugins[armor].output_mode` is `custom_item`.
+ */
+export type OutputArmorBlockedItem = {
+    /**
+     * The arguments exactly as the model wrote them.
+     */
+    arguments: string;
+    /**
+     * The call id the model chose. Use it to find this call in `safeguard_results`.
+     */
+    callId: string;
+    /**
+     * The rule that blocked the call, in the same `[Rule Name]` form as `safeguard_results`.
+     */
+    explanation: string;
+    id: string;
+    /**
+     * The name of the tool the model called.
+     */
+    name: string;
+    /**
+     * The namespace the tool belongs to, for namespaced tools such as MCP. Absent for a plain function tool.
+     */
+    namespace?: string | undefined;
+    /**
+     * The error text the model received as the result of this call. Sending this item back replays that text to the model.
+     */
+    reason: string;
+    status: OutputArmorBlockedItemStatus;
+    type: OutputArmorBlockedItemType;
+};
+/** @internal */
+export declare const OutputArmorBlockedItemStatus$inboundSchema: z.ZodEnum<typeof OutputArmorBlockedItemStatus>;
+/** @internal */
+export declare const OutputArmorBlockedItemStatus$outboundSchema: z.ZodEnum<typeof OutputArmorBlockedItemStatus>;
+/** @internal */
+export declare const OutputArmorBlockedItemType$inboundSchema: z.ZodEnum<typeof OutputArmorBlockedItemType>;
+/** @internal */
+export declare const OutputArmorBlockedItemType$outboundSchema: z.ZodEnum<typeof OutputArmorBlockedItemType>;
+/** @internal */
+export declare const OutputArmorBlockedItem$inboundSchema: z.ZodType<OutputArmorBlockedItem, unknown>;
+/** @internal */
+export type OutputArmorBlockedItem$Outbound = {
+    arguments: string;
+    call_id: string;
+    explanation: string;
+    id: string;
+    name: string;
+    namespace?: string | undefined;
+    reason: string;
+    status: string;
+    type: string;
+};
+/** @internal */
+export declare const OutputArmorBlockedItem$outboundSchema: z.ZodType<OutputArmorBlockedItem$Outbound, OutputArmorBlockedItem>;
+export declare function outputArmorBlockedItemToJSON(outputArmorBlockedItem: OutputArmorBlockedItem): string;
+export declare function outputArmorBlockedItemFromJSON(jsonString: string): SafeParseResult<OutputArmorBlockedItem, SDKValidationError>;
+//# sourceMappingURL=outputarmorblockeditem.d.ts.map

package/esm/models/outputarmorblockeditem.js

@@ -0,0 +1,60 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ * @generated-id: 97c8f227ed0a
+ */
+import * as z from "zod/v4";
+import { remap as remap$ } from "../lib/primitives.js";
+import { safeParse } from "../lib/schemas.js";
+export const OutputArmorBlockedItemStatus = {
+    Completed: "completed",
+};
+export const OutputArmorBlockedItemType = {
+    OpenrouterArmorBlocked: "openrouter:armor_blocked",
+};
+/** @internal */
+export const OutputArmorBlockedItemStatus$inboundSchema = z.enum(OutputArmorBlockedItemStatus);
+/** @internal */
+export const OutputArmorBlockedItemStatus$outboundSchema = OutputArmorBlockedItemStatus$inboundSchema;
+/** @internal */
+export const OutputArmorBlockedItemType$inboundSchema = z.enum(OutputArmorBlockedItemType);
+/** @internal */
+export const OutputArmorBlockedItemType$outboundSchema = OutputArmorBlockedItemType$inboundSchema;
+/** @internal */
+export const OutputArmorBlockedItem$inboundSchema = z.object({
+    arguments: z.string(),
+    call_id: z.string(),
+    explanation: z.string(),
+    id: z.string(),
+    name: z.string(),
+    namespace: z.string().optional(),
+    reason: z.string(),
+    status: OutputArmorBlockedItemStatus$inboundSchema,
+    type: OutputArmorBlockedItemType$inboundSchema,
+}).transform((v) => {
+    return remap$(v, {
+        "call_id": "callId",
+    });
+});
+/** @internal */
+export const OutputArmorBlockedItem$outboundSchema = z.object({
+    arguments: z.string(),
+    callId: z.string(),
+    explanation: z.string(),
+    id: z.string(),
+    name: z.string(),
+    namespace: z.string().optional(),
+    reason: z.string(),
+    status: OutputArmorBlockedItemStatus$outboundSchema,
+    type: OutputArmorBlockedItemType$outboundSchema,
+}).transform((v) => {
+    return remap$(v, {
+        callId: "call_id",
+    });
+});
+export function outputArmorBlockedItemToJSON(outputArmorBlockedItem) {
+    return JSON.stringify(OutputArmorBlockedItem$outboundSchema.parse(outputArmorBlockedItem));
+}
+export function outputArmorBlockedItemFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => OutputArmorBlockedItem$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'OutputArmorBlockedItem' from JSON`);
+}
+//# sourceMappingURL=outputarmorblockeditem.js.map

package/esm/models/outputdatetimeitem.d.ts

@@ -2,7 +2,7 @@ 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";
+import { FailableToolCallStatus } from "./failabletoolcallstatus.js";
 export declare const OutputDatetimeItemType: {
     readonly OpenrouterDatetime: "openrouter:datetime";
 };
@@ -15,8 +15,12 @@ export type OutputDatetimeItem = {
      * ISO 8601 datetime string
      */
     datetime: string;
+    /**
+     * The error message when the tool call failed before producing a result. Set together with `status: 'failed'`; absent on a successful call.
+     */
+    error?: string | undefined;
     id?: string | undefined;
-    status: ToolCallStatus;
+    status: FailableToolCallStatus;
     /**
      * IANA timezone name
      */
@@ -32,6 +36,7 @@ export declare const OutputDatetimeItem$inboundSchema: z.ZodType<OutputDatetimeI
 /** @internal */
 export type OutputDatetimeItem$Outbound = {
     datetime: string;
+    error?: string | undefined;
     id?: string | undefined;
     status: string;
     timezone: string;

package/esm/models/outputdatetimeitem.js

@@ -4,7 +4,7 @@
  */
 import * as z from "zod/v4";
 import { safeParse } from "../lib/schemas.js";
-import { ToolCallStatus$inboundSchema, ToolCallStatus$outboundSchema, } from "./toolcallstatus.js";
+import { FailableToolCallStatus$inboundSchema, FailableToolCallStatus$outboundSchema, } from "./failabletoolcallstatus.js";
 export const OutputDatetimeItemType = {
     OpenrouterDatetime: "openrouter:datetime",
 };
@@ -15,16 +15,18 @@ export const OutputDatetimeItemType$outboundSchema = OutputDatetimeItemType$inbo
 /** @internal */
 export const OutputDatetimeItem$inboundSchema = z.object({
     datetime: z.string(),
+    error: z.string().optional(),
     id: z.string().optional(),
-    status: ToolCallStatus$inboundSchema,
+    status: FailableToolCallStatus$inboundSchema,
     timezone: z.string(),
     type: OutputDatetimeItemType$inboundSchema,
 });
 /** @internal */
 export const OutputDatetimeItem$outboundSchema = z.object({
     datetime: z.string(),
+    error: z.string().optional(),
     id: z.string().optional(),
-    status: ToolCallStatus$outboundSchema,
+    status: FailableToolCallStatus$outboundSchema,
     timezone: z.string(),
     type: OutputDatetimeItemType$outboundSchema,
 });

package/esm/models/outputimagegenerationservertoolitem.d.ts

@@ -2,7 +2,7 @@ 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";
+import { FailableToolCallStatus } from "./failabletoolcallstatus.js";
 export declare const OutputImageGenerationServerToolItemType: {
     readonly OpenrouterImageGeneration: "openrouter:image_generation";
 };
@@ -11,6 +11,10 @@ export type OutputImageGenerationServerToolItemType = ClosedEnum<typeof OutputIm
  * An openrouter:image_generation server tool output item
  */
 export type OutputImageGenerationServerToolItem = {
+    /**
+     * The error message when the tool call failed before producing a result. Set together with `status: 'failed'`; absent on a successful call.
+     */
+    error?: string | undefined;
     id?: string | undefined;
     imageB64?: string | undefined;
     imageUrl?: string | undefined;
@@ -23,7 +27,7 @@ export type OutputImageGenerationServerToolItem = {
      */
     result?: string | null | undefined;
     revisedPrompt?: string | undefined;
-    status: ToolCallStatus;
+    status: FailableToolCallStatus;
     type: OutputImageGenerationServerToolItemType;
 };
 /** @internal */
@@ -34,6 +38,7 @@ export declare const OutputImageGenerationServerToolItemType$outboundSchema: z.Z
 export declare const OutputImageGenerationServerToolItem$inboundSchema: z.ZodType<OutputImageGenerationServerToolItem, unknown>;
 /** @internal */
 export type OutputImageGenerationServerToolItem$Outbound = {
+    error?: string | undefined;
     id?: string | undefined;
     imageB64?: string | undefined;
     imageUrl?: string | undefined;

package/esm/models/outputimagegenerationservertoolitem.js

@@ -4,7 +4,7 @@
  */
 import * as z from "zod/v4";
 import { safeParse } from "../lib/schemas.js";
-import { ToolCallStatus$inboundSchema, ToolCallStatus$outboundSchema, } from "./toolcallstatus.js";
+import { FailableToolCallStatus$inboundSchema, FailableToolCallStatus$outboundSchema, } from "./failabletoolcallstatus.js";
 export const OutputImageGenerationServerToolItemType = {
     OpenrouterImageGeneration: "openrouter:image_generation",
 };
@@ -14,24 +14,26 @@ export const OutputImageGenerationServerToolItemType$inboundSchema = z.enum(Outp
 export const OutputImageGenerationServerToolItemType$outboundSchema = OutputImageGenerationServerToolItemType$inboundSchema;
 /** @internal */
 export const OutputImageGenerationServerToolItem$inboundSchema = z.object({
+    error: z.string().optional(),
     id: z.string().optional(),
     imageB64: z.string().optional(),
     imageUrl: z.string().optional(),
     prompt: z.string().optional(),
     result: z.nullable(z.string()).optional(),
     revisedPrompt: z.string().optional(),
-    status: ToolCallStatus$inboundSchema,
+    status: FailableToolCallStatus$inboundSchema,
     type: OutputImageGenerationServerToolItemType$inboundSchema,
 });
 /** @internal */
 export const OutputImageGenerationServerToolItem$outboundSchema = z.object({
+    error: z.string().optional(),
     id: z.string().optional(),
     imageB64: z.string().optional(),
     imageUrl: z.string().optional(),
     prompt: z.string().optional(),
     result: z.nullable(z.string()).optional(),
     revisedPrompt: z.string().optional(),
-    status: ToolCallStatus$outboundSchema,
+    status: FailableToolCallStatus$outboundSchema,
     type: OutputImageGenerationServerToolItemType$outboundSchema,
 });
 export function outputImageGenerationServerToolItemToJSON(outputImageGenerationServerToolItem) {

package/esm/models/outputitems.d.ts

@@ -5,6 +5,7 @@ import { SDKValidationError } from "./errors/sdkvalidationerror.js";
 import { OutputAdvisorServerToolItem } from "./outputadvisorservertoolitem.js";
 import { OutputApplyPatchCallItem } from "./outputapplypatchcallitem.js";
 import { OutputApplyPatchServerToolItem } from "./outputapplypatchservertoolitem.js";
+import { OutputArmorBlockedItem } from "./outputarmorblockeditem.js";
 import { OutputBashServerToolItem } from "./outputbashservertoolitem.js";
 import { OutputBrowserUseServerToolItem } from "./outputbrowseruseservertoolitem.js";
 import { OutputCodeInterpreterCallItem } from "./outputcodeinterpretercallitem.js";
@@ -29,6 +30,7 @@ import { OutputShellCallOutputItem } from "./outputshellcalloutputitem.js";
 import { OutputShellServerToolItem } from "./outputshellservertoolitem.js";
 import { OutputSubagentServerToolItem } from "./outputsubagentservertoolitem.js";
 import { OutputTextEditorServerToolItem } from "./outputtexteditorservertoolitem.js";
+import { OutputToolSearchCallItem } from "./outputtoolsearchcallitem.js";
 import { OutputToolSearchServerToolItem } from "./outputtoolsearchservertoolitem.js";
 import { OutputWebFetchServerToolItem } from "./outputwebfetchservertoolitem.js";
 import { OutputWebSearchCallItem } from "./outputwebsearchcallitem.js";
@@ -48,6 +50,8 @@ export type OutputItems = OutputApplyPatchCallItem | (OutputCodeInterpreterCallI
     type: "openrouter:advisor";
 }) | (OutputApplyPatchServerToolItem & {
     type: "openrouter:apply_patch";
+}) | (OutputArmorBlockedItem & {
+    type: "openrouter:armor_blocked";
 }) | (OutputBashServerToolItem & {
     type: "openrouter:bash";
 }) | (OutputBrowserUseServerToolItem & {
@@ -82,7 +86,7 @@ export type OutputItems = OutputApplyPatchCallItem | (OutputCodeInterpreterCallI
     type: "openrouter:web_fetch";
 }) | (OutputWebSearchServerToolItem & {
     type: "openrouter:web_search";
-}) | OutputReasoningItem | OutputShellCallItem | OutputShellCallOutputItem | (OutputWebSearchCallItem & {
+}) | OutputReasoningItem | OutputShellCallItem | OutputShellCallOutputItem | OutputToolSearchCallItem | (OutputWebSearchCallItem & {
     type: "web_search_call";
 }) | discriminatedUnionTypes.Unknown<"type">;
 /** @internal */

package/esm/models/outputitems.js

@@ -8,6 +8,7 @@ import { discriminatedUnion } from "../types/discriminatedUnion.js";
 import { OutputAdvisorServerToolItem$inboundSchema, } from "./outputadvisorservertoolitem.js";
 import { OutputApplyPatchCallItem$inboundSchema, } from "./outputapplypatchcallitem.js";
 import { OutputApplyPatchServerToolItem$inboundSchema, } from "./outputapplypatchservertoolitem.js";
+import { OutputArmorBlockedItem$inboundSchema, } from "./outputarmorblockeditem.js";
 import { OutputBashServerToolItem$inboundSchema, } from "./outputbashservertoolitem.js";
 import { OutputBrowserUseServerToolItem$inboundSchema, } from "./outputbrowseruseservertoolitem.js";
 import { OutputCodeInterpreterCallItem$inboundSchema, } from "./outputcodeinterpretercallitem.js";
@@ -32,6 +33,7 @@ import { OutputShellCallOutputItem$inboundSchema, } from "./outputshellcalloutpu
 import { OutputShellServerToolItem$inboundSchema, } from "./outputshellservertoolitem.js";
 import { OutputSubagentServerToolItem$inboundSchema, } from "./outputsubagentservertoolitem.js";
 import { OutputTextEditorServerToolItem$inboundSchema, } from "./outputtexteditorservertoolitem.js";
+import { OutputToolSearchCallItem$inboundSchema, } from "./outputtoolsearchcallitem.js";
 import { OutputToolSearchServerToolItem$inboundSchema, } from "./outputtoolsearchservertoolitem.js";
 import { OutputWebFetchServerToolItem$inboundSchema, } from "./outputwebfetchservertoolitem.js";
 import { OutputWebSearchCallItem$inboundSchema, } from "./outputwebsearchcallitem.js";
@@ -49,6 +51,7 @@ export const OutputItems$inboundSchema = discriminatedUnion("type", {
     ["openrouter:advisor"]: OutputAdvisorServerToolItem$inboundSchema.and(z.object({ type: z.literal("openrouter:advisor") })),
     ["openrouter:apply_patch"]: OutputApplyPatchServerToolItem$inboundSchema
         .and(z.object({ type: z.literal("openrouter:apply_patch") })),
+    ["openrouter:armor_blocked"]: OutputArmorBlockedItem$inboundSchema.and(z.object({ type: z.literal("openrouter:armor_blocked") })),
     ["openrouter:bash"]: OutputBashServerToolItem$inboundSchema.and(z.object({ type: z.literal("openrouter:bash") })),
     ["openrouter:browser_use"]: OutputBrowserUseServerToolItem$inboundSchema
         .and(z.object({ type: z.literal("openrouter:browser_use") })),
@@ -73,6 +76,7 @@ export const OutputItems$inboundSchema = discriminatedUnion("type", {
     reasoning: OutputReasoningItem$inboundSchema,
     shell_call: OutputShellCallItem$inboundSchema,
     shell_call_output: OutputShellCallOutputItem$inboundSchema,
+    tool_search_call: OutputToolSearchCallItem$inboundSchema,
     web_search_call: OutputWebSearchCallItem$inboundSchema.and(z.object({ type: z.literal("web_search_call") })),
 });
 export function outputItemsFromJSON(jsonString) {

package/esm/models/outputsearchmodelsservertoolitem.d.ts

@@ -2,7 +2,7 @@ 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";
+import { FailableToolCallStatus } from "./failabletoolcallstatus.js";
 export declare const OutputSearchModelsServerToolItemType: {
     readonly OpenrouterExperimentalSearchModels: "openrouter:experimental__search_models";
 };
@@ -15,9 +15,13 @@ export type OutputSearchModelsServerToolItem = {
      * The JSON arguments submitted to the search tool (e.g. {"query":"Claude"})
      */
     arguments?: string | undefined;
+    /**
+     * The error message when the tool call failed before producing a result. Set together with `status: 'failed'`; absent on a successful call.
+     */
+    error?: string | undefined;
     id?: string | undefined;
     query?: string | undefined;
-    status: ToolCallStatus;
+    status: FailableToolCallStatus;
     type: OutputSearchModelsServerToolItemType;
 };
 /** @internal */
@@ -29,6 +33,7 @@ export declare const OutputSearchModelsServerToolItem$inboundSchema: z.ZodType<O
 /** @internal */
 export type OutputSearchModelsServerToolItem$Outbound = {
     arguments?: string | undefined;
+    error?: string | undefined;
     id?: string | undefined;
     query?: string | undefined;
     status: string;

package/esm/models/outputsearchmodelsservertoolitem.js

@@ -4,7 +4,7 @@
  */
 import * as z from "zod/v4";
 import { safeParse } from "../lib/schemas.js";
-import { ToolCallStatus$inboundSchema, ToolCallStatus$outboundSchema, } from "./toolcallstatus.js";
+import { FailableToolCallStatus$inboundSchema, FailableToolCallStatus$outboundSchema, } from "./failabletoolcallstatus.js";
 export const OutputSearchModelsServerToolItemType = {
     OpenrouterExperimentalSearchModels: "openrouter:experimental__search_models",
 };
@@ -15,17 +15,19 @@ export const OutputSearchModelsServerToolItemType$outboundSchema = OutputSearchM
 /** @internal */
 export const OutputSearchModelsServerToolItem$inboundSchema = z.object({
     arguments: z.string().optional(),
+    error: z.string().optional(),
     id: z.string().optional(),
     query: z.string().optional(),
-    status: ToolCallStatus$inboundSchema,
+    status: FailableToolCallStatus$inboundSchema,
     type: OutputSearchModelsServerToolItemType$inboundSchema,
 });
 /** @internal */
 export const OutputSearchModelsServerToolItem$outboundSchema = z.object({
     arguments: z.string().optional(),
+    error: z.string().optional(),
     id: z.string().optional(),
     query: z.string().optional(),
-    status: ToolCallStatus$outboundSchema,
+    status: FailableToolCallStatus$outboundSchema,
     type: OutputSearchModelsServerToolItemType$outboundSchema,
 });
 export function outputSearchModelsServerToolItemToJSON(outputSearchModelsServerToolItem) {

package/esm/models/outputtoolsearchcallitem.d.ts

@@ -0,0 +1,26 @@
+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 OutputToolSearchCallItemExecution: {
+    readonly Client: "client";
+};
+export type OutputToolSearchCallItemExecution = ClosedEnum<typeof OutputToolSearchCallItemExecution>;
+/**
+ * A call the model made to a `tool_search` tool declared with `"execution": "client"`. The client runs the search and replays this item with a `tool_search_output` item.
+ */
+export type OutputToolSearchCallItem = {
+    arguments?: any | undefined;
+    callId: string;
+    execution: OutputToolSearchCallItemExecution;
+    id?: string | undefined;
+    status: ToolCallStatus;
+    type: "tool_search_call";
+};
+/** @internal */
+export declare const OutputToolSearchCallItemExecution$inboundSchema: z.ZodEnum<typeof OutputToolSearchCallItemExecution>;
+/** @internal */
+export declare const OutputToolSearchCallItem$inboundSchema: z.ZodType<OutputToolSearchCallItem, unknown>;
+export declare function outputToolSearchCallItemFromJSON(jsonString: string): SafeParseResult<OutputToolSearchCallItem, SDKValidationError>;
+//# sourceMappingURL=outputtoolsearchcallitem.d.ts.map

package/esm/models/outputtoolsearchcallitem.js

@@ -0,0 +1,30 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ * @generated-id: 5eee8247f3f8
+ */
+import * as z from "zod/v4";
+import { remap as remap$ } from "../lib/primitives.js";
+import { safeParse } from "../lib/schemas.js";
+import { ToolCallStatus$inboundSchema, } from "./toolcallstatus.js";
+export const OutputToolSearchCallItemExecution = {
+    Client: "client",
+};
+/** @internal */
+export const OutputToolSearchCallItemExecution$inboundSchema = z.enum(OutputToolSearchCallItemExecution);
+/** @internal */
+export const OutputToolSearchCallItem$inboundSchema = z.object({
+    arguments: z.any().optional(),
+    call_id: z.string(),
+    execution: OutputToolSearchCallItemExecution$inboundSchema,
+    id: z.string().optional(),
+    status: ToolCallStatus$inboundSchema,
+    type: z.literal("tool_search_call"),
+}).transform((v) => {
+    return remap$(v, {
+        "call_id": "callId",
+    });
+});
+export function outputToolSearchCallItemFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => OutputToolSearchCallItem$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'OutputToolSearchCallItem' from JSON`);
+}
+//# sourceMappingURL=outputtoolsearchcallitem.js.map

package/esm/models/outputtoolsearchservertoolitem.d.ts

@@ -2,7 +2,14 @@ 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";
+import { FailableToolCallStatus } from "./failabletoolcallstatus.js";
+export type Match = {
+    definition: {
+        [k: string]: any;
+    };
+    schemaDigest: string;
+    toolId: string;
+};
 export declare const OutputToolSearchServerToolItemType: {
     readonly OpenrouterToolSearch: "openrouter:tool_search";
 };
@@ -11,12 +18,31 @@ export type OutputToolSearchServerToolItemType = ClosedEnum<typeof OutputToolSea
  * An openrouter:tool_search server tool output item
  */
 export type OutputToolSearchServerToolItem = {
+    /**
+     * The error message when the tool call failed before producing a result. Set together with `status: 'failed'`; absent on a successful call.
+     */
+    error?: string | undefined;
     id?: string | undefined;
+    matches?: Array<Match> | undefined;
     query?: string | undefined;
-    status: ToolCallStatus;
+    status: FailableToolCallStatus;
     type: OutputToolSearchServerToolItemType;
 };
 /** @internal */
+export declare const Match$inboundSchema: z.ZodType<Match, unknown>;
+/** @internal */
+export type Match$Outbound = {
+    definition: {
+        [k: string]: any;
+    };
+    schema_digest: string;
+    tool_id: string;
+};
+/** @internal */
+export declare const Match$outboundSchema: z.ZodType<Match$Outbound, Match>;
+export declare function matchToJSON(match: Match): string;
+export declare function matchFromJSON(jsonString: string): SafeParseResult<Match, SDKValidationError>;
+/** @internal */
 export declare const OutputToolSearchServerToolItemType$inboundSchema: z.ZodEnum<typeof OutputToolSearchServerToolItemType>;
 /** @internal */
 export declare const OutputToolSearchServerToolItemType$outboundSchema: z.ZodEnum<typeof OutputToolSearchServerToolItemType>;
@@ -24,7 +50,9 @@ export declare const OutputToolSearchServerToolItemType$outboundSchema: z.ZodEnu
 export declare const OutputToolSearchServerToolItem$inboundSchema: z.ZodType<OutputToolSearchServerToolItem, unknown>;
 /** @internal */
 export type OutputToolSearchServerToolItem$Outbound = {
+    error?: string | undefined;
     id?: string | undefined;
+    matches?: Array<Match$Outbound> | undefined;
     query?: string | undefined;
     status: string;
     type: string;

package/esm/models/outputtoolsearchservertoolitem.js

@@ -3,27 +3,60 @@
  * @generated-id: 54b4dacceeab
  */
 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";
+import { FailableToolCallStatus$inboundSchema, FailableToolCallStatus$outboundSchema, } from "./failabletoolcallstatus.js";
 export const OutputToolSearchServerToolItemType = {
     OpenrouterToolSearch: "openrouter:tool_search",
 };
 /** @internal */
+export const Match$inboundSchema = z.object({
+    definition: z.record(z.string(), z.any()),
+    schema_digest: z.string(),
+    tool_id: z.string(),
+}).transform((v) => {
+    return remap$(v, {
+        "schema_digest": "schemaDigest",
+        "tool_id": "toolId",
+    });
+});
+/** @internal */
+export const Match$outboundSchema = z.object({
+    definition: z.record(z.string(), z.any()),
+    schemaDigest: z.string(),
+    toolId: z.string(),
+}).transform((v) => {
+    return remap$(v, {
+        schemaDigest: "schema_digest",
+        toolId: "tool_id",
+    });
+});
+export function matchToJSON(match) {
+    return JSON.stringify(Match$outboundSchema.parse(match));
+}
+export function matchFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => Match$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'Match' from JSON`);
+}
+/** @internal */
 export const OutputToolSearchServerToolItemType$inboundSchema = z.enum(OutputToolSearchServerToolItemType);
 /** @internal */
 export const OutputToolSearchServerToolItemType$outboundSchema = OutputToolSearchServerToolItemType$inboundSchema;
 /** @internal */
 export const OutputToolSearchServerToolItem$inboundSchema = z.object({
+    error: z.string().optional(),
     id: z.string().optional(),
+    matches: z.array(z.lazy(() => Match$inboundSchema)).optional(),
     query: z.string().optional(),
-    status: ToolCallStatus$inboundSchema,
+    status: FailableToolCallStatus$inboundSchema,
     type: OutputToolSearchServerToolItemType$inboundSchema,
 });
 /** @internal */
 export const OutputToolSearchServerToolItem$outboundSchema = z.object({
+    error: z.string().optional(),
     id: z.string().optional(),
+    matches: z.array(z.lazy(() => Match$outboundSchema)).optional(),
     query: z.string().optional(),
-    status: ToolCallStatus$outboundSchema,
+    status: FailableToolCallStatus$outboundSchema,
     type: OutputToolSearchServerToolItemType$outboundSchema,
 });
 export function outputToolSearchServerToolItemToJSON(outputToolSearchServerToolItem) {