@cavi-ai/api-client 0.1.0

package/dist/extensions/cavi/library/clip.js

@@ -0,0 +1,272 @@
+import { LIBRARY_API_ENDPOINTS, resolveLibraryApiPath } from "../contracts/paths.js";
+import { resolveCaviPath } from "../contracts/resolve.js";
+export const LIBRARY_CLIP_ENDPOINT = LIBRARY_API_ENDPOINTS.clip;
+export const LIBRARY_CLIP_HEALTH_ENDPOINT = LIBRARY_API_ENDPOINTS.clipHealth;
+export const LIBRARY_CLIP_SCHEMA_ENDPOINT = LIBRARY_API_ENDPOINTS.clipSchema;
+export const LIBRARY_CLIP_LOGS_ENDPOINT = LIBRARY_API_ENDPOINTS.clipLogs;
+export const LIBRARY_CLIP_DEFAULT_TEAM = "library";
+export const LIBRARY_CLIP_SOURCE_TAG = "caviclip";
+function cleanString(value) {
+    const trimmed = value?.trim();
+    return trimmed ? trimmed : undefined;
+}
+function asRecord(value) {
+    return value !== null && typeof value === "object" && !Array.isArray(value)
+        ? value
+        : {};
+}
+function statusFromError(error) {
+    const status = error?.status;
+    return typeof status === "number" ? status : undefined;
+}
+function messageFromError(error) {
+    return error instanceof Error ? error.message : String(error);
+}
+function uniqueStrings(values) {
+    const seen = new Set();
+    const result = [];
+    for (const value of values) {
+        const trimmed = value.trim();
+        if (!trimmed || seen.has(trimmed))
+            continue;
+        seen.add(trimmed);
+        result.push(trimmed);
+    }
+    return result;
+}
+function titleFromUrl(sourceUrl) {
+    try {
+        const parsed = new URL(sourceUrl);
+        const host = parsed.host.trim();
+        if (host)
+            return host;
+    }
+    catch {
+        return undefined;
+    }
+    return undefined;
+}
+function titleFromText(text) {
+    const firstLine = text
+        .split(/\r?\n/u)
+        .map((line) => line.trim())
+        .find(Boolean);
+    if (!firstLine)
+        return undefined;
+    return firstLine.length > 96 ? `${firstLine.slice(0, 93)}...` : firstLine;
+}
+export function buildLibraryClipPayload(input) {
+    const sourceUrl = cleanString(input.sourceUrl);
+    const text = cleanString(input.text);
+    if (!sourceUrl && !text) {
+        throw new Error("Library clip requires a sourceUrl or text value.");
+    }
+    const title = cleanString(input.title) ??
+        (sourceUrl ? titleFromUrl(sourceUrl) : undefined) ??
+        (text ? titleFromText(text) : undefined) ??
+        "CaviClip";
+    const team = cleanString(input.team) ?? LIBRARY_CLIP_DEFAULT_TEAM;
+    const tags = uniqueStrings([
+        LIBRARY_CLIP_SOURCE_TAG,
+        ...(input.tags ?? []),
+    ]);
+    const capturedAt = cleanString(input.capturedAt) ?? new Date().toISOString();
+    const metadata = {
+        ...(input.metadata ?? {}),
+        source: LIBRARY_CLIP_SOURCE_TAG,
+        captured_at: capturedAt,
+    };
+    return {
+        title,
+        team,
+        tags,
+        note: cleanString(input.note) ?? "Captured from CaviClip.",
+        ...(sourceUrl ? { source_url: sourceUrl } : {}),
+        ...(text ? { text } : {}),
+        metadata,
+    };
+}
+export function buildLibraryClipSchemaSnapshot() {
+    return {
+        contract: "LIBRARY_CLIP_V1",
+        endpoint: LIBRARY_CLIP_ENDPOINT,
+        method: "POST",
+        fields: {
+            title: {
+                type: "string",
+                required: true,
+                description: "Human-readable title for the captured URL, text, or manual file smoke.",
+            },
+            team: {
+                type: "string",
+                required: true,
+                description: "Library team routing key. Defaults to library/Sigmund intake.",
+            },
+            tags: {
+                type: "string[]",
+                required: true,
+                description: "Deduplicated tags. The caviclip source tag is always included.",
+            },
+            note: {
+                type: "string",
+                required: true,
+                description: "Operator-facing note attached to the clip.",
+            },
+            source_url: {
+                type: "string",
+                required: false,
+                description: "Original URL when the clip comes from a web share.",
+            },
+            text: {
+                type: "string",
+                required: false,
+                description: "Captured body text or manual file smoke content.",
+            },
+            metadata: {
+                type: "object",
+                required: true,
+                description: "Non-secret ingress metadata for diagnostics and routing.",
+            },
+        },
+        example: buildLibraryClipPayload({
+            title: "CaviClip diagnostic",
+            text: "Manual CaviClip diagnostic clip.",
+            tags: ["diagnostic"],
+            capturedAt: "2026-05-21T12:00:00.000Z",
+            metadata: { ingress: "sigmund-portal" },
+        }),
+    };
+}
+export function buildLibraryManualFileClipInput(input) {
+    const name = cleanString(input.name) ?? "manual-file";
+    const text = cleanString(input.text);
+    const size = typeof input.size === "number" && Number.isFinite(input.size)
+        ? input.size
+        : null;
+    const mimeType = cleanString(input.mimeType);
+    const uri = cleanString(input.uri);
+    const fallbackText = [
+        `Manual CaviClip file ingest smoke for ${name}.`,
+        mimeType ? `MIME: ${mimeType}` : null,
+        size !== null ? `Size: ${size} bytes` : null,
+        "File content was not embedded because the file is binary, empty, or over the mobile diagnostic limit.",
+    ].filter(Boolean).join("\n");
+    return {
+        title: name,
+        text: text ?? fallbackText,
+        team: LIBRARY_CLIP_DEFAULT_TEAM,
+        tags: ["manual-test", "file"],
+        note: "Manual file ingest smoke from Sigmund CaviClip diagnostics.",
+        capturedAt: input.capturedAt,
+        metadata: {
+            ingress: "sigmund-portal-manual-file",
+            file: {
+                name,
+                ...(uri ? { uri } : {}),
+                ...(mimeType ? { mime_type: mimeType } : {}),
+                ...(size !== null ? { size } : {}),
+                content_included: Boolean(text),
+            },
+        },
+    };
+}
+export function postLibraryClip(requestJson, input, opts) {
+    // Resolve through the canonical surface contract instead of hardcoding the
+    // endpoint, matching every other CAVI surface. Defaults to legacy mode so the
+    // wire path is unchanged (/library/api/clip); canonical callers pass mode.
+    return requestJson(resolveCaviPath("library.clip", "legacy"), {
+        method: "POST",
+        body: buildLibraryClipPayload(input),
+        timeoutMs: opts?.timeoutMs,
+    });
+}
+async function optionalGet(requestJson, id, label, path) {
+    try {
+        const payload = await requestJson(path, { method: "GET" });
+        return {
+            payload,
+            check: {
+                id,
+                label,
+                path,
+                ok: true,
+                message: "reachable",
+                source: "gateway",
+            },
+        };
+    }
+    catch (error) {
+        const status = statusFromError(error);
+        return {
+            payload: null,
+            check: {
+                id,
+                label,
+                path,
+                ok: false,
+                ...(status !== undefined ? { status } : {}),
+                message: messageFromError(error),
+                source: "gateway",
+            },
+        };
+    }
+}
+function normalizeDiagnosticsLogs(payload) {
+    const root = asRecord(payload);
+    const source = Array.isArray(root.logs)
+        ? root.logs
+        : Array.isArray(root.items)
+            ? root.items
+            : Array.isArray(payload)
+                ? payload
+                : [];
+    return source
+        .map((entry) => {
+        const record = asRecord(entry);
+        const message = cleanString(record.message) ??
+            cleanString(record.event) ??
+            cleanString(record.error);
+        if (!message)
+            return null;
+        return {
+            ...(cleanString(record.at) ? { at: cleanString(record.at) } : {}),
+            ...(cleanString(record.level) ? { level: cleanString(record.level) } : {}),
+            message,
+            ...(cleanString(record.path) ? { path: cleanString(record.path) } : {}),
+        };
+    })
+        .filter((entry) => entry !== null)
+        .slice(0, 25);
+}
+export async function requestLibraryClipDiagnostics(requestJson) {
+    const [pipeline, health, schema, logs] = await Promise.all([
+        optionalGet(requestJson, "pipeline-status", "Pipeline status", resolveLibraryApiPath("status")),
+        optionalGet(requestJson, "clip-health", "CaviClip health", LIBRARY_CLIP_HEALTH_ENDPOINT),
+        optionalGet(requestJson, "clip-schema", "CaviClip schema", LIBRARY_CLIP_SCHEMA_ENDPOINT),
+        optionalGet(requestJson, "clip-logs", "CaviClip logs", LIBRARY_CLIP_LOGS_ENDPOINT),
+    ]);
+    const remoteSchema = schema.check.ok && Object.keys(asRecord(schema.payload)).length > 0
+        ? asRecord(schema.payload)
+        : null;
+    return {
+        fetchedAt: Date.now(),
+        endpoint: LIBRARY_CLIP_ENDPOINT,
+        schema: remoteSchema ?? buildLibraryClipSchemaSnapshot(),
+        schemaSource: remoteSchema ? "gateway" : "local-contract",
+        checks: [
+            {
+                id: "clip-endpoint",
+                label: "Clip endpoint",
+                path: LIBRARY_CLIP_ENDPOINT,
+                ok: true,
+                message: "POST contract loaded from canonical package",
+                source: "local-contract",
+            },
+            pipeline.check,
+            health.check,
+            schema.check,
+            logs.check,
+        ],
+        logs: normalizeDiagnosticsLogs(logs.payload),
+    };
+}

