open-multi-agent-kit 0.79.3 → 0.80.2

package/dist/runtime/freedomd-incidents.js

@@ -0,0 +1,103 @@
+/**
+ * Freedomd provider incident monitor.
+ *
+ * Reads local incident overrides from `.omk/provider-incidents.json` and
+ * optional per-project policy files. This avoids scraping public web pages by
+ * default while still letting operators react to events like Fable 5 quickly.
+ */
+import { readFile } from "node:fs/promises";
+import { join, resolve } from "node:path";
+function parseIncidentFile(raw) {
+    try {
+        const parsed = JSON.parse(raw);
+        if (!Array.isArray(parsed.incidents))
+            return [];
+        return parsed.incidents.filter(isValidIncident);
+    }
+    catch {
+        return [];
+    }
+}
+function isValidIncident(value) {
+    if (!value || typeof value !== "object")
+        return false;
+    const incident = value;
+    return (typeof incident.providerId === "string" &&
+        typeof incident.kind === "string" &&
+        typeof incident.severity === "string" &&
+        ["availability", "policy", "export-control", "retention", "jurisdiction"].includes(incident.kind) &&
+        ["info", "warn", "block"].includes(incident.severity));
+}
+function incidentsFromEnv(env) {
+    const raw = env.OMK_PROVIDER_INCIDENTS;
+    if (!raw)
+        return [];
+    try {
+        const parsed = JSON.parse(raw);
+        if (Array.isArray(parsed))
+            return parsed.filter(isValidIncident);
+        if (parsed && typeof parsed === "object" && "incidents" in parsed) {
+            return (parsed.incidents ?? []).filter(isValidIncident);
+        }
+        return [];
+    }
+    catch {
+        return [];
+    }
+}
+export async function loadProviderIncidents(options = {}) {
+    const root = resolve(options.projectRoot ?? process.cwd());
+    const env = options.env ?? process.env;
+    const filePath = join(root, ".omk", "provider-incidents.json");
+    let fileIncidents = [];
+    try {
+        const raw = await readFile(filePath, "utf-8");
+        fileIncidents = parseIncidentFile(raw);
+    }
+    catch {
+        // Missing or unreadable file is fine; fall back to env.
+    }
+    const envIncidents = incidentsFromEnv(env);
+    const feedIncidents = await fetchFeedIncidents(options.feedUrls ?? [], options.fetch);
+    // Merge by providerId+kind, preferring the most recent and most severe.
+    const map = new Map();
+    for (const incident of [...fileIncidents, ...envIncidents, ...feedIncidents]) {
+        const key = `${incident.providerId}:${incident.kind}:${incident.runtimeMode ?? ""}`;
+        const existing = map.get(key);
+        if (!existing || severityRank(incident.severity) > severityRank(existing.severity)) {
+            map.set(key, incident);
+        }
+    }
+    return [...map.values()];
+}
+async function fetchFeedIncidents(urls, fetchImpl) {
+    if (urls.length === 0)
+        return [];
+    const fetcher = fetchImpl ?? defaultFetch;
+    const results = [];
+    for (const url of urls) {
+        try {
+            const response = await fetcher(url);
+            if (!response.ok)
+                continue;
+            const text = await response.text();
+            const parsed = parseIncidentFile(text);
+            results.push(...parsed);
+        }
+        catch {
+            // Best-effort: individual feed failures must not block routing.
+        }
+    }
+    return results;
+}
+async function defaultFetch(url) {
+    const response = await fetch(url, { signal: AbortSignal.timeout(5_000) });
+    return { ok: response.ok, text: () => response.text() };
+}
+function severityRank(severity) {
+    if (severity === "block")
+        return 2;
+    if (severity === "warn")
+        return 1;
+    return 0;
+}

package/dist/runtime/freedomd-policy.d.ts

@@ -0,0 +1,35 @@
+/**
+ * Freedomd policy compiler.
+ *
+ * Translates environment, org defaults, and optional user config into a
+ * normalized policy that drives provider-sovereignty routing, retention gates,
+ * and degraded-mode fallback decisions.
+ */
+export type FreedomdMode = "off" | "balanced" | "strict";
+export interface FreedomdProviderOverride {
+    readonly enabled: boolean;
+    readonly reason?: string;
+    readonly priority?: number;
+}
+export interface FreedomdPolicy {
+    readonly mode: FreedomdMode;
+    readonly preferLocal: boolean;
+    readonly maxRetentionDays: number;
+    readonly allowExportRestrictedProvider: boolean;
+    readonly allowProviderExceptions: boolean;
+    readonly requireLocalEvidenceEnvelope: boolean;
+    readonly providerOverrides: Readonly<Record<string, FreedomdProviderOverride>>;
+    readonly maxJurisdictionRisk: number;
+    readonly maxRetentionRisk: number;
+    readonly maxCutoffRisk: number;
+    /** Optional public/provider incident feed URLs. Best-effort only. */
+    readonly incidentFeedUrls: readonly string[];
+}
+export interface FreedomdPolicyInputs {
+    readonly env?: NodeJS.ProcessEnv;
+    readonly orgDefaults?: Partial<FreedomdPolicy>;
+    readonly taskFlags?: Partial<FreedomdPolicy>;
+}
+export declare function compileFreedomdPolicy(inputs?: FreedomdPolicyInputs): FreedomdPolicy;
+export declare function isFreedomdEnabled(policy: Pick<FreedomdPolicy, "mode">): boolean;
+export declare function explainFreedomdPolicy(policy: FreedomdPolicy): string;

