@vib-rato/ai 0.16.0

package/dist/types/utils/oauth/opencode.d.ts

@@ -0,0 +1,18 @@
+/**
+ * OpenCode Zen login flow.
+ *
+ * OpenCode Zen is a subscription service that provides access to various AI models
+ * (GPT-5.x, Anthropic model 4.x, Gemini 3, etc.) through a unified API at opencode.ai/zen.
+ * This is not OAuth - it's a simple API key flow:
+ * 1. Open browser to https://opencode.ai/auth
+ * 2. User logs in and copies their API key
+ * 3. User pastes the API key back into the CLI
+ */
+import type { OAuthController } from "./types";
+/**
+ * Login to OpenCode Zen.
+ *
+ * Opens browser to auth page, prompts user to paste their API key.
+ * Returns the API key directly (not OAuthCredentials - this isn't OAuth).
+ */
+export declare function loginOpenCode(options: OAuthController): Promise<string>;

package/dist/types/utils/oauth/opengateway.d.ts

@@ -0,0 +1 @@
+export declare const loginOpenGateway: (options: import("./types").OAuthController) => Promise<string>;

package/dist/types/utils/oauth/openrouter.d.ts

@@ -0,0 +1 @@
+export declare const loginOpenRouter: (options: import("./types").OAuthController) => Promise<string>;

package/dist/types/utils/oauth/parallel.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Parallel login flow.
+ *
+ * Parallel uses an API key from the account settings page.
+ * This is an API key flow:
+ * 1. Open browser to Parallel API key settings
+ * 2. User copies API key
+ * 3. User pastes key into the CLI/TUI
+ */
+import type { OAuthController } from "./types";
+/**
+ * Login to Parallel.
+ *
+ * Opens browser to the API keys page, prompts the user to paste their API key,
+ * and returns the API key directly.
+ */
+export declare function loginParallel(options: OAuthController): Promise<string>;

package/dist/types/utils/oauth/perplexity.d.ts

@@ -0,0 +1,4 @@
+import type { OAuthController, OAuthCredentials } from "./types";
+/** Test seam: the resolved native-app borrowing opt-out. */
+export declare function authBorrowDisabledForTest(): boolean;
+export declare function loginPerplexity(ctrl: OAuthController): Promise<OAuthCredentials>;

package/dist/types/utils/oauth/pkce.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Generate PKCE code verifier and challenge.
+ * Uses Web Crypto API for cross-platform compatibility.
+ */
+export declare function generatePKCE(): Promise<{
+    verifier: string;
+    challenge: string;
+}>;

package/dist/types/utils/oauth/qianfan.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Qianfan login flow.
+ *
+ * Qianfan provides an OpenAI-compatible API endpoint.
+ * Login is API-key based:
+ * 1. Open browser to Qianfan API key console
+ * 2. User copies API key
+ * 3. User pastes key into CLI prompt
+ */
+import type { OAuthController } from "./types";
+/**
+ * Login to Qianfan.
+ *
+ * Opens browser to API key page, prompts user to paste their API key.
+ * Returns the API key directly (not OAuthCredentials - this isn't OAuth).
+ */
+export declare function loginQianfan(options: OAuthController): Promise<string>;

package/dist/types/utils/oauth/qwen-portal.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Qwen Portal login flow.
+ *
+ * Qwen Portal exposes an OpenAI-compatible endpoint at https://portal.qwen.ai/v1
+ * and accepts OAuth bearer tokens or API keys.
+ *
+ * This is a token/API-key flow:
+ * 1. Open Qwen Portal
+ * 2. Copy either your OAuth token or API key
+ * 3. Paste it into the CLI
+ */
+import type { OAuthController } from "./types";
+/**
+ * Login to Qwen Portal.
+ *
+ * Prompts for either `QWEN_OAUTH_TOKEN` or `QWEN_PORTAL_API_KEY` value.
+ * Returns the value directly (stored as api_key credential in auth storage).
+ */
+export declare function loginQwenPortal(options: OAuthController): Promise<string>;

package/dist/types/utils/oauth/sglang.d.ts

