@openrouter/sdk 1.0.2 → 1.0.4

package/esm/funcs/apiKeysList.d.ts

@@ -14,5 +14,5 @@ import { Result } from "../types/fp.js";
  * @remarks
  * List all API keys for the authenticated user. [Management key](/docs/guides/overview/auth/management-api-keys) required.
  */
-export declare function apiKeysList(client: OpenRouterCore, request?: operations.ListRequest | undefined, options?: RequestOptions): APIPromise<Result<operations.ListResponse, errors.UnauthorizedResponseError | errors.TooManyRequestsResponseError | errors.InternalServerResponseError | OpenRouterError | ResponseValidationError | ConnectionError | RequestAbortedError | RequestTimeoutError | InvalidRequestError | UnexpectedClientError | SDKValidationError>>;
+export declare function apiKeysList(client: OpenRouterCore, request?: operations.ListRequest | undefined, options?: RequestOptions): APIPromise<Result<operations.ListResponse, errors.BadRequestResponseError | errors.UnauthorizedResponseError | errors.TooManyRequestsResponseError | errors.InternalServerResponseError | OpenRouterError | ResponseValidationError | ConnectionError | RequestAbortedError | RequestTimeoutError | InvalidRequestError | UnexpectedClientError | SDKValidationError>>;
 //# sourceMappingURL=apiKeysList.d.ts.map

package/esm/funcs/apiKeysList.js

