@intutic/shared-types 1.10.0 → 1.10.1

package/dist/posturePresets.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"posturePresets.d.ts","sourceRoot":"","sources":["../src/posturePresets.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AAEH,MAAM,WAAW,aAAa;IAC5B,IAAI,EAAE,MAAM,CAAA;IACZ,KAAK,EAAE,MAAM,CAAA;IACb,WAAW,EAAE,MAAM,CAAA;IACnB,8CAA8C;IAC9C,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,CAAA;IAC1C,wEAAwE;IACxE,YAAY,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;CACtC;AAED;;GAEG;AACH,eAAO,MAAM,iBAAiB,EAAE,SAAS,aAAa,EAkD5C,CAAA;AAEV;;;;;;;GAOG;AACH,eAAO,MAAM,aAAa,EAAE,SAAS,aAAa,EA6CxC,CAAA;AAEV,MAAM,MAAM,WAAW,GAAG,UAAU,GAAG,MAAM,CAAA;AAE7C,yEAAyE;AACzE,wBAAgB,WAAW,CAAC,IAAI,EAAE,WAAW,EAAE,IAAI,EAAE,MAAM,GAAG,aAAa,GAAG,SAAS,CAGtF;AAED;;;;;;;;GAQG;AACH,MAAM,WAAW,aAAa;IAC5B,EAAE,EAAE,MAAM,CAAA;IACV,UAAU,EAAE,MAAM,CAAA;IAClB,IAAI,EAAE,MAAM,CAAA;IACZ,uFAAuF;IACvF,MAAM,EAAE,MAAM,CAAA;IACd,oFAAoF;IACpF,OAAO,EAAE,OAAO,CAAA;IAChB,KAAK,EAAE,MAAM,CAAA;IACb,MAAM,EAAE,MAAM,CAAA;IACd,WAAW,EAAE,MAAM,CAAA;CACpB"}

package/dist/posturePresets.js

