@openrouter/sdk 1.4.6 → 1.4.8

package/esm/models/operations/gettool.js

@@ -0,0 +1,43 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ * @generated-id: 643b31a6a57a
+ */
+import * as z from "zod/v4";
+import { remap as remap$ } from "../../lib/primitives.js";
+import { safeParse } from "../../lib/schemas.js";
+import { GetToolResponse$inboundSchema as models_GetToolResponse$inboundSchema } from "../gettoolresponse.js";
+/** @internal */
+export const GetToolSecurity$outboundSchema = z.object({
+    bearer: z.string(),
+});
+export function getToolSecurityToJSON(getToolSecurity) {
+    return JSON.stringify(GetToolSecurity$outboundSchema.parse(getToolSecurity));
+}
+/** @internal */
+export const GetToolRequest$outboundSchema = z.object({
+    httpReferer: z.string().optional(),
+    appTitle: z.string().optional(),
+    appCategories: z.string().optional(),
+    name: z.string(),
+}).transform((v) => {
+    return remap$(v, {
+        httpReferer: "HTTP-Referer",
+    });
+});
+export function getToolRequestToJSON(getToolRequest) {
+    return JSON.stringify(GetToolRequest$outboundSchema.parse(getToolRequest));
+}
+/** @internal */
+export const GetToolResponse$inboundSchema = z.object({
+    Headers: z.record(z.string(), z.array(z.string())).default({}),
+    Result: models_GetToolResponse$inboundSchema.optional(),
+}).transform((v) => {
+    return remap$(v, {
+        "Headers": "headers",
+        "Result": "result",
+    });
+});
+export function getToolResponseFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => GetToolResponse$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'GetToolResponse' from JSON`);
+}
+//# sourceMappingURL=gettool.js.map

package/esm/models/operations/index.d.ts

@@ -76,6 +76,7 @@ export * from "./getscimgroupmapping.js";
 export * from "./getscimsyncjob.js";
 export * from "./getsessioncost.js";
 export * from "./gettaskclassifications.js";
+export * from "./gettool.js";
 export * from "./getuseractivity.js";
 export * from "./getvideos.js";
 export * from "./getworkspace.js";
@@ -111,6 +112,7 @@ export * from "./listprivateendpoints.js";
 export * from "./listproviders.js";
 export * from "./listscimgroupmappings.js";
 export * from "./listscimgroups.js";
+export * from "./listtools.js";
 export * from "./listvaultsecrets.js";
 export * from "./listvideoscontent.js";
 export * from "./listvideosmodels.js";

package/esm/models/operations/index.js

@@ -80,6 +80,7 @@ export * from "./getscimgroupmapping.js";
 export * from "./getscimsyncjob.js";
 export * from "./getsessioncost.js";
 export * from "./gettaskclassifications.js";
+export * from "./gettool.js";
 export * from "./getuseractivity.js";
 export * from "./getvideos.js";
 export * from "./getworkspace.js";
@@ -115,6 +116,7 @@ export * from "./listprivateendpoints.js";
 export * from "./listproviders.js";
 export * from "./listscimgroupmappings.js";
 export * from "./listscimgroups.js";
+export * from "./listtools.js";
 export * from "./listvaultsecrets.js";
 export * from "./listvideoscontent.js";
 export * from "./listvideosmodels.js";

package/esm/models/operations/listtools.d.ts

@@ -0,0 +1,93 @@
+import * as z from "zod/v4";
+import { OpenEnum } from "../../types/enums.js";
+export type ListToolsGlobals = {
+    /**
+     * The app identifier should be your app's URL and is used as the primary identifier for rankings.
+     *
+     * @remarks
+     * This is used to track API usage per application.
+     */
+    httpReferer?: string | undefined;
+    /**
+     * The app display name allows you to customize how your app appears in OpenRouter's dashboard.
+     *
+     * @remarks
+     */
+    appTitle?: string | undefined;
+    /**
+     * Comma-separated list of app categories (e.g. "cli-agent,cloud-agent"). Used for marketplace rankings.
+     *
+     * @remarks
+     */
+    appCategories?: string | undefined;
+};
+export type ListToolsSecurity = {
+    bearer: string;
+};
+/**
+ * Only tools usable on this API format
+ */
+export declare const ApiFormat: {
+    readonly Responses: "responses";
+    readonly ChatCompletions: "chat-completions";
+    readonly AnthropicMessages: "anthropic-messages";
+};
+/**
+ * Only tools usable on this API format
+ */
+export type ApiFormat = OpenEnum<typeof ApiFormat>;
+export type ListToolsRequest = {
+    /**
+     * The app identifier should be your app's URL and is used as the primary identifier for rankings.
+     *
+     * @remarks
+     * This is used to track API usage per application.
+     */
+    httpReferer?: string | undefined;
+    /**
+     * The app display name allows you to customize how your app appears in OpenRouter's dashboard.
+     *
+     * @remarks
+     */
+    appTitle?: string | undefined;
+    /**
+     * Comma-separated list of app categories (e.g. "cli-agent,cloud-agent"). Used for marketplace rankings.
+     *
+     * @remarks
+     */
+    appCategories?: string | undefined;
+    /**
+     * Number of records to skip for pagination. When both offset and limit are omitted, the full list is returned
+     */
+    offset?: number | null | undefined;
+    /**
+     * Maximum number of records to return (max 100). When both offset and limit are omitted, the full list is returned
+     */
+    limit?: number | undefined;
+    /**
+     * Only tools usable on this API format
+     */
+    apiFormat?: ApiFormat | undefined;
+};
+/** @internal */
+export type ListToolsSecurity$Outbound = {
+    bearer: string;
+};
+/** @internal */
+export declare const ListToolsSecurity$outboundSchema: z.ZodType<ListToolsSecurity$Outbound, ListToolsSecurity>;
+export declare function listToolsSecurityToJSON(listToolsSecurity: ListToolsSecurity): string;
+/** @internal */
+export declare const ApiFormat$outboundSchema: z.ZodType<string, ApiFormat>;
+/** @internal */
+export type ListToolsRequest$Outbound = {
+    "HTTP-Referer"?: string | undefined;
+    appTitle?: string | undefined;
+    appCategories?: string | undefined;
+    offset: number | null;
+    limit: number;
+    api_format?: string | undefined;
+};
+/** @internal */
+export declare const ListToolsRequest$outboundSchema: z.ZodType<ListToolsRequest$Outbound, ListToolsRequest>;
+export declare function listToolsRequestToJSON(listToolsRequest: ListToolsRequest): string;
+//# sourceMappingURL=listtools.d.ts.map

package/esm/models/operations/listtools.js

@@ -0,0 +1,43 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ * @generated-id: 42a61de0bc0f
+ */
+import * as z from "zod/v4";
+import { remap as remap$ } from "../../lib/primitives.js";
+import * as openEnums from "../../types/enums.js";
+/**
+ * Only tools usable on this API format
+ */
+export const ApiFormat = {
+    Responses: "responses",
+    ChatCompletions: "chat-completions",
+    AnthropicMessages: "anthropic-messages",
+};
+/** @internal */
+export const ListToolsSecurity$outboundSchema = z.object({
+    bearer: z.string(),
+});
+export function listToolsSecurityToJSON(listToolsSecurity) {
+    return JSON.stringify(ListToolsSecurity$outboundSchema.parse(listToolsSecurity));
+}
+/** @internal */
+export const ApiFormat$outboundSchema = openEnums
+    .outboundSchema(ApiFormat);
+/** @internal */
+export const ListToolsRequest$outboundSchema = z.object({
+    httpReferer: z.string().optional(),
+    appTitle: z.string().optional(),
+    appCategories: z.string().optional(),
+    offset: z.nullable(z.int().default(0)),
+    limit: z.int().default(50),
+    apiFormat: ApiFormat$outboundSchema.optional(),
+}).transform((v) => {
+    return remap$(v, {
+        httpReferer: "HTTP-Referer",
+        apiFormat: "api_format",
+    });
+});
+export function listToolsRequestToJSON(listToolsRequest) {
+    return JSON.stringify(ListToolsRequest$outboundSchema.parse(listToolsRequest));
+}
+//# sourceMappingURL=listtools.js.map

package/esm/models/servertool.d.ts

@@ -0,0 +1,79 @@
+import * as z from "zod/v4";
+import { OpenEnum } from "../types/enums.js";
+import { Result as SafeParseResult } from "../types/fp.js";
+import { SDKValidationError } from "./errors/sdkvalidationerror.js";
+import { ServerToolEngine } from "./servertoolengine.js";
+import { ServerToolInputName } from "./servertoolinputname.js";
+import { ServerToolNativeSupport } from "./servertoolnativesupport.js";
+export declare const ServerToolStatus: {
+    readonly Active: "active";
+    readonly Deprecated: "deprecated";
+};
+export type ServerToolStatus = OpenEnum<typeof ServerToolStatus>;
+export declare const ServerToolSupportedApiFormat: {
+    readonly Responses: "responses";
+    readonly ChatCompletions: "chat-completions";
+    readonly AnthropicMessages: "anthropic-messages";
+};
+export type ServerToolSupportedApiFormat = OpenEnum<typeof ServerToolSupportedApiFormat>;
+export type ServerTool = {
+    /**
+     * Every spelling accepted in `tools[].type` for this tool, including the canonical `id`, and what the call surfaces as under each
+     */
+    aliases: Array<ServerToolInputName>;
+    /**
+     * The engine a request without `parameters.engine` (or with `engine: "auto"`) runs on; `native` applies where the endpoint runs the tool itself, otherwise `fallback_engine`. A request pinned to a data region skips either engine when its `data_regions` does not list that region. Null for a tool without an engine parameter
+     */
+    defaultEngine: string | null;
+    docsUrl: string;
+    engines: Array<ServerToolEngine>;
+    /**
+     * The engine an unpinned request runs on when `default_engine` is `native` and the endpoint does not run the tool itself; null when there is no fallback
+     */
+    fallbackEngine: string | null;
+    /**
+     * Canonical `openrouter:*` name; the stable `tools[].type` on every API format in `supported_api_formats`
+     */
+    id: string;
+    /**
+     * JSON Schema of the arguments the model emits when calling the tool
+     */
+    inputSchema: {
+        [k: string]: any;
+    };
+    name: string;
+    /**
+     * Endpoints whose provider runs this tool itself during inference. Zero for tools no provider runs natively.
+     */
+    nativeSupport: ServerToolNativeSupport;
+    /**
+     * JSON Schema of the result returned to the model; null when undeclared
+     */
+    outputSchema: {
+        [k: string]: any;
+    } | null;
+    /**
+     * JSON Schema for the caller-side `tools[].parameters` object
+     */
+    parametersSchema: {
+        [k: string]: any;
+    };
+    status: ServerToolStatus;
+    /**
+     * One sentence for cards and search results; never sent to a model
+     */
+    summary: string;
+    supportedApiFormats: Array<ServerToolSupportedApiFormat>;
+    /**
+     * The description sent upstream as the function tool description
+     */
+    toolDescription: string;
+};
+/** @internal */
+export declare const ServerToolStatus$inboundSchema: z.ZodType<ServerToolStatus, unknown>;
+/** @internal */
+export declare const ServerToolSupportedApiFormat$inboundSchema: z.ZodType<ServerToolSupportedApiFormat, unknown>;
+/** @internal */
+export declare const ServerTool$inboundSchema: z.ZodType<ServerTool, unknown>;
+export declare function serverToolFromJSON(jsonString: string): SafeParseResult<ServerTool, SDKValidationError>;
+//# sourceMappingURL=servertool.d.ts.map

package/esm/models/servertool.js

@@ -0,0 +1,59 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ * @generated-id: 51581c50c8ce
+ */
+import * as z from "zod/v4";
+import { remap as remap$ } from "../lib/primitives.js";
+import { safeParse } from "../lib/schemas.js";
+import * as openEnums from "../types/enums.js";
+import { ServerToolEngine$inboundSchema, } from "./servertoolengine.js";
+import { ServerToolInputName$inboundSchema, } from "./servertoolinputname.js";
+import { ServerToolNativeSupport$inboundSchema, } from "./servertoolnativesupport.js";
+export const ServerToolStatus = {
+    Active: "active",
+    Deprecated: "deprecated",
+};
+export const ServerToolSupportedApiFormat = {
+    Responses: "responses",
+    ChatCompletions: "chat-completions",
+    AnthropicMessages: "anthropic-messages",
+};
+/** @internal */
+export const ServerToolStatus$inboundSchema = openEnums.inboundSchema(ServerToolStatus);
+/** @internal */
+export const ServerToolSupportedApiFormat$inboundSchema = openEnums.inboundSchema(ServerToolSupportedApiFormat);
+/** @internal */
+export const ServerTool$inboundSchema = z
+    .object({
+    aliases: z.array(ServerToolInputName$inboundSchema),
+    default_engine: z.nullable(z.string()),
+    docs_url: z.string(),
+    engines: z.array(ServerToolEngine$inboundSchema),
+    fallback_engine: z.nullable(z.string()),
+    id: z.string(),
+    input_schema: z.record(z.string(), z.any()),
+    name: z.string(),
+    native_support: ServerToolNativeSupport$inboundSchema,
+    output_schema: z.nullable(z.record(z.string(), z.any())),
+    parameters_schema: z.record(z.string(), z.any()),
+    status: ServerToolStatus$inboundSchema,
+    summary: z.string(),
+    supported_api_formats: z.array(ServerToolSupportedApiFormat$inboundSchema),
+    tool_description: z.string(),
+}).transform((v) => {
+    return remap$(v, {
+        "default_engine": "defaultEngine",
+        "docs_url": "docsUrl",
+        "fallback_engine": "fallbackEngine",
+        "input_schema": "inputSchema",
+        "native_support": "nativeSupport",
+        "output_schema": "outputSchema",
+        "parameters_schema": "parametersSchema",
+        "supported_api_formats": "supportedApiFormats",
+        "tool_description": "toolDescription",
+    });
+});
+export function serverToolFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => ServerTool$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'ServerTool' from JSON`);
+}
+//# sourceMappingURL=servertool.js.map

