@openrouter/sdk 0.9.11 → 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/tooldefinitionjson.d.ts

@@ -1,14 +1,12 @@
 import * as z from "zod/v4";
-import { ClosedEnum } from "../types/enums.js";
 import { ChatMessageContentItemCacheControl, ChatMessageContentItemCacheControl$Outbound } from "./chatmessagecontentitemcachecontrol.js";
-export declare const ToolDefinitionJsonType: {
-    readonly Function: "function";
-};
-export type ToolDefinitionJsonType = ClosedEnum<typeof ToolDefinitionJsonType>;
+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 ToolDefinitionJsonFunction = {
+export type ToolDefinitionJsonFunctionFunction = {
     /**
      * Function name (a-z, A-Z, 0-9, underscores, dashes, max 64 chars)
      */
@@ -28,24 +26,31 @@ export type ToolDefinitionJsonFunction = {
      */
     strict?: boolean | null | undefined;
 };
-/**
- * Tool definition for function calling
- */
-export type ToolDefinitionJson = {
-    type: ToolDefinitionJsonType;
+export type ToolDefinitionJsonFunction = {
+    type: "function";
     /**
      * Function definition for tool calling
      */
-    function: ToolDefinitionJsonFunction;
+    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 declare const ToolDefinitionJsonType$outboundSchema: z.ZodEnum<typeof ToolDefinitionJsonType>;
-/** @internal */
-export type ToolDefinitionJsonFunction$Outbound = {
+export type ToolDefinitionJsonFunctionFunction$Outbound = {
     name: string;
     description?: string | undefined;
     parameters?: {
@@ -54,15 +59,28 @@ export type ToolDefinitionJsonFunction$Outbound = {
     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 = {
-    type: string;
-    function: ToolDefinitionJsonFunction$Outbound;
+export type ToolDefinitionJsonFunction$Outbound = {
+    type: "function";
+    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

@@ -5,31 +5,42 @@
 import * as z from "zod/v4";
 import { remap as remap$ } from "../lib/primitives.js";
 import { ChatMessageContentItemCacheControl$outboundSchema, } from "./chatmessagecontentitemcachecontrol.js";
-export const ToolDefinitionJsonType = {
-    Function: "function",
-};
+import { DatetimeServerTool$outboundSchema, } from "./datetimeservertool.js";
+import { WebSearchServerTool$outboundSchema, } from "./websearchservertool.js";
+import { WebSearchShorthand$outboundSchema, } from "./websearchshorthand.js";
 /** @internal */
-export const ToolDefinitionJsonType$outboundSchema = z.enum(ToolDefinitionJsonType);
-/** @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.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({
-    type: ToolDefinitionJsonType$outboundSchema,
-    function: z.lazy(() => ToolDefinitionJsonFunction$outboundSchema),
+export const ToolDefinitionJsonFunction$outboundSchema = z.object({
+    type: z.literal("function"),
+    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/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

package/esm/models/websearchservertool.js

@@ -0,0 +1,77 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ * @generated-id: 478da2f8e455
+ */
+import * as z from "zod/v4";
+import { remap as remap$ } from "../lib/primitives.js";
+import * as openEnums 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 const WebSearchServerToolEngine = {
+    Auto: "auto",
+    Native: "native",
+    Exa: "exa",
+};
+/**
+ * How much context to retrieve per result. Defaults to medium (15000 chars).
+ */
+export const WebSearchServerToolSearchContextSize = {
+    Low: "low",
+    Medium: "medium",
+    High: "high",
+};
+export const WebSearchServerToolParametersType = {
+    Approximate: "approximate",
+};
+/** @internal */
+export const WebSearchServerToolEngine$outboundSchema = openEnums.outboundSchema(WebSearchServerToolEngine);
+/** @internal */
+export const WebSearchServerToolSearchContextSize$outboundSchema = openEnums.outboundSchema(WebSearchServerToolSearchContextSize);
+/** @internal */
+export const WebSearchServerToolParametersType$outboundSchema = z.enum(WebSearchServerToolParametersType);
+/** @internal */
+export const WebSearchServerToolUserLocation$outboundSchema = z.object({
+    type: WebSearchServerToolParametersType$outboundSchema.optional(),
+    city: z.string().optional(),
+    region: z.string().optional(),
+    country: z.string().optional(),
+    timezone: z.string().optional(),
+});
+export function webSearchServerToolUserLocationToJSON(webSearchServerToolUserLocation) {
+    return JSON.stringify(WebSearchServerToolUserLocation$outboundSchema.parse(webSearchServerToolUserLocation));
+}
+/** @internal */
+export const WebSearchServerToolParameters$outboundSchema = z.object({
+    engine: WebSearchServerToolEngine$outboundSchema.optional(),
+    maxResults: z.number().optional(),
+    maxTotalResults: z.number().optional(),
+    searchContextSize: WebSearchServerToolSearchContextSize$outboundSchema
+        .optional(),
+    userLocation: z.lazy(() => WebSearchServerToolUserLocation$outboundSchema)
+        .optional(),
+    allowedDomains: z.array(z.string()).optional(),
+    excludedDomains: z.array(z.string()).optional(),
+}).transform((v) => {
+    return remap$(v, {
+        maxResults: "max_results",
+        maxTotalResults: "max_total_results",
+        searchContextSize: "search_context_size",
+        userLocation: "user_location",
+        allowedDomains: "allowed_domains",
+        excludedDomains: "excluded_domains",
+    });
+});
+export function webSearchServerToolParametersToJSON(webSearchServerToolParameters) {
+    return JSON.stringify(WebSearchServerToolParameters$outboundSchema.parse(webSearchServerToolParameters));
+}
+/** @internal */
+export const WebSearchServerTool$outboundSchema = z.object({
+    type: z.literal("openrouter:web_search"),
+    parameters: z.lazy(() => WebSearchServerToolParameters$outboundSchema)
+        .optional(),
+});
+export function webSearchServerToolToJSON(webSearchServerTool) {
+    return JSON.stringify(WebSearchServerTool$outboundSchema.parse(webSearchServerTool));
+}
+//# sourceMappingURL=websearchservertool.js.map