@cavi-ai/api-client 0.1.0

package/dist/core/ws/targets.js

@@ -0,0 +1,61 @@
+/**
+ * Resolve paired HTTP and WebSocket targets from any supported input scheme:
+ * `http://`, `https://`, `ws://`, or `wss://`.
+ *
+ * HTTP(S) inputs preserve their pathname for `httpBase` and use `/ws` for the
+ * socket path. WS(S) inputs preserve their socket pathname and expose the HTTP
+ * origin as `httpBase`.
+ */
+export function resolveHttpWebSocketTargets(baseUrl) {
+    const trimmed = baseUrl.replace(/\/+$/u, "");
+    const url = new URL(trimmed);
+    let httpProtocol;
+    let wsProtocol;
+    switch (url.protocol) {
+        case "http:":
+            httpProtocol = "http:";
+            wsProtocol = "ws:";
+            break;
+        case "https:":
+            httpProtocol = "https:";
+            wsProtocol = "wss:";
+            break;
+        case "ws:":
+            httpProtocol = "http:";
+            wsProtocol = "ws:";
+            break;
+        case "wss:":
+            httpProtocol = "https:";
+            wsProtocol = "wss:";
+            break;
+        default:
+            throw new Error(`resolveHttpWebSocketTargets: unsupported scheme "${url.protocol.replace(/:$/u, "")}". Expected one of http, https, ws, wss.`);
+    }
+    const pathname = url.pathname === "/" ? "" : url.pathname.replace(/\/+$/u, "");
+    const explicitWsInput = url.protocol === "ws:" || url.protocol === "wss:";
+    const httpBase = `${httpProtocol}//${url.host}${explicitWsInput ? "" : pathname}`;
+    const wsPath = explicitWsInput ? pathname || "/ws" : "/ws";
+    const wsUrl = `${wsProtocol}//${url.host}${wsPath}`;
+    return {
+        httpBase,
+        wsUrl,
+    };
+}
+/**
+ * Safe variant of {@link resolveHttpWebSocketTargets}; returns null for empty,
+ * malformed, or unsupported values.
+ */
+export function tryResolveHttpWebSocketTargets(baseUrl) {
+    const trimmed = baseUrl.trim().replace(/\/+$/u, "");
+    if (!trimmed) {
+        return null;
+    }
+    try {
+        return resolveHttpWebSocketTargets(trimmed);
+    }
+    catch {
+        return null;
+    }
+}
+export const resolveGatewayTargets = resolveHttpWebSocketTargets;
+export const tryResolveGatewayTargets = tryResolveHttpWebSocketTargets;

package/dist/extensions/cavi/adapters/cavi-control-adapters/gateway-ws-loaders.d.ts

@@ -0,0 +1,21 @@
+import type { GatewayWebSocketClient } from "../../../../core/ws/index.js";
+import type { JsonHttpRequest } from "../../../../core/http/json-client.js";
+import { type CreateGatewayWsSnapshotLoadersOptions } from "./gateway-ws-snapshot-loaders.js";
+export declare function createGatewayWsLoaders(deps: {
+    client: GatewayWebSocketClient | null | undefined;
+    requestJson: JsonHttpRequest;
+    snapshotOptions?: CreateGatewayWsSnapshotLoadersOptions;
+}): {
+    loadOverview: () => Promise<import("../../../../index.js").DataEnvelope<import("../../../../index.js").OverviewSnapshot>>;
+    loadAgentRuns: (filters: import("../../../../index.js").AgentRunsFilters) => Promise<import("../../../../index.js").DataEnvelope<import("../../../../index.js").GatewaySessionRunsSnapshot>>;
+    loadRunDetail: (key: string) => Promise<import("../../../../index.js").DataEnvelope<import("../../../../index.js").GatewaySessionRunDetailSnapshot>>;
+    loadRoutingMatrix: (windowDays: number) => Promise<import("../../../../index.js").DataEnvelope<import("../../../../index.js").RoutingMatrixSnapshot>>;
+    loadIncidents: () => Promise<import("../../../../index.js").DataEnvelope<import("../../../../index.js").IncidentsSnapshot>>;
+    loadCostHistory: (range: import("../../../../index.js").CostHistoryRange) => Promise<import("../../../../index.js").DataEnvelope<import("../../../../index.js").CostHistorySnapshot>>;
+    loadSessionsListRaw: (params: import("../../../../index.js").SessionsListRequestParams) => Promise<import("../../../../index.js").SessionsListPayloadWithCache>;
+    loadSessionsUsageRaw: (params: Record<string, unknown>) => Promise<import("../../../../index.js").SessionsUsagePayload>;
+    loadSessionsPreviewRaw: (params: import("../../../../index.js").SessionsPreviewRequestParams) => Promise<import("../../../../index.js").SessionsPreviewPayload>;
+    loadSessionDetailRaw: (params: import("../../../../index.js").SessionDetailRequestParams) => Promise<import("../../../../index.js").SessionDetailPayload>;
+    patchSessionRaw: (params: import("../../../../index.js").SessionPatchInput) => Promise<void>;
+};
+//# sourceMappingURL=gateway-ws-loaders.d.ts.map