package/dist/extensions/cavi/operator-control/constants.d.ts

@@ -0,0 +1,4 @@
+export declare const OPERATOR_TASK_SAMPLE_LIMIT = 20;
+export declare const OPERATOR_MEMORY_SAMPLE_LIMIT = 20;
+export declare const OPERATOR_WORKER_TASK_SAMPLE_LIMIT = 20;
+//# sourceMappingURL=constants.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"constants.d.ts","sourceRoot":"","sources":["../../../../src/extensions/cavi/operator-control/constants.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,0BAA0B,KAAK,CAAC;AAC7C,eAAO,MAAM,4BAA4B,KAAK,CAAC;AAC/C,eAAO,MAAM,iCAAiC,KAAK,CAAC"}

package/dist/extensions/cavi/operator-control/constants.js

@@ -0,0 +1,3 @@
+export const OPERATOR_TASK_SAMPLE_LIMIT = 20;
+export const OPERATOR_MEMORY_SAMPLE_LIMIT = 20;
+export const OPERATOR_WORKER_TASK_SAMPLE_LIMIT = 20;

package/dist/extensions/cavi/operator-control/defaults.d.ts

@@ -0,0 +1,11 @@
+import type { OperatorControlSnapshot } from "../domain/index.js";
+export declare function createEmptyWorkerTransport(): OperatorControlSnapshot["status"]["worker"];
+export declare function createEmptyDelegatedTransport(): OperatorControlSnapshot["status"]["delegatedFirstClassAgents"];
+export declare function createEmptyOperatorStatus(): OperatorControlSnapshot["status"];
+export declare function createEmptyOperatorRegistry(): OperatorControlSnapshot["registryDetail"];
+export declare function createEmptyOperatorTasks(): OperatorControlSnapshot["tasks"];
+export declare function createEmptyOperatorMemory(): OperatorControlSnapshot["memory"];
+export declare function createEmptyWorkerReady(): OperatorControlSnapshot["workerReady"];
+export declare function createEmptyWorkerTasks(): OperatorControlSnapshot["workerTasks"];
+export declare function createEmptyOperatorSectionStatus(): OperatorControlSnapshot["sectionStatus"];
+//# sourceMappingURL=defaults.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"defaults.d.ts","sourceRoot":"","sources":["../../../../src/extensions/cavi/operator-control/defaults.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,oBAAoB,CAAC;AAclE,wBAAgB,0BAA0B,IAAI,uBAAuB,CAAC,QAAQ,CAAC,CAAC,QAAQ,CAAC,CAWxF;AAED,wBAAgB,6BAA6B,IAAI,uBAAuB,CAAC,QAAQ,CAAC,CAAC,2BAA2B,CAAC,CAiB9G;AAED,wBAAgB,yBAAyB,IAAI,uBAAuB,CAAC,QAAQ,CAAC,CA6E7E;AAED,wBAAgB,2BAA2B,IAAI,uBAAuB,CAAC,gBAAgB,CAAC,CAmBvF;AAED,wBAAgB,wBAAwB,IAAI,uBAAuB,CAAC,OAAO,CAAC,CAK3E;AAED,wBAAgB,yBAAyB,IAAI,uBAAuB,CAAC,QAAQ,CAAC,CA6B7E;AAED,wBAAgB,sBAAsB,IAAI,uBAAuB,CAAC,aAAa,CAAC,CAiB/E;AAED,wBAAgB,sBAAsB,IAAI,uBAAuB,CAAC,aAAa,CAAC,CAS/E;AAED,wBAAgB,gCAAgC,IAAI,uBAAuB,CAAC,eAAe,CAAC,CAuC3F"}