@@ -0,0 +1,139 @@
+"use strict";
+/**
+ * Posture presets — named bundles over knobs that already reach enforcement.
+ *
+ * A posture is one decision ("how should governance treat this workspace?")
+ * expressed over several settings a user would otherwise have to correlate by
+ * hand. Every key a preset writes has a verified consumer TODAY:
+ *
+ * - `featureFlags.*` sync to `workspace:feature_flags:{ws}` in Valkey on every
+ *   settings write, and the proxy reads them per request (`store/valkey.rs`).
+ * - `bypassEnforcementTier` drives the sync-daemon's drift watcher.
+ * - `mcpProxyFailBehavior` decides whether a broken MCP proxy fails open or
+ *   closed.
+ * - `featureFlags.ff_sql_drop_strict_block` is read by `GET
+ *   /api/v1/policy/resolve` and applied by the sync daemon's
+ *   `buildSnapshotRules` (Wave 7, audit-remediation) to promote the hook
+ *   gate's `destructive.sql_drop` rule from warn to block.
+ *
+ * A preset key without a consumer would make the posture selector the exact
+ * inert control this product exists to remove, so adding one requires naming
+ * its reader here.
+ *
+ * Presets are DATA, applied through the same settings pipeline as a manual
+ * PUT — same merge semantics, same Valkey sync, same audit surface. Applying
+ * one records its name; editing an underlying knob afterwards clears it,
+ * because a posture that no longer matches its knobs is a label lying about
+ * the configuration.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.COST_POSTURES = exports.SECURITY_POSTURES = void 0;
+exports.findPosture = findPosture;
+/**
+ * Security postures: how enforcement behaves when a guard fires.
+ */
+exports.SECURITY_POSTURES = [
+    {
+        name: 'strict',
+        title: 'Strict',
+        description: 'Findings enforce in real time, harness configs are rewritten on drift and made ' +
+            'immutable where the OS supports it, and a broken MCP proxy fails closed. ' +
+            'The posture for regulated environments and production credentials.',
+        settings: {
+            bypassEnforcementTier: 'immutable',
+            mcpProxyFailBehavior: 'closed',
+        },
+        // ff_sql_drop_strict_block (Wave 7, audit-remediation): promotes the
+        // sync-daemon hook gate's `destructive.sql_drop` rule from warn to
+        // block, matching what the MCP path already does unconditionally. Read
+        // by `GET /api/v1/policy/resolve` (`sqlDropStrictBlock` on the
+        // response) and applied by the sync daemon's `buildSnapshotRules`
+        // (`services/sync-daemon/src/lib/policySnapshot.ts`) — a per-rule
+        // override, not a flip of `DESTRUCTIVE_TIER_SEVERITY`'s separate,
+        // evidence-gated promotion ramp for the other six destructive-command
+        // patterns. Accepts the dev-DSN false-positive risk explicitly, which is
+        // exactly the trade this posture's own description already commits to.
+        featureFlags: { ff_shadow_enforcement: false, ff_sql_drop_strict_block: true },
+    },
+    {
+        name: 'balanced',
+        title: 'Balanced',
+        description: 'Findings enforce in real time and drifted harness configs are rewritten, but ' +
+            'nothing is made immutable and a broken MCP proxy fails open rather than ' +
+            'blocking work. The default.',
+        settings: {
+            bypassEnforcementTier: 'rewrite',
+            mcpProxyFailBehavior: 'open',
+        },
+        featureFlags: { ff_shadow_enforcement: false },
+    },
+    {
+        name: 'observe',
+        title: 'Observe',
+        description: 'Every detector runs and every finding is recorded, but nothing blocks: shadow ' +
+            'enforcement, drift creates incidents instead of rewrites, MCP fails open. The ' +
+            'posture for evaluating Intutic against live traffic before letting it act.',
+        settings: {
+            bypassEnforcementTier: 'alert-only',
+            mcpProxyFailBehavior: 'open',
+        },
+        featureFlags: { ff_shadow_enforcement: true },
+    },
+];
+/**
+ * Cost postures: how aggressively the workspace pursues savings.
+ *
+ * Deliberately conservative about what "savings" may claim: routing quality is
+ * guarded against malformed/truncated/unusable responses (the Response
+ * Integrity signal), not against worse-but-well-formed ones — so the
+ * aggressive posture is named for what it does, not "no quality loss".
+ */
+exports.COST_POSTURES = [
+    {
+        name: 'savings',
+        title: 'Max savings',
+        description: 'Bandit routing enforces its selections, and both response caches serve ' +
+            'repeats without an upstream call. Routing learns from measured integrity ' +
+            'and cost; it detects malformed and truncated responses, not subtly worse ones.',
+        settings: {},
+        featureFlags: {
+            ff_bandit_routing: true,
+            ff_shadow_routing: false,
+            ff_response_cache_exact: true,
+            ff_response_cache_semantic: true,
+        },
+    },
+    {
+        name: 'balanced',
+        title: 'Balanced',
+        description: 'Routing runs in shadow — it reports what it would have picked and what that ' +
+            'would have saved, while every request is served by the model you asked for. ' +
+            'Exact-match caching on; semantic caching off.',
+        settings: {},
+        featureFlags: {
+            ff_bandit_routing: false,
+            ff_shadow_routing: true,
+            ff_response_cache_exact: true,
+            ff_response_cache_semantic: false,
+        },
+    },
+    {
+        name: 'quality-first',
+        title: 'Quality first',
+        description: 'No routing, no semantic cache: every request is served by the requested ' +
+            'model, fresh, with only byte-identical repeats served from cache.',
+        settings: {},
+        featureFlags: {
+            ff_bandit_routing: false,
+            ff_shadow_routing: false,
+            ff_response_cache_exact: true,
+            ff_response_cache_semantic: false,
+        },
+    },
+];
+/** Look up a preset, or nothing — the route turns nothing into a 400. */
+function findPosture(kind, name) {
+    const set = kind === 'security' ? exports.SECURITY_POSTURES : exports.COST_POSTURES;
+    return set.find((p) => p.name === name);
+}
+//# sourceMappingURL=posturePresets.js.map