package/dist/runtime/freedomd-policy.js

@@ -0,0 +1,114 @@
+/**
+ * Freedomd policy compiler.
+ *
+ * Translates environment, org defaults, and optional user config into a
+ * normalized policy that drives provider-sovereignty routing, retention gates,
+ * and degraded-mode fallback decisions.
+ */
+const DEFAULT_POLICY = {
+    mode: "off",
+    preferLocal: false,
+    maxRetentionDays: Number.POSITIVE_INFINITY,
+    allowExportRestrictedProvider: true,
+    allowProviderExceptions: true,
+    requireLocalEvidenceEnvelope: false,
+    providerOverrides: {},
+    maxJurisdictionRisk: 1.0,
+    maxRetentionRisk: 1.0,
+    maxCutoffRisk: 1.0,
+    incidentFeedUrls: [],
+};
+function parseMode(raw) {
+    if (!raw)
+        return undefined;
+    const normalized = raw.trim().toLowerCase();
+    if (normalized === "off" || normalized === "0" || normalized === "false")
+        return "off";
+    if (normalized === "balanced" || normalized === "1" || normalized === "true")
+        return "balanced";
+    if (normalized === "strict" || normalized === "2")
+        return "strict";
+    return undefined;
+}
+function parseBoolean(raw) {
+    if (raw === undefined)
+        return undefined;
+    const normalized = raw.trim().toLowerCase();
+    if (normalized === "1" || normalized === "true" || normalized === "on")
+        return true;
+    if (normalized === "0" || normalized === "false" || normalized === "off")
+        return false;
+    return undefined;
+}
+function parseNumber(raw) {
+    if (raw === undefined)
+        return undefined;
+    const value = Number(raw);
+    if (!Number.isFinite(value))
+        return undefined;
+    return value;
+}
+function mergePolicy(base, patch) {
+    return {
+        ...base,
+        ...patch,
+        providerOverrides: {
+            ...base.providerOverrides,
+            ...patch.providerOverrides,
+        },
+    };
+}
+export function compileFreedomdPolicy(inputs = {}) {
+    const env = inputs.env ?? process.env;
+    let policy = mergePolicy(DEFAULT_POLICY, inputs.orgDefaults ?? {});
+    const envMode = parseMode(env.OMK_FREEDOMD_MODE);
+    if (envMode !== undefined) {
+        policy = mergePolicy(policy, { mode: envMode });
+    }
+    const preferLocal = parseBoolean(env.OMK_PREFER_LOCAL);
+    if (preferLocal !== undefined) {
+        policy = mergePolicy(policy, { preferLocal });
+    }
+    const maxRetentionDays = parseNumber(env.OMK_MAX_RETENTION_DAYS);
+    if (maxRetentionDays !== undefined) {
+        policy = mergePolicy(policy, { maxRetentionDays });
+    }
+    const allowExportRestricted = parseBoolean(env.OMK_BLOCK_EXPORT_RESTRICTED);
+    if (allowExportRestricted !== undefined) {
+        policy = mergePolicy(policy, { allowExportRestrictedProvider: !allowExportRestricted });
+    }
+    const allowProviderExceptions = parseBoolean(env.OMK_ALLOW_PROVIDER_EXCEPTIONS);
+    if (allowProviderExceptions !== undefined) {
+        policy = mergePolicy(policy, { allowProviderExceptions });
+    }
+    const incidentFeedUrlsRaw = env.OMK_FREEDOMD_FEED_URLS;
+    if (incidentFeedUrlsRaw) {
+        const urls = incidentFeedUrlsRaw.split(",").map((u) => u.trim()).filter(Boolean);
+        policy = mergePolicy(policy, { incidentFeedUrls: urls });
+    }
+    policy = mergePolicy(policy, inputs.taskFlags ?? {});
+    if (policy.mode === "strict") {
+        policy = mergePolicy(policy, {
+            preferLocal: true,
+            allowExportRestrictedProvider: false,
+            requireLocalEvidenceEnvelope: true,
+        });
+        if (!Number.isFinite(policy.maxRetentionDays) || policy.maxRetentionDays > 0) {
+            policy = mergePolicy(policy, { maxRetentionDays: 0 });
+        }
+    }
+    return policy;
+}
+export function isFreedomdEnabled(policy) {
+    return policy.mode !== "off";
+}
+export function explainFreedomdPolicy(policy) {
+    return [
+        `mode=${policy.mode}`,
+        `preferLocal=${policy.preferLocal}`,
+        `maxRetentionDays=${Number.isFinite(policy.maxRetentionDays) ? policy.maxRetentionDays : "unlimited"}`,
+        `allowExportRestricted=${policy.allowExportRestrictedProvider}`,
+        `allowExceptions=${policy.allowProviderExceptions}`,
+        `localEvidenceEnvelope=${policy.requireLocalEvidenceEnvelope}`,
+    ].join("; ");
+}

