@openrouter/sdk 1.4.9 → 1.4.11

package/esm/funcs/endUsersUpdate.js

@@ -0,0 +1,106 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ * @generated-id: 7fb2aab2b543
+ */
+import { encodeJSON, encodeSimple } from "../lib/encodings.js";
+import { matchStatusCode } from "../lib/http.js";
+import * as M from "../lib/matchers.js";
+import { compactMap } from "../lib/primitives.js";
+import { safeParse } from "../lib/schemas.js";
+import { extractSecurity, resolveGlobalSecurity } from "../lib/security.js";
+import { pathToFunc } from "../lib/url.js";
+import { BadRequestResponseError$inboundSchema as errors_BadRequestResponseError$inboundSchema } from "../models/errors/badrequestresponseerror.js"; import { InternalServerResponseError$inboundSchema as errors_InternalServerResponseError$inboundSchema } from "../models/errors/internalserverresponseerror.js"; import { NotFoundResponseError$inboundSchema as errors_NotFoundResponseError$inboundSchema } from "../models/errors/notfoundresponseerror.js"; import { UnauthorizedResponseError$inboundSchema as errors_UnauthorizedResponseError$inboundSchema } from "../models/errors/unauthorizedresponseerror.js";
+import { EndUserResponse$inboundSchema as models_EndUserResponse$inboundSchema } from "../models/enduserresponse.js";
+import { UpdateEndUserRequest$outboundSchema as operations_UpdateEndUserRequest$outboundSchema } from "../models/operations/updateenduser.js";
+import { APIPromise } from "../types/async.js";
+/**
+ * Update a registered end user
+ *
+ * @remarks
+ * Update registration state without changing identity. State changes do not enforce inference access. [Management key](/docs/guides/overview/auth/management-api-keys) required.
+ */
+export function endUsersUpdate(client, request, options) {
+    return new APIPromise($do(client, request, options));
+}
+async function $do(client, request, options) {
+    const parsed = safeParse(request, (value) => operations_UpdateEndUserRequest$outboundSchema.parse(value), "Input validation failed");
+    if (!parsed.ok) {
+        return [parsed, { status: "invalid" }];
+    }
+    const payload = parsed.value;
+    const body = encodeJSON("body", payload.UpdateEndUserRequest, {
+        explode: true,
+    });
+    const pathParams = {
+        user: encodeSimple("user", payload.user, {
+            explode: false,
+            charEncoding: "percent",
+        }),
+    };
+    const path = pathToFunc("/end-users/{user}")(pathParams);
+    const headers = new Headers(compactMap({
+        "Content-Type": "application/json",
+        Accept: "application/json",
+        "HTTP-Referer": encodeSimple("HTTP-Referer", payload["HTTP-Referer"] ?? client._options.httpReferer, { explode: false, charEncoding: "none" }),
+        "X-OpenRouter-Categories": encodeSimple("X-OpenRouter-Categories", payload.appCategories ?? client._options.appCategories, { explode: false, charEncoding: "none" }),
+        "X-OpenRouter-Title": encodeSimple("X-OpenRouter-Title", payload.appTitle ?? client._options.appTitle, { explode: false, charEncoding: "none" }),
+    }));
+    const secConfig = await extractSecurity(client._options.apiKey);
+    const securityInput = secConfig == null ? {} : { apiKey: secConfig };
+    const requestSecurity = resolveGlobalSecurity(securityInput);
+    const context = {
+        options: client._options,
+        baseURL: options?.serverURL ?? client._baseURL ?? "",
+        operationID: "updateEndUser",
+        oAuth2Scopes: null,
+        resolvedSecurity: requestSecurity,
+        securitySource: client._options.apiKey,
+        retryConfig: options?.retries
+            || client._options.retryConfig
+            || {
+                strategy: "backoff",
+                backoff: {
+                    initialInterval: 500,
+                    maxInterval: 60000,
+                    exponent: 1.5,
+                    maxElapsedTime: 3600000,
+                },
+                retryConnectionErrors: true,
+            }
+            || { strategy: "none" },
+        retryCodes: options?.retryCodes || ["5XX"],
+    };
+    const requestRes = client._createRequest(context, {
+        security: requestSecurity,
+        method: "PATCH",
+        baseURL: options?.serverURL,
+        path: path,
+        headers: headers,
+        body: body,
+        userAgent: client._options.userAgent,
+        timeoutMs: options?.timeoutMs || client._options.timeoutMs || -1,
+    }, options);
+    if (!requestRes.ok) {
+        return [requestRes, { status: "invalid" }];
+    }
+    const req = requestRes.value;
+    const doResult = await client._do(req, {
+        context,
+        isErrorStatusCode: (statusCode) => matchStatusCode({ status: statusCode }, ["4XX", "5XX"]),
+        retryConfig: context.retryConfig,
+        retryCodes: context.retryCodes,
+    });
+    if (!doResult.ok) {
+        return [doResult, { status: "request-error", request: req }];
+    }
+    const response = doResult.value;
+    const responseFields = {
+        HttpMeta: { Response: response, Request: req },
+    };
+    const [result] = await M.match(M.json(200, models_EndUserResponse$inboundSchema), M.jsonErr(400, errors_BadRequestResponseError$inboundSchema), M.jsonErr(401, errors_UnauthorizedResponseError$inboundSchema), M.jsonErr(404, errors_NotFoundResponseError$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 }];
+    }
+    return [result, { status: "complete", request: req, response }];
+}
+//# sourceMappingURL=endUsersUpdate.js.map