package/dist/posturePresets.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"posturePresets.js","sourceRoot":"","sources":["../src/posturePresets.ts"],"names":[],"mappings":";AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;;;AA6HH,kCAGC;AApHD;;GAEG;AACU,QAAA,iBAAiB,GAA6B;IACzD;QACE,IAAI,EAAE,QAAQ;QACd,KAAK,EAAE,QAAQ;QACf,WAAW,EACT,iFAAiF;YACjF,2EAA2E;YAC3E,oEAAoE;QACtE,QAAQ,EAAE;YACR,qBAAqB,EAAE,WAAW;YAClC,oBAAoB,EAAE,QAAQ;SAC/B;QACD,qEAAqE;QACrE,mEAAmE;QACnE,uEAAuE;QACvE,+DAA+D;QAC/D,kEAAkE;QAClE,kEAAkE;QAClE,kEAAkE;QAClE,sEAAsE;QACtE,yEAAyE;QACzE,uEAAuE;QACvE,YAAY,EAAE,EAAE,qBAAqB,EAAE,KAAK,EAAE,wBAAwB,EAAE,IAAI,EAAE;KAC/E;IACD;QACE,IAAI,EAAE,UAAU;QAChB,KAAK,EAAE,UAAU;QACjB,WAAW,EACT,+EAA+E;YAC/E,0EAA0E;YAC1E,6BAA6B;QAC/B,QAAQ,EAAE;YACR,qBAAqB,EAAE,SAAS;YAChC,oBAAoB,EAAE,MAAM;SAC7B;QACD,YAAY,EAAE,EAAE,qBAAqB,EAAE,KAAK,EAAE;KAC/C;IACD;QACE,IAAI,EAAE,SAAS;QACf,KAAK,EAAE,SAAS;QAChB,WAAW,EACT,gFAAgF;YAChF,gFAAgF;YAChF,4EAA4E;QAC9E,QAAQ,EAAE;YACR,qBAAqB,EAAE,YAAY;YACnC,oBAAoB,EAAE,MAAM;SAC7B;QACD,YAAY,EAAE,EAAE,qBAAqB,EAAE,IAAI,EAAE;KAC9C;CACO,CAAA;AAEV;;;;;;;GAOG;AACU,QAAA,aAAa,GAA6B;IACrD;QACE,IAAI,EAAE,SAAS;QACf,KAAK,EAAE,aAAa;QACpB,WAAW,EACT,yEAAyE;YACzE,2EAA2E;YAC3E,gFAAgF;QAClF,QAAQ,EAAE,EAAE;QACZ,YAAY,EAAE;YACZ,iBAAiB,EAAE,IAAI;YACvB,iBAAiB,EAAE,KAAK;YACxB,uBAAuB,EAAE,IAAI;YAC7B,0BAA0B,EAAE,IAAI;SACjC;KACF;IACD;QACE,IAAI,EAAE,UAAU;QAChB,KAAK,EAAE,UAAU;QACjB,WAAW,EACT,8EAA8E;YAC9E,8EAA8E;YAC9E,+CAA+C;QACjD,QAAQ,EAAE,EAAE;QACZ,YAAY,EAAE;YACZ,iBAAiB,EAAE,KAAK;YACxB,iBAAiB,EAAE,IAAI;YACvB,uBAAuB,EAAE,IAAI;YAC7B,0BAA0B,EAAE,KAAK;SAClC;KACF;IACD;QACE,IAAI,EAAE,eAAe;QACrB,KAAK,EAAE,eAAe;QACtB,WAAW,EACT,0EAA0E;YAC1E,mEAAmE;QACrE,QAAQ,EAAE,EAAE;QACZ,YAAY,EAAE;YACZ,iBAAiB,EAAE,KAAK;YACxB,iBAAiB,EAAE,KAAK;YACxB,uBAAuB,EAAE,IAAI;YAC7B,0BAA0B,EAAE,KAAK;SAClC;KACF;CACO,CAAA;AAIV,yEAAyE;AACzE,SAAgB,WAAW,CAAC,IAAiB,EAAE,IAAY;IACzD,MAAM,GAAG,GAAG,IAAI,KAAK,UAAU,CAAC,CAAC,CAAC,yBAAiB,CAAC,CAAC,CAAC,qBAAa,CAAA;IACnE,OAAO,GAAG,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,IAAI,KAAK,IAAI,CAAC,CAAA;AACzC,CAAC"}

package/dist/providerVerification.d.ts

@@ -0,0 +1,64 @@
+/**
+ * Provider credential verification (LLD #70, model catalog & cohort wizard).
+ *
+ * Pure, network-free description of how to check whether a credential works —
+ * the cheapest authenticated call each provider's own API exposes. Two
+ * different executors run the same probe spec because a credential crosses a
+ * trust boundary differently depending on who holds it at verification time:
+ *
+ * - `tools/cli/src/lib/providerProbe.ts` — the CLI legitimately holds a raw
+ *   key locally before it is ever sent anywhere, and probes with it directly.
+ * - `services/control-plane/src/lib/providerVerify.ts` — probes a credential
+ *   already stored in Valkey, server-side, so the raw value never has to
+ *   leave the control plane a second time.
+ *
+ * Neither executor lives in this package (no network calls here — shared-types
+ * is pure data and types, consumed by both the CLI and the control plane).
+ * This module only describes WHAT to request; each executor decides HOW to
+ * make that request in its own runtime.
+ *
+ * Deliberately, no probe here targets `/v1/chat/completions` —
+ * `services/control-plane/__tests__/unit/monitorSeparation.test.ts` treats
+ * every fetch call to that literal URL shape as a judge/generation call
+ * requiring classification. A verification probe is neither; it must not add
+ * a site to that census.
+ *
+ * @module
+ */
+export interface ProviderProbeRequest {
+    url: string;
+    method: 'GET' | 'POST';
+    headers: Record<string, string>;
+    /** Present only for POST probes (currently: Anthropic's 1-token message). */
+    body?: string;
+}
+/**
+ * Build the cheapest authenticated request that proves a credential works,
+ * or `null` if this provider has no such probe defined yet.
+ *
+ * `fields` is the provider's credential field map exactly as stored — the
+ * same shape `PROVIDER_REGISTRY`'s `ProviderCredentialField.key`s describe
+ * (`providers.ts`), e.g. `{ apiKey: '...' }` for Anthropic, `{ apiKey, endpoint,
+ * deploymentName }` for Azure OpenAI.
+ *
+ * Bedrock and Vertex AI return `null`: verifying them means SigV4 request
+ * signing or a GCP OAuth2/JWT exchange, neither of which exists anywhere in
+ * this codebase yet (the same "real per-provider engineering, not a config
+ * change" boundary LLD #67 §3 draws around routing those two providers). A
+ * caller seeing `null` should say "cannot verify automatically," not fail
+ * the credential.
+ */
+export declare function buildVerificationProbe(provider: string, fields: Record<string, string>): ProviderProbeRequest | null;
+export type ProbeVerdict = 'valid' | 'invalid' | 'unknown';
+/**
+ * Classify a probe's HTTP response. Deliberately narrow about what counts as
+ * "invalid": only 401/403 mean the credential itself is wrong. A 429
+ * (rate-limited) or 5xx (upstream trouble) still proves the key is
+ * authenticated — reporting either as invalid would tell an operator to
+ * re-enter a working key. `unknown` covers both cases plus a request that
+ * never got a response at all (network error, timeout) — callers should
+ * treat `unknown` as "could not verify," not as a failure, and let the
+ * operator proceed.
+ */
+export declare function classifyProbeResponse(httpStatus: number): ProbeVerdict;
+//# sourceMappingURL=providerVerification.d.ts.map

