@a5c-ai/agent-catalog 5.0.1-staging.b41a545e

package/dist/sdk.js

@@ -0,0 +1,902 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.clearAgentCatalogSdkCache = clearAgentCatalogSdkCache;
+exports.getCatalogGraphSnapshot = getCatalogGraphSnapshot;
+exports.getCatalogGraphDocument = getCatalogGraphDocument;
+exports.getCatalogOntologySchema = getCatalogOntologySchema;
+exports.getAgentCatalog = getAgentCatalog;
+exports.listCatalogClaims = listCatalogClaims;
+exports.getCapabilitySupportAssertions = getCapabilitySupportAssertions;
+exports.listAgentVersions = listAgentVersions;
+exports.getAgentVersions = getAgentVersions;
+exports.getAgentVersion = getAgentVersion;
+exports.listOntologyNodesByKind = listOntologyNodesByKind;
+exports.listOntologyRelations = listOntologyRelations;
+exports.listCapabilitySupportForSubject = listCapabilitySupportForSubject;
+exports.listCapabilitySupportByAgentVersion = listCapabilitySupportByAgentVersion;
+exports.getCapabilitySupportForAgentVersion = getCapabilitySupportForAgentVersion;
+exports.supportsAgentCapability = supportsAgentCapability;
+exports.getAgentVersionTopology = getAgentVersionTopology;
+exports.getProviderModelTopology = getProviderModelTopology;
+exports.listPackageSurfaces = listPackageSurfaces;
+exports.getPackageSurface = getPackageSurface;
+exports.listPackagesBySurfaceKind = listPackagesBySurfaceKind;
+exports.findPackageSurfaceByWorkspacePath = findPackageSurfaceByWorkspacePath;
+exports.listProcessDescriptors = listProcessDescriptors;
+exports.listProcessesByPackage = listProcessesByPackage;
+exports.listPathDescriptors = listPathDescriptors;
+exports.getPathDescriptor = getPathDescriptor;
+exports.listPathsByOwner = listPathsByOwner;
+exports.findProcessesByPath = findProcessesByPath;
+exports.getPackageTopology = getPackageTopology;
+exports.getFallbackHarnessMetadata = getFallbackHarnessMetadata;
+exports.listFallbackHarnessMetadata = listFallbackHarnessMetadata;
+exports.getHostSignalMap = getHostSignalMap;
+exports.getHostMetadataFields = getHostMetadataFields;
+exports.getHostDetectionRules = getHostDetectionRules;
+exports.getHooksMuxDetectionRules = getHooksMuxDetectionRules;
+exports.getHarnessImages = getHarnessImages;
+exports.lookupHarnessImage = lookupHarnessImage;
+exports.listPluginTargets = listPluginTargets;
+exports.listPluginTargetDescriptors = listPluginTargetDescriptors;
+exports.getPluginTargetDescriptor = getPluginTargetDescriptor;
+exports.getHookCatalog = getHookCatalog;
+exports.getHookNameMap = getHookNameMap;
+exports.getAgentVersionSlug = getAgentVersionSlug;
+exports.getUiAgentOntologyList = getUiAgentOntologyList;
+exports.getUiAgentOntologyEntry = getUiAgentOntologyEntry;
+exports.getUiAgentCards = getUiAgentCards;
+const data_1 = require("./data");
+const graph_1 = require("./graph");
+const transport_mux_cutover_1 = require("./transport-mux-cutover");
+const HARNESS_ALIASES = {
+    claude: "claude-code",
+    "claude-code": "claude-code",
+    codex: "codex",
+    cursor: "cursor",
+    gemini: "gemini-cli",
+    "gemini-cli": "gemini-cli",
+    copilot: "github-copilot",
+    "github-copilot": "github-copilot",
+    omp: "oh-my-pi",
+    "oh-my-pi": "oh-my-pi",
+    opencode: "opencode",
+    openclaw: "openclaw",
+    pi: "pi",
+};
+let cachedSdkState;
+function buildSdkState() {
+    const dataState = (0, data_1.getCatalogDataState)();
+    const graph = (0, graph_1.getCatalogGraph)();
+    return {
+        graph,
+        nodeById: new Map(graph.nodes.map((node) => [node.id, node])),
+        outgoingByNode: groupEdgesBy(graph.edges, "from"),
+        incomingByNode: groupEdgesBy(graph.edges, "to"),
+        agentByKey: new Map(dataState.agentCatalog.agents.map((agent) => [versionKey(agent.agentId, agent.versionRange), agent])),
+        providerVersionByKey: new Map(dataState.agentCatalog.providers.map((provider) => [versionKey(provider.providerId, provider.versionRange), provider])),
+        modelVersionByKey: new Map(dataState.agentCatalog.models.map((model) => [versionKey(model.modelId, model.versionRange), model])),
+        transportById: new Map(dataState.agentCatalog.transports.map((transport) => [transport.transportId, transport])),
+        capabilityById: new Map(dataState.agentCatalog.capabilities.map((capability) => [capability.capabilityId, capability])),
+        modalityById: new Map(dataState.agentCatalog.modalities.map((modality) => [modality.modalityId, modality])),
+        sessionById: new Map(dataState.agentCatalog.sessionNuances.map((nuance) => [nuance.nuanceId, nuance])),
+        lifecycleById: new Map(dataState.agentCatalog.lifecycleNuances.map((nuance) => [nuance.nuanceId, nuance])),
+        hookById: new Map(dataState.hooks.map((hook) => [hook.hookId, hook])),
+        pluginTargetById: new Map(dataState.pluginTargets.map((target) => [target.targetId, target])),
+    };
+}
+function getSdkState() {
+    if (!cachedSdkState) {
+        cachedSdkState = buildSdkState();
+    }
+    return cachedSdkState;
+}
+function clearAgentCatalogSdkCache() {
+    cachedSdkState = undefined;
+}
+function clone(value) {
+    return JSON.parse(JSON.stringify(value));
+}
+const AGENT_FILE_PATH = "packages/agent-catalog/graph/nodes/agents/versions.yaml";
+const AGENT_DIRECTORY = "packages/agent-catalog/graph";
+function slugifyVersionRange(versionRange) {
+    return slugify(versionRange);
+}
+function agentVersionNodeId(agent) {
+    return `agentVersion:${agent.agentId}:${slugifyVersionRange(agent.versionRange)}`;
+}
+function orderedByIds(ids, items, getId) {
+    const byId = new Map(items.map((item) => [getId(item), item]));
+    return ids.map((id) => byId.get(id)).filter((item) => Boolean(item));
+}
+function findProviderVersions(agent) {
+    return orderedByIds(agent.providerIds, data_1.AGENT_CATALOG.providers.filter((provider) => agent.providerIds.includes(provider.providerId)), (provider) => provider.providerId);
+}
+function findModelVersions(agent) {
+    return orderedByIds(agent.modelIds, data_1.AGENT_CATALOG.models.filter((model) => agent.modelIds.includes(model.modelId)), (model) => model.modelId);
+}
+function findTransports(agent) {
+    return orderedByIds(agent.transportIds, data_1.AGENT_CATALOG.transports.filter((transport) => agent.transportIds.includes(transport.transportId)), (transport) => transport.transportId);
+}
+function findModalities(agent) {
+    return orderedByIds(agent.modalityIds, data_1.AGENT_CATALOG.modalities.filter((modality) => agent.modalityIds.includes(modality.modalityId)), (modality) => modality.modalityId);
+}
+function findCapabilities(agent) {
+    return orderedByIds(agent.capabilityIds, data_1.AGENT_CATALOG.capabilities.filter((capability) => agent.capabilityIds.includes(capability.capabilityId)), (capability) => capability.capabilityId);
+}
+function groupEdgesBy(edges, key) {
+    const grouped = new Map();
+    for (const edge of edges) {
+        const bucket = grouped.get(edge[key]);
+        if (bucket) {
+            bucket.push(edge);
+            continue;
+        }
+        grouped.set(edge[key], [edge]);
+    }
+    return grouped;
+}
+function valueAsString(value) {
+    return typeof value === "string" ? value : "";
+}
+function stringArray(value) {
+    return Array.isArray(value) ? value.filter((entry) => typeof entry === "string") : [];
+}
+function nodeEvidenceIds(node) {
+    return node ? stringArray(node.evidenceRefs) : [];
+}
+function versionKey(subjectId, versionRange) {
+    return `${subjectId}@@${versionRange}`;
+}
+function normalizeLookup(value) {
+    return value.trim().toLowerCase();
+}
+function sortStrings(values) {
+    return [...values].sort((left, right) => left.localeCompare(right));
+}
+function uniqueBy(values, key) {
+    const seen = new Set();
+    const unique = [];
+    for (const value of values) {
+        const nextKey = key(value);
+        if (seen.has(nextKey)) {
+            continue;
+        }
+        seen.add(nextKey);
+        unique.push(value);
+    }
+    return unique;
+}
+function getNode(nodeId) {
+    return getSdkState().nodeById.get(nodeId);
+}
+function outgoingEdges(nodeId, relation) {
+    const edges = getSdkState().outgoingByNode.get(nodeId) ?? [];
+    return relation ? edges.filter((edge) => edge.relation === relation) : edges;
+}
+function incomingEdges(nodeId, relation) {
+    const edges = getSdkState().incomingByNode.get(nodeId) ?? [];
+    return relation ? edges.filter((edge) => edge.relation === relation) : edges;
+}
+function outgoingNodes(nodeId, relation) {
+    return outgoingEdges(nodeId, relation)
+        .map((edge) => getNode(edge.to))
+        .filter((node) => Boolean(node));
+}
+function incomingNodes(nodeId, relation) {
+    return incomingEdges(nodeId, relation)
+        .map((edge) => getNode(edge.from))
+        .filter((node) => Boolean(node));
+}
+function toAgentProduct(node) {
+    return {
+        agentId: valueAsString(node.agentId),
+        displayName: valueAsString(node.displayName),
+        aliases: stringArray(node.aliases),
+        vendor: valueAsString(node.vendor),
+        families: stringArray(node.families),
+        status: valueAsString(node.status),
+        evidenceIds: nodeEvidenceIds(node),
+    };
+}
+function toModelProviderProduct(node) {
+    const homepage = valueAsString(node.homepage);
+    return {
+        providerId: valueAsString(node.providerId),
+        displayName: valueAsString(node.displayName),
+        kindLabel: valueAsString(node.kindLabel),
+        vendor: valueAsString(node.vendor),
+        homepage: homepage || null,
+        apiFamilies: stringArray(node.apiFamilies),
+        authKinds: stringArray(node.authKinds),
+        evidenceIds: nodeEvidenceIds(node),
+    };
+}
+function toModelFamily(node) {
+    return {
+        modelId: valueAsString(node.modelId),
+        providerId: valueAsString(node.providerId),
+        label: valueAsString(node.label),
+        modalities: stringArray(node.modalities),
+        reasoningFamily: valueAsString(node.reasoningFamily) || undefined,
+        status: valueAsString(node.status),
+        evidenceIds: nodeEvidenceIds(node),
+    };
+}
+function toTransportProtocol(node) {
+    return {
+        transportId: valueAsString(node.transportId),
+        label: valueAsString(node.label),
+        status: (0, transport_mux_cutover_1.effectiveTransportMuxClaimStatus)(valueAsString(node.status), nodeEvidenceIds(node)),
+        protocolKind: valueAsString(node.protocolKind),
+        interactive: Boolean(node.interactive),
+        streaming: Boolean(node.streaming),
+        requestShape: valueAsString(node.requestShape),
+        responseShape: valueAsString(node.responseShape),
+        evidenceIds: nodeEvidenceIds(node),
+    };
+}
+function toCapabilitySupport(node) {
+    return {
+        supportId: valueAsString(node.supportId),
+        capabilityId: valueAsString(node.capabilityId),
+        supportLevel: valueAsString(node.supportLevel),
+        subjectKind: valueAsString(node.subjectKind) || "AgentVersion",
+        subjectId: valueAsString(node.subjectId),
+        versionRange: valueAsString(node.versionRange),
+        notes: valueAsString(node.notes) || undefined,
+        evidenceIds: nodeEvidenceIds(node),
+    };
+}
+function toHookMapping(node) {
+    return {
+        mappingId: valueAsString(node.mappingId),
+        hookId: valueAsString(node.hookId),
+        targetId: valueAsString(node.targetId),
+        nativeName: valueAsString(node.nativeName),
+        versionRange: valueAsString(node.versionRange),
+        requiresRuntimeHooks: Boolean(node.requiresRuntimeHooks),
+        evidenceIds: nodeEvidenceIds(node),
+    };
+}
+function toDiscoverySignal(node) {
+    return {
+        signalId: valueAsString(node.signalId),
+        signalKind: valueAsString(node.signalKind),
+        key: valueAsString(node.key),
+        matchMode: valueAsString(node.matchMode),
+        confidence: valueAsString(node.confidence) || "low",
+        scope: valueAsString(node.scope),
+        signals: stringArray(node.signals),
+        absentSignals: stringArray(node.absentSignals),
+        argvMatches: stringArray(node.argvMatches),
+        metadataFields: (Array.isArray(node.metadataFields) ? node.metadataFields : []).map((field) => ({
+            key: valueAsString(field.key),
+            envVars: stringArray(field.envVars),
+        })),
+        evidenceIds: nodeEvidenceIds(node),
+    };
+}
+function toPackageSurface(node) {
+    return {
+        packageId: valueAsString(node.packageId),
+        packageName: valueAsString(node.packageName),
+        workspacePath: valueAsString(node.workspacePath),
+        moduleType: valueAsString(node.moduleType),
+        surfaceKinds: stringArray(node.surfaceKinds),
+        sourceOfTruthRole: valueAsString(node.sourceOfTruthRole),
+        evidenceIds: nodeEvidenceIds(node),
+    };
+}
+function toPathDescriptor(node) {
+    return {
+        pathId: valueAsString(node.pathId),
+        path: valueAsString(node.path),
+        pathKind: valueAsString(node.pathKind),
+        ownerKind: valueAsString(node.ownerKind),
+        ownerId: valueAsString(node.ownerId),
+        platform: valueAsString(node.platform),
+        notes: valueAsString(node.notes) || undefined,
+        evidenceIds: nodeEvidenceIds(node),
+    };
+}
+function toCiSurface(node) {
+    return {
+        ciId: valueAsString(node.ciId),
+        packageId: valueAsString(node.packageId),
+        scripts: stringArray(node.scripts),
+        publishStrategy: valueAsString(node.publishStrategy),
+        releaseChannels: stringArray(node.releaseChannels),
+        validationCommands: stringArray(node.validationCommands),
+        evidenceIds: nodeEvidenceIds(node),
+    };
+}
+function slugify(versionRange) {
+    return versionRange
+        .replace(/>=/g, "ge-")
+        .replace(/<=/g, "le-")
+        .replace(/>/g, "gt-")
+        .replace(/</g, "lt-")
+        .replace(/=/g, "eq-")
+        .replace(/\s+/g, "-")
+        .replace(/[^a-zA-Z0-9-]+/g, "-")
+        .replace(/-+/g, "-")
+        .replace(/^-|-$/g, "")
+        .toLowerCase();
+}
+function parseVersion(version) {
+    const match = version.trim().match(/^v?(\d+(?:\.\d+)*)/);
+    if (!match) {
+        return undefined;
+    }
+    return match[1].split(".").map((part) => Number.parseInt(part, 10));
+}
+function compareVersions(left, right) {
+    const length = Math.max(left.length, right.length);
+    for (let index = 0; index < length; index += 1) {
+        const leftPart = left[index] ?? 0;
+        const rightPart = right[index] ?? 0;
+        if (leftPart !== rightPart) {
+            return leftPart < rightPart ? -1 : 1;
+        }
+    }
+    return 0;
+}
+function rangeLowerBound(range) {
+    const tokens = range.split(/\s+/).filter(Boolean);
+    for (const token of tokens) {
+        const match = token.match(/^(>=|>|=)?(.+)$/);
+        if (!match) {
+            continue;
+        }
+        const comparator = match[1] ?? "=";
+        if (!["=", ">=", ">"].includes(comparator)) {
+            continue;
+        }
+        const parsed = parseVersion(match[2]);
+        if (parsed) {
+            return parsed;
+        }
+    }
+    return [0, 0, 0];
+}
+function satisfiesVersion(version, range) {
+    const parsedVersion = parseVersion(version);
+    if (!parsedVersion) {
+        return false;
+    }
+    const tokens = range.split(/\s+/).filter(Boolean);
+    return tokens.every((token) => {
+        const match = token.match(/^(>=|<=|>|<|=)?(.+)$/);
+        if (!match) {
+            return false;
+        }
+        const comparator = match[1] ?? "=";
+        const parsedTarget = parseVersion(match[2]);
+        if (!parsedTarget) {
+            return false;
+        }
+        const comparison = compareVersions(parsedVersion, parsedTarget);
+        switch (comparator) {
+            case ">":
+                return comparison > 0;
+            case ">=":
+                return comparison >= 0;
+            case "<":
+                return comparison < 0;
+            case "<=":
+                return comparison <= 0;
+            case "=":
+            default:
+                return comparison === 0;
+        }
+    });
+}
+function sortVersionScopedNodes(nodes) {
+    return [...nodes].sort((left, right) => {
+        const leftBound = rangeLowerBound(valueAsString(left.versionRange));
+        const rightBound = rangeLowerBound(valueAsString(right.versionRange));
+        const comparison = compareVersions(rightBound, leftBound);
+        if (comparison !== 0) {
+            return comparison;
+        }
+        return left.id.localeCompare(right.id);
+    });
+}
+function agentVersionNodes(agentIdOrAlias) {
+    const graph = getSdkState().graph;
+    const normalized = normalizeLookup(agentIdOrAlias);
+    const products = graph.nodes.filter((node) => node.kind === "AgentProduct" &&
+        (valueAsString(node.agentId).toLowerCase() === normalized ||
+            valueAsString(node.displayName).toLowerCase() === normalized ||
+            stringArray(node.aliases).some((alias) => alias.toLowerCase() === normalized)));
+    const versionNodes = uniqueBy([
+        ...products.flatMap((product) => outgoingNodes(product.id, "has_version").filter((node) => node.kind === "AgentVersion")),
+        ...graph.nodes.filter((node) => node.kind === "AgentVersion" &&
+            (valueAsString(node.agentId).toLowerCase() === normalized ||
+                valueAsString(node.displayName).toLowerCase() === normalized ||
+                stringArray(node.aliases).some((alias) => alias.toLowerCase() === normalized))),
+    ], (node) => node.id);
+    return sortVersionScopedNodes(versionNodes);
+}
+function resolveVersionNode(nodes, selector) {
+    if (nodes.length === 0) {
+        return undefined;
+    }
+    if (!selector) {
+        return sortVersionScopedNodes(nodes)[0];
+    }
+    const normalizedSelector = normalizeLookup(selector);
+    const direct = nodes.find((node) => normalizeLookup(node.id) === normalizedSelector ||
+        normalizeLookup(valueAsString(node.versionRange)) === normalizedSelector ||
+        normalizeLookup(valueAsString(node.agentVersionId)) === normalizedSelector);
+    if (direct) {
+        return direct;
+    }
+    const semanticMatches = nodes.filter((node) => satisfiesVersion(selector, valueAsString(node.versionRange)));
+    return sortVersionScopedNodes(semanticMatches)[0];
+}
+function typedAgentVersionFromNode(node) {
+    return getSdkState().agentByKey.get(versionKey(valueAsString(node.agentId), valueAsString(node.versionRange)));
+}
+function typedProviderVersionFromNode(node) {
+    return getSdkState().providerVersionByKey.get(versionKey(valueAsString(node.providerId), valueAsString(node.versionRange)));
+}
+function typedModelVersionFromNode(node) {
+    return getSdkState().modelVersionByKey.get(versionKey(valueAsString(node.modelId), valueAsString(node.versionRange)));
+}
+function typedTransportFromNode(node) {
+    return getSdkState().transportById.get(valueAsString(node.runtimeId));
+}
+function typedCapabilityFromNode(node) {
+    return getSdkState().capabilityById.get(valueAsString(node.capabilityId));
+}
+function typedModalityFromNode(node) {
+    return getSdkState().modalityById.get(valueAsString(node.modalityId));
+}
+function typedSessionFromNode(node) {
+    return getSdkState().sessionById.get(valueAsString(node.sessionSemanticsId));
+}
+function typedLifecycleFromNode(node) {
+    return getSdkState().lifecycleById.get(valueAsString(node.lifecycleSemanticsId));
+}
+function typedHookFromNode(node) {
+    return getSdkState().hookById.get(valueAsString(node.hookId));
+}
+function typedPluginTargetFromNode(node) {
+    return getSdkState().pluginTargetById.get(valueAsString(node.targetId));
+}
+function capabilitySupportNodesForSubject(subjectId) {
+    return outgoingNodes(subjectId, "supports_capability").filter((node) => node.kind === "CapabilitySupport");
+}
+function capabilitySupportForSubject(subjectId) {
+    return capabilitySupportNodesForSubject(subjectId).map(toCapabilitySupport);
+}
+function capabilitiesForSupportNodes(nodes) {
+    return uniqueBy(nodes
+        .flatMap((node) => outgoingNodes(node.id, "for_capability"))
+        .filter((node) => node.kind === "Capability")
+        .map((node) => typedCapabilityFromNode(node))
+        .filter((capability) => Boolean(capability)), (capability) => capability.capabilityId);
+}
+function findHooks(agent) {
+    return orderedByIds(agent.hookIds, data_1.AGENT_CATALOG.hooks.filter((hook) => agent.hookIds.includes(hook.hookId)), (hook) => hook.hookId);
+}
+function findPluginTargets(agent) {
+    return orderedByIds(agent.pluginTargetIds, data_1.PLUGIN_TARGETS.filter((target) => agent.pluginTargetIds.includes(target.targetId)), (target) => target.targetId);
+}
+function findSessionSemantics(agent) {
+    return orderedByIds(agent.sessionNuanceIds, data_1.AGENT_CATALOG.sessionNuances.filter((nuance) => agent.sessionNuanceIds.includes(nuance.nuanceId)), (nuance) => nuance.nuanceId);
+}
+function findLifecycleSemantics(agent) {
+    return orderedByIds(agent.lifecycleNuanceIds, data_1.AGENT_CATALOG.lifecycleNuances.filter((nuance) => agent.lifecycleNuanceIds.includes(nuance.nuanceId)), (nuance) => nuance.nuanceId);
+}
+function findCapabilityMatrix(agent) {
+    const subjectId = agentVersionNodeId(agent);
+    return data_1.CAPABILITY_ASSERTIONS.filter((assertion) => assertion.subjectKind === "AgentVersion" && assertion.subjectId === subjectId);
+}
+function findClaims(agent, capabilityMatrix) {
+    const claimMap = new Map();
+    for (const assertion of capabilityMatrix) {
+        for (const claim of assertion.supportingClaims) {
+            claimMap.set(claim.claimId, claim);
+        }
+    }
+    for (const claim of data_1.CLAIMS) {
+        if (claim.subjectKind === "AgentVersion" && claim.subjectId === agentVersionNodeId(agent)) {
+            claimMap.set(claim.claimId, claim);
+        }
+        if (agent.evidenceIds.includes(claim.claimId)) {
+            claimMap.set(claim.claimId, claim);
+        }
+    }
+    return Array.from(claimMap.values());
+}
+function findEvidence(agent, capabilityMatrix, claims) {
+    const evidenceIds = new Set([
+        ...agent.evidenceIds,
+        ...capabilityMatrix.flatMap((assertion) => assertion.evidenceIds),
+        ...claims.flatMap((claim) => claim.evidenceIds),
+    ]);
+    return data_1.AGENT_CATALOG.evidence.filter((evidence) => evidenceIds.has(evidence.evidenceId));
+}
+function buildEvidenceSummary(capabilityMatrix, claims, evidenceCount) {
+    return {
+        evidenceCount,
+        claimCount: claims.length,
+        corroboratedCount: capabilityMatrix.filter((assertion) => assertion.evidenceStrength === "corroborated").length,
+        partialCount: capabilityMatrix.filter((assertion) => assertion.evidenceStrength === "partial").length,
+        inferredCount: capabilityMatrix.filter((assertion) => assertion.evidenceStrength === "inferred").length,
+        unresolvedGapCount: new Set(capabilityMatrix.flatMap((assertion) => assertion.unresolvedGaps)).size,
+    };
+}
+function toAgentReference(agent) {
+    return {
+        id: agentVersionNodeId(agent),
+        slug: getAgentVersionSlug(agent),
+        agentId: agent.agentId,
+        name: agent.displayName,
+        versionRange: agent.versionRange,
+    };
+}
+function buildOntologyListItem(agent) {
+    const capabilityMatrix = findCapabilityMatrix(agent);
+    const claims = findClaims(agent, capabilityMatrix);
+    const evidence = findEvidence(agent, capabilityMatrix, claims);
+    return {
+        ...toAgentReference(agent),
+        aliases: agent.aliases,
+        runtimeFamily: agent.runtimeFamily,
+        releaseChannel: agent.releaseChannel,
+        since: agent.since,
+        until: agent.until,
+        osSupport: agent.osSupport,
+        description: agent.summary,
+        sourcePackage: agent.sourcePackage,
+        providers: findProviderVersions(agent),
+        models: findModelVersions(agent),
+        transports: findTransports(agent),
+        modalities: findModalities(agent),
+        capabilities: findCapabilities(agent),
+        hooks: findHooks(agent),
+        pluginTargets: findPluginTargets(agent),
+        sessionSemantics: findSessionSemantics(agent),
+        lifecycleSemantics: findLifecycleSemantics(agent),
+        evidenceSummary: buildEvidenceSummary(capabilityMatrix, claims, evidence.length),
+        filePath: AGENT_FILE_PATH,
+        directory: AGENT_DIRECTORY,
+    };
+}
+function getRelatedVersionReferences(agent, relation, direction) {
+    const currentNodeId = agentVersionNodeId(agent);
+    const matchingIds = (0, graph_1.listRelationshipsByRelation)(relation)
+        .filter((edge) => (direction === "from" ? edge.from === currentNodeId : edge.to === currentNodeId))
+        .map((edge) => (direction === "from" ? edge.to : edge.from));
+    return data_1.AGENT_CATALOG.agents
+        .filter((candidate) => matchingIds.includes(agentVersionNodeId(candidate)))
+        .map(toAgentReference);
+}
+function productNodeForVersionNode(versionNodeId) {
+    return incomingNodes(versionNodeId, "has_version")[0];
+}
+function getCatalogGraphSnapshot() {
+    return clone((0, graph_1.getCatalogGraph)());
+}
+function getCatalogGraphDocument() {
+    return clone(data_1.GRAPH_DOCUMENT);
+}
+function getCatalogOntologySchema() {
+    return clone(data_1.ONTOLOGY_SCHEMA);
+}
+function getAgentCatalog() {
+    return clone(data_1.AGENT_CATALOG);
+}
+function listCatalogClaims() {
+    return clone(data_1.CLAIMS);
+}
+function getCapabilitySupportAssertions() {
+    return clone(data_1.CAPABILITY_ASSERTIONS);
+}
+function listAgentVersions() {
+    return clone(data_1.AGENT_CATALOG.agents);
+}
+function getAgentVersions(agentIdOrAlias) {
+    return agentVersionNodes(agentIdOrAlias)
+        .map((node) => typedAgentVersionFromNode(node))
+        .filter((agent) => Boolean(agent))
+        .map(clone);
+}
+function getAgentVersion(agentIdOrAlias, versionSelector) {
+    const node = resolveVersionNode(agentVersionNodes(agentIdOrAlias), versionSelector);
+    const agent = node ? typedAgentVersionFromNode(node) : undefined;
+    return agent ? clone(agent) : undefined;
+}
+function listOntologyNodesByKind(kind) {
+    return clone((0, graph_1.listGraphNodes)().filter((node) => node.kind === kind));
+}
+function listOntologyRelations(relation) {
+    return clone((0, graph_1.listRelationshipsByRelation)(relation));
+}
+function listCapabilitySupportForSubject(subjectId) {
+    return capabilitySupportForSubject(subjectId).map(clone);
+}
+function listCapabilitySupportByAgentVersion(agentIdOrAlias) {
+    return getAgentVersions(agentIdOrAlias).map((agent) => {
+        const nodeId = `agentVersion:${agent.agentId}:${slugify(agent.versionRange)}`;
+        const supportNodes = capabilitySupportNodesForSubject(nodeId);
+        return {
+            agent,
+            capabilitySupport: supportNodes.map(toCapabilitySupport),
+            capabilities: capabilitiesForSupportNodes(supportNodes),
+        };
+    }).map(clone);
+}
+function getCapabilitySupportForAgentVersion(agentIdOrAlias, versionSelector) {
+    const agentNode = resolveVersionNode(agentVersionNodes(agentIdOrAlias), versionSelector);
+    return agentNode ? capabilitySupportForSubject(agentNode.id).map(clone) : [];
+}
+function supportsAgentCapability(agentIdOrAlias, capabilityId, versionSelector) {
+    return getCapabilitySupportForAgentVersion(agentIdOrAlias, versionSelector).some((record) => record.capabilityId === capabilityId);
+}
+function getAgentVersionTopology(agentIdOrAlias, versionSelector) {
+    const agentNode = resolveVersionNode(agentVersionNodes(agentIdOrAlias), versionSelector);
+    const agent = agentNode ? typedAgentVersionFromNode(agentNode) : undefined;
+    if (!agentNode || !agent) {
+        return undefined;
+    }
+    const productNode = productNodeForVersionNode(agentNode.id);
+    const supportNodes = capabilitySupportNodesForSubject(agentNode.id);
+    const defaultModelNodes = outgoingNodes(agentNode.id, "defaults_to_model").filter((node) => node.kind === "ModelVersion");
+    const providerVersionNodes = uniqueBy(defaultModelNodes.flatMap((node) => outgoingNodes(node.id, "provided_by").filter((candidate) => candidate.kind === "ModelProviderVersion")), (node) => node.id);
+    const providerNodes = uniqueBy(providerVersionNodes.flatMap((node) => incomingNodes(node.id, "has_version").filter((candidate) => candidate.kind === "ModelProviderProduct")), (node) => node.id);
+    const transportRuntimeNodes = outgoingNodes(agentNode.id, "uses_transport").filter((node) => node.kind === "TransportRuntime");
+    const transportProtocolNodes = uniqueBy(outgoingNodes(agentNode.id, "uses_transport").filter((node) => node.kind === "TransportProtocol" && (0, transport_mux_cutover_1.shouldSurfaceTransportProtocol)(nodeEvidenceIds(node))), (node) => node.id);
+    const modalityNodes = outgoingNodes(agentNode.id, "supports_modality").filter((node) => node.kind === "Modality");
+    const sessionNodes = outgoingNodes(agentNode.id, "uses_session_semantics").filter((node) => node.kind === "SessionSemantics");
+    const lifecycleNodes = outgoingNodes(agentNode.id, "uses_lifecycle_semantics").filter((node) => node.kind === "LifecycleSemantics");
+    const discoveryNodes = outgoingNodes(agentNode.id, "discovered_by").filter((node) => node.kind === "DiscoverySignal");
+    const hookMappingNodes = outgoingNodes(agentNode.id, "emits_hook").filter((node) => node.kind === "HookMapping");
+    const hookNodes = uniqueBy(hookMappingNodes.flatMap((node) => outgoingNodes(node.id, "maps_hook").filter((candidate) => candidate.kind === "HookSurface")), (node) => node.id);
+    const pluginTargetNodes = outgoingNodes(agentNode.id, "targets_plugin_surface").filter((node) => node.kind === "PluginTarget");
+    return clone({
+        agent,
+        product: productNode?.kind === "AgentProduct" ? toAgentProduct(productNode) : undefined,
+        capabilitySupport: supportNodes.map(toCapabilitySupport),
+        capabilities: capabilitiesForSupportNodes(supportNodes),
+        defaultModels: defaultModelNodes
+            .map((node) => typedModelVersionFromNode(node))
+            .filter((model) => Boolean(model)),
+        modelFamilies: uniqueBy(defaultModelNodes
+            .flatMap((node) => incomingNodes(node.id, "has_version").filter((candidate) => candidate.kind === "ModelFamily"))
+            .map(toModelFamily), (model) => model.modelId),
+        providerVersions: providerVersionNodes
+            .map((node) => typedProviderVersionFromNode(node))
+            .filter((provider) => Boolean(provider)),
+        providers: providerNodes.map(toModelProviderProduct),
+        transportRuntimes: transportRuntimeNodes
+            .map((node) => typedTransportFromNode(node))
+            .filter((transport) => Boolean(transport)),
+        transportProtocols: transportProtocolNodes.map(toTransportProtocol),
+        modalities: modalityNodes
+            .map((node) => typedModalityFromNode(node))
+            .filter((modality) => Boolean(modality)),
+        sessionSemantics: sessionNodes
+            .map((node) => typedSessionFromNode(node))
+            .filter((nuance) => Boolean(nuance)),
+        lifecycleSemantics: lifecycleNodes
+            .map((node) => typedLifecycleFromNode(node))
+            .filter((nuance) => Boolean(nuance)),
+        discoverySignals: discoveryNodes.map(toDiscoverySignal),
+        hookMappings: hookMappingNodes.map(toHookMapping),
+        hooks: hookNodes
+            .map((node) => typedHookFromNode(node))
+            .filter((hook) => Boolean(hook)),
+        pluginTargets: pluginTargetNodes
+            .map((node) => typedPluginTargetFromNode(node))
+            .filter((target) => Boolean(target)),
+    });
+}
+function getProviderModelTopology(providerId) {
+    const providerNode = getNode(`provider:${providerId}`);
+    if (!providerNode || providerNode.kind !== "ModelProviderProduct") {
+        return undefined;
+    }
+    const providerVersionNodes = outgoingNodes(providerNode.id, "has_version").filter((node) => node.kind === "ModelProviderVersion");
+    const modelVersionNodes = uniqueBy(providerVersionNodes.flatMap((node) => incomingNodes(node.id, "provided_by").filter((candidate) => candidate.kind === "ModelVersion")), (node) => node.id);
+    const modelFamilyNodes = uniqueBy(modelVersionNodes.flatMap((node) => incomingNodes(node.id, "has_version").filter((candidate) => candidate.kind === "ModelFamily")), (node) => node.id);
+    const agentNodes = uniqueBy(modelVersionNodes.flatMap((node) => incomingNodes(node.id, "defaults_to_model").filter((candidate) => candidate.kind === "AgentVersion")), (node) => node.id);
+    const supportNodes = uniqueBy(providerVersionNodes.flatMap((node) => capabilitySupportNodesForSubject(node.id)), (node) => node.id);
+    return clone({
+        provider: toModelProviderProduct(providerNode),
+        versions: providerVersionNodes
+            .map((node) => typedProviderVersionFromNode(node))
+            .filter((version) => Boolean(version)),
+        capabilitySupport: supportNodes.map(toCapabilitySupport),
+        capabilities: capabilitiesForSupportNodes(supportNodes),
+        models: modelVersionNodes
+            .map((node) => typedModelVersionFromNode(node))
+            .filter((model) => Boolean(model)),
+        modelFamilies: modelFamilyNodes.map(toModelFamily),
+        agents: agentNodes
+            .map((node) => typedAgentVersionFromNode(node))
+            .filter((agent) => Boolean(agent)),
+    });
+}
+function listPackageSurfaces() {
+    return getSdkState().graph.nodes.filter((node) => node.kind === "PackageSurface").map(toPackageSurface).map(clone);
+}
+function getPackageSurface(packageId) {
+    const node = getNode(`package:${packageId}`);
+    return node?.kind === "PackageSurface" ? clone(toPackageSurface(node)) : undefined;
+}
+function listPackagesBySurfaceKind(surfaceKind) {
+    return listPackageSurfaces().filter((pkg) => pkg.surfaceKinds.includes(surfaceKind));
+}
+function findPackageSurfaceByWorkspacePath(workspacePath) {
+    const normalized = workspacePath.trim();
+    const node = getSdkState().graph.nodes.find((candidate) => candidate.kind === "PackageSurface" && valueAsString(candidate.workspacePath) === normalized);
+    return node ? clone(toPackageSurface(node)) : undefined;
+}
+function listProcessDescriptors() {
+    return clone(data_1.AGENT_CATALOG.processes);
+}
+function listProcessesByPackage(packageId) {
+    const packageNode = getNode(`package:${packageId}`);
+    if (!packageNode || packageNode.kind !== "PackageSurface") {
+        return [];
+    }
+    return outgoingNodes(packageNode.id, "surfaces_process")
+        .filter((node) => node.kind === "ProcessDescriptor")
+        .map((node) => data_1.AGENT_CATALOG.processes.find((process) => process.processId === valueAsString(node.processId)))
+        .filter((process) => Boolean(process))
+        .map(clone);
+}
+function listPathDescriptors() {
+    return getSdkState().graph.nodes.filter((node) => node.kind === "PathDescriptor").map(toPathDescriptor).map(clone);
+}
+function getPathDescriptor(pathIdOrPath) {
+    const directNode = getNode(`path:${pathIdOrPath}`);
+    if (directNode?.kind === "PathDescriptor") {
+        return clone(toPathDescriptor(directNode));
+    }
+    const pathNode = getSdkState().graph.nodes.find((node) => node.kind === "PathDescriptor" && valueAsString(node.pathId) === pathIdOrPath) ?? getSdkState().graph.nodes.find((node) => node.kind === "PathDescriptor" && valueAsString(node.path) === pathIdOrPath);
+    return pathNode ? clone(toPathDescriptor(pathNode)) : undefined;
+}
+function listPathsByOwner(ownerId) {
+    return outgoingNodes(ownerId, "references_path")
+        .filter((node) => node.kind === "PathDescriptor")
+        .map(toPathDescriptor)
+        .map(clone);
+}
+function findProcessesByPath(pathIdOrPath) {
+    const pathNode = getNode(`path:${pathIdOrPath}`) ??
+        getSdkState().graph.nodes.find((node) => node.kind === "PathDescriptor" &&
+            (valueAsString(node.pathId) === pathIdOrPath || valueAsString(node.path) === pathIdOrPath));
+    if (!pathNode || pathNode.kind !== "PathDescriptor") {
+        return [];
+    }
+    return incomingNodes(pathNode.id, "references_path")
+        .filter((node) => node.kind === "ProcessDescriptor")
+        .map((node) => data_1.AGENT_CATALOG.processes.find((process) => process.processId === valueAsString(node.processId)))
+        .filter((process) => Boolean(process))
+        .map(clone);
+}
+function getPackageTopology(packageId) {
+    const packageNode = getNode(`package:${packageId}`);
+    if (!packageNode || packageNode.kind !== "PackageSurface") {
+        return undefined;
+    }
+    const processNodes = outgoingNodes(packageNode.id, "surfaces_process").filter((node) => node.kind === "ProcessDescriptor");
+    const ciNodes = outgoingNodes(packageNode.id, "validated_by_ci").filter((node) => node.kind === "CiSurface");
+    const directPathNodes = outgoingNodes(packageNode.id, "references_path").filter((node) => node.kind === "PathDescriptor");
+    const processPathNodes = uniqueBy(processNodes.flatMap((node) => outgoingNodes(node.id, "references_path").filter((candidate) => candidate.kind === "PathDescriptor")), (node) => node.id);
+    return clone({
+        package: toPackageSurface(packageNode),
+        processes: processNodes
+            .map((node) => data_1.AGENT_CATALOG.processes.find((process) => process.processId === valueAsString(node.processId)))
+            .filter((process) => Boolean(process)),
+        ciSurfaces: ciNodes.map(toCiSurface),
+        directPaths: directPathNodes.map(toPathDescriptor),
+        processPaths: processPathNodes.map(toPathDescriptor),
+        wrapsGraphIds: sortStrings(outgoingEdges(packageNode.id, "wraps_graph").map((edge) => edge.to)),
+    });
+}
+function getFallbackHarnessMetadata(harnessName) {
+    const key = HARNESS_ALIASES[harnessName] ?? harnessName;
+    const metadata = data_1.FALLBACK_METADATA[key];
+    return metadata ? clone(metadata) : undefined;
+}
+function listFallbackHarnessMetadata() {
+    return clone(data_1.FALLBACK_METADATA);
+}
+function getHostSignalMap() {
+    return clone(data_1.HOST_SIGNAL_MAP);
+}
+function getHostMetadataFields() {
+    return clone(data_1.HOST_METADATA_FIELDS);
+}
+function getHostDetectionRules() {
+    return clone(data_1.HOST_DETECTION_RULES);
+}
+function getHooksMuxDetectionRules() {
+    return clone(data_1.HOOKS_MUX_DETECTION_RULES);
+}
+function getHarnessImages() {
+    return clone(data_1.HARNESS_IMAGES);
+}
+function lookupHarnessImage(harness) {
+    const normalized = harness.toLowerCase();
+    const key = HARNESS_ALIASES[normalized] ?? normalized;
+    const image = data_1.HARNESS_IMAGES.find((entry) => entry.harness === key);
+    return image ? clone(image) : undefined;
+}
+function listPluginTargets() {
+    return data_1.PLUGIN_TARGETS.map((target) => target.targetId).sort();
+}
+function listPluginTargetDescriptors() {
+    return clone(data_1.PLUGIN_TARGETS);
+}
+function getPluginTargetDescriptor(targetId) {
+    const target = data_1.PLUGIN_TARGETS.find((entry) => entry.targetId === targetId);
+    return target ? clone(target) : undefined;
+}
+function getHookCatalog() {
+    return clone(data_1.HOOKS);
+}
+function getHookNameMap() {
+    const map = {};
+    for (const hook of data_1.HOOKS) {
+        map[hook.canonicalName] = { ...hook.targetNames };
+    }
+    return map;
+}
+function getAgentVersionSlug(agent) {
+    return `${agent.agentId}--${slugifyVersionRange(agent.versionRange)}`;
+}
+function getUiAgentOntologyList() {
+    return clone(data_1.AGENT_CATALOG.agents.map(buildOntologyListItem));
+}
+function getUiAgentOntologyEntry(slugOrId) {
+    const agent = data_1.AGENT_CATALOG.agents.find((candidate) => getAgentVersionSlug(candidate) === slugOrId ||
+        agentVersionNodeId(candidate) === slugOrId);
+    if (!agent) {
+        return undefined;
+    }
+    const capabilityMatrix = findCapabilityMatrix(agent);
+    const claims = findClaims(agent, capabilityMatrix);
+    const evidence = findEvidence(agent, capabilityMatrix, claims);
+    return clone({
+        ...buildOntologyListItem(agent),
+        capabilityMatrix,
+        evidence,
+        claims,
+        supersedes: getRelatedVersionReferences(agent, "supersedes", "from"),
+        supersededBy: getRelatedVersionReferences(agent, "supersedes", "to"),
+        schemaVersion: data_1.GRAPH_DOCUMENT.schemaVersion,
+        generatedAt: data_1.GRAPH_DOCUMENT.generatedAt,
+    });
+}
+function getUiAgentCards() {
+    return getUiAgentOntologyList().map((agent) => ({
+        id: agent.slug,
+        name: agent.name,
+        versionRange: agent.versionRange,
+        description: agent.description,
+        providerNames: agent.providers.map((provider) => provider.displayName),
+        transportLabels: agent.transports.map((transport) => transport.label),
+        capabilities: agent.capabilities.map((capability) => capability.label),
+        hookNames: agent.hooks.map((hook) => hook.canonicalName),
+        filePath: agent.filePath,
+        directory: agent.directory,
+        metadata: {
+            agentId: agent.agentId,
+            aliases: agent.aliases,
+            slug: agent.slug,
+            runtimeFamily: agent.runtimeFamily,
+            pluginTargets: agent.pluginTargets.map((target) => target.targetId),
+            modalities: agent.modalities.map((modality) => modality.modalityId),
+            evidenceSummary: agent.evidenceSummary,
+            schemaVersion: data_1.GRAPH_DOCUMENT.schemaVersion,
+        },
+    }));
+}