package/esm/lib/config.d.ts

@@ -50,8 +50,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.4.9";
+    readonly sdkVersion: "1.4.11";
     readonly genVersion: "2.914.0";
-    readonly userAgent: "speakeasy-sdk/typescript 1.4.9 2.914.0 1.0.0 @openrouter/sdk";
+    readonly userAgent: "speakeasy-sdk/typescript 1.4.11 2.914.0 1.0.0 @openrouter/sdk";
 };
 //# sourceMappingURL=config.d.ts.map

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.9",
+    sdkVersion: "1.4.11",
     genVersion: "2.914.0",
-    userAgent: "speakeasy-sdk/typescript 1.4.9 2.914.0 1.0.0 @openrouter/sdk",
+    userAgent: "speakeasy-sdk/typescript 1.4.11 2.914.0 1.0.0 @openrouter/sdk",
 };
 //# sourceMappingURL=config.js.map

package/esm/models/alignment.d.ts

@@ -0,0 +1,17 @@
+import * as z from "zod/v4";
+import { Result as SafeParseResult } from "../types/fp.js";
+import { AlignmentCallRecord } from "./alignmentcallrecord.js";
+import { SDKValidationError } from "./errors/sdkvalidationerror.js";
+/**
+ * Beta. The result of the alignment plugin for this request; the shape may change.
+ */
+export type Alignment = {
+    /**
+     * One record per evaluated assistant message of the request, in the order the messages were produced.
+     */
+    calls: Array<AlignmentCallRecord>;
+};
+/** @internal */
+export declare const Alignment$inboundSchema: z.ZodType<Alignment, unknown>;
+export declare function alignmentFromJSON(jsonString: string): SafeParseResult<Alignment, SDKValidationError>;
+//# sourceMappingURL=alignment.d.ts.map

package/esm/models/alignment.js