package/dist/extensions/cavi/operator-control/defaults.js

@@ -0,0 +1,243 @@
+function createEmptyTaskSummary() {
+    return {
+        accepted: 0,
+        queued: 0,
+        started: 0,
+        retrying: 0,
+        blocked: 0,
+        completed: 0,
+        "dead-letter": 0,
+    };
+}
+export function createEmptyWorkerTransport() {
+    return {
+        dispatchTransport: "primary-operator-2-http",
+        role: "legacy-worker-fleet",
+        configured: false,
+        baseUrl: null,
+        receiptTemplate: null,
+        authScheme: null,
+        authEnv: null,
+        authConfigured: false,
+    };
+}
+export function createEmptyDelegatedTransport() {
+    return {
+        dispatchTransport: "delegated-http",
+        transportAliases: ["service-operator-http"],
+        role: "delegated-first-class-agent-boundary",
+        configured: false,
+        baseUrl: null,
+        authScheme: null,
+        authEnv: null,
+        authConfigured: false,
+        globalDefaultAlias: null,
+        servedTeams: [],
+        leadAliases: [],
+        defaultAliasByTeam: {},
+        teamTopology: [],
+        legacyTeams: [],
+    };
+}
+export function createEmptyOperatorStatus() {
+    const worker = createEmptyWorkerTransport();
+    const delegatedTransport = createEmptyDelegatedTransport();
+    return {
+        primaryOperator: "primary-operator",
+        fallbackOperator: "operator-a",
+        authorityMode: "authoritative-failover",
+        taskStorePath: "n/a",
+        registry: {
+            agentCount: 0,
+            teamCount: 0,
+            sourcePath: "n/a",
+            sourceHash: "n/a",
+            generatedAt: 0,
+        },
+        taskSummary: {
+            primaryOperator: "primary-operator",
+            fallbackOperator: "operator-a",
+            authorityMode: "authoritative-failover",
+            tasks: createEmptyTaskSummary(),
+            totals: {
+                total: 0,
+                terminal: 0,
+                active: 0,
+            },
+        },
+        runtimes: {
+            acpBackendId: null,
+            acpBackendHealthy: false,
+            sharedMemoryAuthority: "local-json-shim",
+        },
+        sharedMemory: {
+            storePath: "n/a",
+            collections: {
+                "service-context": {
+                    count: 0,
+                    lastVerifiedAt: null,
+                    writeMode: "append-only",
+                },
+                "task-outcomes": {
+                    count: 0,
+                    lastVerifiedAt: null,
+                    writeMode: "append-only",
+                },
+                "contract-registry": {
+                    count: 0,
+                    lastVerifiedAt: null,
+                    writeMode: "append-only",
+                },
+                "channel-events": {
+                    count: 0,
+                    lastVerifiedAt: null,
+                    writeMode: "append-only",
+                },
+            },
+        },
+        legacyWorkerFleet: worker,
+        delegatedFirstClassAgents: delegatedTransport,
+        worker,
+        mesh: {
+            legacyExecutionFleet: worker,
+            delegatedFirstClassAgents: delegatedTransport,
+            executionFleet: worker,
+            projectOps: {
+                mode: "task-lifecycle",
+                configured: false,
+                baseUrl: null,
+                eventEndpoint: null,
+                authScheme: null,
+                authEnv: null,
+                authConfigured: false,
+            },
+            domainOrchestrators: delegatedTransport,
+            marketing: delegatedTransport,
+            research: delegatedTransport,
+        },
+    };
+}
+export function createEmptyOperatorRegistry() {
+    return {
+        schema: "OperatorAgentRegistryV2",
+        generatedAt: 0,
+        sourcePath: "n/a",
+        sourceHash: "n/a",
+        agentCount: 0,
+        teamCount: 0,
+        operatorRuntime: {
+            transports: {
+                delegatedHttp: { globalDefaultAlias: null },
+            },
+        },
+        agents: [],
+        teams: [],
+        k8sCluster: [],
+        identities: [],
+        skillOwnership: [],
+    };
+}
+export function createEmptyOperatorTasks() {
+    return {
+        tasks: [],
+        summary: createEmptyTaskSummary(),
+    };
+}
+export function createEmptyOperatorMemory() {
+    return {
+        authority: "local-json-shim",
+        storePath: "n/a",
+        generatedAt: 0,
+        collections: {
+            "service-context": {
+                count: 0,
+                lastVerifiedAt: null,
+                writeMode: "append-only",
+            },
+            "task-outcomes": {
+                count: 0,
+                lastVerifiedAt: null,
+                writeMode: "append-only",
+            },
+            "contract-registry": {
+                count: 0,
+                lastVerifiedAt: null,
+                writeMode: "append-only",
+            },
+            "channel-events": {
+                count: 0,
+                lastVerifiedAt: null,
+                writeMode: "append-only",
+            },
+        },
+        records: [],
+    };
+}
+export function createEmptyWorkerReady() {
+    return {
+        status: "not-ready",
+        pending: 0,
+        active: 0,
+        shuttingDown: false,
+        auth: {
+            enabled: false,
+            scheme: "none",
+        },
+        backend: {
+            mode: "memory",
+            persistenceEnabled: false,
+            stateFile: null,
+            recoveredTasks: 0,
+        },
+    };
+}
+export function createEmptyWorkerTasks() {
+    return {
+        tasks: [],
+        stats: {
+            pending: 0,
+            active: 0,
+            shuttingDown: false,
+        },
+    };
+}
+export function createEmptyOperatorSectionStatus() {
+    return {
+        status: {
+            available: false,
+            authoritative: true,
+            error: null,
+            sampleLimit: null,
+        },
+        registryDetail: {
+            available: false,
+            authoritative: true,
+            error: null,
+            sampleLimit: null,
+        },
+        tasks: {
+            available: false,
+            authoritative: false,
+            error: null,
+            sampleLimit: 20,
+        },
+        memory: {
+            available: false,
+            authoritative: false,
+            error: null,
+            sampleLimit: 20,
+        },
+        workerReady: {
+            available: false,
+            authoritative: true,
+            error: null,
+            sampleLimit: null,
+        },
+        workerTasks: {
+            available: false,
+            authoritative: false,
+            error: null,
+            sampleLimit: 20,
+        },
+    };
+}