package/esm/models/servertooldetails.d.ts

@@ -0,0 +1,90 @@
+import * as z from "zod/v4";
+import { OpenEnum } from "../types/enums.js";
+import { Result as SafeParseResult } from "../types/fp.js";
+import { SDKValidationError } from "./errors/sdkvalidationerror.js";
+import { ServerToolEngine } from "./servertoolengine.js";
+import { ServerToolInputName } from "./servertoolinputname.js";
+import { ServerToolNativeModel } from "./servertoolnativemodel.js";
+/**
+ * Endpoints whose provider runs this tool itself during inference. Zero for tools no provider runs natively.
+ */
+export type NativeSupport = {
+    endpointCount: number;
+    modelCount: number;
+    models: Array<ServerToolNativeModel>;
+};
+export declare const ServerToolDetailsStatus: {
+    readonly Active: "active";
+    readonly Deprecated: "deprecated";
+};
+export type ServerToolDetailsStatus = OpenEnum<typeof ServerToolDetailsStatus>;
+export declare const ServerToolDetailsSupportedApiFormat: {
+    readonly Responses: "responses";
+    readonly ChatCompletions: "chat-completions";
+    readonly AnthropicMessages: "anthropic-messages";
+};
+export type ServerToolDetailsSupportedApiFormat = OpenEnum<typeof ServerToolDetailsSupportedApiFormat>;
+export type ServerToolDetails = {
+    /**
+     * Every spelling accepted in `tools[].type` for this tool, including the canonical `id`, and what the call surfaces as under each
+     */
+    aliases: Array<ServerToolInputName>;
+    /**
+     * The engine a request without `parameters.engine` (or with `engine: "auto"`) runs on; `native` applies where the endpoint runs the tool itself, otherwise `fallback_engine`. A request pinned to a data region skips either engine when its `data_regions` does not list that region. Null for a tool without an engine parameter
+     */
+    defaultEngine: string | null;
+    docsUrl: string;
+    engines: Array<ServerToolEngine>;
+    /**
+     * The engine an unpinned request runs on when `default_engine` is `native` and the endpoint does not run the tool itself; null when there is no fallback
+     */
+    fallbackEngine: string | null;
+    /**
+     * Canonical `openrouter:*` name; the stable `tools[].type` on every API format in `supported_api_formats`
+     */
+    id: string;
+    /**
+     * JSON Schema of the arguments the model emits when calling the tool
+     */
+    inputSchema: {
+        [k: string]: any;
+    };
+    name: string;
+    /**
+     * Endpoints whose provider runs this tool itself during inference. Zero for tools no provider runs natively.
+     */
+    nativeSupport: NativeSupport;
+    /**
+     * JSON Schema of the result returned to the model; null when undeclared
+     */
+    outputSchema: {
+        [k: string]: any;
+    } | null;
+    /**
+     * JSON Schema for the caller-side `tools[].parameters` object
+     */
+    parametersSchema: {
+        [k: string]: any;
+    };
+    status: ServerToolDetailsStatus;
+    /**
+     * One sentence for cards and search results; never sent to a model
+     */
+    summary: string;
+    supportedApiFormats: Array<ServerToolDetailsSupportedApiFormat>;
+    /**
+     * The description sent upstream as the function tool description
+     */
+    toolDescription: string;
+};
+/** @internal */
+export declare const NativeSupport$inboundSchema: z.ZodType<NativeSupport, unknown>;
+export declare function nativeSupportFromJSON(jsonString: string): SafeParseResult<NativeSupport, SDKValidationError>;
+/** @internal */
+export declare const ServerToolDetailsStatus$inboundSchema: z.ZodType<ServerToolDetailsStatus, unknown>;
+/** @internal */
+export declare const ServerToolDetailsSupportedApiFormat$inboundSchema: z.ZodType<ServerToolDetailsSupportedApiFormat, unknown>;
+/** @internal */
+export declare const ServerToolDetails$inboundSchema: z.ZodType<ServerToolDetails, unknown>;
+export declare function serverToolDetailsFromJSON(jsonString: string): SafeParseResult<ServerToolDetails, SDKValidationError>;
+//# sourceMappingURL=servertooldetails.d.ts.map