package/dist/extensions/cavi/adapters/cavi-control-adapters/gateway-ws-loaders.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"gateway-ws-loaders.d.ts","sourceRoot":"","sources":["../../../../../src/extensions/cavi/adapters/cavi-control-adapters/gateway-ws-loaders.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,8BAA8B,CAAC;AAG3E,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,sCAAsC,CAAC;AAC5E,OAAO,EAEL,KAAK,qCAAqC,EAC3C,MAAM,kCAAkC,CAAC;AAE1C,wBAAgB,sBAAsB,CAAC,IAAI,EAAE;IAC3C,MAAM,EAAE,sBAAsB,GAAG,IAAI,GAAG,SAAS,CAAC;IAClD,WAAW,EAAE,eAAe,CAAC;IAC7B,eAAe,CAAC,EAAE,qCAAqC,CAAC;CACzD;;;;;;;;;;;;EAmBA"}

package/dist/extensions/cavi/adapters/cavi-control-adapters/gateway-ws-loaders.js

@@ -0,0 +1,22 @@
+import { createSessionLoaders } from "../../../../core/gateway/snapshots/session-loaders.js";
+import { createGatewaySystemLoaders } from "../../../../core/gateway/snapshots/system-loaders.js";
+import { createGatewayWsSnapshotLoaders, } from "./gateway-ws-snapshot-loaders.js";
+export function createGatewayWsLoaders(deps) {
+    const { client, requestJson } = deps;
+    const sessionLoaders = createSessionLoaders(client, { requestJson });
+    const systemLoaders = createGatewaySystemLoaders(client);
+    const snapshotLoaders = createGatewayWsSnapshotLoaders({
+        sessionLoaders,
+        systemLoaders,
+        requestJson,
+        options: deps.snapshotOptions,
+    });
+    return {
+        loadSessionsListRaw: sessionLoaders.loadSessionsListRaw,
+        loadSessionsUsageRaw: sessionLoaders.loadSessionsUsageRaw,
+        loadSessionsPreviewRaw: sessionLoaders.loadSessionsPreviewRaw,
+        loadSessionDetailRaw: sessionLoaders.loadSessionDetailRaw,
+        patchSessionRaw: sessionLoaders.patchSession,
+        ...snapshotLoaders,
+    };
+}

package/dist/extensions/cavi/adapters/cavi-control-adapters/gateway-ws-snapshot-loaders.d.ts

@@ -0,0 +1,30 @@
+import type { SessionLoaders } from "../../../../core/gateway/snapshots/session-loaders.js";
+import { resolveGatewaySnapshotFallbacks, type GatewaySnapshotBindingResolver, type GatewaySnapshotFallbackMode, type GatewaySnapshotFallbacks, type GatewaySnapshotFallbackProvider, type GatewayCostHistoryFallback } from "../../../../core/gateway/snapshots/loaders.js";
+import { type DataEnvelope } from "../../../../core/gateway/envelope/index.js";
+import { type JsonHttpRequest } from "../../../../core/http/json-client.js";
+import type { GatewaySessionRunDetailSnapshot, AgentRunsFilters, GatewaySessionRunsSnapshot, CostHistoryRange, CostHistorySnapshot, IncidentsSnapshot, OverviewSnapshot, RoutingMatrixSnapshot } from "../../../../core/gateway/snapshots/contracts.js";
+import type { GatewaySystemLoaders } from "../../../../core/gateway/snapshots/system-loaders.js";
+export type CaviSnapshotFallbackMode = GatewaySnapshotFallbackMode | "compat";
+export type GatewayWsSnapshotLoaders = {
+    loadOverview: () => Promise<DataEnvelope<OverviewSnapshot>>;
+    loadAgentRuns: (filters: AgentRunsFilters) => Promise<DataEnvelope<GatewaySessionRunsSnapshot>>;
+    loadRunDetail: (key: string) => Promise<DataEnvelope<GatewaySessionRunDetailSnapshot>>;
+    loadRoutingMatrix: (windowDays: number) => Promise<DataEnvelope<RoutingMatrixSnapshot>>;
+    loadIncidents: () => Promise<DataEnvelope<IncidentsSnapshot>>;
+    loadCostHistory: (range: CostHistoryRange) => Promise<DataEnvelope<CostHistorySnapshot>>;
+};
+export type CreateGatewayWsSnapshotLoadersOptions = {
+    fallbackMode?: CaviSnapshotFallbackMode;
+    fallbackProvider?: GatewaySnapshotFallbackProvider | null;
+    snapshotFallbacks?: Partial<GatewaySnapshotFallbacks>;
+    costHistoryFallback?: GatewayCostHistoryFallback | null;
+    resolveBinding?: GatewaySnapshotBindingResolver | null;
+};
+export declare function resolveCaviSnapshotFallbacks(options?: CreateGatewayWsSnapshotLoadersOptions): ReturnType<typeof resolveGatewaySnapshotFallbacks>;
+export declare function createGatewayWsSnapshotLoaders(deps: {
+    sessionLoaders: SessionLoaders;
+    systemLoaders: GatewaySystemLoaders;
+    requestJson: JsonHttpRequest;
+    options?: CreateGatewayWsSnapshotLoadersOptions;
+}): GatewayWsSnapshotLoaders;
+//# sourceMappingURL=gateway-ws-snapshot-loaders.d.ts.map