package/dist/runtime/freedomd-router.d.ts

@@ -0,0 +1,66 @@
+/**
+ * Freedomd runtime router.
+ *
+ * Wraps the base RuntimeRouter with provider-sovereignty scoring, data-retention
+ * gating, cutoff-resilient fallback, degraded-mode planning, and local-first
+ * evidence envelopes. This is the control-plane boundary that keeps OMK loops
+ * alive when a provider becomes unavailable or policy-blocked.
+ */
+import type { AgentRunResult, AgentRuntime, AgentTask, AgentTaskSovereignty } from "./agent-runtime.js";
+import type { ContextCapsule } from "./context-capsule.js";
+import type { LocalGraphMemoryStore } from "../memory/local-graph-memory-store.js";
+import { type RuntimeRouterOptions } from "./runtime-router.js";
+import { type FreedomdMode, type FreedomdPolicy } from "./freedomd-policy.js";
+import { type ProviderIncidentState, type ProviderSovereigntyProfile, type SovereigntyScore } from "./provider-sovereignty.js";
+import { type DataRetentionGateResult } from "./data-retention-gate.js";
+import { type ProviderExceptionResult } from "./freedomd-exception.js";
+export type { FreedomdMode };
+export interface FreedomdRouterOptions extends RuntimeRouterOptions {
+    readonly freedomdMode?: FreedomdMode;
+    readonly userCountry?: string;
+    readonly sovereigntyProfiles?: Readonly<Record<string, ProviderSovereigntyProfile>>;
+    readonly incidents?: readonly ProviderIncidentState[];
+    readonly graphStore?: LocalGraphMemoryStore;
+    readonly allowRedaction?: boolean;
+    readonly projectRoot?: string;
+    readonly autoLoadIncidents?: boolean;
+    readonly promptUser?: (message: string) => Promise<string>;
+    readonly isTty?: boolean;
+}
+export interface FreedomdScoredRuntime {
+    readonly runtime: AgentRuntime;
+    readonly score: number;
+    readonly sovereignty: SovereigntyScore;
+    readonly retention: DataRetentionGateResult;
+}
+export interface FreedomdDegradedPlan {
+    readonly mode: string;
+    readonly runtime?: AgentRuntime;
+    readonly allowedCapabilities: readonly string[];
+    readonly reason: string;
+    readonly blockedOriginalAuthority?: readonly string[];
+}
+export interface FreedomdRouteResult {
+    readonly selectedRuntime?: AgentRuntime;
+    readonly fallbackChain: readonly AgentRuntime[];
+    readonly degradedPlan?: FreedomdDegradedPlan;
+    readonly sovereignty: AgentTaskSovereignty;
+    readonly diagnostics: string;
+    readonly providerException?: ProviderExceptionResult;
+}
+export declare function evaluateTaskSovereignty(task: AgentTask, policy: FreedomdPolicy, runtimes: readonly AgentRuntime[], incidents?: readonly ProviderIncidentState[]): AgentTaskSovereignty;
+export declare function scoreRuntimesWithSovereignty(task: AgentTask, runtimes: readonly AgentRuntime[], policy: FreedomdPolicy, options?: {
+    readonly profiles?: Readonly<Record<string, ProviderSovereigntyProfile>>;
+    readonly incidents?: readonly ProviderIncidentState[];
+    readonly userCountry?: string;
+    readonly allowRedaction?: boolean;
+    readonly capsule?: ContextCapsule;
+}): FreedomdScoredRuntime[];
+export declare function buildFreedomdDegradedPlan(task: AgentTask, reason: string, runtimes: readonly AgentRuntime[]): FreedomdDegradedPlan;
+export declare function createFreedomdRuntimeRouter(options?: FreedomdRouterOptions): Promise<{
+    readonly policy: FreedomdPolicy;
+    readonly baseRouter: unknown;
+    readonly freedomdRoute: (task: AgentTask, capsule: ContextCapsule) => Promise<FreedomdRouteResult>;
+    readonly scoreRuntimesWithSovereignty: (task: AgentTask) => FreedomdScoredRuntime[];
+    readonly executeTask: (task: AgentTask, capsule: ContextCapsule, signal: AbortSignal) => Promise<AgentRunResult>;
+}>;