package/dist/providerVerification.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"providerVerification.d.ts","sourceRoot":"","sources":["../src/providerVerification.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AAiBH,MAAM,WAAW,oBAAoB;IACnC,GAAG,EAAE,MAAM,CAAA;IACX,MAAM,EAAE,KAAK,GAAG,MAAM,CAAA;IACtB,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;IAC/B,6EAA6E;IAC7E,IAAI,CAAC,EAAE,MAAM,CAAA;CACd;AAED;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,sBAAsB,CACpC,QAAQ,EAAE,MAAM,EAChB,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,GAC7B,oBAAoB,GAAG,IAAI,CAwG7B;AAED,MAAM,MAAM,YAAY,GAAG,OAAO,GAAG,SAAS,GAAG,SAAS,CAAA;AAE1D;;;;;;;;;GASG;AACH,wBAAgB,qBAAqB,CAAC,UAAU,EAAE,MAAM,GAAG,YAAY,CAItE"}

package/dist/providerVerification.js

@@ -0,0 +1,184 @@
+"use strict";
+/**
+ * Provider credential verification (LLD #70, model catalog & cohort wizard).
+ *
+ * Pure, network-free description of how to check whether a credential works —
+ * the cheapest authenticated call each provider's own API exposes. Two
+ * different executors run the same probe spec because a credential crosses a
+ * trust boundary differently depending on who holds it at verification time:
+ *
+ * - `tools/cli/src/lib/providerProbe.ts` — the CLI legitimately holds a raw
+ *   key locally before it is ever sent anywhere, and probes with it directly.
+ * - `services/control-plane/src/lib/providerVerify.ts` — probes a credential
+ *   already stored in Valkey, server-side, so the raw value never has to
+ *   leave the control plane a second time.
+ *
+ * Neither executor lives in this package (no network calls here — shared-types
+ * is pure data and types, consumed by both the CLI and the control plane).
+ * This module only describes WHAT to request; each executor decides HOW to
+ * make that request in its own runtime.
+ *
+ * Deliberately, no probe here targets `/v1/chat/completions` —
+ * `services/control-plane/__tests__/unit/monitorSeparation.test.ts` treats
+ * every fetch call to that literal URL shape as a judge/generation call
+ * requiring classification. A verification probe is neither; it must not add
+ * a site to that census.
+ *
+ * @module
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildVerificationProbe = buildVerificationProbe;
+exports.classifyProbeResponse = classifyProbeResponse;
+/**
+ * Strip trailing `/` characters, without a regex. `endpoint`/`apiBase` are
+ * workspace-provisioned credential fields — CodeQL correctly flagged the
+ * original `.replace(/\/+$/, '')` as a polynomial-regex risk on uncontrolled
+ * input (this module is a pure function with no length bound of its own;
+ * the server-side 512-char cap in `providerCredentials.ts` is a different
+ * layer, not a guarantee this function can rely on). A plain index walk is
+ * linear by construction, with no backtracking to worry about.
+ */
+function stripTrailingSlashes(s) {
+    let end = s.length;
+    while (end > 0 && s[end - 1] === '/')
+        end--;
+    return s.slice(0, end);
+}
+/**
+ * Build the cheapest authenticated request that proves a credential works,
+ * or `null` if this provider has no such probe defined yet.
+ *
+ * `fields` is the provider's credential field map exactly as stored — the
+ * same shape `PROVIDER_REGISTRY`'s `ProviderCredentialField.key`s describe
+ * (`providers.ts`), e.g. `{ apiKey: '...' }` for Anthropic, `{ apiKey, endpoint,
+ * deploymentName }` for Azure OpenAI.
+ *
+ * Bedrock and Vertex AI return `null`: verifying them means SigV4 request
+ * signing or a GCP OAuth2/JWT exchange, neither of which exists anywhere in
+ * this codebase yet (the same "real per-provider engineering, not a config
+ * change" boundary LLD #67 §3 draws around routing those two providers). A
+ * caller seeing `null` should say "cannot verify automatically," not fail
+ * the credential.
+ */
+function buildVerificationProbe(provider, fields) {
+    switch (provider) {
+        case 'anthropic': {
+            const apiKey = fields.apiKey;
+            if (!apiKey)
+                return null;
+            // Anthropic's API has no /v1/models endpoint to probe cheaply, so the
+            // cheapest real call is a 1-max-token message — costs about one token.
+            return {
+                url: 'https://api.anthropic.com/v1/messages',
+                method: 'POST',
+                headers: {
+                    'x-api-key': apiKey,
+                    'anthropic-version': '2023-06-01',
+                    'content-type': 'application/json',
+                },
+                body: JSON.stringify({
+                    model: 'claude-haiku-4-5',
+                    max_tokens: 1,
+                    messages: [{ role: 'user', content: 'hi' }],
+                }),
+            };
+        }
+        case 'openai': {
+            const apiKey = fields.apiKey;
+            if (!apiKey)
+                return null;
+            return {
+                url: 'https://api.openai.com/v1/models',
+                method: 'GET',
+                headers: { Authorization: `Bearer ${apiKey}` },
+            };
+        }
+        case 'mistral': {
+            const apiKey = fields.apiKey;
+            if (!apiKey)
+                return null;
+            return {
+                url: 'https://api.mistral.ai/v1/models',
+                method: 'GET',
+                headers: { Authorization: `Bearer ${apiKey}` },
+            };
+        }
+        case 'openrouter': {
+            const apiKey = fields.apiKey;
+            if (!apiKey)
+                return null;
+            return {
+                url: 'https://openrouter.ai/api/v1/models',
+                method: 'GET',
+                headers: { Authorization: `Bearer ${apiKey}` },
+            };
+        }
+        case 'cohere': {
+            const apiKey = fields.apiKey;
+            if (!apiKey)
+                return null;
+            return {
+                url: 'https://api.cohere.com/v1/models',
+                method: 'GET',
+                headers: { Authorization: `Bearer ${apiKey}` },
+            };
+        }
+        case 'gemini': {
+            const apiKey = fields.apiKey;
+            if (!apiKey)
+                return null;
+            return {
+                url: `https://generativelanguage.googleapis.com/v1beta/models?key=${encodeURIComponent(apiKey)}`,
+                method: 'GET',
+                headers: {},
+            };
+        }
+        case 'azure_openai': {
+            const apiKey = fields.apiKey;
+            const endpoint = fields.endpoint ? stripTrailingSlashes(fields.endpoint) : undefined;
+            if (!apiKey || !endpoint)
+                return null;
+            return {
+                url: `${endpoint}/openai/models?api-version=2024-02-01`,
+                method: 'GET',
+                headers: { 'api-key': apiKey },
+            };
+        }
+        case 'ollama': {
+            const apiBase = fields.apiBase ? stripTrailingSlashes(fields.apiBase) : undefined;
+            if (!apiBase)
+                return null;
+            // Ollama has no API key by default — this checks reachability, not
+            // authentication. A 200 here means "something is listening," which is
+            // the most this provider's shape lets a probe promise.
+            return {
+                url: `${apiBase}/api/tags`,
+                method: 'GET',
+                headers: {},
+            };
+        }
+        case 'bedrock':
+        case 'vertex_ai':
+            return null;
+        default:
+            return null;
+    }
+}
+/**
+ * Classify a probe's HTTP response. Deliberately narrow about what counts as
+ * "invalid": only 401/403 mean the credential itself is wrong. A 429
+ * (rate-limited) or 5xx (upstream trouble) still proves the key is
+ * authenticated — reporting either as invalid would tell an operator to
+ * re-enter a working key. `unknown` covers both cases plus a request that
+ * never got a response at all (network error, timeout) — callers should
+ * treat `unknown` as "could not verify," not as a failure, and let the
+ * operator proceed.
+ */
+function classifyProbeResponse(httpStatus) {
+    if (httpStatus >= 200 && httpStatus < 300)
+        return 'valid';
+    if (httpStatus === 401 || httpStatus === 403)
+        return 'invalid';
+    return 'unknown';
+}
+//# sourceMappingURL=providerVerification.js.map

