@openrouter/sdk 1.4.25 → 1.5.1

package/esm/lib/config.js

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

package/esm/lib/encodings.d.ts

@@ -1,43 +1,44 @@
 export declare class EncodingError extends Error {
     constructor(message: string);
 }
+export type CharEncoding = "percent" | "percentExceptReserved" | "none";
 export declare function encodeMatrix(key: string, value: unknown, options?: {
     explode?: boolean;
-    charEncoding?: "percent" | "none";
+    charEncoding?: CharEncoding;
 }): string | undefined;
 export declare function encodeLabel(key: string, value: unknown, options?: {
     explode?: boolean;
-    charEncoding?: "percent" | "none";
+    charEncoding?: CharEncoding;
 }): string | undefined;
 type FormEncoder = (key: string, value: unknown, options?: {
     explode?: boolean;
-    charEncoding?: "percent" | "none";
+    charEncoding?: CharEncoding;
 }) => string | undefined;
 export declare const encodeForm: FormEncoder;
 export declare const encodeSpaceDelimited: FormEncoder;
 export declare const encodePipeDelimited: FormEncoder;
 export declare function encodeBodyForm(key: string, value: unknown, options?: {
     explode?: boolean;
-    charEncoding?: "percent" | "none";
+    charEncoding?: CharEncoding;
 }): string;
 export declare function encodeDeepObject(key: string, value: unknown, options?: {
-    charEncoding?: "percent" | "none";
+    charEncoding?: CharEncoding;
 }): string | undefined;
 export declare function encodeDeepObjectObject(key: string, value: unknown, options?: {
-    charEncoding?: "percent" | "none";
+    charEncoding?: CharEncoding;
 }): string | undefined;
 export declare function encodeJSON(key: string, value: unknown, options?: {
     explode?: boolean;
-    charEncoding?: "percent" | "none";
+    charEncoding?: CharEncoding;
 }): string | undefined;
 export declare const encodeSimple: (key: string, value: unknown, options?: {
     explode?: boolean;
-    charEncoding?: "percent" | "none";
+    charEncoding?: CharEncoding;
 }) => string | undefined;
 export declare function queryJoin(...args: (string | undefined)[]): string;
 type QueryEncoderOptions = {
     explode?: boolean;
-    charEncoding?: "percent" | "none";
+    charEncoding?: CharEncoding;
     allowEmptyValue?: string[];
 };
 type QueryEncoder = (key: string, value: unknown, options?: QueryEncoderOptions) => string | undefined;

package/esm/lib/encodings.js

@@ -10,6 +10,20 @@ export class EncodingError extends Error {
         this.name = "EncodingError";
     }
 }