@@ -0,0 +1,16 @@
+/**
+ * SGLang login flow.
+ *
+ * SGLang is commonly self-hosted with an OpenAI-compatible API at a local base URL.
+ * Some deployments require a bearer token, others allow unauthenticated access.
+ *
+ * This flow stores an API-key-style credential used by `/login` and auth storage.
+ */
+import type { OAuthController } from "./types";
+/**
+ * Login to SGLang.
+ *
+ * Opens SGLang OpenAI-compatible auth docs, prompts for a bearer token,
+ * and returns a stored key value. Local no-auth servers need no login.
+ */
+export declare function loginSglang(options: OAuthController): Promise<string>;

package/dist/types/utils/oauth/synthetic.d.ts

@@ -0,0 +1 @@
+export declare const loginSynthetic: (options: import("./types").OAuthController) => Promise<string>;

package/dist/types/utils/oauth/tavily.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Tavily login flow.
+ *
+ * Tavily web search uses an API key from the account settings page.
+ * This is an API key flow:
+ * 1. Open browser to Tavily settings
+ * 2. User copies API key
+ * 3. User pastes key into CLI
+ */
+import type { OAuthController } from "./types";
+/**
+ * Login to Tavily.
+ *
+ * Opens browser to API keys page and prompts user to paste their API key.
+ * Returns the API key directly (not OAuthCredentials - this isn't OAuth).
+ */
+export declare function loginTavily(options: OAuthController): Promise<string>;

package/dist/types/utils/oauth/together.d.ts

@@ -0,0 +1 @@
+export declare const loginTogether: (options: import("./types").OAuthController) => Promise<string>;

package/dist/types/utils/oauth/types.d.ts

@@ -0,0 +1,56 @@
+export type OAuthCredentials = {
+    refresh: string;
+    access: string;
+    expires: number;
+    enterpriseUrl?: string;
+    projectId?: string;
+    email?: string;
+    accountId?: string;
+};
+export type OAuthProvider = "kiro" | "alibaba-token-plan" | "anthropic" | "bizrouter" | "mara" | "cerebras" | "cloudflare-ai-gateway" | "cursor" | "deepseek" | "deepinfra" | "fireworks" | "firepass" | "fugu" | "github-copilot" | "google-gemini-cli" | "google-antigravity" | "gitlab-duo" | "huggingface" | "kimi-code" | "kilo" | "kagi" | "litellm" | "lm-studio" | "minimax-code" | "minimax-code-cn" | "moonshot" | "nvidia" | "nanogpt" | "ollama" | "ollama-cloud" | "openai-codex" | "openai-codex-device" | "opencode-go" | "opencode-zen" | "commandcode-goat" | "opengateway" | "openrouter" | "parallel" | "perplexity" | "qianfan" | "qwen-portal" | "sglang" | "synthetic" | "tavily" | "together" | "venice" | "vercel-ai-gateway" | "vllm" | "xai" | "glm-zcode" | "xiaomi" | "xiaomi-token-plan-sgp" | "xiaomi-token-plan-ams" | "xiaomi-token-plan-cn" | "zenmux" | "opencodex" | "zai";
+export type OAuthProviderId = OAuthProvider | (string & {});
+export type OAuthPrompt = {
+    message: string;
+    placeholder?: string;
+    allowEmpty?: boolean;
+};
+export type OAuthAuthInfo = {
+    url: string;
+    instructions?: string;
+};
+export interface OAuthProviderInfo {
+    id: OAuthProviderId;
+    name: string;
+    available: boolean;
+}
+/** Per-login switches that change how the authorization code is delivered. */
+export interface OAuthLoginOptions {
+    /**
+     * Pair by pasting the authorization code the provider displays instead of
+     * waiting on a local loopback callback. Set when the browser completing the
+     * login has no network route back to the machine running vib (SSH, remote
+     * container, headless host). Providers without a paste-a-code redirect
+     * ignore it.
+     */
+    manualCode?: boolean;
+}
+export interface OAuthController {
+    onAuth?(info: OAuthAuthInfo): void;
+    onProgress?(message: string): void;
+    onManualCodeInput?(): Promise<string>;
+    onPrompt?(prompt: OAuthPrompt): Promise<string>;
+    signal?: AbortSignal;
+    fetch?: typeof globalThis.fetch;
+}
+export interface OAuthLoginCallbacks extends OAuthController {
+    onAuth: (info: OAuthAuthInfo) => void;
+    onPrompt: (prompt: OAuthPrompt) => Promise<string>;
+}
+export interface OAuthProviderInterface {
+    readonly id: OAuthProviderId;
+    readonly name: string;
+    readonly sourceId?: string;
+    login(callbacks: OAuthLoginCallbacks): Promise<OAuthCredentials | string>;
+    refreshToken?(credentials: OAuthCredentials): Promise<OAuthCredentials>;
+    getApiKey?(credentials: OAuthCredentials): string;
+}

