@skaile/forge-settings 1.3.3 → 2.0.0

package/src/runtime/shared/harness-providers.ts

@@ -8,11 +8,16 @@
  * Eligibility is by wire surface, never by vendor name: an entry is eligible
  * for a harness when it is an enabled `llm` entry whose `surface` the harness
  * declares. A harness that declares no surfaces accepts every `llm` entry.
+ * A host's data-zone rule then keeps out the entries outside it: such an
+ * entry is reported as `blocked-by-rule`, never eligible and never chosen.
  *
  * Browser-safe on purpose — no `node:` imports.
  */
 
-/** How many registry entries a harness can run at once (`@skaile/workspaces` `HarnessInfo.providerPlurality`). */
+import { DATA_ZONE_RULE_LABELS, dataZoneRefusal, presetDataZone } from "./data-zone";
+import type { AIProviderDataZone, AIProviderDataZoneRule } from "./provider-registry";
+
+/** How many registry entries a harness can run at once (`HarnessInfo.providerPlurality` of a Workspaces harness). */
 export type HarnessProviderPlurality = "registry" | "credentials-n" | "single";
 
 /** The slice of a harness the rule reads. `GET /api/agents` rows satisfy it. */
@@ -33,6 +38,35 @@ export interface HarnessProviderCandidate {
   surface?: string;
   /** Absent means enabled. */
   enabled?: boolean;
+  /** Catalog preset; gives the zone when {@link dataZone} is absent. */
+  preset?: string;
+  /** Effective data zone (`GET /api/providers` rows carry it). Absent: the preset's, else `transfer`. */
+  dataZone?: AIProviderDataZone;
+  /** The account's EU-processing setting is on. */
+  euProcessing?: boolean;
+}
+
+/** Why an entry on a surface the harness speaks still cannot be used. */
+export type HarnessProviderBlockReason = "blocked-by-rule";
+
+/** One entry the harness could speak to that the host's rule keeps out. */
+export interface HarnessProviderBlock {
+  id: string;
+  reason: HarnessProviderBlockReason;
+  /** The rule in force. */
+  rule: AIProviderDataZoneRule;
+  /** The rule's label ("EU only"). */
+  ruleLabel: string;
+  /** The entry's effective zone. */
+  zone: AIProviderDataZone;
+  /** What a settings table shows on the box it cannot tick. Secret-free. */
+  message: string;
+}
+
+/** What {@link resolveHarnessProviders} applies beyond the surface rule. */
+export interface HarnessProviderOptions {
+  /** The host's data-zone rule. Absent: `any`. */
+  dataZoneRule?: AIProviderDataZoneRule;
 }
 
 /**
@@ -55,8 +89,10 @@ export interface HarnessProviderResolution<
   state: HarnessProviderState;
   /** The harness can run several providers at once. */
   multiple: boolean;
-  /** Stored pick ids that are no longer eligible, deduplicated, in stored order. */
+  /** Stored pick ids that are no longer eligible (blocked ones included), deduplicated, in stored order. */
   stale: string[];
+  /** Candidates on a surface the harness speaks that the data-zone rule keeps out, in registry order. */
+  blocked: HarnessProviderBlock[];
 }
 
 /** Whether `candidate` is an enabled `llm` entry on a surface `harness` speaks. */
@@ -70,22 +106,55 @@ export function isProviderEligibleForHarness(
   return candidate.surface !== undefined && harness.surfaces.includes(candidate.surface);
 }
 