package/dist/extensions/cavi/adapters/cavi-control-adapters/gateway-ws-snapshot-loaders.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"gateway-ws-snapshot-loaders.d.ts","sourceRoot":"","sources":["../../../../../src/extensions/cavi/adapters/cavi-control-adapters/gateway-ws-snapshot-loaders.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,uDAAuD,CAAC;AAC5F,OAAO,EAEL,+BAA+B,EAC/B,KAAK,8BAA8B,EACnC,KAAK,2BAA2B,EAChC,KAAK,wBAAwB,EAE7B,KAAK,+BAA+B,EACpC,KAAK,0BAA0B,EAChC,MAAM,+CAA+C,CAAC;AACvD,OAAO,EAAE,KAAK,YAAY,EAAgB,MAAM,4CAA4C,CAAC;AAC7F,OAAO,EACL,KAAK,eAAe,EAErB,MAAM,sCAAsC,CAAC;AAI9C,OAAO,KAAK,EACV,+BAA+B,EAC/B,gBAAgB,EAChB,0BAA0B,EAC1B,gBAAgB,EAChB,mBAAmB,EACnB,iBAAiB,EACjB,gBAAgB,EAChB,qBAAqB,EACtB,MAAM,iDAAiD,CAAC;AACzD,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,sDAAsD,CAAC;AAEjG,MAAM,MAAM,wBAAwB,GAAG,2BAA2B,GAAG,QAAQ,CAAC;AAE9E,MAAM,MAAM,wBAAwB,GAAG;IACrC,YAAY,EAAE,MAAM,OAAO,CAAC,YAAY,CAAC,gBAAgB,CAAC,CAAC,CAAC;IAC5D,aAAa,EAAE,CACb,OAAO,EAAE,gBAAgB,KACtB,OAAO,CAAC,YAAY,CAAC,0BAA0B,CAAC,CAAC,CAAC;IACvD,aAAa,EAAE,CACb,GAAG,EAAE,MAAM,KACR,OAAO,CAAC,YAAY,CAAC,+BAA+B,CAAC,CAAC,CAAC;IAC5D,iBAAiB,EAAE,CACjB,UAAU,EAAE,MAAM,KACf,OAAO,CAAC,YAAY,CAAC,qBAAqB,CAAC,CAAC,CAAC;IAClD,aAAa,EAAE,MAAM,OAAO,CAAC,YAAY,CAAC,iBAAiB,CAAC,CAAC,CAAC;IAC9D,eAAe,EAAE,CACf,KAAK,EAAE,gBAAgB,KACpB,OAAO,CAAC,YAAY,CAAC,mBAAmB,CAAC,CAAC,CAAC;CACjD,CAAC;AAEF,MAAM,MAAM,qCAAqC,GAAG;IAClD,YAAY,CAAC,EAAE,wBAAwB,CAAC;IACxC,gBAAgB,CAAC,EAAE,+BAA+B,GAAG,IAAI,CAAC;IAC1D,iBAAiB,CAAC,EAAE,OAAO,CAAC,wBAAwB,CAAC,CAAC;IACtD,mBAAmB,CAAC,EAAE,0BAA0B,GAAG,IAAI,CAAC;IACxD,cAAc,CAAC,EAAE,8BAA8B,GAAG,IAAI,CAAC;CACxD,CAAC;AAEF,wBAAgB,4BAA4B,CAC1C,OAAO,GAAE,qCAA0C,GAClD,UAAU,CAAC,OAAO,+BAA+B,CAAC,CAepD;AAWD,wBAAgB,8BAA8B,CAAC,IAAI,EAAE;IACnD,cAAc,EAAE,cAAc,CAAC;IAC/B,aAAa,EAAE,oBAAoB,CAAC;IACpC,WAAW,EAAE,eAAe,CAAC;IAC7B,OAAO,CAAC,EAAE,qCAAqC,CAAC;CACjD,GAAG,wBAAwB,CA4D3B"}