package/esm/models/servertooldetails.js

@@ -0,0 +1,73 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ * @generated-id: f94cb5399ef7
+ */
+import * as z from "zod/v4";
+import { remap as remap$ } from "../lib/primitives.js";
+import { safeParse } from "../lib/schemas.js";
+import * as openEnums from "../types/enums.js";
+import { ServerToolEngine$inboundSchema, } from "./servertoolengine.js";
+import { ServerToolInputName$inboundSchema, } from "./servertoolinputname.js";
+import { ServerToolNativeModel$inboundSchema, } from "./servertoolnativemodel.js";
+export const ServerToolDetailsStatus = {
+    Active: "active",
+    Deprecated: "deprecated",
+};
+export const ServerToolDetailsSupportedApiFormat = {
+    Responses: "responses",
+    ChatCompletions: "chat-completions",
+    AnthropicMessages: "anthropic-messages",
+};
+/** @internal */
+export const NativeSupport$inboundSchema = z
+    .object({
+    endpoint_count: z.int(),
+    model_count: z.int(),
+    models: z.array(ServerToolNativeModel$inboundSchema),
+}).transform((v) => {
+    return remap$(v, {
+        "endpoint_count": "endpointCount",
+        "model_count": "modelCount",
+    });
+});
+export function nativeSupportFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => NativeSupport$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'NativeSupport' from JSON`);
+}
+/** @internal */
+export const ServerToolDetailsStatus$inboundSchema = openEnums.inboundSchema(ServerToolDetailsStatus);
+/** @internal */
+export const ServerToolDetailsSupportedApiFormat$inboundSchema = openEnums.inboundSchema(ServerToolDetailsSupportedApiFormat);
+/** @internal */
+export const ServerToolDetails$inboundSchema = z.object({
+    aliases: z.array(ServerToolInputName$inboundSchema),
+    default_engine: z.nullable(z.string()),
+    docs_url: z.string(),
+    engines: z.array(ServerToolEngine$inboundSchema),
+    fallback_engine: z.nullable(z.string()),
+    id: z.string(),
+    input_schema: z.record(z.string(), z.any()),
+    name: z.string(),
+    native_support: z.lazy(() => NativeSupport$inboundSchema),
+    output_schema: z.nullable(z.record(z.string(), z.any())),
+    parameters_schema: z.record(z.string(), z.any()),
+    status: ServerToolDetailsStatus$inboundSchema,
+    summary: z.string(),
+    supported_api_formats: z.array(ServerToolDetailsSupportedApiFormat$inboundSchema),
+    tool_description: z.string(),
+}).transform((v) => {
+    return remap$(v, {
+        "default_engine": "defaultEngine",
+        "docs_url": "docsUrl",
+        "fallback_engine": "fallbackEngine",
+        "input_schema": "inputSchema",
+        "native_support": "nativeSupport",
+        "output_schema": "outputSchema",
+        "parameters_schema": "parametersSchema",
+        "supported_api_formats": "supportedApiFormats",
+        "tool_description": "toolDescription",
+    });
+});
+export function serverToolDetailsFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => ServerToolDetails$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'ServerToolDetails' from JSON`);
+}
+//# sourceMappingURL=servertooldetails.js.map

