@openrouter/sdk 0.8.0 → 0.10.2

package/esm/models/responseswebsearchcalloutput.js

@@ -5,23 +5,131 @@
 import * as z from "zod/v4";
 import { safeParse } from "../lib/schemas.js";
 import { WebSearchStatus$inboundSchema, WebSearchStatus$outboundSchema, } from "./websearchstatus.js";
-export const ResponsesWebSearchCallOutputType = {
+export const TypeWebSearchCall = {
     WebSearchCall: "web_search_call",
 };
+export const TypeURL = {
+    Url: "url",
+};
+/** @internal */
+export const TypeWebSearchCall$inboundSchema = z.enum(TypeWebSearchCall);
+/** @internal */
+export const TypeWebSearchCall$outboundSchema = TypeWebSearchCall$inboundSchema;
+/** @internal */
+export const ActionFindInPage$inboundSchema = z.object({
+    type: z.literal("find_in_page"),
+    pattern: z.string(),
+    url: z.string(),
+});
+/** @internal */
+export const ActionFindInPage$outboundSchema = z.object({
+    type: z.literal("find_in_page"),
+    pattern: z.string(),
+    url: z.string(),
+});
+export function actionFindInPageToJSON(actionFindInPage) {
+    return JSON.stringify(ActionFindInPage$outboundSchema.parse(actionFindInPage));
+}
+export function actionFindInPageFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => ActionFindInPage$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'ActionFindInPage' from JSON`);
+}
+/** @internal */
+export const ActionOpenPage$inboundSchema = z.object({
+    type: z.literal("open_page"),
+    url: z.nullable(z.string()).optional(),
+});
+/** @internal */
+export const ActionOpenPage$outboundSchema = z.object({
+    type: z.literal("open_page"),
+    url: z.nullable(z.string()).optional(),
+});
+export function actionOpenPageToJSON(actionOpenPage) {
+    return JSON.stringify(ActionOpenPage$outboundSchema.parse(actionOpenPage));
+}
+export function actionOpenPageFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => ActionOpenPage$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'ActionOpenPage' from JSON`);
+}
+/** @internal */
+export const TypeURL$inboundSchema = z.enum(TypeURL);
 /** @internal */
-export const ResponsesWebSearchCallOutputType$inboundSchema = z.enum(ResponsesWebSearchCallOutputType);
+export const TypeURL$outboundSchema = TypeURL$inboundSchema;
 /** @internal */