@@ -0,0 +1,15 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ * @generated-id: 43184be859d0
+ */
+import * as z from "zod/v4";
+import { safeParse } from "../lib/schemas.js";
+import { AlignmentCallRecord$inboundSchema, } from "./alignmentcallrecord.js";
+/** @internal */
+export const Alignment$inboundSchema = z.object({
+    calls: z.array(AlignmentCallRecord$inboundSchema),
+});
+export function alignmentFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => Alignment$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'Alignment' from JSON`);
+}
+//# sourceMappingURL=alignment.js.map

package/esm/models/alignmentallowedcallrecord.d.ts

@@ -0,0 +1,19 @@
+import * as z from "zod/v4";
+import { Result as SafeParseResult } from "../types/fp.js";
+import { AlignmentRuleRecord } from "./alignmentrulerecord.js";
+import { SDKValidationError } from "./errors/sdkvalidationerror.js";
+export type AlignmentAllowedCallRecord = {
+    /**
+     * Number of the record, from 1. A record is one evaluated assistant message; a model call of a server-tool loop that produces several messages has one record per message, and a retry continues the numbering.
+     */
+    call: number;
+    outcome: "allowed";
+    /**
+     * One record per rule, in the order of `rules` in the request.
+     */
+    rules: Array<AlignmentRuleRecord>;
+};
+/** @internal */
+export declare const AlignmentAllowedCallRecord$inboundSchema: z.ZodType<AlignmentAllowedCallRecord, unknown>;
+export declare function alignmentAllowedCallRecordFromJSON(jsonString: string): SafeParseResult<AlignmentAllowedCallRecord, SDKValidationError>;
+//# sourceMappingURL=alignmentallowedcallrecord.d.ts.map

package/esm/models/alignmentallowedcallrecord.js

@@ -0,0 +1,17 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ * @generated-id: e25d7cab6275
+ */
+import * as z from "zod/v4";
+import { safeParse } from "../lib/schemas.js";
+import { AlignmentRuleRecord$inboundSchema, } from "./alignmentrulerecord.js";
+/** @internal */
+export const AlignmentAllowedCallRecord$inboundSchema = z.object({
+    call: z.int(),
+    outcome: z.literal("allowed"),
+    rules: z.array(AlignmentRuleRecord$inboundSchema),
+});
+export function alignmentAllowedCallRecordFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => AlignmentAllowedCallRecord$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'AlignmentAllowedCallRecord' from JSON`);
+}
+//# sourceMappingURL=alignmentallowedcallrecord.js.map

package/esm/models/alignmentblockedcallrecord.d.ts

@@ -0,0 +1,19 @@
+import * as z from "zod/v4";
+import { Result as SafeParseResult } from "../types/fp.js";
+import { AlignmentRuleRecord } from "./alignmentrulerecord.js";
+import { SDKValidationError } from "./errors/sdkvalidationerror.js";
+export type AlignmentBlockedCallRecord = {
+    /**
+     * Number of the record, from 1. A record is one evaluated assistant message; a model call of a server-tool loop that produces several messages has one record per message, and a retry continues the numbering.
+     */
+    call: number;
+    outcome: "blocked";
+    /**
+     * One record per rule, in the order of `rules` in the request.
+     */
+    rules: Array<AlignmentRuleRecord>;
+};
+/** @internal */
+export declare const AlignmentBlockedCallRecord$inboundSchema: z.ZodType<AlignmentBlockedCallRecord, unknown>;
+export declare function alignmentBlockedCallRecordFromJSON(jsonString: string): SafeParseResult<AlignmentBlockedCallRecord, SDKValidationError>;
+//# sourceMappingURL=alignmentblockedcallrecord.d.ts.map

package/esm/models/alignmentblockedcallrecord.js