package/dist/extensions/cavi/adapters/cavi-control-adapters/gateway-ws-snapshot-loaders.js

@@ -0,0 +1,72 @@
+import { createGatewaySnapshotLoaders, resolveGatewaySnapshotFallbacks, } from "../../../../core/gateway/snapshots/loaders.js";
+import { withFallback } from "../../../../core/gateway/envelope/index.js";
+import { withQuery, } from "../../../../core/http/json-client.js";
+import { describeHttpContract } from "../../../../core/http/contracts.js";
+import { CAVI_CONTROL_API_ENDPOINTS } from "../../contracts/paths.js";
+import { createCaviSnapshotFallbackProvider } from "../../fallbacks/provider.js";
+export function resolveCaviSnapshotFallbacks(options = {}) {
+    const mode = options.fallbackMode ?? "empty";
+    const overrides = {
+        ...(options.snapshotFallbacks ?? {}),
+    };
+    if ("costHistoryFallback" in options) {
+        overrides.costHistory = options.costHistoryFallback ?? null;
+    }
+    const resolved = resolveGatewaySnapshotFallbacks({
+        mode: mode === "compat" ? "empty" : mode,
+        provider: options.fallbackProvider ??
+            (mode === "compat" ? createCaviSnapshotFallbackProvider() : null),
+        overrides,
+    });
+    return resolved;
+}
+function gatewayEnvelope(data) {
+    return {
+        data,
+        source: "gateway",
+        fetchedAt: Date.now(),
+        contractGaps: [],
+    };
+}
+export function createGatewayWsSnapshotLoaders(deps) {
+    const { requestJson } = deps;
+    const fallbacks = resolveCaviSnapshotFallbacks(deps.options);
+    const coreLoaders = createGatewaySnapshotLoaders({
+        sessionLoaders: deps.sessionLoaders,
+        systemLoaders: deps.systemLoaders,
+        options: {
+            fallbacks: fallbacks.snapshots,
+            resolveBinding: deps.options?.resolveBinding ?? null,
+        },
+    });
+    return {
+        loadOverview: coreLoaders.loadOverview,
+        loadAgentRuns: async (filters) => await coreLoaders.loadAgentRuns(filters),
+        loadRunDetail: async (key) => await coreLoaders.loadRunDetail(key),
+        loadRoutingMatrix: async (windowDays) => await coreLoaders.loadRoutingMatrix(windowDays),
+        loadIncidents: coreLoaders.loadIncidents,
+        loadCostHistory: async (range) => deps.options?.fallbackMode === "none"
+            ? gatewayEnvelope(await requestJson(withQuery(CAVI_CONTROL_API_ENDPOINTS.costHistory, { range })))
+            : await withFallback({
+                area: "cost-history",
+                expectedContract: describeHttpContract("GET", CAVI_CONTROL_API_ENDPOINTS.costHistory),
+                note: "Cost history endpoint unavailable",
+                fallback: fallbacks.costHistory
+                    ? (typeof fallbacks.costHistory === "function"
+                        ? fallbacks.costHistory(range)
+                        : fallbacks.costHistory)
+                    : {
+                        range,
+                        resolution: "none",
+                        generatedAt: Date.now(),
+                        buckets: [],
+                        totals: {
+                            totalTokens: 0,
+                            estimatedCostUsd: 0,
+                            totalErrors: 0,
+                        },
+                    },
+                run: async () => await requestJson(withQuery(CAVI_CONTROL_API_ENDPOINTS.costHistory, { range })),
+            }),
+    };
+}

package/dist/extensions/cavi/adapters/cavi-control-adapters/library-live.d.ts

@@ -0,0 +1,4 @@
+import type { FleetLibrarySnapshot } from "../../domain/index.js";
+import type { JsonHttpRequest } from "../../../../core/http/json-client.js";
+export declare function loadFleetLibraryLive(requestJson: JsonHttpRequest): Promise<FleetLibrarySnapshot>;
+//# sourceMappingURL=library-live.d.ts.map