package/dist/extensions/cavi/operator-control/load-section.d.ts

@@ -0,0 +1,24 @@
+import type { OperatorControlSnapshot, OperatorControlSectionKey } from "../domain/index.js";
+import { type ContractGap } from "../../../core/gateway/envelope/index.js";
+export type OperatorSectionLoadResult<TKey extends OperatorControlSectionKey, TData> = {
+    key: TKey;
+    data: TData;
+    status: OperatorControlSnapshot["sectionStatus"][TKey];
+    contractGap: ContractGap | null;
+};
+export declare function createOperatorSectionStatus<TKey extends OperatorControlSectionKey>(params: {
+    available: boolean;
+    authoritative: boolean;
+    error: string | null;
+    sampleLimit: number | null;
+}): OperatorControlSnapshot["sectionStatus"][TKey];
+export declare function loadOperatorControlSection<TKey extends OperatorControlSectionKey, TData>(params: {
+    key: TKey;
+    run: () => Promise<TData>;
+    fallback: () => TData;
+    authoritative: boolean;
+    sampleLimit: number | null;
+    expectedContract: string;
+    note: string;
+}): Promise<OperatorSectionLoadResult<TKey, TData>>;
+//# sourceMappingURL=load-section.d.ts.map

package/dist/extensions/cavi/operator-control/load-section.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"load-section.d.ts","sourceRoot":"","sources":["../../../../src/extensions/cavi/operator-control/load-section.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,uBAAuB,EACvB,yBAAyB,EAC1B,MAAM,oBAAoB,CAAC;AAC5B,OAAO,EAGL,KAAK,WAAW,EACjB,MAAM,yCAAyC,CAAC;AAGjD,MAAM,MAAM,yBAAyB,CACnC,IAAI,SAAS,yBAAyB,EACtC,KAAK,IACH;IACF,GAAG,EAAE,IAAI,CAAC;IACV,IAAI,EAAE,KAAK,CAAC;IACZ,MAAM,EAAE,uBAAuB,CAAC,eAAe,CAAC,CAAC,IAAI,CAAC,CAAC;IACvD,WAAW,EAAE,WAAW,GAAG,IAAI,CAAC;CACjC,CAAC;AAEF,wBAAgB,2BAA2B,CACzC,IAAI,SAAS,yBAAyB,EACtC,MAAM,EAAE;IACR,SAAS,EAAE,OAAO,CAAC;IACnB,aAAa,EAAE,OAAO,CAAC;IACvB,KAAK,EAAE,MAAM,GAAG,IAAI,CAAC;IACrB,WAAW,EAAE,MAAM,GAAG,IAAI,CAAC;CAC5B,GAAG,uBAAuB,CAAC,eAAe,CAAC,CAAC,IAAI,CAAC,CAOjD;AAED,wBAAsB,0BAA0B,CAC9C,IAAI,SAAS,yBAAyB,EACtC,KAAK,EACL,MAAM,EAAE;IACR,GAAG,EAAE,IAAI,CAAC;IACV,GAAG,EAAE,MAAM,OAAO,CAAC,KAAK,CAAC,CAAC;IAC1B,QAAQ,EAAE,MAAM,KAAK,CAAC;IACtB,aAAa,EAAE,OAAO,CAAC;IACvB,WAAW,EAAE,MAAM,GAAG,IAAI,CAAC;IAC3B,gBAAgB,EAAE,MAAM,CAAC;IACzB,IAAI,EAAE,MAAM,CAAC;CACd,GAAG,OAAO,CAAC,yBAAyB,CAAC,IAAI,EAAE,KAAK,CAAC,CAAC,CA2ClD"}