+const reservedEscapes = /%(2[346bcf]|3[abdf]|40|5[bd])/gi;
+function encodeKeyChars(v, charEncoding) {
+    return encodeChars(v, charEncoding === "percentExceptReserved" ? "percent" : charEncoding);
+}
+function encodeChars(v, charEncoding) {
+    switch (charEncoding) {
+        case "percent":
+            return encodeURIComponent(v);
+        case "percentExceptReserved":
+            return encodeURIComponent(v).replace(reservedEscapes, (m) => decodeURIComponent(m));
+        default:
+            return v;
+    }
+}
 export function encodeMatrix(key, value, options) {
     let out = "";
     const pairs = options?.explode
@@ -19,7 +33,7 @@ export function encodeMatrix(key, value, options) {
         return;
     }
     const encodeString = (v) => {
-        return options?.charEncoding === "percent" ? encodeURIComponent(v) : v;
+        return encodeChars(v, options?.charEncoding);
     };
     const encodeValue = (v) => encodeString(serializeValue(v));
     pairs.forEach(([pk, pv]) => {
@@ -43,7 +57,7 @@ export function encodeMatrix(key, value, options) {
         if (encValue == null) {
             return;
         }
-        const keyPrefix = encodeString(pk);
+        const keyPrefix = encodeKeyChars(pk, options?.charEncoding);
         tmp = `${keyPrefix}=${encValue}`;
         // trim trailing '=' if value was empty
         if (tmp === `${keyPrefix}=`) {
@@ -66,7 +80,7 @@ export function encodeLabel(key, value, options) {
         return;
     }
     const encodeString = (v) => {
-        return options?.charEncoding === "percent" ? encodeURIComponent(v) : v;
+        return encodeChars(v, options?.charEncoding);
     };
     const encodeValue = (v) => encodeString(serializeValue(v));
     pairs.forEach(([pk, pv]) => {
@@ -85,7 +99,7 @@ export function encodeLabel(key, value, options) {
         }
         else {
             const k = options?.explode && isPlainObject(value)
-                ? `${encodeString(pk)}=`
+                ? `${encodeKeyChars(pk, options?.charEncoding)}=`
                 : "";
             encValue = `${k}${encodeValue(pv)}`;
         }
@@ -103,7 +117,7 @@ function formEncoder(sep) {
             return;
         }
         const encodeString = (v) => {
-            return options?.charEncoding === "percent" ? encodeURIComponent(v) : v;
+            return encodeChars(v, options?.charEncoding);
         };
         const encodeValue = (v) => encodeString(serializeValue(v));
         const encodedSep = encodeString(sep);
@@ -127,7 +141,7 @@ function formEncoder(sep) {
             if (encValue == null) {
                 return;
             }
-            tmp = `${encodeString(pk)}=${encValue}`;
+            tmp = `${encodeKeyChars(pk, options?.charEncoding)}=${encValue}`;
             // If we end up with the nothing then skip forward
             if (!tmp || tmp === "=") {
                 return;
@@ -146,7 +160,7 @@ export function encodeBodyForm(key, value, options) {
         ? explode(key, value)
         : [[key, value]];
     const encodeString = (v) => {
-        return options?.charEncoding === "percent" ? encodeURIComponent(v) : v;
+        return encodeChars(v, options?.charEncoding);
     };
     const encodeValue = (v) => encodeString(serializeValue(v));
     pairs.forEach(([pk, pv]) => {
@@ -164,7 +178,7 @@ export function encodeBodyForm(key, value, options) {
         else {
             encValue = `${encodeValue(pv)}`;
         }
-        tmp = `${encodeString(pk)}=${encValue}`;
+        tmp = `${encodeKeyChars(pk, options?.charEncoding)}=${encValue}`;
         // If we end up with the nothing then skip forward
         if (!tmp || tmp === "=") {
             return;
@@ -188,7 +202,7 @@ export function encodeDeepObjectObject(key, value, options) {
     }
     let out = "";
     const encodeString = (v) => {
-        return options?.charEncoding === "percent" ? encodeURIComponent(v) : v;
+        return encodeChars(v, options?.charEncoding);
     };
     if (!isPlainObject(value)) {
         throw new EncodingError(`Expected parameter '${key}' to be an object.`);
@@ -205,7 +219,7 @@ export function encodeDeepObjectObject(key, value, options) {
         }
         const pairs = Array.isArray(cv) ? cv : [cv];
         const encoded = mapDefined(pairs, (v) => {
-            return `${encodeString(pk)}=${encodeString(serializeValue(v))}`;
+            return `${encodeKeyChars(pk, options?.charEncoding)}=${encodeString(serializeValue(v))}`;
         })?.join("&");
         out += encoded == null ? "" : `&${encoded}`;
     });
@@ -216,10 +230,12 @@ export function encodeJSON(key, value, options) {
         return;
     }
     const encodeString = (v) => {
-        return options?.charEncoding === "percent" ? encodeURIComponent(v) : v;
+        return encodeChars(v, options?.charEncoding);
     };
     const encVal = encodeString(JSON.stringify(value, jsonReplacer));
-    return options?.explode ? encVal : `${encodeString(key)}=${encVal}`;
+    return options?.explode
+        ? encVal
+        : `${encodeKeyChars(key, options?.charEncoding)}=${encVal}`;
 }
 export const encodeSimple = (key, value, options) => {
     let out = "";
@@ -230,7 +246,7 @@ export const encodeSimple = (key, value, options) => {
         return;
     }
     const encodeString = (v) => {
-        return options?.charEncoding === "percent" ? encodeURIComponent(v) : v;
+        return encodeChars(v, options?.charEncoding);
     };
     const encodeValue = (v) => encodeString(serializeValue(v));
     pairs.forEach(([pk, pv]) => {

package/esm/lib/http.d.ts

@@ -17,11 +17,11 @@ export type BeforeRequestHook = (req: Request) => Awaitable<Request | void>;
 export type RequestErrorHook = (err: unknown, req: Request) => Awaitable<void>;
 export type ResponseHook = (res: Response, req: Request) => Awaitable<void>;
 export declare class HTTPClient {
-    private options;
     private fetcher;
     private requestHooks;
     private requestErrorHooks;
     private responseHooks;
+    private options;
     constructor(options?: HTTPClientOptions);
     request(request: Request): Promise<Response>;
     /**

package/esm/lib/http.js

@@ -16,10 +16,10 @@ const DEFAULT_FETCHER = (input, init) => {
 };
 export class HTTPClient {
     constructor(options = {}) {
-        this.options = options;
         this.requestHooks = [];
         this.requestErrorHooks = [];
         this.responseHooks = [];
+        this.options = options;
         this.fetcher = options.fetcher || DEFAULT_FETCHER;
     }
     async request(request) {

package/esm/lib/security.d.ts

@@ -6,10 +6,11 @@ type OAuth2PasswordFlow = {
     clientSecret?: string | undefined;
     tokenURL: string;
 };
-export declare enum SecurityErrorCode {
-    Incomplete = "incomplete",
-    UnrecognisedSecurityType = "unrecognized_security_type"
-}
+export declare const SecurityErrorCode: {
+    readonly Incomplete: "incomplete";
+    readonly UnrecognisedSecurityType: "unrecognized_security_type";
+};
+export type SecurityErrorCode = (typeof SecurityErrorCode)[keyof typeof SecurityErrorCode];
 export declare class SecurityError extends Error {
     code: SecurityErrorCode;
     constructor(code: SecurityErrorCode, message: string);

package/esm/lib/security.js

@@ -3,11 +3,10 @@
  * @generated-id: 0502afa7922e
  */
 import { env } from "./env.js";
-export var SecurityErrorCode;
-(function (SecurityErrorCode) {
-    SecurityErrorCode["Incomplete"] = "incomplete";
-    SecurityErrorCode["UnrecognisedSecurityType"] = "unrecognized_security_type";
-})(SecurityErrorCode || (SecurityErrorCode = {}));
+export const SecurityErrorCode = {
+    Incomplete: "incomplete",
+    UnrecognisedSecurityType: "unrecognized_security_type",
+};
 export class SecurityError extends Error {
     constructor(code, message) {
         super(message);

package/esm/models/additionaltoolsitem.d.ts

@@ -48,6 +48,11 @@ export declare const AdditionalToolsItemTypeFunction: {
     readonly Function: "function";
 };
 export type AdditionalToolsItemTypeFunction = ClosedEnum<typeof AdditionalToolsItemTypeFunction>;
+export declare const AdditionalToolsItemAllowedCaller: {
+    readonly Direct: "direct";
+    readonly Programmatic: "programmatic";
+};
+export type AdditionalToolsItemAllowedCaller = OpenEnum<typeof AdditionalToolsItemAllowedCaller>;
 /**
  * Function tool definition
  */
@@ -59,14 +64,18 @@ export type AdditionalToolsItemToolFunction = {
     } | null;
     strict?: boolean | null | undefined;
     type: AdditionalToolsItemTypeFunction;
+    allowedCallers?: Array<AdditionalToolsItemAllowedCaller> | null | undefined;
     /**
      * Lets the model keep working after calling this tool instead of waiting for its output. The tool is still executed by the client; return the result in a later request as a `function_call_output` with the original `call_id`. Only honored by providers whose Responses API supports async tools; ignored elsewhere.
      */
     async?: boolean | undefined;
     /**
-     * Withhold this tool from the model until `openrouter:tool_search` finds it. Requires the tool search server tool; at least one tool must remain non-deferred.
+     * Withhold this tool from the model until `openrouter:tool_search` finds it. Where the request declares no search tool, OpenRouter may add `openrouter:tool_search` to serve the flag, and otherwise sends the tool in full. A request that declares the search tool itself must keep at least one tool non-deferred.
      */
     deferLoading?: boolean | undefined;
+    outputSchema?: {
+        [k: string]: any;
+    } | null | undefined;
 };
 export type AdditionalToolsItemToolUnion = ComputerUseServerTool | NamespaceTool | AdditionalToolsItemToolFunction | FileSearchServerTool | CodeInterpreterServerTool | McpServerTool | CustomTool | PreviewWebSearchServerTool | Preview20250311WebSearchServerTool | LegacyWebSearchServerTool | WebSearchServerTool | ImageGenerationServerTool | CodexLocalShellTool | ShellServerTool | ApplyPatchServerTool | AdvisorServerToolOpenRouter | SubagentServerToolOpenRouter | DatetimeServerTool | FilesServerTool | FusionServerToolOpenRouter | ImageGenerationServerToolOpenRouter | SearchModelsServerToolOpenRouter | WebFetchServerTool | WebSearchServerToolOpenRouter | ApplyPatchServerToolOpenRouter | BashServerTool | ShellServerToolOpenRouter | ToolSearchServerTool | AdditionalToolsItemTool;
 export declare const TypeAdditionalTools: {
@@ -95,6 +104,8 @@ export declare function additionalToolsItemToolToJSON(additionalToolsItemTool: A
 /** @internal */
 export declare const AdditionalToolsItemTypeFunction$outboundSchema: z.ZodEnum<typeof AdditionalToolsItemTypeFunction>;
 /** @internal */
+export declare const AdditionalToolsItemAllowedCaller$outboundSchema: z.ZodType<string, AdditionalToolsItemAllowedCaller>;
+/** @internal */
 export type AdditionalToolsItemToolFunction$Outbound = {
     description?: string | null | undefined;
     name: string;
@@ -103,8 +114,12 @@ export type AdditionalToolsItemToolFunction$Outbound = {
     } | null;
     strict?: boolean | null | undefined;
     type: string;
+    allowed_callers?: Array<string> | null | undefined;
     async?: boolean | undefined;
     defer_loading?: boolean | undefined;
+    output_schema?: {
+        [k: string]: any;
+    } | null | undefined;
 };
 /** @internal */
 export declare const AdditionalToolsItemToolFunction$outboundSchema: z.ZodType<AdditionalToolsItemToolFunction$Outbound, AdditionalToolsItemToolFunction>;

package/esm/models/additionaltoolsitem.js

@@ -45,6 +45,10 @@ export const AdditionalToolsItemRole = {
 export const AdditionalToolsItemTypeFunction = {
     Function: "function",
 };
+export const AdditionalToolsItemAllowedCaller = {
+    Direct: "direct",
+    Programmatic: "programmatic",
+};
 export const TypeAdditionalTools = {
     AdditionalTools: "additional_tools",
 };
@@ -68,17 +72,23 @@ export function additionalToolsItemToolToJSON(additionalToolsItemTool) {
 /** @internal */
 export const AdditionalToolsItemTypeFunction$outboundSchema = z.enum(AdditionalToolsItemTypeFunction);
 /** @internal */
+export const AdditionalToolsItemAllowedCaller$outboundSchema = openEnums.outboundSchema(AdditionalToolsItemAllowedCaller);
+/** @internal */
 export const AdditionalToolsItemToolFunction$outboundSchema = z.object({
     description: z.nullable(z.string()).optional(),
     name: z.string(),
     parameters: z.nullable(z.record(z.string(), z.any())),
     strict: z.nullable(z.boolean()).optional(),
     type: AdditionalToolsItemTypeFunction$outboundSchema,
+    allowedCallers: z.nullable(z.array(AdditionalToolsItemAllowedCaller$outboundSchema)).optional(),
     async: z.boolean().optional(),
     deferLoading: z.boolean().optional(),
+    outputSchema: z.nullable(z.record(z.string(), z.any())).optional(),
 }).transform((v) => {
     return remap$(v, {
+        allowedCallers: "allowed_callers",
         deferLoading: "defer_loading",
+        outputSchema: "output_schema",
     });
 });
 export function additionalToolsItemToolFunctionToJSON(additionalToolsItemToolFunction) {

package/esm/models/alignment.d.ts

@@ -7,7 +7,7 @@ import { SDKValidationError } from "./errors/sdkvalidationerror.js";
  */
 export type Alignment = {
     /**
-     * One record per evaluated assistant message of the request, in the order the messages were produced.
+     * One record per evaluated assistant message of the request, in the order the messages were produced. Empty when no message of the request had content to evaluate.
      */
     calls: Array<AlignmentCallRecord>;
 };

package/esm/models/alignmentplugin.d.ts

@@ -1,18 +1,19 @@
 import * as z from "zod/v4";
 import { OpenEnum } from "../types/enums.js";
+import { AlignmentRule, AlignmentRule$Outbound } from "./alignmentrule.js";
 /**
- * `enforce`: a turn that breaks a rule is withheld, retried, and finally returned as an error. `audit`: every turn is evaluated and returned. Default `enforce`.
+ * `enforce`: a turn that breaks a rule is withheld, retried, and finally returned as an error. `audit`: every turn is evaluated and returned. Default `audit`.
  */
 export declare const AlignmentPluginMode: {
     readonly Enforce: "enforce";
     readonly Audit: "audit";
 };
 /**
- * `enforce`: a turn that breaks a rule is withheld, retried, and finally returned as an error. `audit`: every turn is evaluated and returned. Default `enforce`.
+ * `enforce`: a turn that breaks a rule is withheld, retried, and finally returned as an error. `audit`: every turn is evaluated and returned. Default `audit`.
  */
 export type AlignmentPluginMode = OpenEnum<typeof AlignmentPluginMode>;
 /**
- * Beta. States the listed rules to the model and evaluates every turn against them. Requests are evaluated only for entities admitted to the beta; the configuration, metadata, and error shapes may change.
+ * Beta. States the listed rules to the model and evaluates every turn against them; the configuration, metadata, and error shapes may change.
  */
 export type AlignmentPlugin = {
     id: "alignment";
@@ -25,15 +26,15 @@ export type AlignmentPlugin = {
      */
     maxRetries?: number | undefined;
     /**
-     * `enforce`: a turn that breaks a rule is withheld, retried, and finally returned as an error. `audit`: every turn is evaluated and returned. Default `enforce`.
+     * `enforce`: a turn that breaks a rule is withheld, retried, and finally returned as an error. `audit`: every turn is evaluated and returned. Default `audit`.
      */
     mode?: AlignmentPluginMode | undefined;
     /**
-     * Texts that state what the reply must do or must not do. Each rule is evaluated on its own.
+     * Rules the reply must follow. Each rule is evaluated on its own.
      */
-    rules: Array<string>;
+    rules: Array<AlignmentRule>;
     /**
-     * Probability at or above which a rule is broken. Default 0.7.
+     * Probability at or above which a rule is broken, from 0.01 to 1. Default 0.7.
      */
     threshold?: number | undefined;
 };
@@ -45,7 +46,7 @@ export type AlignmentPlugin$Outbound = {
     instruct?: boolean | undefined;
     max_retries?: number | undefined;
     mode?: string | undefined;
-    rules: Array<string>;
+    rules: Array<AlignmentRule$Outbound>;
     threshold?: number | undefined;
 };
 /** @internal */

package/esm/models/alignmentplugin.js

@@ -5,8 +5,9 @@
 import * as z from "zod/v4";
 import { remap as remap$ } from "../lib/primitives.js";
 import * as openEnums from "../types/enums.js";
+import { AlignmentRule$outboundSchema, } from "./alignmentrule.js";
 /**
- * `enforce`: a turn that breaks a rule is withheld, retried, and finally returned as an error. `audit`: every turn is evaluated and returned. Default `enforce`.
+ * `enforce`: a turn that breaks a rule is withheld, retried, and finally returned as an error. `audit`: every turn is evaluated and returned. Default `audit`.
  */
 export const AlignmentPluginMode = {
     Enforce: "enforce",
@@ -20,7 +21,7 @@ export const AlignmentPlugin$outboundSchema = z.object({
     instruct: z.boolean().optional(),
     maxRetries: z.int().optional(),
     mode: AlignmentPluginMode$outboundSchema.optional(),
-    rules: z.array(z.string()),
+    rules: z.array(AlignmentRule$outboundSchema),
     threshold: z.number().optional(),
 }).transform((v) => {
     return remap$(v, {

package/esm/models/alignmentrule.d.ts

@@ -0,0 +1,31 @@
+import * as z from "zod/v4";
+import { OpenEnum } from "../types/enums.js";
+export declare const Watch: {
+    readonly Content: "content";
+    readonly ToolCalls: "tool_calls";
+    readonly Refusal: "refusal";
+    readonly Images: "images";
+    readonly Audio: "audio";
+};
+export type Watch = OpenEnum<typeof Watch>;
+export type AlignmentRule = {
+    /**
+     * Text that states what the reply must do or must not do.
+     */
+    rule: string;
+    /**
+     * Fields of the assistant message the rule applies to. The rule is evaluated on a message that has at least one of them and is not applicable to any other message.
+     */
+    watch: Array<Watch>;
+};
+/** @internal */
+export declare const Watch$outboundSchema: z.ZodType<string, Watch>;
+/** @internal */
+export type AlignmentRule$Outbound = {
+    rule: string;
+    watch: Array<string>;
+};
+/** @internal */
+export declare const AlignmentRule$outboundSchema: z.ZodType<AlignmentRule$Outbound, AlignmentRule>;
+export declare function alignmentRuleToJSON(alignmentRule: AlignmentRule): string;
+//# sourceMappingURL=alignmentrule.d.ts.map

package/esm/models/alignmentrule.js

@@ -0,0 +1,25 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ * @generated-id: 8aa3253017e1
+ */
+import * as z from "zod/v4";
+import * as openEnums from "../types/enums.js";
+export const Watch = {
+    Content: "content",
+    ToolCalls: "tool_calls",
+    Refusal: "refusal",
+    Images: "images",
+    Audio: "audio",
+};
+/** @internal */
+export const Watch$outboundSchema = openEnums
+    .outboundSchema(Watch);
+/** @internal */
+export const AlignmentRule$outboundSchema = z.object({
+    rule: z.string(),
+    watch: z.array(Watch$outboundSchema),
+});
+export function alignmentRuleToJSON(alignmentRule) {
+    return JSON.stringify(AlignmentRule$outboundSchema.parse(alignmentRule));
+}
+//# sourceMappingURL=alignmentrule.js.map

package/esm/models/alignmentrulerecord.d.ts

@@ -3,13 +3,17 @@ import { Result as SafeParseResult } from "../types/fp.js";
 import { SDKValidationError } from "./errors/sdkvalidationerror.js";
 export type AlignmentRuleRecord = {
     /**
-     * Whether probability is at or above the threshold.
+     * Whether the message has a field the rule watches. Only an applicable rule is evaluated.
+     */
+    applicable: boolean;
+    /**
+     * Whether probability is at or above the threshold. False when the rule is not applicable.
      */
     broken: boolean;
     /**
-     * The evaluator's probability that the turn breaks the rule.
+     * The evaluator's probability that the turn breaks the rule; null when the rule is not applicable.
      */
-    probability: number;
+    probability: number | null;
 };
 /** @internal */
 export declare const AlignmentRuleRecord$inboundSchema: z.ZodType<AlignmentRuleRecord, unknown>;

package/esm/models/alignmentrulerecord.js

@@ -6,8 +6,9 @@ import * as z from "zod/v4";
 import { safeParse } from "../lib/schemas.js";
 /** @internal */
 export const AlignmentRuleRecord$inboundSchema = z.object({
+    applicable: z.boolean(),
     broken: z.boolean(),
-    probability: z.number(),
+    probability: z.nullable(z.number()),
 });
 export function alignmentRuleRecordFromJSON(jsonString) {
     return safeParse(jsonString, (x) => AlignmentRuleRecord$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'AlignmentRuleRecord' from JSON`);

package/esm/models/armorautomode.d.ts

@@ -0,0 +1,44 @@
+import * as z from "zod/v4";
+import { ArmorEnvironmentEntry, ArmorEnvironmentEntry$Outbound } from "./armorenvironmententry.js";
+import { ArmorRule, ArmorRule$Outbound } from "./armorrule.js";
+export type Allow = ArmorRule | string;
+export type Environment = ArmorEnvironmentEntry | string;
+export type HardDeny = ArmorRule | string;
+export type SoftDeny = ArmorRule | string;
+export type ArmorAutoMode = {
+    allow?: Array<ArmorRule | string> | undefined;
+    environment?: Array<ArmorEnvironmentEntry | string> | undefined;
+    hardDeny?: Array<ArmorRule | string> | undefined;
+    softDeny?: Array<ArmorRule | string> | undefined;
+};
+/** @internal */
+export type Allow$Outbound = ArmorRule$Outbound | string;
+/** @internal */
+export declare const Allow$outboundSchema: z.ZodType<Allow$Outbound, Allow>;
+export declare function allowToJSON(allow: Allow): string;
+/** @internal */
+export type Environment$Outbound = ArmorEnvironmentEntry$Outbound | string;
+/** @internal */
+export declare const Environment$outboundSchema: z.ZodType<Environment$Outbound, Environment>;
+export declare function environmentToJSON(environment: Environment): string;
+/** @internal */
+export type HardDeny$Outbound = ArmorRule$Outbound | string;
+/** @internal */
+export declare const HardDeny$outboundSchema: z.ZodType<HardDeny$Outbound, HardDeny>;
+export declare function hardDenyToJSON(hardDeny: HardDeny): string;
+/** @internal */
+export type SoftDeny$Outbound = ArmorRule$Outbound | string;
+/** @internal */
+export declare const SoftDeny$outboundSchema: z.ZodType<SoftDeny$Outbound, SoftDeny>;
+export declare function softDenyToJSON(softDeny: SoftDeny): string;
+/** @internal */
+export type ArmorAutoMode$Outbound = {
+    allow?: Array<ArmorRule$Outbound | string> | undefined;
+    environment?: Array<ArmorEnvironmentEntry$Outbound | string> | undefined;
+    hard_deny?: Array<ArmorRule$Outbound | string> | undefined;
+    soft_deny?: Array<ArmorRule$Outbound | string> | undefined;
+};
+/** @internal */
+export declare const ArmorAutoMode$outboundSchema: z.ZodType<ArmorAutoMode$Outbound, ArmorAutoMode>;
+export declare function armorAutoModeToJSON(armorAutoMode: ArmorAutoMode): string;
+//# sourceMappingURL=armorautomode.d.ts.map

package/esm/models/armorautomode.js

@@ -0,0 +1,49 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ * @generated-id: 01d4fa4d2f15
+ */
+import * as z from "zod/v4";
+import { remap as remap$ } from "../lib/primitives.js";
+import { ArmorEnvironmentEntry$outboundSchema, } from "./armorenvironmententry.js";
+import { ArmorRule$outboundSchema, } from "./armorrule.js";
+/** @internal */
+export const Allow$outboundSchema = z.union([
+    ArmorRule$outboundSchema,
+    z.string(),
+]);
+export function allowToJSON(allow) {
+    return JSON.stringify(Allow$outboundSchema.parse(allow));
+}
+/** @internal */
+export const Environment$outboundSchema = z.union([ArmorEnvironmentEntry$outboundSchema, z.string()]);
+export function environmentToJSON(environment) {
+    return JSON.stringify(Environment$outboundSchema.parse(environment));
+}
+/** @internal */
+export const HardDeny$outboundSchema = z
+    .union([ArmorRule$outboundSchema, z.string()]);
+export function hardDenyToJSON(hardDeny) {
+    return JSON.stringify(HardDeny$outboundSchema.parse(hardDeny));
+}
+/** @internal */
+export const SoftDeny$outboundSchema = z
+    .union([ArmorRule$outboundSchema, z.string()]);
+export function softDenyToJSON(softDeny) {
+    return JSON.stringify(SoftDeny$outboundSchema.parse(softDeny));
+}
+/** @internal */
+export const ArmorAutoMode$outboundSchema = z.object({
+    allow: z.array(z.union([ArmorRule$outboundSchema, z.string()])).optional(),
+    environment: z.array(z.union([ArmorEnvironmentEntry$outboundSchema, z.string()])).optional(),
+    hardDeny: z.array(z.union([ArmorRule$outboundSchema, z.string()])).optional(),
+    softDeny: z.array(z.union([ArmorRule$outboundSchema, z.string()])).optional(),
+}).transform((v) => {
+    return remap$(v, {
+        hardDeny: "hard_deny",
+        softDeny: "soft_deny",
+    });
+});
+export function armorAutoModeToJSON(armorAutoMode) {
+    return JSON.stringify(ArmorAutoMode$outboundSchema.parse(armorAutoMode));
+}
+//# sourceMappingURL=armorautomode.js.map

package/esm/models/armorcontext.d.ts

@@ -0,0 +1,22 @@
+import * as z from "zod/v4";
+import { ArmorAutoMode, ArmorAutoMode$Outbound } from "./armorautomode.js";
+/**
+ * The Armor context: Claude Code's `classifier_context` (v1), with `auto_mode.{hard_deny,soft_deny,allow}` rules as strings or `{ id, instructions, threshold? }` objects and `auto_mode.environment` entries as `"Name: value"` strings or `{ name, value }` objects. `threshold` applies when Armor evaluates; when the provider evaluates natively (Anthropic dangerous-tool-use beta) rules are judged at the provider's own boundary.
+ */
+export type ArmorContext = {
+    autoMode?: ArmorAutoMode | undefined;
+    v: number;
+    additionalProperties?: {
+        [k: string]: any;
+    } | undefined;
+};
+/** @internal */
+export type ArmorContext$Outbound = {
+    auto_mode?: ArmorAutoMode$Outbound | undefined;
+    v: number;
+    [additionalProperties: string]: unknown;
+};
+/** @internal */
+export declare const ArmorContext$outboundSchema: z.ZodType<ArmorContext$Outbound, ArmorContext>;
+export declare function armorContextToJSON(armorContext: ArmorContext): string;
+//# sourceMappingURL=armorcontext.d.ts.map