package/dist/extensions/cavi/adapters/cavi-control-adapters/library-live.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"library-live.d.ts","sourceRoot":"","sources":["../../../../../src/extensions/cavi/adapters/cavi-control-adapters/library-live.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,oBAAoB,EAAqB,MAAM,uBAAuB,CAAC;AACrF,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,sCAAsC,CAAC;AAsG5E,wBAAsB,oBAAoB,CACxC,WAAW,EAAE,eAAe,GAC3B,OAAO,CAAC,oBAAoB,CAAC,CAc/B"}

package/dist/extensions/cavi/adapters/cavi-control-adapters/library-live.js

@@ -0,0 +1,66 @@
+import { requestLibraryApiJson } from "../../library/api.js";
+import { getPortalTeamIdentity } from "../../registry/canonical-team-registry.js";
+import { listPortalLibraryRefs } from "../../registry/portal-library-registry.js";
+function listTeamLibraryRefs() {
+    return listPortalLibraryRefs().filter((ref) => ref.scope === "team" && ref.ownerPortalId);
+}
+function resolveTeamMeta(ref) {
+    if (ref.ownerPortalId) {
+        const team = getPortalTeamIdentity(ref.ownerPortalId);
+        return {
+            name: team.displayName || team.name || ref.libraryTeamId,
+            lead: team.lead ?? team.dispatchDefaultAlias ?? ref.ownerPortalId,
+        };
+    }
+    return { name: ref.libraryTeamId, lead: "unknown" };
+}
+function numberFromStatus(value, fallback = 0) {
+    return typeof value === "number" && Number.isFinite(value) ? value : fallback;
+}
+function buildTeamStatus(ref, fleetStatus) {
+    const meta = resolveTeamMeta(ref);
+    return {
+        teamId: ref.libraryTeamId,
+        teamName: meta.name,
+        lead: meta.lead,
+        inboxCount: 0,
+        candidatesCount: 0,
+        promotedCount: 0,
+        rejectedCount: 0,
+        recentPromotions: [],
+        qmdHealth: {
+            lastIndexedAt: fleetStatus.last_ingest_at ?? null,
+            collectionSize: numberFromStatus(fleetStatus.total_processed, numberFromStatus(fleetStatus.processed)),
+            healthy: fleetStatus.status === "ok",
+        },
+    };
+}
+async function fetchFleetStatus(requestJson) {
+    return await requestLibraryApiJson(requestJson, "/fleet-status");
+}
+function buildSigmundStatus(data) {
+    const status = data.sigmund_status === "online"
+        ? "online"
+        : data.sigmund_status === "offline"
+            ? "offline"
+            : data.status === "ok"
+                ? "online"
+                : "unknown";
+    return {
+        status: status,
+        lastIngestAt: data.last_ingest_at ?? null,
+        totalProcessed: numberFromStatus(data.total_processed, numberFromStatus(data.processed)),
+    };
+}
+export async function loadFleetLibraryLive(requestJson) {
+    const teamLibraryRefs = listTeamLibraryRefs();
+    if (teamLibraryRefs.length === 0) {
+        throw new Error("Team registry config does not define team library refs. Load TEAM_REGISTRY_CONFIG before loading fleet library status.");
+    }
+    const fleetStatus = await fetchFleetStatus(requestJson);
+    return {
+        generatedAt: Date.now(),
+        teams: teamLibraryRefs.map((ref) => buildTeamStatus(ref, fleetStatus)),
+        sigmund: buildSigmundStatus(fleetStatus),
+    };
+}

package/dist/extensions/cavi/adapters/cavi-control-adapters/operator-control-live.d.ts

@@ -0,0 +1,7 @@
+import type { GatewayWebSocketClient } from "../../../../core/ws/index.js";
+import { type DataEnvelope } from "../../../../core/gateway/envelope/index.js";
+import { type JsonHttpRequest } from "../../../../core/http/json-client.js";
+import type { OperatorControlSnapshot } from "../../domain/index.js";
+export type OperatorControlFallback = OperatorControlSnapshot | (() => OperatorControlSnapshot);
+export declare function loadOperatorControlLive(requestJson: JsonHttpRequest, client: GatewayWebSocketClient | null | undefined, fallback?: OperatorControlFallback | null): Promise<DataEnvelope<OperatorControlSnapshot>>;
+//# sourceMappingURL=operator-control-live.d.ts.map