@@ -0,0 +1,17 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ * @generated-id: 645166311886
+ */
+import * as z from "zod/v4";
+import { safeParse } from "../lib/schemas.js";
+import { AlignmentRuleRecord$inboundSchema, } from "./alignmentrulerecord.js";
+/** @internal */
+export const AlignmentBlockedCallRecord$inboundSchema = z.object({
+    call: z.int(),
+    outcome: z.literal("blocked"),
+    rules: z.array(AlignmentRuleRecord$inboundSchema),
+});
+export function alignmentBlockedCallRecordFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => AlignmentBlockedCallRecord$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'AlignmentBlockedCallRecord' from JSON`);
+}
+//# sourceMappingURL=alignmentblockedcallrecord.js.map

package/esm/models/alignmentcallrecord.d.ts

@@ -0,0 +1,12 @@
+import * as z from "zod/v4";
+import * as discriminatedUnionTypes from "../types/discriminatedUnion.js";
+import { Result as SafeParseResult } from "../types/fp.js";
+import { AlignmentAllowedCallRecord } from "./alignmentallowedcallrecord.js";
+import { AlignmentBlockedCallRecord } from "./alignmentblockedcallrecord.js";
+import { AlignmentUnavailableCallRecord } from "./alignmentunavailablecallrecord.js";
+import { SDKValidationError } from "./errors/sdkvalidationerror.js";
+export type AlignmentCallRecord = AlignmentAllowedCallRecord | AlignmentBlockedCallRecord | AlignmentUnavailableCallRecord | discriminatedUnionTypes.Unknown<"outcome">;
+/** @internal */
+export declare const AlignmentCallRecord$inboundSchema: z.ZodType<AlignmentCallRecord, unknown>;
+export declare function alignmentCallRecordFromJSON(jsonString: string): SafeParseResult<AlignmentCallRecord, SDKValidationError>;
+//# sourceMappingURL=alignmentcallrecord.d.ts.map

package/esm/models/alignmentcallrecord.js

@@ -0,0 +1,19 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ * @generated-id: 4a29229bf91b
+ */
+import { safeParse } from "../lib/schemas.js";
+import { discriminatedUnion } from "../types/discriminatedUnion.js";
+import { AlignmentAllowedCallRecord$inboundSchema, } from "./alignmentallowedcallrecord.js";
+import { AlignmentBlockedCallRecord$inboundSchema, } from "./alignmentblockedcallrecord.js";
+import { AlignmentUnavailableCallRecord$inboundSchema, } from "./alignmentunavailablecallrecord.js";
+/** @internal */
+export const AlignmentCallRecord$inboundSchema = discriminatedUnion("outcome", {
+    allowed: AlignmentAllowedCallRecord$inboundSchema,
+    blocked: AlignmentBlockedCallRecord$inboundSchema,
+    unavailable: AlignmentUnavailableCallRecord$inboundSchema,
+});
+export function alignmentCallRecordFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => AlignmentCallRecord$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'AlignmentCallRecord' from JSON`);
+}
+//# sourceMappingURL=alignmentcallrecord.js.map

package/esm/models/alignmentchataudio.d.ts

@@ -0,0 +1,20 @@
+import * as z from "zod/v4";
+import { Result as SafeParseResult } from "../types/fp.js";
+import { SDKValidationError } from "./errors/sdkvalidationerror.js";
+/**
+ * The audio of the withheld message: its `id` and `transcript`. The plugin does not retain `data` or `expires_at`.
+ */
+export type AlignmentChatAudio = {
+    /**
+     * The provider id of the audio.
+     */
+    id?: string | undefined;
+    /**
+     * The transcript of the audio.
+     */
+    transcript: string;
+};
+/** @internal */
+export declare const AlignmentChatAudio$inboundSchema: z.ZodType<AlignmentChatAudio, unknown>;
+export declare function alignmentChatAudioFromJSON(jsonString: string): SafeParseResult<AlignmentChatAudio, SDKValidationError>;
+//# sourceMappingURL=alignmentchataudio.d.ts.map

package/esm/models/alignmentchataudio.js