@@ -93,7 +93,7 @@ async function $do(client, request, options) {
     const responseFields = {
         HttpMeta: { Response: response, Request: req },
     };
-    const [result] = await M.match(M.json(200, operations.ListResponse$inboundSchema), M.jsonErr(401, errors.UnauthorizedResponseError$inboundSchema), M.jsonErr(429, errors.TooManyRequestsResponseError$inboundSchema), M.jsonErr(500, errors.InternalServerResponseError$inboundSchema), M.fail("4XX"), M.fail("5XX"))(response, req, { extraFields: responseFields });
+    const [result] = await M.match(M.json(200, operations.ListResponse$inboundSchema), M.jsonErr(400, errors.BadRequestResponseError$inboundSchema), M.jsonErr(401, errors.UnauthorizedResponseError$inboundSchema), M.jsonErr(429, errors.TooManyRequestsResponseError$inboundSchema), M.jsonErr(500, errors.InternalServerResponseError$inboundSchema), M.fail("4XX"), M.fail("5XX"))(response, req, { extraFields: responseFields });
     if (!result.ok) {
         return [result, { status: "complete", request: req, response }];
     }

package/esm/funcs/byokList.d.ts

@@ -15,7 +15,7 @@ import { PageIterator } from "../types/operations.js";
  * @remarks
  * List the bring-your-own-key (BYOK) provider credentials for the authenticated entity's default workspace. Use the `workspace_id` query parameter to scope the result to a different workspace, or the `provider` query parameter to filter by upstream provider. [Management key](/docs/guides/overview/auth/management-api-keys) required.
  */
-export declare function byokList(client: OpenRouterCore, request?: operations.ListBYOKKeysRequest | undefined, options?: RequestOptions): APIPromise<PageIterator<Result<operations.ListBYOKKeysResponse, errors.UnauthorizedResponseError | errors.InternalServerResponseError | OpenRouterError | ResponseValidationError | ConnectionError | RequestAbortedError | RequestTimeoutError | InvalidRequestError | UnexpectedClientError | SDKValidationError>, {
+export declare function byokList(client: OpenRouterCore, request?: operations.ListBYOKKeysRequest | undefined, options?: RequestOptions): APIPromise<PageIterator<Result<operations.ListBYOKKeysResponse, errors.BadRequestResponseError | errors.UnauthorizedResponseError | errors.InternalServerResponseError | OpenRouterError | ResponseValidationError | ConnectionError | RequestAbortedError | RequestTimeoutError | InvalidRequestError | UnexpectedClientError | SDKValidationError>, {
     offset: number;
 }>>;
 //# sourceMappingURL=byokList.d.ts.map

package/esm/funcs/byokList.js

@@ -97,7 +97,7 @@ async function $do(client, request, options) {
     };
     const [result, raw] = await M.match(M.json(200, operations.ListBYOKKeysResponse$inboundSchema, {
         key: "Result",
-    }), M.jsonErr(401, errors.UnauthorizedResponseError$inboundSchema), M.jsonErr(500, errors.InternalServerResponseError$inboundSchema), M.fail("4XX"), M.fail("5XX"))(response, req, { extraFields: responseFields });
+    }), M.jsonErr(400, errors.BadRequestResponseError$inboundSchema), M.jsonErr(401, errors.UnauthorizedResponseError$inboundSchema), M.jsonErr(500, errors.InternalServerResponseError$inboundSchema), M.fail("4XX"), M.fail("5XX"))(response, req, { extraFields: responseFields });
     if (!result.ok) {
         return [haltIterator(result), {
                 status: "complete",

package/esm/funcs/guardrailsList.d.ts

@@ -15,7 +15,7 @@ import { PageIterator } from "../types/operations.js";
  * @remarks
  * List all guardrails for the authenticated user. [Management key](/docs/guides/overview/auth/management-api-keys) required.
  */
-export declare function guardrailsList(client: OpenRouterCore, request?: operations.ListGuardrailsRequest | undefined, options?: RequestOptions): APIPromise<PageIterator<Result<operations.ListGuardrailsResponse, errors.UnauthorizedResponseError | errors.InternalServerResponseError | OpenRouterError | ResponseValidationError | ConnectionError | RequestAbortedError | RequestTimeoutError | InvalidRequestError | UnexpectedClientError | SDKValidationError>, {
+export declare function guardrailsList(client: OpenRouterCore, request?: operations.ListGuardrailsRequest | undefined, options?: RequestOptions): APIPromise<PageIterator<Result<operations.ListGuardrailsResponse, errors.BadRequestResponseError | errors.UnauthorizedResponseError | errors.InternalServerResponseError | OpenRouterError | ResponseValidationError | ConnectionError | RequestAbortedError | RequestTimeoutError | InvalidRequestError | UnexpectedClientError | SDKValidationError>, {
     offset: number;
 }>>;
 //# sourceMappingURL=guardrailsList.d.ts.map

package/esm/funcs/guardrailsList.js

@@ -96,7 +96,7 @@ async function $do(client, request, options) {
     };
     const [result, raw] = await M.match(M.json(200, operations.ListGuardrailsResponse$inboundSchema, {
         key: "Result",
-    }), M.jsonErr(401, errors.UnauthorizedResponseError$inboundSchema), M.jsonErr(500, errors.InternalServerResponseError$inboundSchema), M.fail("4XX"), M.fail("5XX"))(response, req, { extraFields: responseFields });
+    }), M.jsonErr(400, errors.BadRequestResponseError$inboundSchema), M.jsonErr(401, errors.UnauthorizedResponseError$inboundSchema), M.jsonErr(500, errors.InternalServerResponseError$inboundSchema), M.fail("4XX"), M.fail("5XX"))(response, req, { extraFields: responseFields });
     if (!result.ok) {
         return [haltIterator(result), {
                 status: "complete",

package/esm/funcs/observabilityList.d.ts

@@ -15,7 +15,7 @@ import { PageIterator } from "../types/operations.js";
  * @remarks
  * List the observability destinations configured for the authenticated entity's default workspace. Use the `workspace_id` query parameter to scope the result to a different workspace. Only destinations with stable release status are surfaced — destinations of other types are excluded. [Management key](/docs/guides/overview/auth/management-api-keys) required.
  */
-export declare function observabilityList(client: OpenRouterCore, request?: operations.ListObservabilityDestinationsRequest | undefined, options?: RequestOptions): APIPromise<PageIterator<Result<operations.ListObservabilityDestinationsResponse, errors.UnauthorizedResponseError | errors.InternalServerResponseError | OpenRouterError | ResponseValidationError | ConnectionError | RequestAbortedError | RequestTimeoutError | InvalidRequestError | UnexpectedClientError | SDKValidationError>, {
+export declare function observabilityList(client: OpenRouterCore, request?: operations.ListObservabilityDestinationsRequest | undefined, options?: RequestOptions): APIPromise<PageIterator<Result<operations.ListObservabilityDestinationsResponse, errors.BadRequestResponseError | errors.UnauthorizedResponseError | errors.InternalServerResponseError | OpenRouterError | ResponseValidationError | ConnectionError | RequestAbortedError | RequestTimeoutError | InvalidRequestError | UnexpectedClientError | SDKValidationError>, {
     offset: number;
 }>>;
 //# sourceMappingURL=observabilityList.d.ts.map

package/esm/funcs/observabilityList.js

@@ -95,7 +95,7 @@ async function $do(client, request, options) {
     const responseFields = {
         HttpMeta: { Response: response, Request: req },
     };
-    const [result, raw] = await M.match(M.json(200, operations.ListObservabilityDestinationsResponse$inboundSchema, { key: "Result" }), M.jsonErr(401, errors.UnauthorizedResponseError$inboundSchema), M.jsonErr(500, errors.InternalServerResponseError$inboundSchema), M.fail("4XX"), M.fail("5XX"))(response, req, { extraFields: responseFields });
+    const [result, raw] = await M.match(M.json(200, operations.ListObservabilityDestinationsResponse$inboundSchema, { key: "Result" }), M.jsonErr(400, errors.BadRequestResponseError$inboundSchema), M.jsonErr(401, errors.UnauthorizedResponseError$inboundSchema), M.jsonErr(500, errors.InternalServerResponseError$inboundSchema), M.fail("4XX"), M.fail("5XX"))(response, req, { extraFields: responseFields });
     if (!result.ok) {
         return [haltIterator(result), {
                 status: "complete",

package/esm/lib/config.d.ts

@@ -49,8 +49,8 @@ export declare function serverURLFromOptions(options: SDKOptions): URL | null;
 export declare const SDK_METADATA: {
     readonly language: "typescript";
     readonly openapiDocVersion: "1.0.0";
-    readonly sdkVersion: "1.0.2";
+    readonly sdkVersion: "1.0.4";
     readonly genVersion: "2.914.0";
-    readonly userAgent: "speakeasy-sdk/typescript 1.0.2 2.914.0 1.0.0 @openrouter/sdk";
+    readonly userAgent: "speakeasy-sdk/typescript 1.0.4 2.914.0 1.0.0 @openrouter/sdk";
 };
 //# sourceMappingURL=config.d.ts.map

package/esm/lib/config.js

@@ -26,8 +26,8 @@ export function serverURLFromOptions(options) {
 export const SDK_METADATA = {
     language: "typescript",
     openapiDocVersion: "1.0.0",
-    sdkVersion: "1.0.2",
+    sdkVersion: "1.0.4",
     genVersion: "2.914.0",
-    userAgent: "speakeasy-sdk/typescript 1.0.2 2.914.0 1.0.0 @openrouter/sdk",
+    userAgent: "speakeasy-sdk/typescript 1.0.4 2.914.0 1.0.0 @openrouter/sdk",
 };
 //# sourceMappingURL=config.js.map

package/esm/models/anthropictoolsearchtoolbm25.d.ts

@@ -0,0 +1,41 @@
+import * as z from "zod/v4";
+import { ClosedEnum, OpenEnum } from "../types/enums.js";
+import { AnthropicAllowedCallers } from "./anthropicallowedcallers.js";
+import { AnthropicCacheControlDirective, AnthropicCacheControlDirective$Outbound } from "./anthropiccachecontroldirective.js";
+export declare const AnthropicToolSearchToolBm25Name: {
+    readonly ToolSearchToolBm25: "tool_search_tool_bm25";
+};
+export type AnthropicToolSearchToolBm25Name = ClosedEnum<typeof AnthropicToolSearchToolBm25Name>;
+export declare const AnthropicToolSearchToolBm25Type: {
+    readonly ToolSearchToolBm2520251119: "tool_search_tool_bm25_20251119";
+    readonly ToolSearchToolBm25: "tool_search_tool_bm25";
+};
+export type AnthropicToolSearchToolBm25Type = OpenEnum<typeof AnthropicToolSearchToolBm25Type>;
+export type AnthropicToolSearchToolBm25 = {
+    allowedCallers?: Array<AnthropicAllowedCallers> | undefined;
+    /**
+     * Enable automatic prompt caching. When set at the top level, the system automatically applies cache breakpoints to the last cacheable block in the request. When set on an individual content block, it marks an explicit cache breakpoint; block-level markers also work on OpenAI models that support explicit prompt caching — OpenRouter converts them to the provider's native format.
+     */
+    cacheControl?: AnthropicCacheControlDirective | undefined;
+    deferLoading?: boolean | undefined;
+    name: AnthropicToolSearchToolBm25Name;
+    strict?: boolean | undefined;
+    type: AnthropicToolSearchToolBm25Type;
+};
+/** @internal */
+export declare const AnthropicToolSearchToolBm25Name$outboundSchema: z.ZodEnum<typeof AnthropicToolSearchToolBm25Name>;
+/** @internal */
+export declare const AnthropicToolSearchToolBm25Type$outboundSchema: z.ZodType<string, AnthropicToolSearchToolBm25Type>;
+/** @internal */
+export type AnthropicToolSearchToolBm25$Outbound = {
+    allowed_callers?: Array<string> | undefined;
+    cache_control?: AnthropicCacheControlDirective$Outbound | undefined;
+    defer_loading?: boolean | undefined;
+    name: string;
+    strict?: boolean | undefined;
+    type: string;
+};
+/** @internal */
+export declare const AnthropicToolSearchToolBm25$outboundSchema: z.ZodType<AnthropicToolSearchToolBm25$Outbound, AnthropicToolSearchToolBm25>;
+export declare function anthropicToolSearchToolBm25ToJSON(anthropicToolSearchToolBm25: AnthropicToolSearchToolBm25): string;
+//# sourceMappingURL=anthropictoolsearchtoolbm25.d.ts.map

package/esm/models/anthropictoolsearchtoolbm25.js

@@ -0,0 +1,39 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ * @generated-id: d06d81d905be
+ */
+import * as z from "zod/v4";
+import { remap as remap$ } from "../lib/primitives.js";
+import * as openEnums from "../types/enums.js";
+import { AnthropicAllowedCallers$outboundSchema, } from "./anthropicallowedcallers.js";
+import { AnthropicCacheControlDirective$outboundSchema, } from "./anthropiccachecontroldirective.js";
+export const AnthropicToolSearchToolBm25Name = {
+    ToolSearchToolBm25: "tool_search_tool_bm25",
+};
+export const AnthropicToolSearchToolBm25Type = {
+    ToolSearchToolBm2520251119: "tool_search_tool_bm25_20251119",
+    ToolSearchToolBm25: "tool_search_tool_bm25",
+};
+/** @internal */
+export const AnthropicToolSearchToolBm25Name$outboundSchema = z.enum(AnthropicToolSearchToolBm25Name);
+/** @internal */
+export const AnthropicToolSearchToolBm25Type$outboundSchema = openEnums.outboundSchema(AnthropicToolSearchToolBm25Type);
+/** @internal */
+export const AnthropicToolSearchToolBm25$outboundSchema = z.object({
+    allowedCallers: z.array(AnthropicAllowedCallers$outboundSchema).optional(),
+    cacheControl: AnthropicCacheControlDirective$outboundSchema.optional(),
+    deferLoading: z.boolean().optional(),
+    name: AnthropicToolSearchToolBm25Name$outboundSchema,
+    strict: z.boolean().optional(),
+    type: AnthropicToolSearchToolBm25Type$outboundSchema,
+}).transform((v) => {
+    return remap$(v, {
+        allowedCallers: "allowed_callers",
+        cacheControl: "cache_control",
+        deferLoading: "defer_loading",
+    });
+});
+export function anthropicToolSearchToolBm25ToJSON(anthropicToolSearchToolBm25) {
+    return JSON.stringify(AnthropicToolSearchToolBm25$outboundSchema.parse(anthropicToolSearchToolBm25));
+}
+//# sourceMappingURL=anthropictoolsearchtoolbm25.js.map

package/esm/models/anthropictoolsearchtoolregex.d.ts

@@ -0,0 +1,41 @@
+import * as z from "zod/v4";
+import { ClosedEnum, OpenEnum } from "../types/enums.js";
+import { AnthropicAllowedCallers } from "./anthropicallowedcallers.js";
+import { AnthropicCacheControlDirective, AnthropicCacheControlDirective$Outbound } from "./anthropiccachecontroldirective.js";
+export declare const AnthropicToolSearchToolRegexName: {
+    readonly ToolSearchToolRegex: "tool_search_tool_regex";
+};
+export type AnthropicToolSearchToolRegexName = ClosedEnum<typeof AnthropicToolSearchToolRegexName>;
+export declare const AnthropicToolSearchToolRegexType: {
+    readonly ToolSearchToolRegex20251119: "tool_search_tool_regex_20251119";
+    readonly ToolSearchToolRegex: "tool_search_tool_regex";
+};
+export type AnthropicToolSearchToolRegexType = OpenEnum<typeof AnthropicToolSearchToolRegexType>;
+export type AnthropicToolSearchToolRegex = {
+    allowedCallers?: Array<AnthropicAllowedCallers> | undefined;
+    /**
+     * Enable automatic prompt caching. When set at the top level, the system automatically applies cache breakpoints to the last cacheable block in the request. When set on an individual content block, it marks an explicit cache breakpoint; block-level markers also work on OpenAI models that support explicit prompt caching — OpenRouter converts them to the provider's native format.
+     */
+    cacheControl?: AnthropicCacheControlDirective | undefined;
+    deferLoading?: boolean | undefined;
+    name: AnthropicToolSearchToolRegexName;
+    strict?: boolean | undefined;
+    type: AnthropicToolSearchToolRegexType;
+};
+/** @internal */
+export declare const AnthropicToolSearchToolRegexName$outboundSchema: z.ZodEnum<typeof AnthropicToolSearchToolRegexName>;
+/** @internal */
+export declare const AnthropicToolSearchToolRegexType$outboundSchema: z.ZodType<string, AnthropicToolSearchToolRegexType>;
+/** @internal */
+export type AnthropicToolSearchToolRegex$Outbound = {
+    allowed_callers?: Array<string> | undefined;
+    cache_control?: AnthropicCacheControlDirective$Outbound | undefined;
+    defer_loading?: boolean | undefined;
+    name: string;
+    strict?: boolean | undefined;
+    type: string;
+};
+/** @internal */
+export declare const AnthropicToolSearchToolRegex$outboundSchema: z.ZodType<AnthropicToolSearchToolRegex$Outbound, AnthropicToolSearchToolRegex>;
+export declare function anthropicToolSearchToolRegexToJSON(anthropicToolSearchToolRegex: AnthropicToolSearchToolRegex): string;
+//# sourceMappingURL=anthropictoolsearchtoolregex.d.ts.map

package/esm/models/anthropictoolsearchtoolregex.js

@@ -0,0 +1,39 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ * @generated-id: 70c2d1fd66ec
+ */
+import * as z from "zod/v4";
+import { remap as remap$ } from "../lib/primitives.js";
+import * as openEnums from "../types/enums.js";
+import { AnthropicAllowedCallers$outboundSchema, } from "./anthropicallowedcallers.js";
+import { AnthropicCacheControlDirective$outboundSchema, } from "./anthropiccachecontroldirective.js";
+export const AnthropicToolSearchToolRegexName = {
+    ToolSearchToolRegex: "tool_search_tool_regex",
+};
+export const AnthropicToolSearchToolRegexType = {
+    ToolSearchToolRegex20251119: "tool_search_tool_regex_20251119",
+    ToolSearchToolRegex: "tool_search_tool_regex",
+};
+/** @internal */
+export const AnthropicToolSearchToolRegexName$outboundSchema = z.enum(AnthropicToolSearchToolRegexName);
+/** @internal */
+export const AnthropicToolSearchToolRegexType$outboundSchema = openEnums.outboundSchema(AnthropicToolSearchToolRegexType);
+/** @internal */
+export const AnthropicToolSearchToolRegex$outboundSchema = z.object({
+    allowedCallers: z.array(AnthropicAllowedCallers$outboundSchema).optional(),
+    cacheControl: AnthropicCacheControlDirective$outboundSchema.optional(),
+    deferLoading: z.boolean().optional(),
+    name: AnthropicToolSearchToolRegexName$outboundSchema,
+    strict: z.boolean().optional(),
+    type: AnthropicToolSearchToolRegexType$outboundSchema,
+}).transform((v) => {
+    return remap$(v, {
+        allowedCallers: "allowed_callers",
+        cacheControl: "cache_control",
+        deferLoading: "defer_loading",
+    });
+});
+export function anthropicToolSearchToolRegexToJSON(anthropicToolSearchToolRegex) {
+    return JSON.stringify(AnthropicToolSearchToolRegex$outboundSchema.parse(anthropicToolSearchToolRegex));
+}
+//# sourceMappingURL=anthropictoolsearchtoolregex.js.map

package/esm/models/chatrequest.d.ts

@@ -223,7 +223,7 @@ export type ChatRequest = {
      */
     stop?: string | Array<string> | null | undefined;
     /**
-     * Stop conditions for the server-tool agent loop. Any condition firing halts the loop (OR logic). When set, this overrides `max_tool_calls`.
+     * Stop conditions for the server-tool agent loop. Any condition firing halts the loop (OR logic). When set, this overrides `max_tool_calls`. When a condition fires while the model is still emitting tool calls, the pending tool calls are executed and one final turn is made with tool calls disabled so the response ends with a natural-language answer instead of an unfinished tool call.
      */
     stopServerToolsWhen?: Array<StopServerToolsWhenCondition> | undefined;
     /**

package/esm/models/index.d.ts

@@ -35,6 +35,8 @@ export * from "./anthropicspeed.js";
 export * from "./anthropictextblockparam.js";
 export * from "./anthropicthinkingdisplay.js";
 export * from "./anthropicthinkingturns.js";
+export * from "./anthropictoolsearchtoolbm25.js";
+export * from "./anthropictoolsearchtoolregex.js";
 export * from "./anthropictooluseskeep.js";
 export * from "./anthropictoolusestrigger.js";
 export * from "./anthropicunknownusageiteration.js";

package/esm/models/index.js

@@ -39,6 +39,8 @@ export * from "./anthropicspeed.js";
 export * from "./anthropictextblockparam.js";
 export * from "./anthropicthinkingdisplay.js";
 export * from "./anthropicthinkingturns.js";
+export * from "./anthropictoolsearchtoolbm25.js";
+export * from "./anthropictoolsearchtoolregex.js";
 export * from "./anthropictooluseskeep.js";
 export * from "./anthropictoolusestrigger.js";
 export * from "./anthropicunknownusageiteration.js";

package/esm/models/messagesrequest.d.ts

@@ -7,6 +7,8 @@ import { AnthropicInputTokensTrigger, AnthropicInputTokensTrigger$Outbound } fro
 import { AnthropicTextBlockParam, AnthropicTextBlockParam$Outbound } from "./anthropictextblockparam.js";
 import { AnthropicThinkingDisplay } from "./anthropicthinkingdisplay.js";
 import { AnthropicThinkingTurns, AnthropicThinkingTurns$Outbound } from "./anthropicthinkingturns.js";
+import { AnthropicToolSearchToolBm25, AnthropicToolSearchToolBm25$Outbound } from "./anthropictoolsearchtoolbm25.js";
+import { AnthropicToolSearchToolRegex, AnthropicToolSearchToolRegex$Outbound } from "./anthropictoolsearchtoolregex.js";
 import { AnthropicToolUsesKeep, AnthropicToolUsesKeep$Outbound } from "./anthropictooluseskeep.js";
 import { AnthropicToolUsesTrigger, AnthropicToolUsesTrigger$Outbound } from "./anthropictoolusestrigger.js";
 import { AnthropicWebSearchToolUserLocation, AnthropicWebSearchToolUserLocation$Outbound } from "./anthropicwebsearchtooluserlocation.js";
@@ -244,7 +246,7 @@ export type ToolCustom = {
     name: string;
     type?: ToolTypeCustom | undefined;
 };
-export type MessagesRequestToolUnion = ToolAdvisor20260301 | ToolCustom | ToolBash20250124 | ToolTextEditor20250124 | ToolWebSearch20250305 | ToolWebSearch20260209 | BashServerTool | DatetimeServerTool | ImageGenerationServerToolOpenRouter | MessagesSearchModelsServerTool | WebFetchServerTool | OpenRouterWebSearchServerTool | MessagesRequestTool;
+export type MessagesRequestToolUnion = ToolAdvisor20260301 | ToolCustom | ToolBash20250124 | ToolTextEditor20250124 | ToolWebSearch20250305 | ToolWebSearch20260209 | AnthropicToolSearchToolBm25 | AnthropicToolSearchToolRegex | BashServerTool | DatetimeServerTool | ImageGenerationServerToolOpenRouter | MessagesSearchModelsServerTool | WebFetchServerTool | OpenRouterWebSearchServerTool | MessagesRequestTool;
 /**
  * Request schema for Anthropic Messages API endpoint
  */
@@ -283,7 +285,7 @@ export type MessagesRequest = {
     speed?: Speed | null | undefined;
     stopSequences?: Array<string> | undefined;
     /**
-     * Stop conditions for the server-tool agent loop. Any condition firing halts the loop (OR logic). When set, this overrides `max_tool_calls`.
+     * Stop conditions for the server-tool agent loop. Any condition firing halts the loop (OR logic). When set, this overrides `max_tool_calls`. When a condition fires while the model is still emitting tool calls, the pending tool calls are executed and one final turn is made with tool calls disabled so the response ends with a natural-language answer instead of an unfinished tool call.
      */
     stopServerToolsWhen?: Array<StopServerToolsWhenCondition> | undefined;
     stream?: boolean | undefined;
@@ -291,7 +293,7 @@ export type MessagesRequest = {
     temperature?: number | undefined;
     thinking?: ThinkingEnabled | ThinkingDisabled | ThinkingAdaptive | undefined;
     toolChoice?: ToolChoiceAuto | ToolChoiceAny | ToolChoiceNone | ToolChoiceTool | undefined;
-    tools?: Array<ToolAdvisor20260301 | ToolCustom | ToolBash20250124 | ToolTextEditor20250124 | ToolWebSearch20250305 | ToolWebSearch20260209 | BashServerTool | DatetimeServerTool | ImageGenerationServerToolOpenRouter | MessagesSearchModelsServerTool | WebFetchServerTool | OpenRouterWebSearchServerTool | MessagesRequestTool> | undefined;
+    tools?: Array<ToolAdvisor20260301 | ToolCustom | ToolBash20250124 | ToolTextEditor20250124 | ToolWebSearch20250305 | ToolWebSearch20260209 | AnthropicToolSearchToolBm25 | AnthropicToolSearchToolRegex | BashServerTool | DatetimeServerTool | ImageGenerationServerToolOpenRouter | MessagesSearchModelsServerTool | WebFetchServerTool | OpenRouterWebSearchServerTool | MessagesRequestTool> | undefined;
     topK?: number | undefined;
     topP?: number | undefined;
     /**
@@ -577,7 +579,7 @@ export type ToolCustom$Outbound = {
 export declare const ToolCustom$outboundSchema: z.ZodType<ToolCustom$Outbound, ToolCustom>;
 export declare function toolCustomToJSON(toolCustom: ToolCustom): string;
 /** @internal */
-export type MessagesRequestToolUnion$Outbound = ToolAdvisor20260301$Outbound | ToolCustom$Outbound | ToolBash20250124$Outbound | ToolTextEditor20250124$Outbound | ToolWebSearch20250305$Outbound | ToolWebSearch20260209$Outbound | BashServerTool$Outbound | DatetimeServerTool$Outbound | ImageGenerationServerToolOpenRouter$Outbound | MessagesSearchModelsServerTool$Outbound | WebFetchServerTool$Outbound | OpenRouterWebSearchServerTool$Outbound | MessagesRequestTool$Outbound;
+export type MessagesRequestToolUnion$Outbound = ToolAdvisor20260301$Outbound | ToolCustom$Outbound | ToolBash20250124$Outbound | ToolTextEditor20250124$Outbound | ToolWebSearch20250305$Outbound | ToolWebSearch20260209$Outbound | AnthropicToolSearchToolBm25$Outbound | AnthropicToolSearchToolRegex$Outbound | BashServerTool$Outbound | DatetimeServerTool$Outbound | ImageGenerationServerToolOpenRouter$Outbound | MessagesSearchModelsServerTool$Outbound | WebFetchServerTool$Outbound | OpenRouterWebSearchServerTool$Outbound | MessagesRequestTool$Outbound;
 /** @internal */
 export declare const MessagesRequestToolUnion$outboundSchema: z.ZodType<MessagesRequestToolUnion$Outbound, MessagesRequestToolUnion>;
 export declare function messagesRequestToolUnionToJSON(messagesRequestToolUnion: MessagesRequestToolUnion): string;
@@ -604,7 +606,7 @@ export type MessagesRequest$Outbound = {
     temperature?: number | undefined;
     thinking?: ThinkingEnabled$Outbound | ThinkingDisabled$Outbound | ThinkingAdaptive$Outbound | undefined;
     tool_choice?: ToolChoiceAuto$Outbound | ToolChoiceAny$Outbound | ToolChoiceNone$Outbound | ToolChoiceTool$Outbound | undefined;
-    tools?: Array<ToolAdvisor20260301$Outbound | ToolCustom$Outbound | ToolBash20250124$Outbound | ToolTextEditor20250124$Outbound | ToolWebSearch20250305$Outbound | ToolWebSearch20260209$Outbound | BashServerTool$Outbound | DatetimeServerTool$Outbound | ImageGenerationServerToolOpenRouter$Outbound | MessagesSearchModelsServerTool$Outbound | WebFetchServerTool$Outbound | OpenRouterWebSearchServerTool$Outbound | MessagesRequestTool$Outbound> | undefined;
+    tools?: Array<ToolAdvisor20260301$Outbound | ToolCustom$Outbound | ToolBash20250124$Outbound | ToolTextEditor20250124$Outbound | ToolWebSearch20250305$Outbound | ToolWebSearch20260209$Outbound | AnthropicToolSearchToolBm25$Outbound | AnthropicToolSearchToolRegex$Outbound | BashServerTool$Outbound | DatetimeServerTool$Outbound | ImageGenerationServerToolOpenRouter$Outbound | MessagesSearchModelsServerTool$Outbound | WebFetchServerTool$Outbound | OpenRouterWebSearchServerTool$Outbound | MessagesRequestTool$Outbound> | undefined;
     top_k?: number | undefined;
     top_p?: number | undefined;
     trace?: TraceConfig$Outbound | undefined;

package/esm/models/messagesrequest.js

@@ -12,6 +12,8 @@ import { AnthropicInputTokensTrigger$outboundSchema, } from "./anthropicinputtok
 import { AnthropicTextBlockParam$outboundSchema, } from "./anthropictextblockparam.js";
 import { AnthropicThinkingDisplay$outboundSchema, } from "./anthropicthinkingdisplay.js";
 import { AnthropicThinkingTurns$outboundSchema, } from "./anthropicthinkingturns.js";
+import { AnthropicToolSearchToolBm25$outboundSchema, } from "./anthropictoolsearchtoolbm25.js";
+import { AnthropicToolSearchToolRegex$outboundSchema, } from "./anthropictoolsearchtoolregex.js";
 import { AnthropicToolUsesKeep$outboundSchema, } from "./anthropictooluseskeep.js";
 import { AnthropicToolUsesTrigger$outboundSchema, } from "./anthropictoolusestrigger.js";
 import { AnthropicWebSearchToolUserLocation$outboundSchema, } from "./anthropicwebsearchtooluserlocation.js";
@@ -503,6 +505,8 @@ export const MessagesRequestToolUnion$outboundSchema = z.union([
     z.lazy(() => ToolTextEditor20250124$outboundSchema),
     z.lazy(() => ToolWebSearch20250305$outboundSchema),
     z.lazy(() => ToolWebSearch20260209$outboundSchema),
+    AnthropicToolSearchToolBm25$outboundSchema,
+    AnthropicToolSearchToolRegex$outboundSchema,
     BashServerTool$outboundSchema,
     DatetimeServerTool$outboundSchema,
     ImageGenerationServerToolOpenRouter$outboundSchema,
@@ -568,6 +572,8 @@ export const MessagesRequest$outboundSchema = z.object({
         z.lazy(() => ToolTextEditor20250124$outboundSchema),
         z.lazy(() => ToolWebSearch20250305$outboundSchema),
         z.lazy(() => ToolWebSearch20260209$outboundSchema),
+        AnthropicToolSearchToolBm25$outboundSchema,
+        AnthropicToolSearchToolRegex$outboundSchema,
         BashServerTool$outboundSchema,
         DatetimeServerTool$outboundSchema,
         ImageGenerationServerToolOpenRouter$outboundSchema,

package/esm/models/responsesrequest.d.ts

@@ -216,7 +216,7 @@ export type ResponsesRequest = {
      */
     sessionId?: string | undefined;
     /**
-     * Stop conditions for the server-tool agent loop. Any condition firing halts the loop (OR logic). When set, this overrides `max_tool_calls`.
+     * Stop conditions for the server-tool agent loop. Any condition firing halts the loop (OR logic). When set, this overrides `max_tool_calls`. When a condition fires while the model is still emitting tool calls, the pending tool calls are executed and one final turn is made with tool calls disabled so the response ends with a natural-language answer instead of an unfinished tool call.
      */
     stopServerToolsWhen?: Array<StopServerToolsWhenCondition> | undefined;
     store?: false | undefined;

package/jsr.json

@@ -2,7 +2,7 @@
 
 {
   "name": "@openrouter/sdk",
-  "version": "1.0.2",
+  "version": "1.0.4",
   "exports": {
     ".": "./src/index.ts",    
     "./models/errors": "./src/models/errors/index.ts",    

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@openrouter/sdk",
-  "version": "1.0.2",
+  "version": "1.0.4",
   "author": "OpenRouter",
   "description": "The OpenRouter TypeScript SDK is a type-safe toolkit for building AI applications with access to 400+ language models through a unified API.",
   "keywords": [
@@ -73,15 +73,15 @@
     "lint": "eslint --cache --max-warnings=0 src",
     "build": "tsc",
     "prepublishOnly": "npm run build",
-    "postinstall": "node scripts/check-types.js || true",
-    "test:e2e": "vitest --run --project e2e",
+    "test": "vitest --run --project unit",
     "test:transit": "exit 0",
     "test:watch": "vitest --watch --project unit",
-    "compile": "tsc",
-    "prepare": "npm run build",
-    "test": "vitest --run --project unit",
     "typecheck": "tsc --noEmit",
-    "typecheck:transit": "exit 0"
+    "prepare": "npm run build",
+    "test:e2e": "vitest --run --project e2e",
+    "typecheck:transit": "exit 0",
+    "compile": "tsc",
+    "postinstall": "node scripts/check-types.js || true"
   },
   "peerDependencies": {},
   "devDependencies": {