package/dist/providerVerification.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"providerVerification.js","sourceRoot":"","sources":["../src/providerVerification.ts"],"names":[],"mappings":";AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;;AAyCH,wDA2GC;AAcD,sDAIC;AApKD;;;;;;;;GAQG;AACH,SAAS,oBAAoB,CAAC,CAAS;IACrC,IAAI,GAAG,GAAG,CAAC,CAAC,MAAM,CAAA;IAClB,OAAO,GAAG,GAAG,CAAC,IAAI,CAAC,CAAC,GAAG,GAAG,CAAC,CAAC,KAAK,GAAG;QAAE,GAAG,EAAE,CAAA;IAC3C,OAAO,CAAC,CAAC,KAAK,CAAC,CAAC,EAAE,GAAG,CAAC,CAAA;AACxB,CAAC;AAUD;;;;;;;;;;;;;;;GAeG;AACH,SAAgB,sBAAsB,CACpC,QAAgB,EAChB,MAA8B;IAE9B,QAAQ,QAAQ,EAAE,CAAC;QACjB,KAAK,WAAW,CAAC,CAAC,CAAC;YACjB,MAAM,MAAM,GAAG,MAAM,CAAC,MAAM,CAAA;YAC5B,IAAI,CAAC,MAAM;gBAAE,OAAO,IAAI,CAAA;YACxB,sEAAsE;YACtE,uEAAuE;YACvE,OAAO;gBACL,GAAG,EAAE,uCAAuC;gBAC5C,MAAM,EAAE,MAAM;gBACd,OAAO,EAAE;oBACP,WAAW,EAAE,MAAM;oBACnB,mBAAmB,EAAE,YAAY;oBACjC,cAAc,EAAE,kBAAkB;iBACnC;gBACD,IAAI,EAAE,IAAI,CAAC,SAAS,CAAC;oBACnB,KAAK,EAAE,kBAAkB;oBACzB,UAAU,EAAE,CAAC;oBACb,QAAQ,EAAE,CAAC,EAAE,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,IAAI,EAAE,CAAC;iBAC5C,CAAC;aACH,CAAA;QACH,CAAC;QAED,KAAK,QAAQ,CAAC,CAAC,CAAC;YACd,MAAM,MAAM,GAAG,MAAM,CAAC,MAAM,CAAA;YAC5B,IAAI,CAAC,MAAM;gBAAE,OAAO,IAAI,CAAA;YACxB,OAAO;gBACL,GAAG,EAAE,kCAAkC;gBACvC,MAAM,EAAE,KAAK;gBACb,OAAO,EAAE,EAAE,aAAa,EAAE,UAAU,MAAM,EAAE,EAAE;aAC/C,CAAA;QACH,CAAC;QAED,KAAK,SAAS,CAAC,CAAC,CAAC;YACf,MAAM,MAAM,GAAG,MAAM,CAAC,MAAM,CAAA;YAC5B,IAAI,CAAC,MAAM;gBAAE,OAAO,IAAI,CAAA;YACxB,OAAO;gBACL,GAAG,EAAE,kCAAkC;gBACvC,MAAM,EAAE,KAAK;gBACb,OAAO,EAAE,EAAE,aAAa,EAAE,UAAU,MAAM,EAAE,EAAE;aAC/C,CAAA;QACH,CAAC;QAED,KAAK,YAAY,CAAC,CAAC,CAAC;YAClB,MAAM,MAAM,GAAG,MAAM,CAAC,MAAM,CAAA;YAC5B,IAAI,CAAC,MAAM;gBAAE,OAAO,IAAI,CAAA;YACxB,OAAO;gBACL,GAAG,EAAE,qCAAqC;gBAC1C,MAAM,EAAE,KAAK;gBACb,OAAO,EAAE,EAAE,aAAa,EAAE,UAAU,MAAM,EAAE,EAAE;aAC/C,CAAA;QACH,CAAC;QAED,KAAK,QAAQ,CAAC,CAAC,CAAC;YACd,MAAM,MAAM,GAAG,MAAM,CAAC,MAAM,CAAA;YAC5B,IAAI,CAAC,MAAM;gBAAE,OAAO,IAAI,CAAA;YACxB,OAAO;gBACL,GAAG,EAAE,kCAAkC;gBACvC,MAAM,EAAE,KAAK;gBACb,OAAO,EAAE,EAAE,aAAa,EAAE,UAAU,MAAM,EAAE,EAAE;aAC/C,CAAA;QACH,CAAC;QAED,KAAK,QAAQ,CAAC,CAAC,CAAC;YACd,MAAM,MAAM,GAAG,MAAM,CAAC,MAAM,CAAA;YAC5B,IAAI,CAAC,MAAM;gBAAE,OAAO,IAAI,CAAA;YACxB,OAAO;gBACL,GAAG,EAAE,+DAA+D,kBAAkB,CAAC,MAAM,CAAC,EAAE;gBAChG,MAAM,EAAE,KAAK;gBACb,OAAO,EAAE,EAAE;aACZ,CAAA;QACH,CAAC;QAED,KAAK,cAAc,CAAC,CAAC,CAAC;YACpB,MAAM,MAAM,GAAG,MAAM,CAAC,MAAM,CAAA;YAC5B,MAAM,QAAQ,GAAG,MAAM,CAAC,QAAQ,CAAC,CAAC,CAAC,oBAAoB,CAAC,MAAM,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC,SAAS,CAAA;YACpF,IAAI,CAAC,MAAM,IAAI,CAAC,QAAQ;gBAAE,OAAO,IAAI,CAAA;YACrC,OAAO;gBACL,GAAG,EAAE,GAAG,QAAQ,uCAAuC;gBACvD,MAAM,EAAE,KAAK;gBACb,OAAO,EAAE,EAAE,SAAS,EAAE,MAAM,EAAE;aAC/B,CAAA;QACH,CAAC;QAED,KAAK,QAAQ,CAAC,CAAC,CAAC;YACd,MAAM,OAAO,GAAG,MAAM,CAAC,OAAO,CAAC,CAAC,CAAC,oBAAoB,CAAC,MAAM,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,SAAS,CAAA;YACjF,IAAI,CAAC,OAAO;gBAAE,OAAO,IAAI,CAAA;YACzB,mEAAmE;YACnE,sEAAsE;YACtE,uDAAuD;YACvD,OAAO;gBACL,GAAG,EAAE,GAAG,OAAO,WAAW;gBAC1B,MAAM,EAAE,KAAK;gBACb,OAAO,EAAE,EAAE;aACZ,CAAA;QACH,CAAC;QAED,KAAK,SAAS,CAAC;QACf,KAAK,WAAW;YACd,OAAO,IAAI,CAAA;QAEb;YACE,OAAO,IAAI,CAAA;IACf,CAAC;AACH,CAAC;AAID;;;;;;;;;GASG;AACH,SAAgB,qBAAqB,CAAC,UAAkB;IACtD,IAAI,UAAU,IAAI,GAAG,IAAI,UAAU,GAAG,GAAG;QAAE,OAAO,OAAO,CAAA;IACzD,IAAI,UAAU,KAAK,GAAG,IAAI,UAAU,KAAK,GAAG;QAAE,OAAO,SAAS,CAAA;IAC9D,OAAO,SAAS,CAAA;AAClB,CAAC"}