package/esm/models/servertoolengine.d.ts

@@ -0,0 +1,82 @@
+import * as z from "zod/v4";
+import { OpenEnum } from "../types/enums.js";
+import { Result as SafeParseResult } from "../types/fp.js";
+import { SDKValidationError } from "./errors/sdkvalidationerror.js";
+import { ServerToolExecutedBy } from "./servertoolexecutedby.js";
+import { ServerToolPrice } from "./servertoolprice.js";
+/**
+ * Whether the engine needs the caller's own key, saved in plugin settings: `required` (OpenRouter holds none), `optional` (OpenRouter's key is used unless the caller saved one), or `none`
+ */
+export declare const BYOK: {
+    readonly Required: "required";
+    readonly Optional: "optional";
+    readonly None: "none";
+};
+/**
+ * Whether the engine needs the caller's own key, saved in plugin settings: `required` (OpenRouter holds none), `optional` (OpenRouter's key is used unless the caller saved one), or `none`
+ */
+export type BYOK = OpenEnum<typeof BYOK>;
+export declare const ServerToolEngineDataRegion: {
+    readonly Global: "global";
+    readonly Europe: "europe";
+    readonly Us: "us";
+};
+export type ServerToolEngineDataRegion = OpenEnum<typeof ServerToolEngineDataRegion>;
+/**
+ * Who bills the engine's calls beyond the model's tokens: `openrouter` (the `pricing` rows, from the caller's credits), `provider` (a per-call tool fee from the model's provider on the inference call, at its own rates), `byok` (the engine's vendor, against the caller's own key), or `none` (no charge)
+ */
+export declare const PricingSource: {
+    readonly Openrouter: "openrouter";
+    readonly Provider: "provider";
+    readonly BYOK: "byok";
+    readonly None: "none";
+};
+/**
+ * Who bills the engine's calls beyond the model's tokens: `openrouter` (the `pricing` rows, from the caller's credits), `provider` (a per-call tool fee from the model's provider on the inference call, at its own rates), `byok` (the engine's vendor, against the caller's own key), or `none` (no charge)
+ */
+export type PricingSource = OpenEnum<typeof PricingSource>;
+export type ServerToolEngine = {
+    /**
+     * Whether the engine needs the caller's own key, saved in plugin settings: `required` (OpenRouter holds none), `optional` (OpenRouter's key is used unless the caller saved one), or `none`
+     */
+    byok: BYOK;
+    /**
+     * The data regions whose requests this engine serves without leaving the region. A request pinned to a region can only use engines that list it; `global` is always listed.
+     */
+    dataRegions: Array<ServerToolEngineDataRegion>;
+    /**
+     * The `parameters.mode` a request without one runs and bills as; null for engines without modes. The `pricing[]` row with this `mode` is what an unmoded request bills
+     */
+    defaultMode: string | null;
+    /**
+     * Who runs the tool call: the model provider during inference (`provider`), OpenRouter (`openrouter`), or the caller's application after the call is returned (`client`).
+     */
+    executedBy: ServerToolExecutedBy;
+    /**
+     * The `parameters.engine` value that selects this engine; null for the single engine of a tool without an engine parameter
+     */
+    id: string | null;
+    name: string;
+    /**
+     * The rows OpenRouter bills; non-empty exactly when `pricing_source` is `openrouter`
+     */
+    pricing: Array<ServerToolPrice>;
+    /**
+     * Where the rates are documented when `pricing_source` is `provider` or `byok`; null otherwise
+     */
+    pricingDocUrl: string | null;
+    /**
+     * Who bills the engine's calls beyond the model's tokens: `openrouter` (the `pricing` rows, from the caller's credits), `provider` (a per-call tool fee from the model's provider on the inference call, at its own rates), `byok` (the engine's vendor, against the caller's own key), or `none` (no charge)
+     */
+    pricingSource: PricingSource;
+};
+/** @internal */
+export declare const BYOK$inboundSchema: z.ZodType<BYOK, unknown>;
+/** @internal */
+export declare const ServerToolEngineDataRegion$inboundSchema: z.ZodType<ServerToolEngineDataRegion, unknown>;
+/** @internal */
+export declare const PricingSource$inboundSchema: z.ZodType<PricingSource, unknown>;
+/** @internal */
+export declare const ServerToolEngine$inboundSchema: z.ZodType<ServerToolEngine, unknown>;
+export declare function serverToolEngineFromJSON(jsonString: string): SafeParseResult<ServerToolEngine, SDKValidationError>;
+//# sourceMappingURL=servertoolengine.d.ts.map