package/dist/types/utils/oauth/venice.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Venice login flow.
+ *
+ * Venice provides OpenAI-compatible models via https://api.venice.ai/api/v1.
+ *
+ * This is not OAuth - it's a simple API key flow:
+ * 1. Open browser to Venice API key settings
+ * 2. User copies their API key
+ * 3. User pastes the API key into the CLI
+ */
+import type { OAuthController } from "./types";
+/**
+ * Login to Venice.
+ *
+ * Opens browser to API keys page, prompts user to paste their API key.
+ * Returns the API key directly (not OAuthCredentials - this isn't OAuth).
+ */
+export declare function loginVenice(options: OAuthController): Promise<string>;

package/dist/types/utils/oauth/vercel-ai-gateway.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Vercel AI Gateway login flow.
+ *
+ * Vercel AI Gateway proxies upstream model providers through a unified endpoint.
+ *
+ * This is not OAuth - it's a simple API key flow:
+ * 1. Open Vercel AI Gateway docs
+ * 2. User copies their API key
+ * 3. User pastes the API key into the CLI
+ */
+import type { OAuthController } from "./types";
+/**
+ * Login to Vercel AI Gateway.
+ *
+ * Opens browser to Vercel AI Gateway docs and prompts for an API key.
+ * Returns the API key directly (not OAuthCredentials - this isn't OAuth).
+ */
+export declare function loginVercelAiGateway(options: OAuthController): Promise<string>;

package/dist/types/utils/oauth/vllm.d.ts

@@ -0,0 +1,16 @@
+/**
+ * vLLM login flow.
+ *
+ * vLLM is commonly self-hosted with an OpenAI-compatible API at a local base URL.
+ * Some deployments require a bearer token, others allow unauthenticated access.
+ *
+ * This flow stores an API-key-style credential used by `/login` and auth storage.
+ */
+import type { OAuthController } from "./types";
+/**
+ * Login to vLLM.
+ *
+ * Opens vLLM OpenAI-compatible auth docs, prompts for a bearer token,
+ * and returns a stored key value. Local no-auth servers need no login.
+ */
+export declare function loginVllm(options: OAuthController): Promise<string>;

package/dist/types/utils/oauth/xai.d.ts

@@ -0,0 +1,30 @@
+/** xAI OAuth flow (Grok account login). */
+import { OAuthCallbackFlow } from "./callback-server";
+import type { OAuthController, OAuthCredentials } from "./types";
+export declare const XAI_OAUTH_DISCOVERY_URL = "https://auth.x.ai/.well-known/openid-configuration";
+export declare const XAI_OAUTH_CLIENT_ID = "b1a00492-073a-47ea-816f-4c329264a828";
+export declare const XAI_OAUTH_SCOPE = "openid profile email offline_access grok-cli:access api:access";
+interface XaiDiscovery {
+    authorizationEndpoint: string;
+    tokenEndpoint: string;
+}
+export interface XaiOAuthFlowOptions {
+    extraAuthorizeParams?: Readonly<Record<string, string>>;
+}
+export interface XaiOAuthRefreshOptions {
+    signal?: AbortSignal;
+    extraTokenParams?: Readonly<Record<string, string>>;
+}
+export declare function discoverXaiOAuthEndpoints(signal?: AbortSignal): Promise<XaiDiscovery>;
+export declare class XaiOAuthFlow extends OAuthCallbackFlow {
+    #private;
+    constructor(ctrl: OAuthController, options?: XaiOAuthFlowOptions);
+    generateAuthUrl(state: string, redirectUri: string): Promise<{
+        url: string;
+        instructions?: string;
+    }>;
+    exchangeToken(code: string, _state: string, redirectUri: string): Promise<OAuthCredentials>;
+}
+export declare function loginXai(ctrl: OAuthController, options?: XaiOAuthFlowOptions): Promise<OAuthCredentials>;
+export declare function refreshXaiToken(refreshToken: string, options?: AbortSignal | XaiOAuthRefreshOptions): Promise<OAuthCredentials>;
+export {};