+/**
+ * Why the data-zone rule keeps `candidate` out of `harness`, or `undefined`
+ * when it does not: the candidate must be otherwise eligible
+ * ({@link isProviderEligibleForHarness}) and outside `rule`.
+ */
+export function harnessProviderBlock(
+  harness: HarnessProviderInfo,
+  candidate: HarnessProviderCandidate,
+  rule: AIProviderDataZoneRule | undefined,
+): HarnessProviderBlock | undefined {
+  if (!rule || rule === "any" || !isProviderEligibleForHarness(harness, candidate)) {
+    return undefined;
+  }
+  const zone = candidate.dataZone ?? presetDataZone(candidate.preset) ?? "transfer";
+  const message = dataZoneRefusal(rule, zone, candidate.euProcessing);
+  if (!message) return undefined;
+  return {
+    id: candidate.id,
+    reason: "blocked-by-rule",
+    rule,
+    ruleLabel: DATA_ZONE_RULE_LABELS[rule],
+    zone,
+    message,
+  };
+}
+
 /**
  * Resolve the providers a harness runs against.
  *
  * @param candidates Registry entries in registry order.
  * @param selection The stored per-harness pick (`SkaileSettings.harnessProviders[harness.id]`).
+ * @param options.dataZoneRule The host's data-zone rule: entries outside it are
+ *   `blocked`, never eligible, never auto-chosen; a stored pick of one is `stale`.
  */
 export function resolveHarnessProviders<C extends HarnessProviderCandidate>(
   harness: HarnessProviderInfo,
   candidates: readonly C[],
   selection: readonly string[] | undefined,
+  options: HarnessProviderOptions = {},
 ): HarnessProviderResolution<C> {
   const multiple =
     harness.providerPlurality === "registry" || harness.providerPlurality === "credentials-n";
-  const eligible = candidates.filter((candidate) =>
-    isProviderEligibleForHarness(harness, candidate),
-  );
+  const blocked: HarnessProviderBlock[] = [];
+  const eligible = candidates.filter((candidate) => {
+    if (!isProviderEligibleForHarness(harness, candidate)) return false;
+    const block = harnessProviderBlock(harness, candidate, options.dataZoneRule);
+    if (block) blocked.push(block);
+    return !block;
+  });
   const eligibleIds = new Set(eligible.map((candidate) => candidate.id));
   const picked = new Set(selection ?? []);
   const stale = [...picked].filter((id) => !eligibleIds.has(id));
@@ -100,10 +169,11 @@ export function resolveHarnessProviders<C extends HarnessProviderCandidate>(
       state: "chosen",
       multiple,
       stale,
+      blocked,
     };
   }
   if (eligible.length === 0) {
-    return { eligible, selected: [], state: "none-eligible", multiple, stale };
+    return { eligible, selected: [], state: "none-eligible", multiple, stale, blocked };
   }
   if (eligible.length === 1 || multiple) {
     return {
@@ -112,7 +182,8 @@ export function resolveHarnessProviders<C extends HarnessProviderCandidate>(
       state: "auto",
       multiple,
       stale,
+      blocked,
     };
   }
-  return { eligible, selected: [], state: "needs-choice", multiple, stale };
+  return { eligible, selected: [], state: "needs-choice", multiple, stale, blocked };
 }

package/src/runtime/shared/harnesses.ts

@@ -32,3 +32,28 @@ export const DEFAULT_ENABLED_HARNESSES = ["omp", "claude-sdk", "codex"] as const
 export function isExperimentalHarness(id: string): boolean {
   return !(DEFAULT_ENABLED_HARNESSES as readonly string[]).includes(id);
 }
+
+/**
+ * The model roles ("models per task") each multi-model harness renders, keyed by
+ * harness id. A harness absent here runs one model and takes no roles.
+ */
+export const HARNESS_ROLES: Readonly<Record<string, readonly string[]>> = {
+  omp: [
+    "default",
+    "smol",
+    "slow",
+    "vision",
+    "plan",
+    "designer",
+    "commit",
+    "tiny",
+    "task",
+    "advisor",
+  ],
+  continue: ["chat", "edit", "apply", "autocomplete", "embed", "rerank", "summarize"],
+};
+
+/** The role ids `harnessId` supports ({@link HARNESS_ROLES}); empty for a one-model harness. */
+export function harnessRoleIds(harnessId: string): string[] {
+  return [...(HARNESS_ROLES[harnessId] ?? [])];
+}