package/dist/extensions/cavi/operator-control/load-section.js

@@ -0,0 +1,46 @@
+import { classifyFallbackError, fallbackGap, } from "../../../core/gateway/envelope/index.js";
+import { GatewayHttpError } from "../../../core/http/gateway-error.js";
+export function createOperatorSectionStatus(params) {
+    return {
+        available: params.available,
+        authoritative: params.authoritative,
+        error: params.error,
+        sampleLimit: params.sampleLimit,
+    };
+}
+export async function loadOperatorControlSection(params) {
+    try {
+        const data = await params.run();
+        return {
+            key: params.key,
+            data,
+            status: createOperatorSectionStatus({
+                available: true,
+                authoritative: params.authoritative,
+                error: null,
+                sampleLimit: params.sampleLimit,
+            }),
+            contractGap: null,
+        };
+    }
+    catch (error) {
+        if (error instanceof GatewayHttpError &&
+            (error.status === 401 || error.status === 403)) {
+            throw error;
+        }
+        return {
+            key: params.key,
+            data: params.fallback(),
+            status: createOperatorSectionStatus({
+                available: false,
+                authoritative: params.authoritative,
+                error: error instanceof Error ? error.message : String(error),
+                sampleLimit: params.sampleLimit,
+            }),
+            contractGap: (() => {
+                const classified = classifyFallbackError(error);
+                return fallbackGap(`operator-control.${params.key}`, params.expectedContract, `${params.note}. ${classified.message}`, classified.reason, classified.httpStatus);
+            })(),
+        };
+    }
+}

