@gajae-code/ai 0.1.1

package/dist/types/utils/oauth/openai-codex.d.ts

@@ -0,0 +1,21 @@
+import type { OAuthController, OAuthCredentials } from "./types";
+export declare function decodeJwt<T = Record<string, unknown>>(token: string): T | null;
+/**
+ * Login with OpenAI code provider OAuth
+ */
+export type OpenAICodexLoginOptions = OAuthController & {
+    /** Optional originator value for OpenAI code provider OAuth. Default: "opencode". */
+    originator?: string;
+};
+export declare function loginOpenAICodex(options: OpenAICodexLoginOptions): Promise<OAuthCredentials>;
+/**
+ * Login with OpenAI code provider using the device-code (headless) flow.
+ *
+ * Avoids a local callback server entirely — useful when port 1455 is unavailable
+ * or when the browser callback flow fails with 403 (e.g. network/proxy issues).
+ */
+export declare function loginOpenAICodexDevice(ctrl: OAuthController): Promise<OAuthCredentials>;
+/**
+ * Refresh OpenAI code provider OAuth token
+ */
+export declare function refreshOpenAICodexToken(refreshToken: string): Promise<OAuthCredentials>;

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/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,9 @@
+import type { OAuthController, OAuthCredentials } from "./types";
+/**
+ * Login to Perplexity.
+ *
+ * Tries auto-extraction from the desktop app, then runs HTTP email OTP login.
+ *
+ * No browser/manual token paste fallback is used.
+ */
+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/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,44 @@
+export type OAuthCredentials = {
+    refresh: string;
+    access: string;
+    expires: number;
+    enterpriseUrl?: string;
+    projectId?: string;
+    email?: string;
+    accountId?: string;
+};
+export type OAuthProvider = "alibaba-coding-plan" | "anthropic" | "cerebras" | "cloudflare-ai-gateway" | "cursor" | "deepseek" | "fireworks" | "firepass" | "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" | "parallel" | "perplexity" | "qianfan" | "qwen-portal" | "synthetic" | "tavily" | "together" | "venice" | "vercel-ai-gateway" | "vllm" | "xiaomi" | "zenmux" | "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;
+}
+export interface OAuthController {
+    onAuth?(info: OAuthAuthInfo): void;
+    onProgress?(message: string): void;
+    onManualCodeInput?(): Promise<string>;
+    onPrompt?(prompt: OAuthPrompt): Promise<string>;
+    signal?: AbortSignal;
+}
+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 an optional token,
+ * and returns a stored key value.
+ */
+export declare function loginVllm(options: OAuthController): Promise<string>;

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

@@ -0,0 +1,19 @@
+/**
+ * Xiaomi MiMo login flow.
+ *
+ * Xiaomi MiMo provides OpenAI-compatible models via
+ * https://api.xiaomimimo.com/v1.
+ *
+ * This is not OAuth - it's a simple API key flow:
+ * 1. Open browser to Xiaomi MiMo API key console
+ * 2. User copies their API key
+ * 3. User pastes the API key into the CLI
+ */
+import type { OAuthController } from "./types";
+/**
+ * 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>;

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,54 @@
+import type { AssistantMessage } from "../types";
+/**
+ * Check if an assistant message represents a context overflow error.
+ *
+ * This handles two cases:
+ * 1. Error-based overflow: Most providers return stopReason "error" with a
+ *    specific error message pattern.
+ * 2. Silent overflow: Some providers accept overflow requests and return
+ *    successfully. For these, we check if usage.input exceeds the context window.
+ *
+ * ## Reliability by Provider
+ *
+ * **Reliable detection (returns error with detectable message):**
+ * - Anthropic: "prompt is too long: X tokens > Y maximum"
+ * - OpenAI (Completions & Responses): "exceeds the context window"
+ * - Google Gemini: "input token count exceeds the maximum"
+ * - xAI (Grok): "maximum prompt length is X but request contains Y"
+ * - Groq: "reduce the length of the messages"
+ * - Cerebras: 400/413 status code (no body)
+ * - Mistral: 400/413 status code (no body)
+ * - HTTP 413 payload/entity-too-large variants
+ * - OpenRouter (all backends): "maximum context length is X tokens"
+ * - llama.cpp: "exceeds the available context size"
+ * - LM Studio: "greater than the context length"
+ * - Kimi For Coding: "exceeded model token limit: X (requested: Y)"
+ * - Anthropic 413: "request_too_large" (request body exceeds size limit)
+ * - HTTP 413: "Payload Too Large" / "Request Entity Too Large"
+ *
+ * **Unreliable detection:**
+ * - z.ai: Sometimes accepts overflow silently (detectable via usage.input > contextWindow),
+ *   sometimes returns rate limit errors. Pass contextWindow param to detect silent overflow.
+ * - Ollama: Silently truncates input without error. Cannot be detected via this function.
+ *   The response will have usage.input < expected, but we don't know the expected value.
+ *
+ * ## Custom Providers
+ *
+ * If you've added custom models via settings.json, this function may not detect
+ * overflow errors from those providers. To add support:
+ *
+ * 1. Send a request that exceeds the model's context window
+ * 2. Check the errorMessage in the response
+ * 3. Create a regex pattern that matches the error
+ * 4. The pattern should be added to OVERFLOW_PATTERNS in this file, or
+ *    check the errorMessage yourself before calling this function
+ *
+ * @param message - The assistant message to check
+ * @param contextWindow - Optional context window size for detecting silent overflow (z.ai)
+ * @returns true if the message indicates a context overflow
+ */
+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,23 @@
+/**
+ * Shared `host:port` parser used by the auth-broker and auth-gateway boot
+ * paths. Centralized so the two servers can't drift on what they accept (the
+ * gateway used to silently allow empty hostnames; this fixes it).
+ */
+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;

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

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

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.d.ts

@@ -0,0 +1,26 @@
+/**
+ * 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;
+}): 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,13 @@
+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 "./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;