package/dist/providers.d.ts

@@ -0,0 +1,93 @@
+/**
+ * Multi-provider credential registry (LLD #67, multi-provider key wizard).
+ *
+ * `services/control-plane/src/routes/providerCredentials.ts` originally
+ * hardcoded exactly 3 providers (anthropic/openai/gemini), each a single
+ * bearer API key — sufficient for those three, but LiteLLM's real provider
+ * surface includes providers needing MULTIPLE credential fields (Azure
+ * OpenAI: endpoint + deployment + key; Bedrock: AWS region + access key +
+ * secret; Vertex AI: a service-account JSON blob). This registry is a
+ * data-driven description of a provider's credential shape, so adding a
+ * new provider's *field layout* is a data change here, not new code in
+ * every place that touches credentials.
+ *
+ * Deliberately NOT exhaustive — LiteLLM supports 100+ providers. This is a
+ * representative slice spanning the shapes that actually differ (single
+ * key, multi-field cloud credential, self-hosted endpoint, structured
+ * blob), chosen so the registry's own shape is proven out before claiming
+ * to cover the full LiteLLM catalog. Adding another provider that fits one
+ * of these shapes is adding one entry, not new plumbing.
+ *
+ * `routingLive: true` means `packages/proxy` actually forwards requests to
+ * this provider today (`fetch_provider_credential` in `proxy.rs` knows its
+ * field name). `routingLive: false` means the credential can be
+ * pre-provisioned here, but nothing in the proxy calls it yet — routing
+ * support is separate, real per-provider engineering (a new `Provider`
+ * enum variant, `get_model_provider`, pricing in `pricing.rs`), not a
+ * config change. The dashboard wizard must say so, not imply the key is
+ * live the moment it's saved.
+ *
+ * @module
+ */
+/** How a single credential field should render in a form. */
+export type ProviderFieldType = 'text' | 'password' | 'textarea';
+export interface ProviderCredentialField {
+    /** Storage key within the provider's config blob, e.g. 'apiKey', 'awsRegion'. */
+    key: string;
+    label: string;
+    type: ProviderFieldType;
+    required: boolean;
+    placeholder?: string;
+    helpText?: string;
+}
+export interface ProviderDefinition {
+    /** Stable id — also the Valkey field/hash-key prefix. */
+    id: string;
+    displayName: string;
+    /** Link to the provider's own API-key docs, shown in the wizard. */
+    docsUrl?: string;
+    fields: ProviderCredentialField[];
+    /** See module doc — whether packages/proxy currently routes to this provider. */
+    routingLive: boolean;
+}
+/**
+ * The 3 providers this system supported before this registry existed —
+ * their storage format (`{provider}_api_key`, a flat string field) is
+ * unchanged here, matching what `packages/proxy/src/proxy.rs`'s
+ * `fetch_provider_credential` has always read for them.
+ *
+ * NOT the same question as a provider's `routingLive` flag. This constant
+ * decides *storage shape* (flat field vs. `{provider}_config` JSON blob);
+ * `routingLive` decides whether the proxy currently forwards requests to a
+ * provider at all. They agreed for exactly these 3 while this registry only
+ * covered its original scope, but multi-provider wizard phase 3 added real
+ * proxy routing for Mistral and OpenRouter *without* changing their storage
+ * format — `fetch_provider_credential` reads the JSON blob for both, never
+ * the flat field, so they stay off this list even though `routingLive` is
+ * now `true` for them. Adding a provider here changes what Valkey field
+ * `services/control-plane/src/routes/providerCredentials.ts` writes to —
+ * only do it alongside the matching proxy-side flat-field read, never for
+ * the "is this provider live" reason alone.
+ */
+export declare const LIVE_ROUTING_PROVIDER_IDS: readonly ["anthropic", "openai", "gemini"];
+export declare const PROVIDER_REGISTRY: ProviderDefinition[];
+export declare function getProviderDefinition(id: string): ProviderDefinition | undefined;
+export declare function isKnownProviderId(id: string): boolean;
+/**
+ * Which provider the data-plane proxy would route a model name to.
+ *
+ * A hand-maintained TS mirror of `get_model_provider` in
+ * `packages/proxy/src/proxy.rs` — the proxy's routing decision is the ground
+ * truth, and this exists so the control plane / dashboard can predict it
+ * (e.g. the BYO judge model "Test" flow fast-failing on an unprovisioned
+ * provider before making a real call, LLD #70). A parity unit test pins this
+ * against the Rust source; if the heuristic changes there, change it here in
+ * the same commit.
+ *
+ * Order matters and matches the Rust exactly: claude → gemini → '/'
+ * (OpenRouter's vendor/model namespacing — checked before the mistral
+ * prefixes so "mistralai/..." routes to OpenRouter) → mistral prefixes →
+ * OpenAI as the default arm.
+ */
+export declare function inferProviderForModel(model: string): 'anthropic' | 'gemini' | 'openrouter' | 'mistral' | 'openai';
+//# sourceMappingURL=providers.d.ts.map