package/esm/models/servertoolengine.js

@@ -0,0 +1,63 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ * @generated-id: 0ee547bdca50
+ */
+import * as z from "zod/v4";
+import { remap as remap$ } from "../lib/primitives.js";
+import { safeParse } from "../lib/schemas.js";
+import * as openEnums from "../types/enums.js";
+import { ServerToolExecutedBy$inboundSchema, } from "./servertoolexecutedby.js";
+import { ServerToolPrice$inboundSchema, } from "./servertoolprice.js";
+/**
+ * Whether the engine needs the caller's own key, saved in plugin settings: `required` (OpenRouter holds none), `optional` (OpenRouter's key is used unless the caller saved one), or `none`
+ */
+export const BYOK = {
+    Required: "required",
+    Optional: "optional",
+    None: "none",
+};
+export const ServerToolEngineDataRegion = {
+    Global: "global",
+    Europe: "europe",
+    Us: "us",
+};
+/**
+ * Who bills the engine's calls beyond the model's tokens: `openrouter` (the `pricing` rows, from the caller's credits), `provider` (a per-call tool fee from the model's provider on the inference call, at its own rates), `byok` (the engine's vendor, against the caller's own key), or `none` (no charge)
+ */
+export const PricingSource = {
+    Openrouter: "openrouter",
+    Provider: "provider",
+    BYOK: "byok",
+    None: "none",
+};
+/** @internal */
+export const BYOK$inboundSchema = openEnums
+    .inboundSchema(BYOK);
+/** @internal */
+export const ServerToolEngineDataRegion$inboundSchema = openEnums.inboundSchema(ServerToolEngineDataRegion);
+/** @internal */
+export const PricingSource$inboundSchema = openEnums.inboundSchema(PricingSource);
+/** @internal */
+export const ServerToolEngine$inboundSchema = z.object({
+    byok: BYOK$inboundSchema,
+    data_regions: z.array(ServerToolEngineDataRegion$inboundSchema),
+    default_mode: z.nullable(z.string()),
+    executed_by: ServerToolExecutedBy$inboundSchema,
+    id: z.nullable(z.string()),
+    name: z.string(),
+    pricing: z.array(ServerToolPrice$inboundSchema),
+    pricing_doc_url: z.nullable(z.string()),
+    pricing_source: PricingSource$inboundSchema,
+}).transform((v) => {
+    return remap$(v, {
+        "data_regions": "dataRegions",
+        "default_mode": "defaultMode",
+        "executed_by": "executedBy",
+        "pricing_doc_url": "pricingDocUrl",
+        "pricing_source": "pricingSource",
+    });
+});
+export function serverToolEngineFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => ServerToolEngine$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'ServerToolEngine' from JSON`);
+}
+//# sourceMappingURL=servertoolengine.js.map