package/dist/extensions/cavi/portal/client.d.ts

@@ -0,0 +1,16 @@
+import { BaseHttpApiClient } from "../../../core/http/client.js";
+import type { HttpApiClientOptions, HttpApiTransport } from "../../../core/http/types.js";
+export type PortalApiClientOptions = HttpApiClientOptions & {
+    portalId: string;
+};
+export declare class PortalApiClient extends BaseHttpApiClient {
+    readonly portalId: string;
+    readonly request: HttpApiTransport;
+    constructor(options: PortalApiClientOptions);
+    protected portalPath(path: string): string;
+    getDashboard<T = unknown>(): Promise<T>;
+    getFromPortal<T = unknown>(relativePath: string): Promise<T>;
+    postToPortal<T = unknown>(relativePath: string, body: unknown, idempotencyKey?: string): Promise<T>;
+    getPortalMemorySnapshot<T = unknown>(teamSlug: string, memberId: string, memoryKey: string): Promise<T>;
+}
+//# sourceMappingURL=client.d.ts.map

package/dist/extensions/cavi/portal/client.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"client.d.ts","sourceRoot":"","sources":["../../../../src/extensions/cavi/portal/client.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,iBAAiB,EAAE,MAAM,8BAA8B,CAAC;AAGjE,OAAO,KAAK,EAAE,oBAAoB,EAAE,gBAAgB,EAAE,MAAM,6BAA6B,CAAC;AAE1F,MAAM,MAAM,sBAAsB,GAAG,oBAAoB,GAAG;IAC1D,QAAQ,EAAE,MAAM,CAAC;CAClB,CAAC;AAUF,qBAAa,eAAgB,SAAQ,iBAAiB;IACpD,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,QAAQ,CAAC,OAAO,EAAE,gBAAgB,CAAC;gBAEvB,OAAO,EAAE,sBAAsB;IAM3C,SAAS,CAAC,UAAU,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM;IAI1C,YAAY,CAAC,CAAC,GAAG,OAAO,KAAK,OAAO,CAAC,CAAC,CAAC;IAMvC,aAAa,CAAC,CAAC,GAAG,OAAO,EAAE,YAAY,EAAE,MAAM,GAAG,OAAO,CAAC,CAAC,CAAC;IAI5D,YAAY,CAAC,CAAC,GAAG,OAAO,EACtB,YAAY,EAAE,MAAM,EACpB,IAAI,EAAE,OAAO,EACb,cAAc,CAAC,EAAE,MAAM,GACtB,OAAO,CAAC,CAAC,CAAC;IAQb,uBAAuB,CAAC,CAAC,GAAG,OAAO,EACjC,QAAQ,EAAE,MAAM,EAChB,QAAQ,EAAE,MAAM,EAChB,SAAS,EAAE,MAAM,GAChB,OAAO,CAAC,CAAC,CAAC;CAKd"}

