@openrouter/sdk 0.11.2 → 0.12.1

package/esm/models/legacywebsearchservertool.js

@@ -5,77 +5,38 @@
 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 { SearchContextSizeEnum$inboundSchema, SearchContextSizeEnum$outboundSchema, } from "./searchcontextsizeenum.js";
+import { WebSearchDomainFilter$inboundSchema, WebSearchDomainFilter$outboundSchema, } from "./websearchdomainfilter.js";
+import { WebSearchEngineEnum$inboundSchema, WebSearchEngineEnum$outboundSchema, } from "./websearchengineenum.js";
 import { WebSearchUserLocation$inboundSchema, WebSearchUserLocation$outboundSchema, } from "./websearchuserlocation.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. "firecrawl" uses Firecrawl (requires BYOK). "parallel" uses the Parallel search API.
- */
-export const LegacyWebSearchServerToolEngine = {
-    Auto: "auto",
-    Native: "native",
-    Exa: "exa",
-    Firecrawl: "firecrawl",
-    Parallel: "parallel",
-};
-/** @internal */
-export const LegacyWebSearchServerToolFilters$inboundSchema = z.object({
-    allowed_domains: z.nullable(z.array(z.string())).optional(),
-    excluded_domains: z.nullable(z.array(z.string())).optional(),
-}).transform((v) => {
-    return remap$(v, {
-        "allowed_domains": "allowedDomains",
-        "excluded_domains": "excludedDomains",
-    });
-});
-/** @internal */
-export const LegacyWebSearchServerToolFilters$outboundSchema = z.object({
-    allowedDomains: z.nullable(z.array(z.string())).optional(),
-    excludedDomains: z.nullable(z.array(z.string())).optional(),
-}).transform((v) => {
-    return remap$(v, {
-        allowedDomains: "allowed_domains",
-        excludedDomains: "excluded_domains",
-    });
-});
-export function legacyWebSearchServerToolFiltersToJSON(legacyWebSearchServerToolFilters) {
-    return JSON.stringify(LegacyWebSearchServerToolFilters$outboundSchema.parse(legacyWebSearchServerToolFilters));
-}
-export function legacyWebSearchServerToolFiltersFromJSON(jsonString) {
-    return safeParse(jsonString, (x) => LegacyWebSearchServerToolFilters$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'LegacyWebSearchServerToolFilters' from JSON`);
-}
-/** @internal */
-export const LegacyWebSearchServerToolEngine$inboundSchema = openEnums.inboundSchema(LegacyWebSearchServerToolEngine);
-/** @internal */
-export const LegacyWebSearchServerToolEngine$outboundSchema = openEnums.outboundSchema(LegacyWebSearchServerToolEngine);
 /** @internal */
 export const LegacyWebSearchServerTool$inboundSchema = z.object({
-    type: z.literal("web_search"),
-    filters: z.nullable(z.lazy(() => LegacyWebSearchServerToolFilters$inboundSchema)).optional(),
+    engine: WebSearchEngineEnum$inboundSchema.optional(),
+    filters: z.nullable(WebSearchDomainFilter$inboundSchema).optional(),
+    max_results: z.int().optional(),
     search_context_size: SearchContextSizeEnum$inboundSchema.optional(),
+    type: z.literal("web_search"),
     user_location: z.nullable(WebSearchUserLocation$inboundSchema).optional(),
-    engine: LegacyWebSearchServerToolEngine$inboundSchema.optional(),
-    max_results: z.number().optional(),
 }).transform((v) => {
     return remap$(v, {
+        "max_results": "maxResults",
         "search_context_size": "searchContextSize",
         "user_location": "userLocation",
-        "max_results": "maxResults",
     });
 });
 /** @internal */
 export const LegacyWebSearchServerTool$outboundSchema = z.object({
-    type: z.literal("web_search"),
-    filters: z.nullable(z.lazy(() => LegacyWebSearchServerToolFilters$outboundSchema)).optional(),
+    engine: WebSearchEngineEnum$outboundSchema.optional(),
+    filters: z.nullable(WebSearchDomainFilter$outboundSchema).optional(),
+    maxResults: z.int().optional(),
     searchContextSize: SearchContextSizeEnum$outboundSchema.optional(),
+    type: z.literal("web_search"),
     userLocation: z.nullable(WebSearchUserLocation$outboundSchema).optional(),
-    engine: LegacyWebSearchServerToolEngine$outboundSchema.optional(),
-    maxResults: z.number().optional(),
 }).transform((v) => {
     return remap$(v, {
+        maxResults: "max_results",
         searchContextSize: "search_context_size",
         userLocation: "user_location",
-        maxResults: "max_results",
     });
 });
 export function legacyWebSearchServerToolToJSON(legacyWebSearchServerTool) {

package/esm/models/listendpointsresponse.d.ts

@@ -16,6 +16,7 @@ export declare const Tokenizer: {
     readonly Gpt: "GPT";
     readonly Claude: "Claude";
     readonly Gemini: "Gemini";
+    readonly Gemma: "Gemma";
     readonly Grok: "Grok";
     readonly Cohere: "Cohere";
     readonly Nova: "Nova";
@@ -38,7 +39,10 @@ export type Tokenizer = OpenEnum<typeof Tokenizer>;
  * Model architecture information
  */
 export type Architecture = {
-    tokenizer: Tokenizer | null;
+    /**
+     * Supported input modalities
+     */
+    inputModalities: Array<InputModality>;
     /**
      * Instruction format type
      */
@@ -47,27 +51,17 @@ export type Architecture = {
      * Primary modality of the model
      */
     modality: string | null;
-    /**
-     * Supported input modalities
-     */
-    inputModalities: Array<InputModality>;
     /**
      * Supported output modalities
      */
     outputModalities: Array<OutputModality>;
+    tokenizer: Tokenizer | null;
 };
 /**
  * List of available endpoints for a model
  */
 export type ListEndpointsResponse = {
-    /**
-     * Unique identifier for the model
-     */
-    id: string;
-    /**
-     * Display name of the model
-     */
-    name: string;
+    architecture: Architecture;
     /**
      * Unix timestamp of when the model was created
      */
@@ -76,11 +70,18 @@ export type ListEndpointsResponse = {
      * Description of the model
      */
     description: string;
-    architecture: Architecture;
     /**
      * List of available endpoints for this model
      */
     endpoints: Array<PublicEndpoint>;
+    /**
+     * Unique identifier for the model
+     */
+    id: string;
+    /**
+     * Display name of the model
+     */
+    name: string;
 };
 /** @internal */
 export declare const Tokenizer$inboundSchema: z.ZodType<Tokenizer, unknown>;

package/esm/models/listendpointsresponse.js

@@ -20,6 +20,7 @@ export const Tokenizer = {
     Gpt: "GPT",
     Claude: "Claude",
     Gemini: "Gemini",
+    Gemma: "Gemma",
     Grok: "Grok",
     Cohere: "Cohere",
     Nova: "Nova",
@@ -40,15 +41,15 @@ export const Tokenizer$inboundSchema = openEnums
 /** @internal */
 export const Architecture$inboundSchema = z
     .object({
-    tokenizer: z.nullable(Tokenizer$inboundSchema),
+    input_modalities: z.array(InputModality$inboundSchema),
     instruct_type: z.nullable(InstructType$inboundSchema),
     modality: z.nullable(z.string()),
-    input_modalities: z.array(InputModality$inboundSchema),
     output_modalities: z.array(OutputModality$inboundSchema),
+    tokenizer: z.nullable(Tokenizer$inboundSchema),
 }).transform((v) => {
     return remap$(v, {
-        "instruct_type": "instructType",
         "input_modalities": "inputModalities",
+        "instruct_type": "instructType",
         "output_modalities": "outputModalities",
     });
 });
@@ -57,12 +58,12 @@ export function architectureFromJSON(jsonString) {
 }
 /** @internal */
 export const ListEndpointsResponse$inboundSchema = z.object({
-    id: z.string(),
-    name: z.string(),
-    created: z.number(),
-    description: z.string(),
     architecture: z.lazy(() => Architecture$inboundSchema),
+    created: z.int(),
+    description: z.string(),
     endpoints: z.array(PublicEndpoint$inboundSchema),
+    id: z.string(),
+    name: z.string(),
 });
 export function listEndpointsResponseFromJSON(jsonString) {
     return safeParse(jsonString, (x) => ListEndpointsResponse$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'ListEndpointsResponse' from JSON`);

package/esm/models/listguardrailsresponse.d.ts

@@ -0,0 +1,18 @@
+import * as z from "zod/v4";
+import { Result as SafeParseResult } from "../types/fp.js";
+import { SDKValidationError } from "./errors/sdkvalidationerror.js";
+import { Guardrail } from "./guardrail.js";
+export type ListGuardrailsResponse = {
+    /**
+     * List of guardrails
+     */
+    data: Array<Guardrail>;
+    /**
+     * Total number of guardrails
+     */
+    totalCount: number;
+};
+/** @internal */
+export declare const ListGuardrailsResponse$inboundSchema: z.ZodType<ListGuardrailsResponse, unknown>;
+export declare function listGuardrailsResponseFromJSON(jsonString: string): SafeParseResult<ListGuardrailsResponse, SDKValidationError>;
+//# sourceMappingURL=listguardrailsresponse.d.ts.map

package/esm/models/listguardrailsresponse.js

@@ -0,0 +1,21 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ * @generated-id: 281c3f73d27b
+ */
+import * as z from "zod/v4";
+import { remap as remap$ } from "../lib/primitives.js";
+import { safeParse } from "../lib/schemas.js";
+import { Guardrail$inboundSchema } from "./guardrail.js";
+/** @internal */
+export const ListGuardrailsResponse$inboundSchema = z.object({
+    data: z.array(Guardrail$inboundSchema),
+    total_count: z.int(),
+}).transform((v) => {
+    return remap$(v, {
+        "total_count": "totalCount",
+    });
+});
+export function listGuardrailsResponseFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => ListGuardrailsResponse$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'ListGuardrailsResponse' from JSON`);
+}
+//# sourceMappingURL=listguardrailsresponse.js.map

package/esm/models/listkeyassignmentsresponse.d.ts

@@ -0,0 +1,18 @@
+import * as z from "zod/v4";
+import { Result as SafeParseResult } from "../types/fp.js";
+import { SDKValidationError } from "./errors/sdkvalidationerror.js";
+import { KeyAssignment } from "./keyassignment.js";
+export type ListKeyAssignmentsResponse = {
+    /**
+     * List of key assignments
+     */
+    data: Array<KeyAssignment>;
+    /**
+     * Total number of key assignments for this guardrail
+     */
+    totalCount: number;
+};
+/** @internal */
+export declare const ListKeyAssignmentsResponse$inboundSchema: z.ZodType<ListKeyAssignmentsResponse, unknown>;
+export declare function listKeyAssignmentsResponseFromJSON(jsonString: string): SafeParseResult<ListKeyAssignmentsResponse, SDKValidationError>;
+//# sourceMappingURL=listkeyassignmentsresponse.d.ts.map

package/esm/models/listkeyassignmentsresponse.js

@@ -0,0 +1,21 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ * @generated-id: 6c14372c6290
+ */
+import * as z from "zod/v4";
+import { remap as remap$ } from "../lib/primitives.js";
+import { safeParse } from "../lib/schemas.js";
+import { KeyAssignment$inboundSchema } from "./keyassignment.js";
+/** @internal */
+export const ListKeyAssignmentsResponse$inboundSchema = z.object({
+    data: z.array(KeyAssignment$inboundSchema),
+    total_count: z.int(),
+}).transform((v) => {
+    return remap$(v, {
+        "total_count": "totalCount",
+    });
+});
+export function listKeyAssignmentsResponseFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => ListKeyAssignmentsResponse$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'ListKeyAssignmentsResponse' from JSON`);
+}
+//# sourceMappingURL=listkeyassignmentsresponse.js.map

