@x12i/memorix-client-api 0.0.0-stage → 0.17.0

package/dist/fetch.js

@@ -0,0 +1,741 @@
+import { findContentType, findObjectType } from "./catalog.js";
+import { chooseStory, declaredTemplate, parseStoryVariant, STORY_AI_TYPE, STORY_TYPE, storyTemplates, } from "./story.js";
+import { ApiError, UpstreamError } from "./errors.js";
+import { scopeBody } from "./scope.js";
+import { SCOPER_MCP_TOOL_NAMES, SCOPER_RELEASE } from "./scoper.js";
+import { asRecord } from "./upstream.js";
+/** Read-only Nexum tools served by memorix-service `POST /mcp/nexum`. */
+export const NEXUM_MCP_TOOLS = [
+    "nexum_list_snapshots",
+    "nexum_get_snapshot",
+    "nexum_get_connected_content",
+    "nexum_knowledge_status",
+    "nexum_list_entities",
+    "nexum_get_entity",
+    "nexum_query",
+];
+/**
+ * Memorix POST routes whose body is a read (compose, list, item, canvas query).
+ * Writes such as `/api/data/content` are not in this map.
+ */
+const READ_POSTS = {
+    "/api/v1/data/compose": "/api/data/compose",
+    "/api/v1/data/compose/data": "/api/data/compose/data",
+    "/api/v1/data/compose/data/list": "/api/data/compose/data/list",
+    "/api/v1/data/lists": "/api/data/lists",
+    "/api/v1/data/items": "/api/data/items",
+    "/api/v1/data-journey/matrix/query": "/api/data-journey/matrix/query",
+    "/api/v1/data-journey/matrix/columns/query": "/api/data-journey/matrix/columns/query",
+    "/api/v1/data-journey/matrix/cells/query": "/api/data-journey/matrix/cells/query",
+    "/api/v1/intelligence/anomalies/content-types": "/api/intelligence/anomalies/content-types",
+};
+/** Story drawings are content rows. Several rows may share this value; the newest revision is the drawing. */
+const TEMPLATE_PATH = "data.template";
+const MAX_SOURCE_REFS = 16;
+const MAX_CONTENT_TYPES = 16;
+const INSTANCE_PAGES = 5;
+/** Messages Memorix relays when it cannot open a connection to the Nexum explore REST. */
+const UNREACHABLE = /fetch failed|ECONNREFUSED|ECONNRESET|ENOTFOUND|EHOSTUNREACH|ETIMEDOUT|timed? ?out|aborted/i;
+export function registerFetchRoutes(app, options) {
+    const memorixBase = options.memorixUrl.replace(/\/+$/, "");
+    const nexumMcpEndpoint = `${memorixBase}/mcp/nexum`;
+    let discoveredMgc = options.mgcMcpUrl === undefined ? undefined : normalizeMcpUrl(options.mgcMcpUrl);
+    app.get("/api/v1/memorix/*", async (req) => {
+        const scope = await options.scopeFor(req);
+        const upstreamPath = memorixPath(wildcard(req), searchOf(req));
+        assertFetchAllowed(upstreamPath);
+        return options.upstream.get(upstreamPath, scope);
+    });
+    app.get("/api/v1/memorix/data/content", async (req) => {
+        const scope = await options.scopeFor(req);
+        const query = (req.query ?? {});
+        const objectType = queryValue(query.objectType);
+        const contentType = queryValue(query.contentType);
+        const recordId = queryValue(query.recordId) ?? queryValue(query.id);
+        const explicit = queryValue(query.discriminatorValue);
+        const rawFilter = queryValue(query.filter);
+        const counting = queryValue(query.count) === "true";
+        const passThrough = () => options.upstream.get(`/api/data/content${searchOf(req)}`, scope);
+        // Lists, counts, and reads with no selector are answered by Memorix.
+        // Service 3.16 reads `discriminatorValue` on a list and rejects a query parameter it does not know.
+        if (!objectType || !contentType || counting || !recordId)
+            return passThrough();
+        if (!explicit && !rawFilter)
+            return passThrough();
+        const filters = parseFilter(rawFilter);
+        const path = await discriminatorPath(scope, objectType, contentType);
+        const value = path ? (explicit ?? discriminatorFromFilter(filters, path)) : undefined;
+        const templateValue = discriminatorFromFilter(filters, TEMPLATE_PATH);
+        const selector = path && value !== undefined
+            ? { path, value }
+            : templateValue !== undefined
+                ? { path: TEMPLATE_PATH, value: templateValue }
+                : null;
+        if (!selector)
+            return passThrough();
+        const rows = await recordInstances(scope, objectType, contentType, recordId, queryValue(query.include), queryValue(query.includeDeleted));
+        return contentInstance(scope, objectType, contentType, recordId, selector.path, selector.value, rows);
+    });
+    app.get("/api/v1/data/story", async (req, reply) => {
+        const scope = await options.scopeFor(req);
+        const query = (req.query ?? {});
+        const objectType = queryValue(query.objectType);
+        const recordId = queryValue(query.recordId) ?? queryValue(query.id);
+        const template = queryValue(query.template);
+        if (!objectType || !recordId || !template) {
+            throw new ApiError(400, "VALIDATION", "objectType, recordId, and template are required");
+        }
+        const variant = parseStoryVariant(queryValue(query.variant));
+        const view = findObjectType(await options.loadCatalog(options.upstream, scope), objectType);
+        if (!view)
+            return options.upstream.get(storyContentPath(objectType, STORY_TYPE, recordId, template), scope);
+        const storyType = findContentType(view, STORY_TYPE);
+        const aiType = findContentType(view, STORY_AI_TYPE);
+        if (!declaredTemplate(storyType, template)) {
+            if (!storyType)
+                return options.upstream.get(storyContentPath(objectType, STORY_TYPE, recordId, template), scope);
+            const rows = await recordInstances(scope, objectType, STORY_TYPE, recordId, undefined, undefined);
+            return contentInstance(scope, objectType, STORY_TYPE, recordId, TEMPLATE_PATH, template, rows);
+        }
+        const [storyRows, aiRows] = await Promise.all([
+            storyType ? recordInstances(scope, objectType, STORY_TYPE, recordId, undefined, undefined) : Promise.resolve([]),
+            aiType ? recordInstances(scope, objectType, STORY_AI_TYPE, recordId, undefined, undefined) : Promise.resolve([]),
+        ]);
+        const choice = chooseStory({
+            variant,
+            template,
+            storyDeclared: Boolean(storyType),
+            aiDeclared: Boolean(aiType),
+            storyRows,
+            aiRows,
+        });
+        if (!choice.record || !choice.contentType) {
+            return reply.status(404).send({
+                error: { code: "STORY_NOT_FOUND", message: `No usable ${template} story for ${recordId}` },
+                story: choice.block,
+            });
+        }
+        const revision = typeof choice.record.revision === "number" ? choice.record.revision : null;
+        return {
+            scope: scopeBody(scope),
+            addressing: {
+                orgId: scope.orgId,
+                objectType,
+                contentType: choice.contentType,
+                id: recordId,
+                recordId,
+                discriminator: { path: TEMPLATE_PATH, value: template },
+            },
+            record: choice.record,
+            currentRevision: revision,
+            unresolvedRelationships: [],
+            story: choice.block,
+        };
+    });
+    app.get("/api/v1/data/stories", async (req) => {
+        const scope = await options.scopeFor(req);
+        const query = (req.query ?? {});
+        const objectType = queryValue(query.objectType);
+        const recordId = queryValue(query.recordId) ?? queryValue(query.id);
+        if (!objectType || !recordId) {
+            throw new ApiError(400, "VALIDATION", "objectType and recordId are required");
+        }
+        const variant = parseStoryVariant(queryValue(query.variant));
+        const view = findObjectType(await options.loadCatalog(options.upstream, scope), objectType);
+        if (!view)
+            return options.upstream.get(storyContentPath(objectType, STORY_TYPE, recordId), scope);
+        const storyType = findContentType(view, STORY_TYPE);
+        const aiType = findContentType(view, STORY_AI_TYPE);
+        const templates = storyTemplates(storyType);
+        const [storyRows, aiRows] = await Promise.all([
+            storyType ? recordInstances(scope, objectType, STORY_TYPE, recordId, undefined, undefined) : Promise.resolve([]),
+            aiType ? recordInstances(scope, objectType, STORY_AI_TYPE, recordId, undefined, undefined) : Promise.resolve([]),
+        ]);
+        return {
+            scope: scopeBody(scope),
+            objectType,
+            recordId,
+            stories: templates.map((item) => {
+                const choice = chooseStory({
+                    variant,
+                    template: item.value,
+                    storyDeclared: Boolean(storyType),
+                    aiDeclared: Boolean(aiType),
+                    storyRows,
+                    aiRows,
+                });
+                return {
+                    template: item.value,
+                    ...(item.label ? { label: item.label } : {}),
+                    story: choice.block,
+                    record: choice.record,
+                };
+            }),
+        };
+    });
+    for (const [publicPath, upstreamPath] of Object.entries(READ_POSTS)) {
+        app.post(publicPath, async (req) => {
+            const scope = await options.scopeFor(req);
+            return options.upstream.post(`${upstreamPath}${searchOf(req)}`, scope, req.body ?? {});
+        });
+    }
+    app.post("/api/v1/nexum/query", async (req) => {
+        const scope = await options.scopeFor(req);
+        return nexumCanvas(() => options.upstream.post(`/api/knowledge/query${searchOf(req)}`, scope, req.body ?? {}));
+    });
+    async function discriminatorPath(scope, objectType, contentType) {
+        const view = findObjectType(await options.loadCatalog(options.upstream, scope), objectType);
+        const contentTypeView = view ? findContentType(view, contentType) : null;
+        return contentTypeView?.discriminator?.path ?? null;
+    }
+    async function recordInstances(scope, objectType, contentType, recordId, include, includeDeleted) {
+        const rows = [];
+        const seen = new Set();
+        let cursor;
+        for (let page = 0; page < INSTANCE_PAGES; page += 1) {
+            const params = new URLSearchParams({
+                objectType,
+                contentType,
+                limit: "200",
+                filter: JSON.stringify([{ field: "recordId", op: "in", value: [recordId] }]),
+            });
+            if (include)
+                params.set("include", include);
+            if (includeDeleted)
+                params.set("includeDeleted", includeDeleted);
+            if (cursor)
+                params.set("cursor", cursor);
+            const body = asRecord(await options.upstream.get(`/api/data/content?${params.toString()}`, scope));
+            for (const item of Array.isArray(body?.records) ? body.records : []) {
+                const row = asRecord(item);
+                if (row && (row.recordId === undefined || row.recordId === recordId))
+                    rows.push(row);
+            }
+            const next = asRecord(body?.pageInfo)?.nextCursor;
+            if (typeof next !== "string" || !next || seen.has(next))
+                break;
+            seen.add(next);
+            cursor = next;
+        }
+        return rows;
+    }
+    app.get("/api/v1/nexum/status", async (req) => {
+        const scope = await options.scopeFor(req);
+        const body = asRecord(await options.upstream.get("/api/knowledge/status", scope));
+        if (!body)
+            return { scope: scopeBody(scope) };
+        return {
+            ...body,
+            upstreamMcpUrl: body.mcpUrl,
+            mcpUrl: publicUrl(req, "/api/v1/mcp/nexum"),
+        };
+    });
+    app.get("/api/v1/nexum/entities", async (req) => {
+        const scope = await options.scopeFor(req);
+        return nexumCanvas(() => options.upstream.get(`/api/knowledge/entities${searchOf(req)}`, scope));
+    });
+    app.get("/api/v1/nexum/entities/*", async (req) => {
+        const scope = await options.scopeFor(req);
+        const entityId = wildcard(req);
+        if (!entityId)
+            throw new ApiError(400, "VALIDATION", "entityId required");
+        return nexumCanvas(() => options.upstream.get(`/api/knowledge/entities/${encodeURIComponent(entityId)}${searchOf(req)}`, scope));
+    });
+    app.get("/api/v1/nexum/snapshots", async (req) => {
+        const scope = await options.scopeFor(req);
+        const query = (req.query ?? {});
+        const limit = limitOf(query.limit);
+        const cursor = typeof query.cursor === "string" && query.cursor ? query.cursor : undefined;
+        const params = new URLSearchParams({
+            objectType: "content",
+            contentType: "snapshots",
+            limit: String(limit),
+        });
+        if (cursor)
+            params.set("cursor", cursor);
+        const listed = asRecord(await options.upstream.get(`/api/data/content?${params.toString()}`, scope));
+        const records = Array.isArray(listed?.records) ? listed.records : [];
+        const kept = truthy(query.knowledgeGraphOnly) ? records.filter(isKnowledgeGraph) : records;
+        const pageInfo = asRecord(listed?.pageInfo);
+        return {
+            ...(listed ?? {}),
+            scope: listed?.scope ?? scopeBody(scope),
+            addressing: listed?.addressing ?? { objectType: "content", contentType: "snapshots" },
+            records: kept,
+            pageInfo: {
+                nextCursor: typeof pageInfo?.nextCursor === "string" ? pageInfo.nextCursor : null,
+                limit: typeof pageInfo?.limit === "number" ? pageInfo.limit : limit,
+            },
+        };
+    });
+    app.get("/api/v1/nexum/snapshots/*", async (req) => {
+        const scope = await options.scopeFor(req);
+        const raw = wildcard(req);
+        const connected = raw.endsWith("/connected");
+        const recordId = (connected ? raw.slice(0, -"/connected".length) : raw).replace(/\/$/, "");
+        if (!recordId)
+            throw new ApiError(400, "VALIDATION", "recordId required");
+        const params = new URLSearchParams({
+            objectType: "content",
+            contentType: "snapshots",
+            recordId,
+        });
+        const loaded = await options.upstream.get(`/api/data/content?${params.toString()}`, scope);
+        const record = contentRecord(loaded);
+        if (!connected) {
+            const body = asRecord(loaded) ?? {};
+            return { ...body, knowledgeGraph: isKnowledgeGraph(record) };
+        }
+        const sourceRefs = sourceRefsOf(record).slice(0, MAX_SOURCE_REFS);
+        const contentTypes = contentTypesOf(req.query?.contentTypes);
+        const rows = [];
+        for (const sourceRecordId of sourceRefs) {
+            rows.push(await connectedContent(options.upstream, scope, sourceRecordId, contentTypes));
+        }
+        return {
+            scope: scopeBody(scope),
+            snapshot: {
+                objectType: "content",
+                contentType: "snapshots",
+                recordId,
+                knowledgeGraph: isKnowledgeGraph(record),
+            },
+            sourceRefs,
+            connected: rows,
+        };
+    });
+    app.get("/api/v1/mcp", async (req) => {
+        const scope = await options.scopeFor(req);
+        const mgcUrl = await mgcEndpoint();
+        let nexum = null;
+        let nexumError;
+        try {
+            const advertised = await exchange(options.fetchImpl, "GET", nexumMcpEndpoint, scope);
+            nexum = advertised.body;
+        }
+        catch (err) {
+            nexumError = err instanceof Error ? err.message : String(err);
+        }
+        return {
+            scope: scopeBody(scope),
+            servers: [
+                {
+                    id: "memorix-nexum",
+                    protocol: "mcp",
+                    transport: "json-rpc",
+                    url: publicUrl(req, "/api/v1/mcp/nexum"),
+                    upstream: nexumMcpEndpoint,
+                    tools: NEXUM_MCP_TOOLS,
+                    advertise: nexum,
+                    ...(nexumError ? { error: nexumError } : {}),
+                },
+                {
+                    id: "memorix-scoper",
+                    protocol: "mcp",
+                    transport: "json-rpc",
+                    url: publicUrl(req, "/api/v1/mcp/scoper"),
+                    package: `${SCOPER_RELEASE.package}@${SCOPER_RELEASE.version}`,
+                    tools: SCOPER_MCP_TOOL_NAMES,
+                    note: "Scope and subject reads hosted in this process. Saved functions are used when SCOPER_FUNCTIONS_DIR is set.",
+                },
+                {
+                    id: "memorix-mgc",
+                    protocol: "mcp",
+                    transport: "json-rpc",
+                    url: mgcUrl ? publicUrl(req, "/api/v1/mcp/mgc") : null,
+                    upstream: mgcUrl,
+                    configured: Boolean(mgcUrl),
+                    tools: ["mgc_list_connectors", "mgc_describe_connector", "mgc_fetch"],
+                    note: "Connector catalog and raw fetch on the MGC source host. Set MGC_MCP_URL or MGC_SOURCE_SERVICE_URL, or rely on Memorix GET /api/connectors genericConnectors.mcpUrl.",
+                },
+            ],
+        };
+        async function mgcEndpoint() {
+            if (discoveredMgc !== undefined)
+                return discoveredMgc;
+            try {
+                const body = asRecord(await options.upstream.get("/api/connectors", scope));
+                const generic = asRecord(body?.genericConnectors);
+                const url = typeof generic?.mcpUrl === "string" ? generic.mcpUrl.trim() : "";
+                discoveredMgc = url ? url.replace(/\/+$/, "") : null;
+            }
+            catch {
+                return null;
+            }
+            return discoveredMgc;
+        }
+    });
+    app.route({
+        method: ["GET", "POST"],
+        url: "/api/v1/mcp/nexum",
+        handler: async (req, reply) => {
+            const scope = await options.scopeFor(req);
+            await proxyMcp(options.fetchImpl, req, reply, nexumMcpEndpoint, scope, "memorix-nexum");
+        },
+    });
+    app.route({
+        method: ["GET", "POST"],
+        url: "/api/v1/mcp/mgc",
+        handler: async (req, reply) => {
+            const scope = await options.scopeFor(req);
+            const target = await resolveMgc(scope);
+            if (!target) {
+                throw new ApiError(404, "MGC_NOT_CONFIGURED", "MGC MCP URL is not configured. Set MGC_MCP_URL or MGC_SOURCE_SERVICE_URL, or expose genericConnectors.mcpUrl from Memorix.");
+            }
+            await proxyMcp(options.fetchImpl, req, reply, target, scope, "memorix-mgc");
+        },
+    });
+    async function resolveMgc(scope) {
+        if (discoveredMgc !== undefined)
+            return discoveredMgc;
+        try {
+            const body = asRecord(await options.upstream.get("/api/connectors", scope));
+            const generic = asRecord(body?.genericConnectors);
+            const url = typeof generic?.mcpUrl === "string" ? generic.mcpUrl.trim() : "";
+            discoveredMgc = url ? url.replace(/\/+$/, "") : null;
+        }
+        catch {
+            return null;
+        }
+        return discoveredMgc;
+    }
+}
+async function nexumCanvas(call) {
+    try {
+        return await call();
+    }
+    catch (err) {
+        if (err instanceof UpstreamError && err.statusCode === 500 && errorCode(err.body) === "INTERNAL_ERROR") {
+            const message = upstreamMessage(err.body);
+            if (UNREACHABLE.test(message)) {
+                throw new ApiError(502, "NEXUM_UPSTREAM_UNREACHABLE", `Nexum explore service is unreachable from the Memorix host (Memorix said: ${message}). See GET /api/v1/nexum/status.`);
+            }
+        }
+        throw err;
+    }
+}
+function queryValue(raw) {
+    const value = Array.isArray(raw) ? raw[0] : raw;
+    if (typeof value !== "string")
+        return undefined;
+    const trimmed = value.trim();
+    return trimmed || undefined;
+}
+/** SafeFilter array, one SafeFilter, or an equality map. `null` when the text is not one of those. */
+function parseFilter(raw) {
+    if (!raw)
+        return null;
+    let parsed;
+    try {
+        parsed = JSON.parse(raw);
+    }
+    catch {
+        return null;
+    }
+    const clause = (item) => {
+        const record = asRecord(item);
+        return record && typeof record.field === "string" && typeof record.op === "string"
+            ? { field: record.field, op: record.op, value: record.value }
+            : null;
+    };
+    if (Array.isArray(parsed)) {
+        const clauses = parsed.map(clause);
+        return clauses.every((item) => item !== null) ? clauses : null;
+    }
+    const single = clause(parsed);
+    if (single)
+        return [single];
+    const map = asRecord(parsed);
+    if (!map)
+        return null;
+    return Object.entries(map).map(([field, value]) => ({ field, op: "eq", value }));
+}
+function discriminatorFromFilter(filters, path) {
+    for (const filter of filters ?? []) {
+        if (filter.field !== path || filter.op !== "eq")
+            continue;
+        const value = filter.value;
+        if (typeof value === "string" || typeof value === "number" || typeof value === "boolean") {
+            return String(value);
+        }
+    }
+    return undefined;
+}
+function stringAt(root, path) {
+    let current = root;
+    for (const part of path.split(".").filter(Boolean)) {
+        const record = asRecord(current);
+        if (!record)
+            return undefined;
+        current = record[part];
+    }
+    if (typeof current === "string" || typeof current === "number" || typeof current === "boolean") {
+        return String(current);
+    }
+    return undefined;
+}
+function storyContentPath(objectType, contentType, recordId, template) {
+    const params = new URLSearchParams({ objectType, contentType, recordId });
+    if (template) {
+        params.set("filter", JSON.stringify([{ field: TEMPLATE_PATH, op: "eq", value: template }]));
+    }
+    return `/api/data/content?${params.toString()}`;
+}
+function contentInstance(scope, objectType, contentType, recordId, path, value, rows) {
+    const record = latest(rows.filter((row) => stringAt(row, path) === value));
+    if (!record) {
+        throw new ApiError(404, "READ_NOT_FOUND", notFoundMessage(rows, recordId, contentType, path, value));
+    }
+    return {
+        scope: scopeBody(scope),
+        addressing: {
+            orgId: scope.orgId,
+            objectType,
+            contentType,
+            id: recordId,
+            recordId,
+            discriminator: { path, value },
+        },
+        record,
+        currentRevision: typeof record.revision === "number" ? record.revision : null,
+        unresolvedRelationships: [],
+    };
+}
+function latest(rows) {
+    let best;
+    for (const row of rows) {
+        const revision = typeof row.revision === "number" ? row.revision : -1;
+        const bestRevision = typeof best?.revision === "number" ? best.revision : -1;
+        if (!best || revision > bestRevision)
+            best = row;
+    }
+    return best;
+}
+function notFoundMessage(rows, recordId, contentType, path, value) {
+    if (rows.length === 0)
+        return `Content not found for ${recordId}/${contentType}`;
+    const stored = [...new Set(rows.map((row) => stringAt(row, path)).filter((v) => v !== undefined))];
+    const present = stored.length > 0
+        ? `Stored values: ${stored.map((v) => JSON.stringify(v)).join(", ")}.`
+        : `The stored ${rows.length === 1 ? "row has" : "rows have"} no ${path}.`;
+    return `No ${contentType} instance of ${recordId} has ${path} = ${JSON.stringify(value)}. ${present}`;
+}
+function upstreamMessage(body) {
+    const error = asRecord(asRecord(body)?.error);
+    return typeof error?.message === "string" ? error.message : "";
+}
+function normalizeMcpUrl(url) {
+    const trimmed = url?.trim() ?? "";
+    return trimmed ? trimmed.replace(/\/+$/, "") : null;
+}
+function wildcard(req) {
+    const params = req.params;
+    return (params["*"] ?? params.path ?? "").trim();
+}
+function searchOf(req) {
+    const index = req.url.indexOf("?");
+    return index >= 0 ? req.url.slice(index) : "";
+}
+function memorixPath(raw, search) {
+    if (!raw || raw.includes("..") || raw.includes("\\")) {
+        throw new ApiError(400, "VALIDATION", "memorix path required");
+    }
+    const encoded = raw
+        .split("/")
+        .filter((part) => part.length > 0)
+        .map((part) => encodeURIComponent(part))
+        .join("/");
+    if (!encoded)
+        throw new ApiError(400, "VALIDATION", "memorix path required");
+    return `/api/${encoded}${search}`;
+}
+function assertFetchAllowed(upstreamPath) {
+    const pathname = upstreamPath.split("?")[0] ?? upstreamPath;
+    if (pathname === "/api/relationships/links" || pathname.startsWith("/api/relationships/links/")) {
+        throw new ApiError(403, "FETCH_DENIED", "Relationship links are not a fetch route");
+    }
+    if (/^\/api\/restricted-store\/(?:.*\/)?content$/.test(pathname)) {
+        throw new ApiError(403, "FETCH_DENIED", "Break-glass content stays on the Memorix host");
+    }
+}
+function publicUrl(req, path) {
+    const forwardedProto = headerValue(req.headers["x-forwarded-proto"]);
+    const proto = forwardedProto?.split(",")[0]?.trim() || req.protocol || "http";
+    const host = headerValue(req.headers["x-forwarded-host"]) ?? headerValue(req.headers.host) ?? "127.0.0.1:5120";
+    return `${proto}://${host}${path}`;
+}
+function headerValue(value) {
+    const raw = Array.isArray(value) ? value[0] : value;
+    const trimmed = raw?.trim();
+    return trimmed || undefined;
+}
+function limitOf(raw) {
+    if (raw === undefined || raw === "")
+        return 50;
+    const limit = Number(raw);
+    if (!Number.isFinite(limit))
+        throw new ApiError(400, "VALIDATION", "limit must be a number");
+    return Math.min(Math.max(Math.trunc(limit), 1), 200);
+}
+function truthy(raw) {
+    return raw === true || raw === "true" || raw === "1";
+}
+function isKnowledgeGraph(record) {
+    const data = asRecord(asRecord(record)?.data);
+    return data?.kind === "knowledge-graph";
+}
+function contentRecord(body) {
+    const root = asRecord(body);
+    if (!root)
+        return body;
+    return root.record ?? root;
+}
+function sourceRefsOf(record) {
+    const data = asRecord(asRecord(record)?.data);
+    const refs = data?.sourceRefs;
+    if (!Array.isArray(refs))
+        return [];
+    const out = [];
+    for (const ref of refs) {
+        const id = String(ref ?? "").trim();
+        if (id && !out.includes(id))
+            out.push(id);
+    }
+    return out;
+}
+function contentTypesOf(raw) {
+    if (raw === undefined || raw === null || raw === "")
+        return undefined;
+    let items;
+    if (Array.isArray(raw))
+        items = raw;
+    else if (typeof raw === "string") {
+        const trimmed = raw.trim();
+        if (!trimmed)
+            return undefined;
+        if (trimmed.startsWith("[")) {
+            try {
+                const parsed = JSON.parse(trimmed);
+                if (!Array.isArray(parsed))
+                    throw new ApiError(400, "VALIDATION", "contentTypes must be a list of strings");
+                items = parsed;
+            }
+            catch (err) {
+                if (err instanceof ApiError)
+                    throw err;
+                throw new ApiError(400, "VALIDATION", "contentTypes must be JSON or comma-separated");
+            }
+        }
+        else {
+            items = trimmed.split(",");
+        }
+    }
+    else {
+        throw new ApiError(400, "VALIDATION", "contentTypes must be a list of strings");
+    }
+    const out = [];
+    for (const item of items) {
+        const id = String(item ?? "").trim();
+        if (!id || out.includes(id))
+            continue;
+        out.push(id);
+        if (out.length > MAX_CONTENT_TYPES) {
+            throw new ApiError(400, "VALIDATION", `contentTypes exceeds ${MAX_CONTENT_TYPES}`);
+        }
+    }
+    return out.length > 0 ? out : undefined;
+}
+async function connectedContent(upstream, scope, recordId, contentTypes) {
+    try {
+        const composed = asRecord(await upstream.post("/api/data/compose/data", scope, {
+            recordId,
+            ...(contentTypes ? { contentTypes } : {}),
+        }));
+        return {
+            recordId,
+            found: true,
+            objectType: typeof composed?.objectType === "string" ? composed.objectType : null,
+            dataCategory: typeof composed?.dataCategory === "string" ? composed.dataCategory : null,
+            contents: composed?.contents ?? {},
+            warnings: composed?.warnings ?? [],
+        };
+    }
+    catch (err) {
+        if (!(err instanceof UpstreamError))
+            throw err;
+        const code = errorCode(err.body);
+        if (err.statusCode === 404 || code === "READ_NOT_FOUND" || code === "READ_UNAVAILABLE") {
+            return {
+                recordId,
+                found: false,
+                code: code || "READ_NOT_FOUND",
+                message: errorMessage(err.body),
+            };
+        }
+        throw err;
+    }
+}
+function errorCode(body) {
+    const error = asRecord(asRecord(body)?.error);
+    return typeof error?.code === "string" ? error.code : "";
+}
+function errorMessage(body) {
+    const error = asRecord(asRecord(body)?.error);
+    if (typeof error?.message === "string")
+        return error.message;
+    return "Subject was not found";
+}
+function scopeHeaders(scope) {
+    return {
+        accept: "application/json",
+        "content-type": "application/json",
+        "x-memorix-org-id": scope.orgId,
+        "x-memorix-agent-ids": scope.agentIds.join(","),
+        "x-memorix-caller": scope.caller,
+    };
+}
+async function exchange(fetchImpl, method, url, scope, body) {
+    let res;
+    try {
+        res = await fetchImpl(url, {
+            method,
+            headers: scopeHeaders(scope),
+            body: body === undefined ? undefined : JSON.stringify(body),
+        });
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        throw new UpstreamError(502, { error: { code: "UPSTREAM", message } });
+    }
+    const text = await res.text();
+    if (!text)
+        return { status: res.status, body: null };
+    try {
+        return { status: res.status, body: JSON.parse(text) };
+    }
+    catch {
+        return { status: res.status, body: text };
+    }
+}
+async function proxyMcp(fetchImpl, req, reply, target, scope, server) {
+    const method = req.method === "POST" ? "POST" : "GET";
+    const exchanged = await exchange(fetchImpl, method, target, scope, method === "POST" ? (req.body ?? {}) : undefined);
+    let payload = exchanged.body;
+    if (method === "GET" && server === "memorix-nexum") {
+        const body = asRecord(payload);
+        if (body) {
+            payload = {
+                ...body,
+                upstreamMcpUrl: body.mcpUrl,
+                mcpUrl: publicUrl(req, "/api/v1/mcp/nexum"),
+            };
+        }
+    }
+    reply.code(exchanged.status);
+    if (payload === null || payload === undefined) {
+        await reply.send();
+        return;
+    }
+    await reply.send(payload);
+}
+//# sourceMappingURL=fetch.js.map