@@ -0,0 +1,15 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ * @generated-id: 01e8aa37a8f9
+ */
+import * as z from "zod/v4";
+import { safeParse } from "../lib/schemas.js";
+/** @internal */
+export const AlignmentChatAudio$inboundSchema = z.object({
+    id: z.string().optional(),
+    transcript: z.string(),
+});
+export function alignmentChatAudioFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => AlignmentChatAudio$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'AlignmentChatAudio' from JSON`);
+}
+//# sourceMappingURL=alignmentchataudio.js.map

package/esm/models/alignmentchatimage.d.ts

@@ -0,0 +1,24 @@
+import * as z from "zod/v4";
+import { ClosedEnum } from "../types/enums.js";
+import { Result as SafeParseResult } from "../types/fp.js";
+import { SDKValidationError } from "./errors/sdkvalidationerror.js";
+export type AlignmentChatImageImageUrl = {
+    url: string;
+};
+export declare const AlignmentChatImageType: {
+    readonly ImageUrl: "image_url";
+};
+export type AlignmentChatImageType = ClosedEnum<typeof AlignmentChatImageType>;
+export type AlignmentChatImage = {
+    imageUrl: AlignmentChatImageImageUrl;
+    type: AlignmentChatImageType;
+};
+/** @internal */
+export declare const AlignmentChatImageImageUrl$inboundSchema: z.ZodType<AlignmentChatImageImageUrl, unknown>;
+export declare function alignmentChatImageImageUrlFromJSON(jsonString: string): SafeParseResult<AlignmentChatImageImageUrl, SDKValidationError>;
+/** @internal */
+export declare const AlignmentChatImageType$inboundSchema: z.ZodEnum<typeof AlignmentChatImageType>;
+/** @internal */
+export declare const AlignmentChatImage$inboundSchema: z.ZodType<AlignmentChatImage, unknown>;
+export declare function alignmentChatImageFromJSON(jsonString: string): SafeParseResult<AlignmentChatImage, SDKValidationError>;
+//# sourceMappingURL=alignmentchatimage.d.ts.map

package/esm/models/alignmentchatimage.js

@@ -0,0 +1,32 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ * @generated-id: f366173904ff
+ */
+import * as z from "zod/v4";
+import { remap as remap$ } from "../lib/primitives.js";
+import { safeParse } from "../lib/schemas.js";
+export const AlignmentChatImageType = {
+    ImageUrl: "image_url",
+};
+/** @internal */
+export const AlignmentChatImageImageUrl$inboundSchema = z.object({
+    url: z.string(),
+});
+export function alignmentChatImageImageUrlFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => AlignmentChatImageImageUrl$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'AlignmentChatImageImageUrl' from JSON`);
+}
+/** @internal */
+export const AlignmentChatImageType$inboundSchema = z.enum(AlignmentChatImageType);
+/** @internal */
+export const AlignmentChatImage$inboundSchema = z.object({
+    image_url: z.lazy(() => AlignmentChatImageImageUrl$inboundSchema),
+    type: AlignmentChatImageType$inboundSchema,
+}).transform((v) => {
+    return remap$(v, {
+        "image_url": "imageUrl",
+    });
+});
+export function alignmentChatImageFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => AlignmentChatImage$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'AlignmentChatImage' from JSON`);
+}
+//# sourceMappingURL=alignmentchatimage.js.map

package/esm/models/alignmentchatrejected.d.ts

@@ -0,0 +1,31 @@
+import * as z from "zod/v4";
+import { ClosedEnum } from "../types/enums.js";
+import { Result as SafeParseResult } from "../types/fp.js";
+import { AlignmentChatAudio } from "./alignmentchataudio.js";
+import { AlignmentChatImage } from "./alignmentchatimage.js";
+import { AlignmentChatToolCall } from "./alignmentchattoolcall.js";
+import { SDKValidationError } from "./errors/sdkvalidationerror.js";
+export declare const AlignmentChatRejectedRole: {
+    readonly Assistant: "assistant";
+};
+export type AlignmentChatRejectedRole = ClosedEnum<typeof AlignmentChatRejectedRole>;
+/**
+ * The assistant message of the withheld turn, without reasoning. `audio` holds the id and transcript of the audio, without `data` or `expires_at`.
+ */
+export type AlignmentChatRejected = {
+    /**
+     * The audio of the withheld message: its `id` and `transcript`. The plugin does not retain `data` or `expires_at`.
+     */
+    audio?: AlignmentChatAudio | undefined;
+    content: string | null;
+    images?: Array<AlignmentChatImage> | undefined;
+    refusal: string | null;
+    role: AlignmentChatRejectedRole;
+    toolCalls?: Array<AlignmentChatToolCall> | undefined;
+};
+/** @internal */
+export declare const AlignmentChatRejectedRole$inboundSchema: z.ZodEnum<typeof AlignmentChatRejectedRole>;
+/** @internal */
+export declare const AlignmentChatRejected$inboundSchema: z.ZodType<AlignmentChatRejected, unknown>;
+export declare function alignmentChatRejectedFromJSON(jsonString: string): SafeParseResult<AlignmentChatRejected, SDKValidationError>;
+//# sourceMappingURL=alignmentchatrejected.d.ts.map

package/esm/models/alignmentchatrejected.js

@@ -0,0 +1,32 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ * @generated-id: 435622aeeeaf
+ */
+import * as z from "zod/v4";
+import { remap as remap$ } from "../lib/primitives.js";
+import { safeParse } from "../lib/schemas.js";
+import { AlignmentChatAudio$inboundSchema, } from "./alignmentchataudio.js";
+import { AlignmentChatImage$inboundSchema, } from "./alignmentchatimage.js";
+import { AlignmentChatToolCall$inboundSchema, } from "./alignmentchattoolcall.js";
+export const AlignmentChatRejectedRole = {
+    Assistant: "assistant",
+};
+/** @internal */
+export const AlignmentChatRejectedRole$inboundSchema = z.enum(AlignmentChatRejectedRole);
+/** @internal */
+export const AlignmentChatRejected$inboundSchema = z.object({
+    audio: AlignmentChatAudio$inboundSchema.optional(),
+    content: z.nullable(z.string()),
+    images: z.array(AlignmentChatImage$inboundSchema).optional(),
+    refusal: z.nullable(z.string()),
+    role: AlignmentChatRejectedRole$inboundSchema,
+    tool_calls: z.array(AlignmentChatToolCall$inboundSchema).optional(),
+}).transform((v) => {
+    return remap$(v, {
+        "tool_calls": "toolCalls",
+    });
+});
+export function alignmentChatRejectedFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => AlignmentChatRejected$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'AlignmentChatRejected' from JSON`);
+}
+//# sourceMappingURL=alignmentchatrejected.js.map