-export const ResponsesWebSearchCallOutputType$outboundSchema = ResponsesWebSearchCallOutputType$inboundSchema;
+export const Source$inboundSchema = z.object({
+    type: TypeURL$inboundSchema,
+    url: z.string(),
+});
+/** @internal */
+export const Source$outboundSchema = z
+    .object({
+    type: TypeURL$outboundSchema,
+    url: z.string(),
+});
+export function sourceToJSON(source) {
+    return JSON.stringify(Source$outboundSchema.parse(source));
+}
+export function sourceFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => Source$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'Source' from JSON`);
+}
+/** @internal */
+export const ActionSearch$inboundSchema = z
+    .object({
+    type: z.literal("search"),
+    query: z.string(),
+    queries: z.array(z.string()).optional(),
+    sources: z.array(z.lazy(() => Source$inboundSchema)).optional(),
+});
+/** @internal */
+export const ActionSearch$outboundSchema = z.object({
+    type: z.literal("search"),
+    query: z.string(),
+    queries: z.array(z.string()).optional(),
+    sources: z.array(z.lazy(() => Source$outboundSchema)).optional(),
+});
+export function actionSearchToJSON(actionSearch) {
+    return JSON.stringify(ActionSearch$outboundSchema.parse(actionSearch));
+}
+export function actionSearchFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => ActionSearch$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'ActionSearch' from JSON`);
+}
+/** @internal */
+export const Action$inboundSchema = z.union([
+    z.lazy(() => ActionSearch$inboundSchema),
+    z.lazy(() => ActionOpenPage$inboundSchema),
+    z.lazy(() => ActionFindInPage$inboundSchema),
+]);
+/** @internal */
+export const Action$outboundSchema = z
+    .union([
+    z.lazy(() => ActionSearch$outboundSchema),
+    z.lazy(() => ActionOpenPage$outboundSchema),
+    z.lazy(() => ActionFindInPage$outboundSchema),
+]);
+export function actionToJSON(action) {
+    return JSON.stringify(Action$outboundSchema.parse(action));
+}
+export function actionFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => Action$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'Action' from JSON`);
+}
 /** @internal */
 export const ResponsesWebSearchCallOutput$inboundSchema = z.object({
-    type: ResponsesWebSearchCallOutputType$inboundSchema,
+    type: TypeWebSearchCall$inboundSchema,
     id: z.string(),
+    action: z.union([
+        z.lazy(() => ActionSearch$inboundSchema),
+        z.lazy(() => ActionOpenPage$inboundSchema),
+        z.lazy(() => ActionFindInPage$inboundSchema),
+    ]),
     status: WebSearchStatus$inboundSchema,
 });
 /** @internal */
 export const ResponsesWebSearchCallOutput$outboundSchema = z.object({
-    type: ResponsesWebSearchCallOutputType$outboundSchema,
+    type: TypeWebSearchCall$outboundSchema,
     id: z.string(),
+    action: z.union([
+        z.lazy(() => ActionSearch$outboundSchema),
+        z.lazy(() => ActionOpenPage$outboundSchema),
+        z.lazy(() => ActionFindInPage$outboundSchema),
+    ]),
     status: WebSearchStatus$outboundSchema,
 });
 export function responsesWebSearchCallOutputToJSON(responsesWebSearchCallOutput) {

package/esm/models/responseswebsearchservertool.d.ts

@@ -0,0 +1,35 @@
+import * as z from "zod/v4";
+export type ResponsesWebSearchServerToolParameters = {
+    /**
+     * Maximum number of search results to return per search call. Defaults to 5.
+     */
+    maxResults?: number | undefined;
+    /**
+     * Maximum total number of search results across all search calls in a single request. Once this limit is reached, the tool will stop returning new results.
+     */
+    maxTotalResults?: number | undefined;
+};
+/**
+ * OpenRouter built-in server tool: searches the web for current information
+ */
+export type ResponsesWebSearchServerTool = {
+    type: "openrouter:web_search";
+    parameters?: ResponsesWebSearchServerToolParameters | undefined;
+};
+/** @internal */
+export type ResponsesWebSearchServerToolParameters$Outbound = {
+    max_results?: number | undefined;
+    max_total_results?: number | undefined;
+};
+/** @internal */
+export declare const ResponsesWebSearchServerToolParameters$outboundSchema: z.ZodType<ResponsesWebSearchServerToolParameters$Outbound, ResponsesWebSearchServerToolParameters>;
+export declare function responsesWebSearchServerToolParametersToJSON(responsesWebSearchServerToolParameters: ResponsesWebSearchServerToolParameters): string;
+/** @internal */
+export type ResponsesWebSearchServerTool$Outbound = {
+    type: "openrouter:web_search";
+    parameters?: ResponsesWebSearchServerToolParameters$Outbound | undefined;
+};
+/** @internal */
+export declare const ResponsesWebSearchServerTool$outboundSchema: z.ZodType<ResponsesWebSearchServerTool$Outbound, ResponsesWebSearchServerTool>;
+export declare function responsesWebSearchServerToolToJSON(responsesWebSearchServerTool: ResponsesWebSearchServerTool): string;
+//# sourceMappingURL=responseswebsearchservertool.d.ts.map

package/esm/models/responseswebsearchservertool.js

@@ -0,0 +1,28 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ * @generated-id: 8ef0e49c5731
+ */
+import * as z from "zod/v4";
+import { remap as remap$ } from "../lib/primitives.js";
+/** @internal */
+export const ResponsesWebSearchServerToolParameters$outboundSchema = z.object({
+    maxResults: z.number().optional(),
+    maxTotalResults: z.number().optional(),
+}).transform((v) => {
+    return remap$(v, {
+        maxResults: "max_results",
+        maxTotalResults: "max_total_results",
+    });
+});
+export function responsesWebSearchServerToolParametersToJSON(responsesWebSearchServerToolParameters) {
+    return JSON.stringify(ResponsesWebSearchServerToolParameters$outboundSchema.parse(responsesWebSearchServerToolParameters));
+}
+/** @internal */
+export const ResponsesWebSearchServerTool$outboundSchema = z.object({
+    type: z.literal("openrouter:web_search"),
+    parameters: z.lazy(() => ResponsesWebSearchServerToolParameters$outboundSchema).optional(),
+});
+export function responsesWebSearchServerToolToJSON(responsesWebSearchServerTool) {
+    return JSON.stringify(ResponsesWebSearchServerTool$outboundSchema.parse(responsesWebSearchServerTool));
+}
+//# sourceMappingURL=responseswebsearchservertool.js.map

package/esm/models/systemmessage.d.ts

@@ -1,9 +1,21 @@
 import * as z from "zod/v4";
 import { ChatMessageContentItemText, ChatMessageContentItemText$Outbound } from "./chatmessagecontentitemtext.js";
+/**
+ * System message content
+ */
 export type SystemMessageContent = string | Array<ChatMessageContentItemText>;
+/**
+ * System message for setting behavior
+ */
 export type SystemMessage = {
     role: "system";
+    /**
+     * System message content
+     */
     content: string | Array<ChatMessageContentItemText>;
+    /**
+     * Optional name for the system message
+     */
     name?: string | undefined;
 };
 /** @internal */

package/esm/models/toolchoiceoption.d.ts

@@ -0,0 +1,31 @@
+import * as z from "zod/v4";
+import { ClosedEnum } from "../types/enums.js";
+import { NamedToolChoice, NamedToolChoice$Outbound } from "./namedtoolchoice.js";
+export declare const ToolChoiceOptionRequired: {
+    readonly Required: "required";
+};
+export type ToolChoiceOptionRequired = ClosedEnum<typeof ToolChoiceOptionRequired>;
+export declare const ToolChoiceOptionAuto: {
+    readonly Auto: "auto";
+};
+export type ToolChoiceOptionAuto = ClosedEnum<typeof ToolChoiceOptionAuto>;
+export declare const ToolChoiceOptionNone: {
+    readonly None: "none";
+};
+export type ToolChoiceOptionNone = ClosedEnum<typeof ToolChoiceOptionNone>;
+/**
+ * Tool choice configuration
+ */
+export type ToolChoiceOption = NamedToolChoice | ToolChoiceOptionNone | ToolChoiceOptionAuto | ToolChoiceOptionRequired;
+/** @internal */
+export declare const ToolChoiceOptionRequired$outboundSchema: z.ZodEnum<typeof ToolChoiceOptionRequired>;
+/** @internal */
+export declare const ToolChoiceOptionAuto$outboundSchema: z.ZodEnum<typeof ToolChoiceOptionAuto>;
+/** @internal */
+export declare const ToolChoiceOptionNone$outboundSchema: z.ZodEnum<typeof ToolChoiceOptionNone>;
+/** @internal */
+export type ToolChoiceOption$Outbound = NamedToolChoice$Outbound | string | string | string;
+/** @internal */
+export declare const ToolChoiceOption$outboundSchema: z.ZodType<ToolChoiceOption$Outbound, ToolChoiceOption>;
+export declare function toolChoiceOptionToJSON(toolChoiceOption: ToolChoiceOption): string;
+//# sourceMappingURL=toolchoiceoption.d.ts.map

package/esm/models/toolchoiceoption.js

@@ -0,0 +1,32 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ * @generated-id: d767ca0ded82
+ */
+import * as z from "zod/v4";
+import { NamedToolChoice$outboundSchema, } from "./namedtoolchoice.js";
+export const ToolChoiceOptionRequired = {
+    Required: "required",
+};
+export const ToolChoiceOptionAuto = {
+    Auto: "auto",
+};
+export const ToolChoiceOptionNone = {
+    None: "none",
+};
+/** @internal */
+export const ToolChoiceOptionRequired$outboundSchema = z.enum(ToolChoiceOptionRequired);
+/** @internal */
+export const ToolChoiceOptionAuto$outboundSchema = z.enum(ToolChoiceOptionAuto);
+/** @internal */
+export const ToolChoiceOptionNone$outboundSchema = z.enum(ToolChoiceOptionNone);
+/** @internal */
+export const ToolChoiceOption$outboundSchema = z.union([
+    NamedToolChoice$outboundSchema,
+    ToolChoiceOptionNone$outboundSchema,
+    ToolChoiceOptionAuto$outboundSchema,
+    ToolChoiceOptionRequired$outboundSchema,
+]);
+export function toolChoiceOptionToJSON(toolChoiceOption) {
+    return JSON.stringify(ToolChoiceOption$outboundSchema.parse(toolChoiceOption));
+}
+//# sourceMappingURL=toolchoiceoption.js.map

package/esm/models/tooldefinitionjson.d.ts

@@ -1,34 +1,86 @@
 import * as z from "zod/v4";
-export type ToolDefinitionJsonFunction = {
+import { ChatMessageContentItemCacheControl, ChatMessageContentItemCacheControl$Outbound } from "./chatmessagecontentitemcachecontrol.js";
+import { DatetimeServerTool, DatetimeServerTool$Outbound } from "./datetimeservertool.js";
+import { WebSearchServerTool, WebSearchServerTool$Outbound } from "./websearchservertool.js";
+import { WebSearchShorthand, WebSearchShorthand$Outbound } from "./websearchshorthand.js";
+/**
+ * Function definition for tool calling
+ */
+export type ToolDefinitionJsonFunctionFunction = {
+    /**
+     * Function name (a-z, A-Z, 0-9, underscores, dashes, max 64 chars)
+     */
     name: string;
+    /**
+     * Function description for the model
+     */
     description?: string | undefined;
+    /**
+     * Function parameters as JSON Schema object
+     */
     parameters?: {
-        [k: string]: any;
+        [k: string]: any | null;
     } | undefined;
+    /**
+     * Enable strict schema adherence
+     */
     strict?: boolean | null | undefined;
 };
-export type ToolDefinitionJson = {
+export type ToolDefinitionJsonFunction = {
     type: "function";
-    function: ToolDefinitionJsonFunction;
+    /**
+     * Function definition for tool calling
+     */
+    function: ToolDefinitionJsonFunctionFunction;
+    /**
+     * Cache control for the content part
+     */
+    cacheControl?: ChatMessageContentItemCacheControl | undefined;
 };
+/**
+ * Tool definition for function calling (regular function or OpenRouter built-in server tool)
+ */
+export type ToolDefinitionJson = ToolDefinitionJsonFunction | DatetimeServerTool | WebSearchServerTool | (WebSearchShorthand & {
+    type: "web_search";
+}) | (WebSearchShorthand & {
+    type: "web_search_preview";
+}) | (WebSearchShorthand & {
+    type: "web_search_preview_2025_03_11";
+}) | (WebSearchShorthand & {
+    type: "web_search_2025_08_26";
+});
 /** @internal */
-export type ToolDefinitionJsonFunction$Outbound = {
+export type ToolDefinitionJsonFunctionFunction$Outbound = {
     name: string;
     description?: string | undefined;
     parameters?: {
-        [k: string]: any;
+        [k: string]: any | null;
     } | undefined;
     strict?: boolean | null | undefined;
 };
 /** @internal */
-export declare const ToolDefinitionJsonFunction$outboundSchema: z.ZodType<ToolDefinitionJsonFunction$Outbound, ToolDefinitionJsonFunction>;
-export declare function toolDefinitionJsonFunctionToJSON(toolDefinitionJsonFunction: ToolDefinitionJsonFunction): string;
+export declare const ToolDefinitionJsonFunctionFunction$outboundSchema: z.ZodType<ToolDefinitionJsonFunctionFunction$Outbound, ToolDefinitionJsonFunctionFunction>;
+export declare function toolDefinitionJsonFunctionFunctionToJSON(toolDefinitionJsonFunctionFunction: ToolDefinitionJsonFunctionFunction): string;
 /** @internal */
-export type ToolDefinitionJson$Outbound = {
+export type ToolDefinitionJsonFunction$Outbound = {
     type: "function";
-    function: ToolDefinitionJsonFunction$Outbound;
+    function: ToolDefinitionJsonFunctionFunction$Outbound;
+    cache_control?: ChatMessageContentItemCacheControl$Outbound | undefined;
 };
 /** @internal */
+export declare const ToolDefinitionJsonFunction$outboundSchema: z.ZodType<ToolDefinitionJsonFunction$Outbound, ToolDefinitionJsonFunction>;
+export declare function toolDefinitionJsonFunctionToJSON(toolDefinitionJsonFunction: ToolDefinitionJsonFunction): string;
+/** @internal */
+export type ToolDefinitionJson$Outbound = ToolDefinitionJsonFunction$Outbound | DatetimeServerTool$Outbound | WebSearchServerTool$Outbound | (WebSearchShorthand$Outbound & {
+    type: "web_search";
+}) | (WebSearchShorthand$Outbound & {
+    type: "web_search_preview";
+}) | (WebSearchShorthand$Outbound & {
+    type: "web_search_preview_2025_03_11";
+}) | (WebSearchShorthand$Outbound & {
+    type: "web_search_2025_08_26";
+});
+/** @internal */
 export declare const ToolDefinitionJson$outboundSchema: z.ZodType<ToolDefinitionJson$Outbound, ToolDefinitionJson>;
 export declare function toolDefinitionJsonToJSON(toolDefinitionJson: ToolDefinitionJson): string;
 //# sourceMappingURL=tooldefinitionjson.d.ts.map

package/esm/models/tooldefinitionjson.js

@@ -3,21 +3,44 @@
  * @generated-id: 546c340f3013
  */
 import * as z from "zod/v4";
+import { remap as remap$ } from "../lib/primitives.js";
+import { ChatMessageContentItemCacheControl$outboundSchema, } from "./chatmessagecontentitemcachecontrol.js";
+import { DatetimeServerTool$outboundSchema, } from "./datetimeservertool.js";
+import { WebSearchServerTool$outboundSchema, } from "./websearchservertool.js";
+import { WebSearchShorthand$outboundSchema, } from "./websearchshorthand.js";
 /** @internal */
-export const ToolDefinitionJsonFunction$outboundSchema = z.object({
+export const ToolDefinitionJsonFunctionFunction$outboundSchema = z.object({
     name: z.string(),
     description: z.string().optional(),
-    parameters: z.record(z.string(), z.any()).optional(),
+    parameters: z.record(z.string(), z.nullable(z.any())).optional(),
     strict: z.nullable(z.boolean()).optional(),
 });
-export function toolDefinitionJsonFunctionToJSON(toolDefinitionJsonFunction) {
-    return JSON.stringify(ToolDefinitionJsonFunction$outboundSchema.parse(toolDefinitionJsonFunction));
+export function toolDefinitionJsonFunctionFunctionToJSON(toolDefinitionJsonFunctionFunction) {
+    return JSON.stringify(ToolDefinitionJsonFunctionFunction$outboundSchema.parse(toolDefinitionJsonFunctionFunction));
 }
 /** @internal */
-export const ToolDefinitionJson$outboundSchema = z.object({
+export const ToolDefinitionJsonFunction$outboundSchema = z.object({
     type: z.literal("function"),
-    function: z.lazy(() => ToolDefinitionJsonFunction$outboundSchema),
+    function: z.lazy(() => ToolDefinitionJsonFunctionFunction$outboundSchema),
+    cacheControl: ChatMessageContentItemCacheControl$outboundSchema.optional(),
+}).transform((v) => {
+    return remap$(v, {
+        cacheControl: "cache_control",
+    });
 });
+export function toolDefinitionJsonFunctionToJSON(toolDefinitionJsonFunction) {
+    return JSON.stringify(ToolDefinitionJsonFunction$outboundSchema.parse(toolDefinitionJsonFunction));
+}
+/** @internal */
+export const ToolDefinitionJson$outboundSchema = z.union([
+    z.lazy(() => ToolDefinitionJsonFunction$outboundSchema),
+    DatetimeServerTool$outboundSchema,
+    WebSearchServerTool$outboundSchema,
+    WebSearchShorthand$outboundSchema.and(z.object({ type: z.literal("web_search") })),
+    WebSearchShorthand$outboundSchema.and(z.object({ type: z.literal("web_search_preview") })),
+    WebSearchShorthand$outboundSchema.and(z.object({ type: z.literal("web_search_preview_2025_03_11") })),
+    WebSearchShorthand$outboundSchema.and(z.object({ type: z.literal("web_search_2025_08_26") })),
+]);
 export function toolDefinitionJsonToJSON(toolDefinitionJson) {
     return JSON.stringify(ToolDefinitionJson$outboundSchema.parse(toolDefinitionJson));
 }

package/esm/models/toolresponsemessage.d.ts

@@ -1,9 +1,21 @@
 import * as z from "zod/v4";
 import { ChatMessageContentItem, ChatMessageContentItem$Outbound } from "./chatmessagecontentitem.js";
+/**
+ * Tool response content
+ */
 export type ToolResponseMessageContent = string | Array<ChatMessageContentItem>;
+/**
+ * Tool response message
+ */
 export type ToolResponseMessage = {
     role: "tool";
+    /**
+     * Tool response content
+     */
     content: string | Array<ChatMessageContentItem>;
+    /**
+     * ID of the assistant message tool call this message responds to
+     */
     toolCallId: string;
 };
 /** @internal */

package/esm/models/usermessage.d.ts

@@ -1,9 +1,21 @@
 import * as z from "zod/v4";
 import { ChatMessageContentItem, ChatMessageContentItem$Outbound } from "./chatmessagecontentitem.js";
+/**
+ * User message content
+ */
 export type UserMessageContent = string | Array<ChatMessageContentItem>;
+/**
+ * User message
+ */
 export type UserMessage = {
     role: "user";
+    /**
+     * User message content
+     */
     content: string | Array<ChatMessageContentItem>;
+    /**
+     * Optional name for the user
+     */
     name?: string | undefined;
 };
 /** @internal */

package/esm/models/videoinput.d.ts

@@ -0,0 +1,23 @@
+import * as z from "zod/v4";
+import { Result as SafeParseResult } from "../types/fp.js";
+import { SDKValidationError } from "./errors/sdkvalidationerror.js";
+/**
+ * Video input object
+ */
+export type VideoInput = {
+    /**
+     * URL of the video (data: URLs supported)
+     */
+    url: string;
+};
+/** @internal */
+export declare const VideoInput$inboundSchema: z.ZodType<VideoInput, unknown>;
+/** @internal */
+export type VideoInput$Outbound = {
+    url: string;
+};
+/** @internal */
+export declare const VideoInput$outboundSchema: z.ZodType<VideoInput$Outbound, VideoInput>;
+export declare function videoInputToJSON(videoInput: VideoInput): string;
+export declare function videoInputFromJSON(jsonString: string): SafeParseResult<VideoInput, SDKValidationError>;
+//# sourceMappingURL=videoinput.d.ts.map

package/esm/models/videoinput.js

@@ -0,0 +1,22 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ * @generated-id: c9307d9d04a6
+ */
+import * as z from "zod/v4";
+import { safeParse } from "../lib/schemas.js";
+/** @internal */
+export const VideoInput$inboundSchema = z
+    .object({
+    url: z.string(),
+});
+/** @internal */
+export const VideoInput$outboundSchema = z.object({
+    url: z.string(),
+});
+export function videoInputToJSON(videoInput) {
+    return JSON.stringify(VideoInput$outboundSchema.parse(videoInput));
+}
+export function videoInputFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => VideoInput$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'VideoInput' from JSON`);
+}
+//# sourceMappingURL=videoinput.js.map