package/dist/types/utils/oauth/xiaomi.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Xiaomi MiMo login flow.
+ *
+ * Xiaomi MiMo provides OpenAI-compatible models via
+ * https://api.xiaomimimo.com/v1.
+ *
+ * Standard Xiaomi login opens the pay-as-you-go API key console. Token Plan
+ * login opens plan management so users copy the regional `tp-...` key.
+ */
+import type { OAuthController } from "./types";
+/** Region codes accepted by the Xiaomi Token Plan login flow. */
+export type XiaomiTokenPlanRegion = "sgp" | "ams" | "cn";
+/**
+ * Login to Xiaomi MiMo.
+ *
+ * Opens browser to API keys page, prompts user to paste their API key.
+ * Returns the API key directly (not OAuthCredentials - this isn't OAuth).
+ */
+export declare function loginXiaomi(options: OAuthController): Promise<string>;
+/**
+ * Login to a regional Xiaomi Token Plan endpoint.
+ *
+ * Prompts for a token-plan API key and validates it against the selected region.
+ */
+export declare function loginXiaomiTokenPlan(options: OAuthController, region: XiaomiTokenPlanRegion): Promise<string>;

package/dist/types/utils/oauth/zai.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Z.AI login flow.
+ *
+ * Z.AI is a platform that provides access to GLM models through an OpenAI-compatible API.
+ * API docs: https://docs.z.ai/guides/overview/quick-start
+ *
+ * This is not OAuth - it's a simple API key flow:
+ * 1. User gets their API key from https://z.ai/settings/api-keys
+ * 2. User pastes the API key into the CLI
+ */
+import type { OAuthController } from "./types";
+/**
+ * Login to Z.AI.
+ *
+ * Opens browser to API keys page, prompts user to paste their API key.
+ * Returns the API key directly (not OAuthCredentials - this isn't OAuth).
+ */
+export declare function loginZai(options: OAuthController): Promise<string>;

package/dist/types/utils/oauth/zenmux.d.ts

@@ -0,0 +1 @@
+export declare const loginZenMux: (options: import("./types").OAuthController) => Promise<string>;

package/dist/types/utils/overflow.d.ts

@@ -0,0 +1,14 @@
+import type { AssistantMessage } from "../types";
+import type { TransportFailureFacts } from "./fallback-transport";
+export declare function classifyContextOverflow(message: AssistantMessage, transportFailure?: TransportFailureFacts, contextWindow?: number): boolean;
+/**
+ * Check if an assistant message represents a context overflow error.
+ *
+ * Callers with normalized transport facts should use {@link classifyContextOverflow}
+ * so typed provider codes take precedence over error prose.
+ */
+export declare function isContextOverflow(message: AssistantMessage, contextWindow?: number): boolean;
+/**
+ * Get the overflow patterns for testing purposes.
+ */
+export declare function getOverflowPatterns(): RegExp[];

package/dist/types/utils/parse-bind.d.ts

@@ -0,0 +1,26 @@
+export interface ParsedBind {
+    hostname: string;
+    port: number;
+}
+/**
+ * Parse a `host:port` (or bare `port`, which assumes loopback) string.
+ *
+ * Accepts:
+ *   - `"4000"`            → `127.0.0.1:4000`
+ *   - `"0.0.0.0:4000"`    → as written
+ *   - `"[::1]:4000"`      → as written (brackets retained, Bun handles them)
+ *
+ * Rejects:
+ *   - empty input
+ *   - empty hostname (`":4000"`)
+ *   - non-integer / out-of-range port
+ */
+export declare function parseBind(raw: string): ParsedBind;
+/** True for loopback-only hostnames the auth servers may bind without credentials. */
+export declare function isLoopbackHostname(hostname: string): boolean;
+/**
+ * Fail closed when an unauthenticated auth server (empty bearer token set)
+ * would bind a non-loopback address: that exposes credential operations to the
+ * network with no proof of possession.
+ */
+export declare function assertAuthenticatedOrLoopback(bind: ParsedBind, bearerTokenCount: number, serverName: string): void;