package/esm/models/alignmentchattoolcall.d.ts

@@ -0,0 +1,26 @@
+import * as z from "zod/v4";
+import { ClosedEnum } from "../types/enums.js";
+import { Result as SafeParseResult } from "../types/fp.js";
+import { SDKValidationError } from "./errors/sdkvalidationerror.js";
+export type AlignmentChatToolCallFunction = {
+    arguments: string;
+    name: string;
+};
+export declare const AlignmentChatToolCallType: {
+    readonly Function: "function";
+};
+export type AlignmentChatToolCallType = ClosedEnum<typeof AlignmentChatToolCallType>;
+export type AlignmentChatToolCall = {
+    function: AlignmentChatToolCallFunction;
+    id: string;
+    type: AlignmentChatToolCallType;
+};
+/** @internal */
+export declare const AlignmentChatToolCallFunction$inboundSchema: z.ZodType<AlignmentChatToolCallFunction, unknown>;
+export declare function alignmentChatToolCallFunctionFromJSON(jsonString: string): SafeParseResult<AlignmentChatToolCallFunction, SDKValidationError>;
+/** @internal */
+export declare const AlignmentChatToolCallType$inboundSchema: z.ZodEnum<typeof AlignmentChatToolCallType>;
+/** @internal */
+export declare const AlignmentChatToolCall$inboundSchema: z.ZodType<AlignmentChatToolCall, unknown>;
+export declare function alignmentChatToolCallFromJSON(jsonString: string): SafeParseResult<AlignmentChatToolCall, SDKValidationError>;
+//# sourceMappingURL=alignmentchattoolcall.d.ts.map