package/dist/extensions/cavi/portal/client.js

@@ -0,0 +1,38 @@
+import { BaseHttpApiClient } from "../../../core/http/client.js";
+import { CAVI_CONTROL_API_ENDPOINTS, resolvePortalApiPath } from "../contracts/paths.js";
+import { resolvePath } from "../contracts/resolve.js";
+function normalizePortalId(portalId) {
+    const trimmed = portalId.trim();
+    if (!trimmed) {
+        throw new Error("PortalApiClient requires a non-empty portalId");
+    }
+    return trimmed;
+}
+export class PortalApiClient extends BaseHttpApiClient {
+    portalId;
+    request;
+    constructor(options) {
+        super("portal-api", options);
+        this.portalId = normalizePortalId(options.portalId);
+        this.request = this.createTransport();
+    }
+    portalPath(path) {
+        return resolvePortalApiPath(this.portalId, path);
+    }
+    getDashboard() {
+        return this.request(resolvePath("portal.dashboard", "canonical", { portal: this.portalId }));
+    }
+    getFromPortal(relativePath) {
+        return this.request(this.portalPath(relativePath));
+    }
+    postToPortal(relativePath, body, idempotencyKey) {
+        return this.request(this.portalPath(relativePath), {
+            method: "POST",
+            body,
+            idempotencyKey,
+        });
+    }
+    getPortalMemorySnapshot(teamSlug, memberId, memoryKey) {
+        return this.request(CAVI_CONTROL_API_ENDPOINTS.portalMemorySnapshot(teamSlug, memberId, memoryKey));
+    }
+}