package/dist/types/utils/provider-response.d.ts

@@ -0,0 +1,6 @@
+import type { Api, AttemptScopeRef, Model, ProviderResponseMetadata, StreamOptions } from "../types";
+export declare function normalizeProviderResponse(response: Response, requestId?: string | null, metadata?: Record<string, unknown>): ProviderResponseMetadata;
+export declare function notifyProviderResponse(options: {
+    onResponse?: StreamOptions["onResponse"];
+    attemptScope?: AttemptScopeRef;
+} | undefined, response: Response, model?: Model<Api>, requestId?: string | null, metadata?: Record<string, unknown>): Promise<void>;

package/dist/types/utils/provider-safety-stop.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Public provider safety-stop surface (issue #4777 review follow-up).
+ *
+ * First-party adapters mint terminal authority through the package-private
+ * adapter-internals module. Public consumers may only verify existing
+ * authority; message fields and structured refusal text never mint authority.
+ */
+export { isProviderSafetyStopAuthenticated } from "../adapter-internals/provider-safety-stop";

package/dist/types/utils/proxy.d.ts

@@ -0,0 +1,7 @@
+import * as tls from "node:tls";
+export interface ProxyConnectOptions {
+    signal?: AbortSignal;
+    timeoutMs?: number;
+}
+export declare function getProxyForUrl(provider: string, url: URL): string | undefined;
+export declare function connectProxiedSocket(proxyUrl: string, targetUrl: string, options?: ProxyConnectOptions): Promise<tls.TLSSocket>;

package/dist/types/utils/retry-after.d.ts

@@ -0,0 +1,3 @@
+export type HeadersLike = Headers | Record<string, string | undefined> | undefined | null;
+export declare function formatErrorMessageWithRetryAfter(error: unknown, headers?: HeadersLike): string;
+export declare function getRetryAfterMsFromHeaders(headers: HeadersLike): number | undefined;

package/dist/types/utils/retry-budget.d.ts

@@ -0,0 +1 @@
+export declare function resolveRetryBudget(value: number | undefined, fallback: number): number;

package/dist/types/utils/retry.d.ts

@@ -0,0 +1,29 @@
+/**
+ * GitHub Copilot intermittently rejects preview models (gpt-5.3-OpenAI code backend,
+ * gpt-5.4, gpt-5.4-mini, ...) with HTTP 400 `model_not_supported`, even
+ * though the model is listed as enabled on the user's account via `/models`.
+ *
+ * Root cause: Copilot's request-routing backend is rolled out per OAuth
+ * client. Our OAuth client id is shared with opencode; VS Code uses its own
+ * client and sees full availability, so the same account may succeed in VS
+ * Code and flap between 200/400 here. See opencode#13313 and copilot-cli#2597.
+ *
+ * Retrying the identical request 2-3 times almost always lands on a backend
+ * that has the model, so we wrap the initial request with a short retry loop.
+ */
+export declare function isCopilotTransientModelError(error: unknown): boolean;
+/**
+ * Wrap an initial Copilot request so transient `model_not_supported` 400s are
+ * retried a small number of times. No-op for non-Copilot providers.
+ *
+ * The callback **MUST** create a fresh in-flight request each invocation — a
+ * once-consumed AsyncIterable cannot be re-iterated.
+ */
+export declare function callWithCopilotModelRetry<T>(fn: () => Promise<T>, options: {
+    provider: string;
+    signal?: AbortSignal;
+    retryBaseDelayMs?: number;
+    fallbackManaged?: boolean;
+    requestMaxRetries?: number;
+    disableProviderRetries?: boolean;
+}): Promise<T>;

package/dist/types/utils/schema/adapt.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Set when callers want to globally bypass OpenAI strict-mode enforcement
+ * (e.g. for debugging a provider that misreports strict support, or when
+ * comparing strict vs non-strict outputs).
+ *
+ * Honored by every provider that emits `strict: true` on its function tools —
+ * see `openai-completions`, `openai-responses`, `OpenAI code provider-responses`, and
+ * the strict candidate selection in `anthropic`.
+ */
+export declare const NO_STRICT: boolean;
+/**
+ * Consolidated helper for OpenAI-style strict schema enforcement.
+ *
+ * Each provider computes its own `strict` boolean (logic differs), then calls
+ * this to handle the tryEnforceStrictSchema dance uniformly:
+ * - Draft-07-shaped inputs are upgraded to draft 2020-12 first.
+ * - If `strict` is false, passes the upgraded schema through unchanged.
+ * - If `strict` is true, attempts to enforce strict mode; falls back to
+ *   non-strict if the schema isn't representable.
+ */
+export declare function adaptSchemaForStrict(schema: Record<string, unknown>, strict: boolean): {
+    schema: Record<string, unknown>;
+    strict: boolean;
+};

package/dist/types/utils/schema/compatibility.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Schema compatibility audits.
+ *
+ * Each provider has a different idea of what JSON Schema features it accepts
+ * for tool definitions. The normalizers in `normalize.ts`, `strict-mode`,
+ * and `adapt.ts` rewrite incoming schemas to fit. This module is the
+ * *audit* counterpart: it walks a (presumably already-sanitized) schema and
+ * reports any feature the target provider would reject. Tests use it to lock
+ * down the contract; the runtime uses it to fail-open with diagnostic logs
+ * rather than silently shipping a broken tool definition.
+ */
+export type SchemaCompatibilityProvider = "openai-strict" | "google" | "cloud-code-assist-claude";
+export interface SchemaCompatibilityViolation {
+    path: string;
+    rule: string;
+    message: string;
+    key?: string;
+    value?: unknown;
+}
+export interface SchemaCompatibilityResult {
+    provider: SchemaCompatibilityProvider;
+    compatible: boolean;
+    violations: SchemaCompatibilityViolation[];
+}
+export interface StrictSchemaEnforcementResult {
+    schema: Record<string, unknown>;
+    strict: boolean;
+}
+export declare function validateSchemaCompatibility(schema: unknown, provider: SchemaCompatibilityProvider): SchemaCompatibilityResult;
+export declare function validateStrictSchemaEnforcement(originalSchema: Record<string, unknown>, result: StrictSchemaEnforcementResult): SchemaCompatibilityResult;

package/dist/types/utils/schema/dereference.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Dereference all local `$ref` pointers in a JSON Schema, inlining definitions
+ * from `$defs` / `definitions`. The `$defs` block is stripped from the output.
+ *
+ * Non-local refs (e.g. `http://...`) are left untouched.
+ * Circular references are broken with `{}`.
+ *
+ * @returns A new schema object with all local refs inlined, or the input unchanged
+ *          if it's not an object or has no `$defs`/`definitions`.
+ */
+export declare function dereferenceJsonSchema(schema: unknown): unknown;

package/dist/types/utils/schema/draft.d.ts

@@ -0,0 +1,10 @@
+export declare const JSON_SCHEMA_DRAFT_2020_12_URI = "https://json-schema.org/draft/2020-12/schema";
+/** Pre-check entrypoint. Exposed so callers can decide whether to take the upgrade path at all. */
+export declare function schemaNeedsDraft202012Upgrade(schema: unknown): boolean;
+/**
+ * Upgrade legacy JSON Schema shapes to the draft 2020-12 form emitted by Zod.
+ *
+ * This keeps extension/MCP/TypeBox schemas compatible with providers whose tool
+ * validators reject draft-07 tuple and dependency keywords.
+ */
+export declare function upgradeJsonSchemaTo202012(schema: unknown): unknown;

package/dist/types/utils/schema/equality.d.ts

@@ -0,0 +1,4 @@
+import type { JsonObject } from "./types";
+export declare function areJsonValuesEqual(left: unknown, right: unknown): boolean;
+export declare function mergeCompatibleEnumSchemas(existing: unknown, incoming: unknown): JsonObject | null;
+export declare function mergePropertySchemas(existing: unknown, incoming: unknown): unknown;

package/dist/types/utils/schema/fields.d.ts

@@ -0,0 +1,49 @@
+/**
+ * Field classification sets for JSON Schema sanitization across providers.
+ *
+ * Each set serves a different provider need. They overlap intentionally —
+ * co-locating them makes the overlap visible and maintainable.
+ *
+ * All keysets here are static and small (≤ ~40 entries) so they live as
+ * `Record<string, true>` literals — `k in REC` resolves through hidden
+ * class inline caches without the per-call hashtable cost of `Set.has`.
+ */
+/**
+ * Google Generative AI unsupported schema fields.
+ * Stripped during normalizeSchemaForGoogle / normalizeSchemaForCCA.
+ */
+export declare const UNSUPPORTED_SCHEMA_FIELDS: Record<string, true>;
+/**
+ * Human-meaningful validation/decorative keywords that can be preserved in a
+ * sibling description when a provider-specific normalizer strips them from the
+ * wire schema.
+ */
+export declare const LIFTABLE_TO_DESCRIPTION_FIELDS: Record<string, true>;
+/**
+ * Non-structural schema keys stripped during OpenAI strict mode sanitization.
+ * These are decorative/validation-only keywords that don't affect the structural
+ * shape OpenAI's strict mode enforces.
+ */
+export declare const NON_STRUCTURAL_SCHEMA_KEYS: Record<string, true>;
+/**
+ * Cloud Code Assist type-specific allowed keys per JSON Schema type.
+ * Used when collapsing mixed-type combiner variants for CCA Anthropic model.
+ */
+export declare const CLOUD_CODE_ASSIST_TYPE_SPECIFIC_KEYS: Record<string, Record<string, true>>;
+/**
+ * Cloud Code Assist shared schema keys allowed on any type.
+ * Used alongside CLOUD_CODE_ASSIST_TYPE_SPECIFIC_KEYS for CCA combiner collapsing.
+ */
+export declare const CLOUD_CODE_ASSIST_SHARED_SCHEMA_KEYS: Record<string, true>;
+/**
+ * Combinator keys used across schema sanitization modules.
+ * Defined once to avoid duplication in strict-mode.ts and normalize.ts.
+ */
+export declare const COMBINATOR_KEYS: readonly ["anyOf", "allOf", "oneOf"];
+/**
+ * Cloud Code Assist Anthropic model unsupported schema fields.
+ * Much smaller than UNSUPPORTED_SCHEMA_FIELDS (Google) because CCA supports
+ * validation keywords like additionalProperties, minLength, pattern, etc.
+ * Meta/reference keywords plus object-key validators that CCA cannot resolve are stripped.
+ */
+export declare const CCA_UNSUPPORTED_SCHEMA_FIELDS: Record<string, true>;

package/dist/types/utils/schema/index.d.ts

@@ -0,0 +1,14 @@
+export * from "./adapt";
+export * from "./compatibility";
+export * from "./dereference";
+export * from "./draft";
+export * from "./equality";
+export * from "./fields";
+export * from "./json-schema-validator";
+export * from "./meta-validator";
+export * from "./normalize";
+export * from "./root-combinator";
+export * from "./spill";
+export * from "./types";
+export * from "./wire";
+export * from "./zod-decontaminate";

package/dist/types/utils/schema/json-schema-validator.d.ts

@@ -0,0 +1,12 @@
+export interface JsonSchemaValidationIssue {
+    path: PropertyKey[];
+    message: string;
+    expectedTypes?: string[];
+    keyword?: string;
+}
+export interface JsonSchemaValidationResult {
+    success: boolean;
+    issues: JsonSchemaValidationIssue[];
+}
+export declare function validateJsonSchemaValue(schema: unknown, value: unknown): JsonSchemaValidationResult;
+export declare function isJsonSchemaValueValid(schema: unknown, value: unknown): boolean;

package/dist/types/utils/schema/meta-validator.d.ts

@@ -0,0 +1,2 @@
+/** Validate that `schema` is structurally a valid JSON Schema (subset). */
+export declare function isValidJsonSchema(schema: unknown): boolean;