package/esm/models/alignmentchattoolcall.js

@@ -0,0 +1,29 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ * @generated-id: 6dab9dad37b6
+ */
+import * as z from "zod/v4";
+import { safeParse } from "../lib/schemas.js";
+export const AlignmentChatToolCallType = {
+    Function: "function",
+};
+/** @internal */
+export const AlignmentChatToolCallFunction$inboundSchema = z.object({
+    arguments: z.string(),
+    name: z.string(),
+});
+export function alignmentChatToolCallFunctionFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => AlignmentChatToolCallFunction$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'AlignmentChatToolCallFunction' from JSON`);
+}
+/** @internal */
+export const AlignmentChatToolCallType$inboundSchema = z.enum(AlignmentChatToolCallType);
+/** @internal */
+export const AlignmentChatToolCall$inboundSchema = z.object({
+    function: z.lazy(() => AlignmentChatToolCallFunction$inboundSchema),
+    id: z.string(),
+    type: AlignmentChatToolCallType$inboundSchema,
+});
+export function alignmentChatToolCallFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => AlignmentChatToolCall$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'AlignmentChatToolCall' from JSON`);
+}
+//# sourceMappingURL=alignmentchattoolcall.js.map

package/esm/models/alignmentplugin.d.ts

@@ -0,0 +1,54 @@
+import * as z from "zod/v4";
+import { OpenEnum } from "../types/enums.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`.
+ */
+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`.
+ */
+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.
+ */
+export type AlignmentPlugin = {
+    id: "alignment";
+    /**
+     * Whether the rules are stated to the model in a system message on every provider call. Default true.
+     */
+    instruct?: boolean | undefined;
+    /**
+     * Provider calls made again after a blocked turn, in enforce mode. Default 1.
+     */
+    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`.
+     */
+    mode?: AlignmentPluginMode | undefined;
+    /**
+     * Texts that state what the reply must do or must not do. Each rule is evaluated on its own.
+     */
+    rules: Array<string>;
+    /**
+     * Probability at or above which a rule is broken. Default 0.7.
+     */
+    threshold?: number | undefined;
+};
+/** @internal */
+export declare const AlignmentPluginMode$outboundSchema: z.ZodType<string, AlignmentPluginMode>;
+/** @internal */
+export type AlignmentPlugin$Outbound = {
+    id: "alignment";
+    instruct?: boolean | undefined;
+    max_retries?: number | undefined;
+    mode?: string | undefined;
+    rules: Array<string>;
+    threshold?: number | undefined;
+};
+/** @internal */
+export declare const AlignmentPlugin$outboundSchema: z.ZodType<AlignmentPlugin$Outbound, AlignmentPlugin>;
+export declare function alignmentPluginToJSON(alignmentPlugin: AlignmentPlugin): string;
+//# sourceMappingURL=alignmentplugin.d.ts.map

package/esm/models/alignmentplugin.js

@@ -0,0 +1,33 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ * @generated-id: d60fbed09ef4
+ */
+import * as z from "zod/v4";
+import { remap as remap$ } from "../lib/primitives.js";
+import * as openEnums from "../types/enums.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`.
+ */
+export const AlignmentPluginMode = {
+    Enforce: "enforce",
+    Audit: "audit",
+};
+/** @internal */
+export const AlignmentPluginMode$outboundSchema = openEnums.outboundSchema(AlignmentPluginMode);
+/** @internal */
+export const AlignmentPlugin$outboundSchema = z.object({
+    id: z.literal("alignment"),
+    instruct: z.boolean().optional(),
+    maxRetries: z.int().optional(),
+    mode: AlignmentPluginMode$outboundSchema.optional(),
+    rules: z.array(z.string()),
+    threshold: z.number().optional(),
+}).transform((v) => {
+    return remap$(v, {
+        maxRetries: "max_retries",
+    });
+});
+export function alignmentPluginToJSON(alignmentPlugin) {
+    return JSON.stringify(AlignmentPlugin$outboundSchema.parse(alignmentPlugin));
+}
+//# sourceMappingURL=alignmentplugin.js.map