package/dist/providers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"providers.d.ts","sourceRoot":"","sources":["../src/providers.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AAEH,6DAA6D;AAC7D,MAAM,MAAM,iBAAiB,GAAG,MAAM,GAAG,UAAU,GAAG,UAAU,CAAA;AAEhE,MAAM,WAAW,uBAAuB;IACtC,iFAAiF;IACjF,GAAG,EAAE,MAAM,CAAA;IACX,KAAK,EAAE,MAAM,CAAA;IACb,IAAI,EAAE,iBAAiB,CAAA;IACvB,QAAQ,EAAE,OAAO,CAAA;IACjB,WAAW,CAAC,EAAE,MAAM,CAAA;IACpB,QAAQ,CAAC,EAAE,MAAM,CAAA;CAClB;AAED,MAAM,WAAW,kBAAkB;IACjC,yDAAyD;IACzD,EAAE,EAAE,MAAM,CAAA;IACV,WAAW,EAAE,MAAM,CAAA;IACnB,oEAAoE;IACpE,OAAO,CAAC,EAAE,MAAM,CAAA;IAChB,MAAM,EAAE,uBAAuB,EAAE,CAAA;IACjC,iFAAiF;IACjF,WAAW,EAAE,OAAO,CAAA;CACrB;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,eAAO,MAAM,yBAAyB,4CAA6C,CAAA;AAEnF,eAAO,MAAM,iBAAiB,EAAE,kBAAkB,EAkFjD,CAAA;AAED,wBAAgB,qBAAqB,CAAC,EAAE,EAAE,MAAM,GAAG,kBAAkB,GAAG,SAAS,CAEhF;AAED,wBAAgB,iBAAiB,CAAC,EAAE,EAAE,MAAM,GAAG,OAAO,CAErD;AAED;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,qBAAqB,CACnC,KAAK,EAAE,MAAM,GACZ,WAAW,GAAG,QAAQ,GAAG,YAAY,GAAG,SAAS,GAAG,QAAQ,CAS9D"}