package/dist/extensions/cavi/adapters/cavi-control-adapters/operator-control-live.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"operator-control-live.d.ts","sourceRoot":"","sources":["../../../../../src/extensions/cavi/adapters/cavi-control-adapters/operator-control-live.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,8BAA8B,CAAC;AAC3E,OAAO,EAGL,KAAK,YAAY,EAClB,MAAM,4CAA4C,CAAC;AACpD,OAAO,EACL,KAAK,eAAe,EAErB,MAAM,sCAAsC,CAAC;AAC9C,OAAO,KAAK,EACV,uBAAuB,EACxB,MAAM,uBAAuB,CAAC;AA8E/B,MAAM,MAAM,uBAAuB,GAC/B,uBAAuB,GACvB,CAAC,MAAM,uBAAuB,CAAC,CAAC;AAkFpC,wBAAsB,uBAAuB,CAC3C,WAAW,EAAE,eAAe,EAC5B,MAAM,EAAE,sBAAsB,GAAG,IAAI,GAAG,SAAS,EACjD,QAAQ,CAAC,EAAE,uBAAuB,GAAG,IAAI,GACxC,OAAO,CAAC,YAAY,CAAC,uBAAuB,CAAC,CAAC,CAmPhD"}

package/dist/extensions/cavi/adapters/cavi-control-adapters/operator-control-live.js