package/esm/models/alignmentrejected.d.ts

@@ -0,0 +1,10 @@
+import * as z from "zod/v4";
+import { Result as SafeParseResult } from "../types/fp.js";
+import { AlignmentChatRejected } from "./alignmentchatrejected.js";
+import { AlignmentResponsesRejected } from "./alignmentresponsesrejected.js";
+import { SDKValidationError } from "./errors/sdkvalidationerror.js";
+export type AlignmentRejected = AlignmentChatRejected | Array<AlignmentResponsesRejected>;
+/** @internal */
+export declare const AlignmentRejected$inboundSchema: z.ZodType<AlignmentRejected, unknown>;
+export declare function alignmentRejectedFromJSON(jsonString: string): SafeParseResult<AlignmentRejected, SDKValidationError>;
+//# sourceMappingURL=alignmentrejected.d.ts.map

package/esm/models/alignmentrejected.js

@@ -0,0 +1,17 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ * @generated-id: 9c98493f46cb
+ */
+import * as z from "zod/v4";
+import { safeParse } from "../lib/schemas.js";
+import { AlignmentChatRejected$inboundSchema, } from "./alignmentchatrejected.js";
+import { AlignmentResponsesRejected$inboundSchema, } from "./alignmentresponsesrejected.js";
+/** @internal */
+export const AlignmentRejected$inboundSchema = z.union([
+    AlignmentChatRejected$inboundSchema,
+    z.array(AlignmentResponsesRejected$inboundSchema),
+]);
+export function alignmentRejectedFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => AlignmentRejected$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'AlignmentRejected' from JSON`);
+}
+//# sourceMappingURL=alignmentrejected.js.map

package/esm/models/alignmentresponsesrejected.d.ts

@@ -0,0 +1,18 @@
+import * as z from "zod/v4";
+import * as discriminatedUnionTypes from "../types/discriminatedUnion.js";
+import { Result as SafeParseResult } from "../types/fp.js";
+import { SDKValidationError } from "./errors/sdkvalidationerror.js";
+import { OutputItemApplyPatchCall } from "./outputitemapplypatchcall.js";
+import { OutputItemCodeInterpreterCall } from "./outputitemcodeinterpretercall.js";
+import { OutputItemCustomToolCall } from "./outputitemcustomtoolcall.js";
+import { OutputItemFileSearchCall } from "./outputitemfilesearchcall.js";
+import { OutputItemFunctionCall } from "./outputitemfunctioncall.js";
+import { OutputItemImageGenerationCall } from "./outputitemimagegenerationcall.js";
+import { OutputItemReasoning } from "./outputitemreasoning.js";
+import { OutputItemWebSearchCall } from "./outputitemwebsearchcall.js";
+import { OutputMessage } from "./outputmessage.js";
+export type AlignmentResponsesRejected = OutputItemApplyPatchCall | OutputItemCodeInterpreterCall | OutputItemCustomToolCall | OutputItemFileSearchCall | OutputItemFunctionCall | OutputItemImageGenerationCall | OutputMessage | OutputItemReasoning | OutputItemWebSearchCall | discriminatedUnionTypes.Unknown<"type">;
+/** @internal */
+export declare const AlignmentResponsesRejected$inboundSchema: z.ZodType<AlignmentResponsesRejected, unknown>;
+export declare function alignmentResponsesRejectedFromJSON(jsonString: string): SafeParseResult<AlignmentResponsesRejected, SDKValidationError>;
+//# sourceMappingURL=alignmentresponsesrejected.d.ts.map