package/esm/models/listmemberassignmentsresponse.d.ts

@@ -0,0 +1,18 @@
+import * as z from "zod/v4";
+import { Result as SafeParseResult } from "../types/fp.js";
+import { SDKValidationError } from "./errors/sdkvalidationerror.js";
+import { MemberAssignment } from "./memberassignment.js";
+export type ListMemberAssignmentsResponse = {
+    /**
+     * List of member assignments
+     */
+    data: Array<MemberAssignment>;
+    /**
+     * Total number of member assignments
+     */
+    totalCount: number;
+};
+/** @internal */
+export declare const ListMemberAssignmentsResponse$inboundSchema: z.ZodType<ListMemberAssignmentsResponse, unknown>;
+export declare function listMemberAssignmentsResponseFromJSON(jsonString: string): SafeParseResult<ListMemberAssignmentsResponse, SDKValidationError>;
+//# sourceMappingURL=listmemberassignmentsresponse.d.ts.map

package/esm/models/listmemberassignmentsresponse.js

@@ -0,0 +1,21 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ * @generated-id: bbd89d5e9f3f
+ */
+import * as z from "zod/v4";
+import { remap as remap$ } from "../lib/primitives.js";
+import { safeParse } from "../lib/schemas.js";
+import { MemberAssignment$inboundSchema, } from "./memberassignment.js";
+/** @internal */
+export const ListMemberAssignmentsResponse$inboundSchema = z.object({
+    data: z.array(MemberAssignment$inboundSchema),
+    total_count: z.int(),
+}).transform((v) => {
+    return remap$(v, {
+        "total_count": "totalCount",
+    });
+});
+export function listMemberAssignmentsResponseFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => ListMemberAssignmentsResponse$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'ListMemberAssignmentsResponse' from JSON`);
+}
+//# sourceMappingURL=listmemberassignmentsresponse.js.map

package/esm/models/mcpservertool.d.ts

@@ -3,9 +3,10 @@ import { ClosedEnum, OpenEnum } from "../types/enums.js";
 import { Result as SafeParseResult } from "../types/fp.js";
 import { SDKValidationError } from "./errors/sdkvalidationerror.js";
 export type AllowedTools = {
-    toolNames?: Array<string> | undefined;
     readOnly?: boolean | undefined;
+    toolNames?: Array<string> | undefined;
 };
+export type AllowedToolsUnion = Array<string> | AllowedTools | any;
 export declare const ConnectorId: {
     readonly ConnectorDropbox: "connector_dropbox";
     readonly ConnectorGmail: "connector_gmail";
@@ -25,44 +26,53 @@ export declare const RequireApprovalAlways: {
     readonly Always: "always";
 };
 export type RequireApprovalAlways = ClosedEnum<typeof RequireApprovalAlways>;
-export type Never = {
+export type Always = {
     toolNames?: Array<string> | undefined;
 };
-export type Always = {
+export type Never = {
     toolNames?: Array<string> | undefined;
 };
 export type RequireApproval = {
-    never?: Never | undefined;
     always?: Always | undefined;
+    never?: Never | undefined;
 };
+export type RequireApprovalUnion = RequireApproval | RequireApprovalAlways | RequireApprovalNever | any;
 /**
  * MCP (Model Context Protocol) tool configuration
  */
 export type McpServerTool = {
-    type: "mcp";
-    serverLabel: string;
-    allowedTools?: any | null | undefined;
+    allowedTools?: Array<string> | AllowedTools | any | null | undefined;
     authorization?: string | undefined;
     connectorId?: ConnectorId | undefined;
     headers?: {
         [k: string]: string;
     } | null | undefined;
-    requireApproval?: any | null | undefined;
+    requireApproval?: RequireApproval | RequireApprovalAlways | RequireApprovalNever | any | null | undefined;
     serverDescription?: string | undefined;
+    serverLabel: string;
     serverUrl?: string | undefined;
+    type: "mcp";
 };
 /** @internal */
 export declare const AllowedTools$inboundSchema: z.ZodType<AllowedTools, unknown>;
 /** @internal */
 export type AllowedTools$Outbound = {
-    tool_names?: Array<string> | undefined;
     read_only?: boolean | undefined;
+    tool_names?: Array<string> | undefined;
 };
 /** @internal */
 export declare const AllowedTools$outboundSchema: z.ZodType<AllowedTools$Outbound, AllowedTools>;
 export declare function allowedToolsToJSON(allowedTools: AllowedTools): string;
 export declare function allowedToolsFromJSON(jsonString: string): SafeParseResult<AllowedTools, SDKValidationError>;
 /** @internal */
+export declare const AllowedToolsUnion$inboundSchema: z.ZodType<AllowedToolsUnion, unknown>;
+/** @internal */
+export type AllowedToolsUnion$Outbound = Array<string> | AllowedTools$Outbound | any;
+/** @internal */
+export declare const AllowedToolsUnion$outboundSchema: z.ZodType<AllowedToolsUnion$Outbound, AllowedToolsUnion>;
+export declare function allowedToolsUnionToJSON(allowedToolsUnion: AllowedToolsUnion): string;
+export declare function allowedToolsUnionFromJSON(jsonString: string): SafeParseResult<AllowedToolsUnion, SDKValidationError>;
+/** @internal */
 export declare const ConnectorId$inboundSchema: z.ZodType<ConnectorId, unknown>;
 /** @internal */
 export declare const ConnectorId$outboundSchema: z.ZodType<string, ConnectorId>;
@@ -75,16 +85,6 @@ export declare const RequireApprovalAlways$inboundSchema: z.ZodEnum<typeof Requi
 /** @internal */
 export declare const RequireApprovalAlways$outboundSchema: z.ZodEnum<typeof RequireApprovalAlways>;
 /** @internal */
-export declare const Never$inboundSchema: z.ZodType<Never, unknown>;
-/** @internal */
-export type Never$Outbound = {
-    tool_names?: Array<string> | undefined;
-};
-/** @internal */
-export declare const Never$outboundSchema: z.ZodType<Never$Outbound, Never>;
-export declare function neverToJSON(never: Never): string;
-export declare function neverFromJSON(jsonString: string): SafeParseResult<Never, SDKValidationError>;
-/** @internal */
 export declare const Always$inboundSchema: z.ZodType<Always, unknown>;
 /** @internal */
 export type Always$Outbound = {
@@ -95,31 +95,49 @@ export declare const Always$outboundSchema: z.ZodType<Always$Outbound, Always>;
 export declare function alwaysToJSON(always: Always): string;
 export declare function alwaysFromJSON(jsonString: string): SafeParseResult<Always, SDKValidationError>;
 /** @internal */
+export declare const Never$inboundSchema: z.ZodType<Never, unknown>;
+/** @internal */
+export type Never$Outbound = {
+    tool_names?: Array<string> | undefined;
+};
+/** @internal */
+export declare const Never$outboundSchema: z.ZodType<Never$Outbound, Never>;
+export declare function neverToJSON(never: Never): string;
+export declare function neverFromJSON(jsonString: string): SafeParseResult<Never, SDKValidationError>;
+/** @internal */
 export declare const RequireApproval$inboundSchema: z.ZodType<RequireApproval, unknown>;
 /** @internal */
 export type RequireApproval$Outbound = {
-    never?: Never$Outbound | undefined;
     always?: Always$Outbound | undefined;
+    never?: Never$Outbound | undefined;
 };
 /** @internal */
 export declare const RequireApproval$outboundSchema: z.ZodType<RequireApproval$Outbound, RequireApproval>;
 export declare function requireApprovalToJSON(requireApproval: RequireApproval): string;
 export declare function requireApprovalFromJSON(jsonString: string): SafeParseResult<RequireApproval, SDKValidationError>;
 /** @internal */
+export declare const RequireApprovalUnion$inboundSchema: z.ZodType<RequireApprovalUnion, unknown>;
+/** @internal */
+export type RequireApprovalUnion$Outbound = RequireApproval$Outbound | string | string | any;
+/** @internal */
+export declare const RequireApprovalUnion$outboundSchema: z.ZodType<RequireApprovalUnion$Outbound, RequireApprovalUnion>;
+export declare function requireApprovalUnionToJSON(requireApprovalUnion: RequireApprovalUnion): string;
+export declare function requireApprovalUnionFromJSON(jsonString: string): SafeParseResult<RequireApprovalUnion, SDKValidationError>;
+/** @internal */
 export declare const McpServerTool$inboundSchema: z.ZodType<McpServerTool, unknown>;
 /** @internal */
 export type McpServerTool$Outbound = {
-    type: "mcp";
-    server_label: string;
-    allowed_tools?: any | null | undefined;
+    allowed_tools?: Array<string> | AllowedTools$Outbound | any | null | undefined;
     authorization?: string | undefined;
     connector_id?: string | undefined;
     headers?: {
         [k: string]: string;
     } | null | undefined;
-    require_approval?: any | null | undefined;
+    require_approval?: RequireApproval$Outbound | string | string | any | null | undefined;
     server_description?: string | undefined;
+    server_label: string;
     server_url?: string | undefined;
+    type: "mcp";
 };
 /** @internal */
 export declare const McpServerTool$outboundSchema: z.ZodType<McpServerTool$Outbound, McpServerTool>;