package/esm/models/websearchengine.d.ts

@@ -6,6 +6,8 @@ import { OpenEnum } from "../types/enums.js";
 export declare const WebSearchEngine: {
     readonly Native: "native";
     readonly Exa: "exa";
+    readonly Firecrawl: "firecrawl";
+    readonly Parallel: "parallel";
 };
 /**
  * The search engine to use for web search.

package/esm/models/websearchengine.js

@@ -9,6 +9,8 @@ import * as openEnums from "../types/enums.js";
 export const WebSearchEngine = {
     Native: "native",
     Exa: "exa",
+    Firecrawl: "firecrawl",
+    Parallel: "parallel",
 };
 /** @internal */
 export const WebSearchEngine$outboundSchema = openEnums.outboundSchema(WebSearchEngine);

package/esm/models/websearchservertool.d.ts

@@ -0,0 +1,116 @@
+import * as z from "zod/v4";
+import { ClosedEnum, OpenEnum } from "../types/enums.js";
+/**
+ * Which search engine to use. "auto" (default) uses native if the provider supports it, otherwise Exa. "native" forces the provider's built-in search. "exa" forces the Exa search API.
+ */
+export declare const WebSearchServerToolEngine: {
+    readonly Auto: "auto";
+    readonly Native: "native";
+    readonly Exa: "exa";
+};
+/**
+ * Which search engine to use. "auto" (default) uses native if the provider supports it, otherwise Exa. "native" forces the provider's built-in search. "exa" forces the Exa search API.
+ */
+export type WebSearchServerToolEngine = OpenEnum<typeof WebSearchServerToolEngine>;
+/**
+ * How much context to retrieve per result. Defaults to medium (15000 chars).
+ */
+export declare const WebSearchServerToolSearchContextSize: {
+    readonly Low: "low";
+    readonly Medium: "medium";
+    readonly High: "high";
+};
+/**
+ * How much context to retrieve per result. Defaults to medium (15000 chars).
+ */
+export type WebSearchServerToolSearchContextSize = OpenEnum<typeof WebSearchServerToolSearchContextSize>;
+export declare const WebSearchServerToolParametersType: {
+    readonly Approximate: "approximate";
+};
+export type WebSearchServerToolParametersType = ClosedEnum<typeof WebSearchServerToolParametersType>;
+/**
+ * Approximate user location for location-biased results.
+ */
+export type WebSearchServerToolUserLocation = {
+    type?: WebSearchServerToolParametersType | undefined;
+    city?: string | undefined;
+    region?: string | undefined;
+    country?: string | undefined;
+    timezone?: string | undefined;
+};
+export type WebSearchServerToolParameters = {
+    /**
+     * Which search engine to use. "auto" (default) uses native if the provider supports it, otherwise Exa. "native" forces the provider's built-in search. "exa" forces the Exa search API.
+     */
+    engine?: WebSearchServerToolEngine | undefined;
+    /**
+     * Maximum number of search results to return per search call. Defaults to 5.
+     */
+    maxResults?: number | undefined;
+    /**
+     * Maximum total number of search results across all search calls in a single request. Once this limit is reached, the tool will stop returning new results. Useful for controlling cost and context size in agentic loops.
+     */
+    maxTotalResults?: number | undefined;
+    /**
+     * How much context to retrieve per result. Defaults to medium (15000 chars).
+     */
+    searchContextSize?: WebSearchServerToolSearchContextSize | undefined;
+    /**
+     * Approximate user location for location-biased results.
+     */
+    userLocation?: WebSearchServerToolUserLocation | undefined;
+    /**
+     * Limit search results to these domains.
+     */
+    allowedDomains?: Array<string> | undefined;
+    /**
+     * Exclude search results from these domains.
+     */
+    excludedDomains?: Array<string> | undefined;
+};
+/**
+ * OpenRouter built-in server tool: searches the web for current information
+ */
+export type WebSearchServerTool = {
+    type: "openrouter:web_search";
+    parameters?: WebSearchServerToolParameters | undefined;
+};
+/** @internal */
+export declare const WebSearchServerToolEngine$outboundSchema: z.ZodType<string, WebSearchServerToolEngine>;
+/** @internal */
+export declare const WebSearchServerToolSearchContextSize$outboundSchema: z.ZodType<string, WebSearchServerToolSearchContextSize>;
+/** @internal */
+export declare const WebSearchServerToolParametersType$outboundSchema: z.ZodEnum<typeof WebSearchServerToolParametersType>;
+/** @internal */
+export type WebSearchServerToolUserLocation$Outbound = {
+    type?: string | undefined;
+    city?: string | undefined;
+    region?: string | undefined;
+    country?: string | undefined;
+    timezone?: string | undefined;
+};
+/** @internal */
+export declare const WebSearchServerToolUserLocation$outboundSchema: z.ZodType<WebSearchServerToolUserLocation$Outbound, WebSearchServerToolUserLocation>;
+export declare function webSearchServerToolUserLocationToJSON(webSearchServerToolUserLocation: WebSearchServerToolUserLocation): string;
+/** @internal */
+export type WebSearchServerToolParameters$Outbound = {
+    engine?: string | undefined;
+    max_results?: number | undefined;
+    max_total_results?: number | undefined;
+    search_context_size?: string | undefined;
+    user_location?: WebSearchServerToolUserLocation$Outbound | undefined;
+    allowed_domains?: Array<string> | undefined;
+    excluded_domains?: Array<string> | undefined;
+};
+/** @internal */
+export declare const WebSearchServerToolParameters$outboundSchema: z.ZodType<WebSearchServerToolParameters$Outbound, WebSearchServerToolParameters>;
+export declare function webSearchServerToolParametersToJSON(webSearchServerToolParameters: WebSearchServerToolParameters): string;
+/** @internal */
+export type WebSearchServerTool$Outbound = {
+    type: "openrouter:web_search";
+    parameters?: WebSearchServerToolParameters$Outbound | undefined;
+};
+/** @internal */
+export declare const WebSearchServerTool$outboundSchema: z.ZodType<WebSearchServerTool$Outbound, WebSearchServerTool>;
+export declare function webSearchServerToolToJSON(webSearchServerTool: WebSearchServerTool): string;
+//# sourceMappingURL=websearchservertool.d.ts.map