@@ -0,0 +1,318 @@
+import { fallbackGap, } from "../../../../core/gateway/envelope/index.js";
+import { withQuery, } from "../../../../core/http/json-client.js";
+import { OPERATOR_MEMORY_SAMPLE_LIMIT, OPERATOR_TASK_SAMPLE_LIMIT, OPERATOR_WORKER_TASK_SAMPLE_LIMIT, } from "../../operator-control/constants.js";
+import { createEmptyOperatorMemory, createEmptyOperatorRegistry, createEmptyOperatorStatus, createEmptyOperatorTasks, createEmptyWorkerReady, createEmptyWorkerTasks, } from "../../operator-control/defaults.js";
+import { OPERATOR_API, operatorControlExpectedContractSummary, } from "../../contracts/paths.js";
+import { loadOperatorControlSection } from "../../operator-control/load-section.js";
+const OPERATOR_FULL_FALLBACK_BACKOFF_MS = 15_000;
+const fullFallbackByRequestJson = new WeakMap();
+function expectedContract(wsContract, httpPath) {
+    return `${wsContract} (fallback: GET ${httpPath})`;
+}
+function buildAvailableSectionStatus(params) {
+    return {
+        status: {
+            available: true,
+            authoritative: true,
+            error: null,
+            sampleLimit: null,
+        },
+        registryDetail: {
+            available: true,
+            authoritative: true,
+            error: null,
+            sampleLimit: null,
+        },
+        tasks: {
+            available: true,
+            authoritative: false,
+            error: null,
+            sampleLimit: params.tasksLimit,
+        },
+        memory: {
+            available: true,
+            authoritative: false,
+            error: null,
+            sampleLimit: params.memoryLimit,
+        },
+        workerReady: {
+            available: true,
+            authoritative: true,
+            error: null,
+            sampleLimit: null,
+        },
+        workerTasks: {
+            available: true,
+            authoritative: false,
+            error: null,
+            sampleLimit: params.workerTasksLimit,
+        },
+    };
+}
+function createUnavailableSectionStatus() {
+    const unavailable = {
+        available: false,
+        authoritative: false,
+        error: "Operator control unavailable",
+        sampleLimit: null,
+    };
+    return {
+        status: { ...unavailable, authoritative: true },
+        registryDetail: { ...unavailable, authoritative: true },
+        tasks: { ...unavailable, sampleLimit: OPERATOR_TASK_SAMPLE_LIMIT },
+        memory: { ...unavailable, sampleLimit: OPERATOR_MEMORY_SAMPLE_LIMIT },
+        workerReady: { ...unavailable, authoritative: true },
+        workerTasks: { ...unavailable, sampleLimit: OPERATOR_WORKER_TASK_SAMPLE_LIMIT },
+    };
+}
+function createEmptyOperatorControlSnapshot() {
+    return {
+        status: createEmptyOperatorStatus(),
+        registryDetail: createEmptyOperatorRegistry(),
+        tasks: createEmptyOperatorTasks(),
+        memory: createEmptyOperatorMemory(),
+        workerReady: createEmptyWorkerReady(),
+        workerTasks: createEmptyWorkerTasks(),
+        sectionStatus: createUnavailableSectionStatus(),
+    };
+}
+function resolveOperatorControlFallback(fallback) {
+    if (!fallback) {
+        return createEmptyOperatorControlSnapshot();
+    }
+    return typeof fallback === "function" ? fallback() : fallback;
+}
+async function requestOperatorSnapshot(params) {
+    const snapshotParams = {
+        taskLimit: OPERATOR_TASK_SAMPLE_LIMIT,
+        memoryLimit: OPERATOR_MEMORY_SAMPLE_LIMIT,
+        workerTaskLimit: OPERATOR_WORKER_TASK_SAMPLE_LIMIT,
+    };
+    const httpPath = withQuery(OPERATOR_API.snapshot, snapshotParams);
+    if (params.client) {
+        try {
+            return await params.client.request("operator.snapshot", snapshotParams);
+        }
+        catch {
+            // Ignore WS aggregate failures and continue with the HTTP aggregate endpoint.
+        }
+    }
+    return await params.requestJson(httpPath);
+}
+async function requestOperatorSection(params) {
+    if (params.client) {
+        try {
+            return await params.client.request(params.wsMethod, params.wsParams ?? {});
+        }
+        catch {
+            // Ignore WS failures and continue with the HTTP operator endpoint.
+        }
+    }
+    return await params.requestJson(params.httpPath);
+}
+export async function loadOperatorControlLive(requestJson, client, fallback) {
+    const cachedFullFallback = fullFallbackByRequestJson.get(requestJson);
+    if (cachedFullFallback && cachedFullFallback.expiresAt > Date.now()) {
+        return {
+            ...cachedFullFallback.envelope,
+            fetchedAt: Date.now(),
+        };
+    }
+    try {
+        const aggregate = await requestOperatorSnapshot({ client, requestJson });
+        fullFallbackByRequestJson.delete(requestJson);
+        return {
+            data: {
+                ...aggregate,
+                sectionStatus: aggregate.sectionStatus ??
+                    buildAvailableSectionStatus({
+                        tasksLimit: OPERATOR_TASK_SAMPLE_LIMIT,
+                        memoryLimit: OPERATOR_MEMORY_SAMPLE_LIMIT,
+                        workerTasksLimit: OPERATOR_WORKER_TASK_SAMPLE_LIMIT,
+                    }),
+            },
+            source: "gateway",
+            fetchedAt: Date.now(),
+            contractGaps: [],
+        };
+    }
+    catch {
+        // Fall back to section-by-section reads for older gateways or partial outages.
+    }
+    const [statusResult, registryResult, tasksResult, memoryResult, workerReadyResult, workerTasksResult,] = await Promise.all([
+        loadOperatorControlSection({
+            key: "status",
+            run: async () => await requestOperatorSection({
+                client,
+                requestJson,
+                wsMethod: "operator.status",
+                httpPath: OPERATOR_API.status,
+            }),
+            fallback: createEmptyOperatorStatus,
+            authoritative: true,
+            sampleLimit: null,
+            expectedContract: expectedContract("WS operator.status", OPERATOR_API.status),
+            note: "Operator status unavailable",
+        }),
+        loadOperatorControlSection({
+            key: "registryDetail",
+            run: async () => await requestOperatorSection({
+                client,
+                requestJson,
+                wsMethod: "operator.registry.get",
+                httpPath: OPERATOR_API.registry,
+            }),
+            fallback: createEmptyOperatorRegistry,
+            authoritative: true,
+            sampleLimit: null,
+            expectedContract: expectedContract("WS operator.registry.get", OPERATOR_API.registry),
+            note: "Operator registry unavailable",
+        }),
+        loadOperatorControlSection({
+            key: "tasks",
+            run: async () => await requestOperatorSection({
+                client,
+                requestJson,
+                wsMethod: "operator.tasks.list",
+                wsParams: { limit: OPERATOR_TASK_SAMPLE_LIMIT },
+                httpPath: withQuery(OPERATOR_API.tasks, {
+                    limit: OPERATOR_TASK_SAMPLE_LIMIT,
+                }),
+            }),
+            fallback: createEmptyOperatorTasks,
+            authoritative: false,
+            sampleLimit: OPERATOR_TASK_SAMPLE_LIMIT,
+            expectedContract: expectedContract("WS operator.tasks.list", OPERATOR_API.tasks),
+            note: "Operator task list unavailable",
+        }),
+        loadOperatorControlSection({
+            key: "memory",
+            run: async () => await requestOperatorSection({
+                client,
+                requestJson,
+                wsMethod: "operator.memory.list",
+                wsParams: { limit: OPERATOR_MEMORY_SAMPLE_LIMIT },
+                httpPath: withQuery(OPERATOR_API.memory, {
+                    limit: OPERATOR_MEMORY_SAMPLE_LIMIT,
+                }),
+            }),
+            fallback: createEmptyOperatorMemory,
+            authoritative: false,
+            sampleLimit: OPERATOR_MEMORY_SAMPLE_LIMIT,
+            expectedContract: expectedContract("WS operator.memory.list", OPERATOR_API.memory),
+            note: "Operator memory list unavailable",
+        }),
+        loadOperatorControlSection({
+            key: "workerReady",
+            run: async () => await requestOperatorSection({
+                client,
+                requestJson,
+                wsMethod: "operator.worker.ready",
+                httpPath: OPERATOR_API.workerReady,
+            }),
+            fallback: createEmptyWorkerReady,
+            authoritative: true,
+            sampleLimit: null,
+            expectedContract: expectedContract("WS operator.worker.ready", OPERATOR_API.workerReady),
+            note: "Operator worker readiness unavailable",
+        }),
+        loadOperatorControlSection({
+            key: "workerTasks",
+            run: async () => await requestOperatorSection({
+                client,
+                requestJson,
+                wsMethod: "operator.worker.tasks.list",
+                wsParams: { limit: OPERATOR_WORKER_TASK_SAMPLE_LIMIT },
+                httpPath: withQuery(OPERATOR_API.workerTasks, {
+                    limit: OPERATOR_WORKER_TASK_SAMPLE_LIMIT,
+                }),
+            }),
+            fallback: createEmptyWorkerTasks,
+            authoritative: false,
+            sampleLimit: OPERATOR_WORKER_TASK_SAMPLE_LIMIT,
+            expectedContract: expectedContract("WS operator.worker.tasks.list", OPERATOR_API.workerTasks),
+            note: "Operator worker task list unavailable",
+        }),
+    ]);
+    const contractGaps = [
+        statusResult.contractGap,
+        registryResult.contractGap,
+        tasksResult.contractGap,
+        memoryResult.contractGap,
+        workerReadyResult.contractGap,
+        workerTasksResult.contractGap,
+    ].filter((gap) => gap !== null);
+    const allSectionsUnavailable = [
+        statusResult,
+        registryResult,
+        tasksResult,
+        memoryResult,
+        workerReadyResult,
+        workerTasksResult,
+    ].every((result) => !result.status.available);
+    if (allSectionsUnavailable) {
+        const primaryGap = contractGaps[0];
+        const envelope = {
+            data: resolveOperatorControlFallback(fallback),
+            source: "mock",
+            fetchedAt: Date.now(),
+            contractGaps: [
+                fallbackGap("operator-control", operatorControlExpectedContractSummary(), primaryGap
+                    ? `Operator control snapshot unavailable. ${primaryGap.note}`
+                    : "Operator control snapshot unavailable.", primaryGap?.reason ?? "backend-unavailable", primaryGap?.httpStatus),
+            ],
+        };
+        fullFallbackByRequestJson.set(requestJson, {
+            expiresAt: Date.now() + OPERATOR_FULL_FALLBACK_BACKOFF_MS,
+            envelope,
+        });
+        return envelope;
+    }
+    fullFallbackByRequestJson.delete(requestJson);
+    const status = statusResult.data;
+    const tasks = tasksResult.status.available
+        ? tasksResult.data
+        : {
+            ...tasksResult.data,
+            summary: { ...status.taskSummary.tasks },
+        };
+    const memory = memoryResult.status.available
+        ? memoryResult.data
+        : {
+            ...memoryResult.data,
+            storePath: status.sharedMemory.storePath,
+            collections: status.sharedMemory.collections,
+        };
+    const workerReady = workerReadyResult.data;
+    const workerTasks = workerTasksResult.status.available
+        ? workerTasksResult.data
+        : {
+            ...workerTasksResult.data,
+            stats: {
+                pending: workerReady.pending,
+                active: workerReady.active,
+                shuttingDown: workerReady.shuttingDown,
+            },
+        };
+    return {
+        data: {
+            status,
+            registryDetail: registryResult.data,
+            tasks,
+            memory,
+            workerReady,
+            workerTasks,
+            sectionStatus: {
+                status: statusResult.status,
+                registryDetail: registryResult.status,
+                tasks: tasksResult.status,
+                memory: memoryResult.status,
+                workerReady: workerReadyResult.status,
+                workerTasks: workerTasksResult.status,
+            },
+        },
+        source: "gateway",
+        fetchedAt: Date.now(),
+        contractGaps,
+    };
+}