@mcoda/agent-setup 0.1.66

package/CHANGELOG.md

@@ -0,0 +1,5 @@
+# Changelog
+
+## 0.1.66
+
+- Initial agent setup SDK package.

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 bekir dag
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,14 @@
+# @mcoda/agent-setup
+
+Turnkey mcoda/mswarm agent setup SDK for applications.
+
+The package provides:
+
+- headless catalog and assignment utilities
+- a typed HTTP client
+- framework-agnostic server service helpers
+- a default programmatic mcoda runtime adapter
+- an optional React setup page
+
+The default server runtime uses mcoda package APIs directly and does not require
+a preinstalled or configured `mcoda` CLI/client tool.

package/dist/client.d.ts

@@ -0,0 +1,20 @@
+import type { McodaAgentSetupClient } from "./types.js";
+type FetchLike = (input: string | URL, init?: {
+    method?: string;
+    headers?: Record<string, string>;
+    body?: string;
+}) => Promise<{
+    ok: boolean;
+    status: number;
+    statusText: string;
+    json(): Promise<unknown>;
+    text(): Promise<string>;
+}>;
+export interface CreateMcodaAgentSetupClientInput {
+    baseUrl: string;
+    getAuthHeaders?: (() => Promise<Record<string, string>> | Record<string, string>) | Record<string, string>;
+    fetch?: FetchLike;
+}
+export declare function createMcodaAgentSetupClient(input: CreateMcodaAgentSetupClientInput): McodaAgentSetupClient;
+export {};
+//# sourceMappingURL=client.d.ts.map

package/dist/client.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"client.d.ts","sourceRoot":"","sources":["../src/client.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,qBAAqB,EAGtB,MAAM,YAAY,CAAC;AAEpB,KAAK,SAAS,GAAG,CACf,KAAK,EAAE,MAAM,GAAG,GAAG,EACnB,IAAI,CAAC,EAAE;IACL,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACjC,IAAI,CAAC,EAAE,MAAM,CAAC;CACf,KACE,OAAO,CAAC;IACX,EAAE,EAAE,OAAO,CAAC;IACZ,MAAM,EAAE,MAAM,CAAC;IACf,UAAU,EAAE,MAAM,CAAC;IACnB,IAAI,IAAI,OAAO,CAAC,OAAO,CAAC,CAAC;IACzB,IAAI,IAAI,OAAO,CAAC,MAAM,CAAC,CAAC;CACzB,CAAC,CAAC;AAEH,MAAM,WAAW,gCAAgC;IAC/C,OAAO,EAAE,MAAM,CAAC;IAChB,cAAc,CAAC,EACX,CAAC,MAAM,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,GAAG,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,GAChE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAC3B,KAAK,CAAC,EAAE,SAAS,CAAC;CACnB;AAED,wBAAgB,2BAA2B,CACzC,KAAK,EAAE,gCAAgC,GACtC,qBAAqB,CAwFvB"}

package/dist/client.js

@@ -0,0 +1,83 @@
+export function createMcodaAgentSetupClient(input) {
+    const baseUrl = input.baseUrl.replace(/\/+$/, "");
+    const fetchImpl = input.fetch ?? globalThis.fetch;
+    if (!fetchImpl) {
+        throw new Error("fetch is required to create a mcoda agent setup client");
+    }
+    const requestJson = async (path, init = {}) => {
+        const headers = {
+            accept: "application/json",
+            ...(await resolveAuthHeaders(input.getAuthHeaders)),
+        };
+        let body;
+        if (init.body !== undefined) {
+            headers["content-type"] = "application/json";
+            body = JSON.stringify(init.body);
+        }
+        const response = await fetchImpl(`${baseUrl}${path}`, {
+            method: init.method ?? "GET",
+            headers,
+            body,
+        });
+        if (!response.ok) {
+            let message = `${response.status} ${response.statusText}`;
+            try {
+                const payload = await response.json();
+                if (payload &&
+                    typeof payload === "object" &&
+                    "error" in payload &&
+                    typeof payload.error === "string") {
+                    message = payload.error;
+                }
+            }
+            catch {
+                const text = await response.text().catch(() => "");
+                if (text.trim())
+                    message = text.trim();
+            }
+            throw new Error(`mcoda agent setup request failed: ${message}`);
+        }
+        return (await response.json());
+    };
+    return {
+        fetchSnapshot: () => requestJson("/agent-settings"),
+        configureMswarmApiKey: (request) => requestJson("/mswarm-api-key", {
+            method: "POST",
+            body: {
+                mswarm_api_key: request.apiKey,
+                reason_code: request.reasonCode,
+                metadata: request.metadata,
+            },
+        }),
+        syncAgents: (request = {}) => requestJson("/agents/sync", {
+            method: "POST",
+            body: {
+                reason_code: request.reasonCode,
+                metadata: request.metadata,
+            },
+        }),
+        updateAssignments: (request) => requestJson("/agent-settings", {
+            method: "PATCH",
+            body: {
+                assignments: request.assignments,
+                reason_code: request.reasonCode,
+                metadata: request.metadata,
+            },
+        }),
+        testAgent: (request) => requestJson("/agents/test", {
+            method: "POST",
+            body: {
+                slug: request.slug,
+                prompt: request.prompt,
+                timeout_ms: request.timeoutMs,
+            },
+        }),
+    };
+}
+async function resolveAuthHeaders(input) {
+    if (!input)
+        return {};
+    if (typeof input === "function")
+        return input();
+    return input;
+}

package/dist/defaultStages.d.ts

@@ -0,0 +1,18 @@
+export declare const defaultMcodaStageDefinitions: ({
+    stageKey: string;
+    displayName: string;
+    description: string;
+    defaultAgentSlug: null;
+    recommendedUsage: string;
+    preferredSource: "cloud_or_self_hosted";
+    nullable: false;
+} | {
+    stageKey: string;
+    displayName: string;
+    description: string;
+    defaultAgentSlug: null;
+    recommendedUsage: string;
+    preferredSource: "cloud_or_self_hosted";
+    nullable: true;
+})[];
+//# sourceMappingURL=defaultStages.d.ts.map

package/dist/defaultStages.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"defaultStages.d.ts","sourceRoot":"","sources":["../src/defaultStages.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,4BAA4B;;;;;;;;;;;;;;;;IAuDP,CAAC"}

package/dist/defaultStages.js

@@ -0,0 +1,56 @@
+export const defaultMcodaStageDefinitions = [
+    {
+        stageKey: "translation",
+        displayName: "Translation",
+        description: "Translate source text into the application's working language.",
+        defaultAgentSlug: null,
+        recommendedUsage: "translation",
+        preferredSource: "cloud_or_self_hosted",
+        nullable: false,
+    },
+    {
+        stageKey: "summarization",
+        displayName: "Summarization",
+        description: "Create concise summaries and digests.",
+        defaultAgentSlug: null,
+        recommendedUsage: "summarization",
+        preferredSource: "cloud_or_self_hosted",
+        nullable: false,
+    },
+    {
+        stageKey: "classification",
+        displayName: "Classification",
+        description: "Classify text into product-specific categories.",
+        defaultAgentSlug: null,
+        recommendedUsage: "classification",
+        preferredSource: "cloud_or_self_hosted",
+        nullable: false,
+    },
+    {
+        stageKey: "extraction",
+        displayName: "Entity Extraction",
+        description: "Extract structured entities or fields.",
+        defaultAgentSlug: null,
+        recommendedUsage: "extraction",
+        preferredSource: "cloud_or_self_hosted",
+        nullable: false,
+    },
+    {
+        stageKey: "reasoning",
+        displayName: "Reasoning",
+        description: "Run deeper analysis where simple classification is not enough.",
+        defaultAgentSlug: null,
+        recommendedUsage: "reasoning",
+        preferredSource: "cloud_or_self_hosted",
+        nullable: true,
+    },
+    {
+        stageKey: "guardrail",
+        displayName: "Guardrail Review",
+        description: "Validate output quality, policy, schema, and safety constraints.",
+        defaultAgentSlug: null,
+        recommendedUsage: "guardrail",
+        preferredSource: "cloud_or_self_hosted",
+        nullable: true,
+    },
+];

package/dist/headless/catalog.d.ts

@@ -0,0 +1,24 @@
+import type { McodaAgentCatalogEntry, McodaSelfHostedServer } from "../types.js";
+export declare function isCloudAgent(agent: McodaAgentCatalogEntry): boolean;
+export declare function isSelfHostedAgent(agent: McodaAgentCatalogEntry): boolean;
+export declare function syncedCloudSlug(agent: McodaAgentCatalogEntry): string;
+export declare function syncedSelfHostedSlug(agent: McodaAgentCatalogEntry): string;
+export declare function mergeCatalogEntries(local: McodaAgentCatalogEntry, catalog?: McodaAgentCatalogEntry): McodaAgentCatalogEntry;
+export declare function buildCloudAgentOptions(localAgents: McodaAgentCatalogEntry[], cloudCatalogAgents: McodaAgentCatalogEntry[]): McodaAgentCatalogEntry[];
+export declare function buildSelfHostedServerOptions(localAgents: McodaAgentCatalogEntry[], remoteAgents: McodaAgentCatalogEntry[]): McodaSelfHostedServer[];
+export declare function filterAgentOptions(agents: McodaAgentCatalogEntry[], query: string): McodaAgentCatalogEntry[];
+export declare function resolveRunnableSelectionSlug(slug: string, localAgents: McodaAgentCatalogEntry[]): string;
+export declare function getVirtualAgentWindow<T>(items: T[], input: {
+    scrollTop: number;
+    rowHeight: number;
+    viewportHeight: number;
+    overscan?: number;
+}): {
+    startIndex: number;
+    endIndex: number;
+    items: T[];
+    beforeHeight: number;
+    afterHeight: number;
+    totalHeight: number;
+};
+//# sourceMappingURL=catalog.d.ts.map

package/dist/headless/catalog.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"catalog.d.ts","sourceRoot":"","sources":["../../src/headless/catalog.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,sBAAsB,EACtB,qBAAqB,EACtB,MAAM,aAAa,CAAC;AAkBrB,wBAAgB,YAAY,CAAC,KAAK,EAAE,sBAAsB,GAAG,OAAO,CAMnE;AAED,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,sBAAsB,GAAG,OAAO,CAOxE;AAED,wBAAgB,eAAe,CAAC,KAAK,EAAE,sBAAsB,GAAG,MAAM,CAIrE;AAED,wBAAgB,oBAAoB,CAAC,KAAK,EAAE,sBAAsB,GAAG,MAAM,CAI1E;AAED,wBAAgB,mBAAmB,CACjC,KAAK,EAAE,sBAAsB,EAC7B,OAAO,CAAC,EAAE,sBAAsB,GAC/B,sBAAsB,CA6BxB;AAED,wBAAgB,sBAAsB,CACpC,WAAW,EAAE,sBAAsB,EAAE,EACrC,kBAAkB,EAAE,sBAAsB,EAAE,GAC3C,sBAAsB,EAAE,CAY1B;AAED,wBAAgB,4BAA4B,CAC1C,WAAW,EAAE,sBAAsB,EAAE,EACrC,YAAY,EAAE,sBAAsB,EAAE,GACrC,qBAAqB,EAAE,CAoCzB;AAED,wBAAgB,kBAAkB,CAChC,MAAM,EAAE,sBAAsB,EAAE,EAChC,KAAK,EAAE,MAAM,GACZ,sBAAsB,EAAE,CA6B1B;AAED,wBAAgB,4BAA4B,CAC1C,IAAI,EAAE,MAAM,EACZ,WAAW,EAAE,sBAAsB,EAAE,GACpC,MAAM,CAkBR;AAED,wBAAgB,qBAAqB,CAAC,CAAC,EACrC,KAAK,EAAE,CAAC,EAAE,EACV,KAAK,EAAE;IACL,SAAS,EAAE,MAAM,CAAC;IAClB,SAAS,EAAE,MAAM,CAAC;IAClB,cAAc,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB,GACA;IACD,UAAU,EAAE,MAAM,CAAC;IACnB,QAAQ,EAAE,MAAM,CAAC;IACjB,KAAK,EAAE,CAAC,EAAE,CAAC;IACX,YAAY,EAAE,MAAM,CAAC;IACrB,WAAW,EAAE,MAAM,CAAC;IACpB,WAAW,EAAE,MAAM,CAAC;CACrB,CAiBA"}

package/dist/headless/catalog.js

@@ -0,0 +1,231 @@
+const CLOUD_PREFIX = "mswarm-cloud-";
+const SELF_HOSTED_PREFIX = "mswarm-self-hosted-";
+const normalizeSlugPart = (value) => value
+    .trim()
+    .toLowerCase()
+    .replace(/[^a-z0-9]+/g, "-")
+    .replace(/^-+|-+$/g, "");
+const lower = (value) => value?.trim().toLowerCase() ?? "";
+const truthyStrings = (values) => values.map((value) => value?.trim() ?? "").filter(Boolean);
+export function isCloudAgent(agent) {
+    return (agent.source === "cloud_catalog" ||
+        agent.managedKind === "cloud" ||
+        agent.slug.startsWith(CLOUD_PREFIX));
+}
+export function isSelfHostedAgent(agent) {
+    return (agent.source === "self_hosted_catalog" ||
+        agent.managedKind === "self_hosted" ||
+        agent.slug.startsWith(SELF_HOSTED_PREFIX) ||
+        Boolean(agent.nodeId || agent.serverName || agent.serverId));
+}
+export function syncedCloudSlug(agent) {
+    if (agent.slug.startsWith(CLOUD_PREFIX))
+        return agent.slug;
+    const remote = agent.remoteSlug ?? agent.slug;
+    return `${CLOUD_PREFIX}${normalizeSlugPart(remote) || "agent"}`;
+}
+export function syncedSelfHostedSlug(agent) {
+    if (agent.slug.startsWith(SELF_HOSTED_PREFIX))
+        return agent.slug;
+    const remote = agent.remoteSlug ?? agent.slug;
+    return `${SELF_HOSTED_PREFIX}${normalizeSlugPart(remote) || "agent"}`;
+}
+export function mergeCatalogEntries(local, catalog) {
+    if (!catalog)
+        return local;
+    return {
+        ...catalog,
+        ...local,
+        displayName: local.displayName ?? catalog.displayName,
+        provider: local.provider ?? catalog.provider,
+        adapter: local.adapter ?? catalog.adapter,
+        model: local.model ?? catalog.model,
+        defaultModel: local.defaultModel ?? catalog.defaultModel,
+        healthStatus: local.healthStatus ?? catalog.healthStatus,
+        supportsTools: local.supportsTools ?? catalog.supportsTools,
+        rating: local.rating ?? catalog.rating,
+        reasoningRating: local.reasoningRating ?? catalog.reasoningRating,
+        maxComplexity: local.maxComplexity ?? catalog.maxComplexity,
+        costPerMillion: local.costPerMillion ?? catalog.costPerMillion,
+        contextWindow: local.contextWindow ?? catalog.contextWindow,
+        maxOutputTokens: local.maxOutputTokens ?? catalog.maxOutputTokens,
+        bestUsage: local.bestUsage ?? catalog.bestUsage,
+        capabilities: local.capabilities?.length
+            ? local.capabilities
+            : catalog.capabilities,
+        metadata: {
+            ...(catalog.metadata ?? {}),
+            ...(local.metadata ?? {}),
+        },
+        source: local.source,
+        synced: true,
+    };
+}
+export function buildCloudAgentOptions(localAgents, cloudCatalogAgents) {
+    const catalogByLocalSlug = new Map(cloudCatalogAgents.map((agent) => [syncedCloudSlug(agent), agent]));
+    const synced = localAgents
+        .filter(isCloudAgent)
+        .map((agent) => mergeCatalogEntries(agent, catalogByLocalSlug.get(agent.slug)));
+    const localSlugs = new Set(synced.map((agent) => agent.slug));
+    const unsynced = cloudCatalogAgents
+        .filter((agent) => !localSlugs.has(syncedCloudSlug(agent)))
+        .map((agent) => ({ ...agent, synced: false }));
+    return sortAgents([...synced, ...unsynced]);
+}
+export function buildSelfHostedServerOptions(localAgents, remoteAgents) {
+    const remoteByLocalSlug = new Map(remoteAgents.map((agent) => [syncedSelfHostedSlug(agent), agent]));
+    const combined = [
+        ...localAgents
+            .filter(isSelfHostedAgent)
+            .map((agent) => mergeCatalogEntries(agent, remoteByLocalSlug.get(agent.slug))),
+        ...remoteAgents
+            .filter((agent) => !localAgents.some((local) => local.slug === syncedSelfHostedSlug(agent)))
+            .map((agent) => ({ ...agent, synced: false })),
+    ];
+    const servers = new Map();
+    for (const agent of combined) {
+        const server = resolveSelfHostedServer(agent);
+        const existing = servers.get(server.id);
+        if (existing) {
+            existing.agents.push(agent);
+            existing.agentCount = existing.agents.length;
+            existing.status = mergeServerStatus(existing.status, server.status);
+            continue;
+        }
+        servers.set(server.id, {
+            ...server,
+            agents: [agent],
+            agentCount: 1,
+        });
+    }
+    return Array.from(servers.values())
+        .map((server) => ({
+        ...server,
+        agents: sortAgents(server.agents),
+    }))
+        .sort((left, right) => left.label.localeCompare(right.label));
+}
+export function filterAgentOptions(agents, query) {
+    const terms = query
+        .trim()
+        .toLowerCase()
+        .split(/\s+/)
+        .filter(Boolean);
+    if (!terms.length)
+        return sortAgents(agents);
+    return sortAgents(agents.filter((agent) => {
+        const haystack = [
+            agent.displayName,
+            agent.slug,
+            agent.remoteSlug,
+            agent.model,
+            agent.defaultModel,
+            agent.provider,
+            agent.adapter,
+            agent.healthStatus,
+            agent.bestUsage,
+            agent.serverName,
+            agent.serverLabel,
+            agent.nodeId,
+            ...(agent.capabilities ?? []),
+        ]
+            .map(lower)
+            .join(" ");
+        return terms.every((term) => haystack.includes(term));
+    }));
+}
+export function resolveRunnableSelectionSlug(slug, localAgents) {
+    const trimmed = slug.trim();
+    if (!trimmed)
+        return trimmed;
+    if (localAgents.some((agent) => agent.slug === trimmed))
+        return trimmed;
+    const candidate = localAgents.find((agent) => {
+        if (agent.remoteSlug === trimmed)
+            return true;
+        if (isCloudAgent(agent) && agent.slug === syncedCloudSlug({ ...agent, slug: trimmed })) {
+            return true;
+        }
+        if (isSelfHostedAgent(agent) &&
+            agent.slug === syncedSelfHostedSlug({ ...agent, slug: trimmed })) {
+            return true;
+        }
+        return false;
+    });
+    return candidate?.slug ?? trimmed;
+}
+export function getVirtualAgentWindow(items, input) {
+    const rowHeight = Math.max(1, Math.trunc(input.rowHeight));
+    const viewportHeight = Math.max(1, Math.trunc(input.viewportHeight));
+    const overscan = Math.max(0, Math.trunc(input.overscan ?? 4));
+    const totalHeight = items.length * rowHeight;
+    const visibleStart = Math.floor(Math.max(0, input.scrollTop) / rowHeight);
+    const visibleCount = Math.ceil(viewportHeight / rowHeight);
+    const startIndex = Math.max(0, visibleStart - overscan);
+    const endIndex = Math.min(items.length, visibleStart + visibleCount + overscan);
+    return {
+        startIndex,
+        endIndex,
+        items: items.slice(startIndex, endIndex),
+        beforeHeight: startIndex * rowHeight,
+        afterHeight: Math.max(0, totalHeight - endIndex * rowHeight),
+        totalHeight,
+    };
+}
+function resolveSelfHostedServer(agent) {
+    const nodeId = agent.nodeId?.trim() || undefined;
+    const serverName = agent.serverName?.trim() || undefined;
+    const serverId = agent.serverId?.trim() || undefined;
+    if (nodeId || serverName || serverId) {
+        const id = normalizeSlugPart(serverId ?? nodeId ?? serverName ?? "server");
+        return {
+            id,
+            label: agent.serverLabel ?? serverName ?? nodeId ?? serverId ?? id,
+            nodeId,
+            serverName,
+            status: agent.healthStatus,
+            remoteSlugPrefix: undefined,
+        };
+    }
+    const remote = agent.remoteSlug ?? agent.slug;
+    const parts = truthyStrings(remote.split(/[-_:/.]+/));
+    const prefixParts = parts.length >= 2 ? parts.slice(0, 2) : parts.slice(0, 1);
+    const remoteSlugPrefix = prefixParts.join("-");
+    const id = normalizeSlugPart(remoteSlugPrefix || remote || "server") || "server";
+    return {
+        id,
+        label: remoteSlugPrefix || id,
+        status: agent.healthStatus,
+        remoteSlugPrefix: remoteSlugPrefix || null,
+    };
+}
+function mergeServerStatus(current, next) {
+    if (current === "healthy" || next === "healthy")
+        return "healthy";
+    if (current === "degraded" || next === "degraded")
+        return "degraded";
+    return current ?? next;
+}
+function sortAgents(agents) {
+    return [...agents].sort((left, right) => {
+        const healthRank = healthScore(right.healthStatus) - healthScore(left.healthStatus);
+        if (healthRank !== 0)
+            return healthRank;
+        const ratingRank = (right.rating ?? -1) - (left.rating ?? -1);
+        if (ratingRank !== 0)
+            return ratingRank;
+        const leftName = left.displayName ?? left.slug;
+        const rightName = right.displayName ?? right.slug;
+        return leftName.localeCompare(rightName);
+    });
+}
+function healthScore(value) {
+    const normalized = value?.trim().toLowerCase();
+    if (normalized === "healthy")
+        return 3;
+    if (normalized === "degraded" || normalized === "limited")
+        return 2;
+    if (normalized === "unreachable" || normalized === "offline")
+        return 1;
+    return 0;
+}

package/dist/headless/index.d.ts

@@ -0,0 +1,4 @@
+export * from "./catalog.js";
+export * from "./normalization.js";
+export type * from "../types.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/headless/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/headless/index.ts"],"names":[],"mappings":"AAAA,cAAc,cAAc,CAAC;AAC7B,cAAc,oBAAoB,CAAC;AACnC,mBAAmB,aAAa,CAAC"}

package/dist/headless/index.js

@@ -0,0 +1,2 @@
+export * from "./catalog.js";
+export * from "./normalization.js";

package/dist/headless/normalization.d.ts

@@ -0,0 +1,12 @@
+import type { McodaAgentCatalogEntry, McodaAgentManagedKind, McodaAgentSource } from "../types.js";
+export declare function normalizeAgentCatalogEntry(raw: unknown, fallback: {
+    source: McodaAgentSource;
+    synced?: boolean;
+    managedKind?: McodaAgentManagedKind;
+}): McodaAgentCatalogEntry;
+export declare function normalizeAgentCatalogEntries(raw: unknown, fallback: {
+    source: McodaAgentSource;
+    synced?: boolean;
+    managedKind?: McodaAgentManagedKind;
+}): McodaAgentCatalogEntry[];
+//# sourceMappingURL=normalization.d.ts.map

package/dist/headless/normalization.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"normalization.d.ts","sourceRoot":"","sources":["../../src/headless/normalization.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,sBAAsB,EACtB,qBAAqB,EACrB,gBAAgB,EACjB,MAAM,aAAa,CAAC;AAwBrB,wBAAgB,0BAA0B,CACxC,GAAG,EAAE,OAAO,EACZ,QAAQ,EAAE;IACR,MAAM,EAAE,gBAAgB,CAAC;IACzB,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB,WAAW,CAAC,EAAE,qBAAqB,CAAC;CACrC,GACA,sBAAsB,CA2GxB;AAED,wBAAgB,4BAA4B,CAC1C,GAAG,EAAE,OAAO,EACZ,QAAQ,EAAE;IACR,MAAM,EAAE,gBAAgB,CAAC;IACzB,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB,WAAW,CAAC,EAAE,qBAAqB,CAAC;CACrC,GACA,sBAAsB,EAAE,CAO1B"}

package/dist/headless/normalization.js

@@ -0,0 +1,105 @@
+const isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+const stringValue = (value) => typeof value === "string" && value.trim() ? value : null;
+const numberValue = (value) => typeof value === "number" && Number.isFinite(value) ? value : null;
+const booleanValue = (value) => typeof value === "boolean" ? value : null;
+const stringArrayValue = (value) => Array.isArray(value)
+    ? value
+        .map((item) => (typeof item === "string" ? item.trim() : ""))
+        .filter(Boolean)
+    : undefined;
+const recordValue = (value) => isRecord(value) ? value : undefined;
+export function normalizeAgentCatalogEntry(raw, fallback) {
+    const record = isRecord(raw) ? raw : {};
+    const config = recordValue(record.config);
+    const mswarmCloud = recordValue(config?.mswarmCloud);
+    const mswarmSelfHosted = recordValue(config?.mswarmSelfHosted);
+    const sync = recordValue(record.sync) ?? recordValue(mswarmSelfHosted?.sync);
+    const managedKind = fallback.managedKind ??
+        (mswarmCloud ? "cloud" : mswarmSelfHosted ? "self_hosted" : null);
+    const remoteSlug = stringValue(record.remoteSlug) ??
+        stringValue(record.remote_slug) ??
+        stringValue(mswarmCloud?.remoteSlug) ??
+        stringValue(mswarmSelfHosted?.remoteSlug);
+    const slug = stringValue(record.slug) ??
+        stringValue(record.agent_slug) ??
+        stringValue(mswarmSelfHosted?.agentSlug) ??
+        remoteSlug ??
+        "agent";
+    const defaultModel = stringValue(record.defaultModel) ??
+        stringValue(record.default_model) ??
+        stringValue(record.defaultModelId) ??
+        stringValue(record.model_id) ??
+        stringValue(mswarmCloud?.modelId) ??
+        stringValue(mswarmSelfHosted?.modelId);
+    const model = stringValue(record.model) ??
+        stringValue(record.modelId) ??
+        stringValue(record.model_id) ??
+        defaultModel;
+    const health = recordValue(record.health);
+    const healthStatus = stringValue(record.healthStatus) ??
+        stringValue(record.health_status) ??
+        stringValue(health?.status) ??
+        stringValue(record.status);
+    const nodeId = stringValue(record.nodeId) ??
+        stringValue(record.node_id) ??
+        stringValue(mswarmSelfHosted?.nodeId) ??
+        stringValue(sync?.node_id);
+    const serverName = stringValue(record.serverName) ??
+        stringValue(record.server_name) ??
+        stringValue(mswarmSelfHosted?.serverName) ??
+        stringValue(sync?.server_name);
+    return {
+        slug,
+        source: fallback.source,
+        synced: fallback.synced ?? fallback.source === "local_registry",
+        remoteSlug,
+        managedKind,
+        nodeId,
+        serverName,
+        serverId: stringValue(record.serverId) ??
+            stringValue(record.server_id) ??
+            stringValue(sync?.server_id),
+        serverLabel: stringValue(record.serverLabel) ??
+            stringValue(record.server_label) ??
+            serverName,
+        displayName: stringValue(record.displayName) ??
+            stringValue(record.display_name) ??
+            stringValue(mswarmCloud?.displayName) ??
+            stringValue(mswarmSelfHosted?.displayName),
+        provider: stringValue(record.provider) ??
+            stringValue(mswarmCloud?.provider) ??
+            stringValue(mswarmSelfHosted?.provider),
+        adapter: stringValue(record.adapter) ??
+            stringValue(mswarmSelfHosted?.adapter),
+        model,
+        defaultModel,
+        healthStatus,
+        supportsTools: booleanValue(record.supportsTools) ??
+            booleanValue(record.supports_tools),
+        rating: numberValue(record.rating),
+        reasoningRating: numberValue(record.reasoningRating) ??
+            numberValue(record.reasoning_rating),
+        maxComplexity: numberValue(record.maxComplexity) ??
+            numberValue(record.max_complexity),
+        costPerMillion: numberValue(record.costPerMillion) ??
+            numberValue(record.cost_per_million),
+        contextWindow: numberValue(record.contextWindow) ??
+            numberValue(record.context_window),
+        maxOutputTokens: numberValue(record.maxOutputTokens) ??
+            numberValue(record.max_output_tokens),
+        bestUsage: stringValue(record.bestUsage) ??
+            stringValue(record.best_usage),
+        capabilities: stringArrayValue(record.capabilities),
+        metadata: {
+            raw,
+        },
+    };
+}
+export function normalizeAgentCatalogEntries(raw, fallback) {
+    const values = Array.isArray(raw)
+        ? raw
+        : isRecord(raw) && Array.isArray(raw.agents)
+            ? raw.agents
+            : [];
+    return values.map((item) => normalizeAgentCatalogEntry(item, fallback));
+}

package/dist/index.d.ts

@@ -0,0 +1,5 @@
+export * from "./types.js";
+export * from "./defaultStages.js";
+export * from "./client.js";
+export * from "./headless/index.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,YAAY,CAAC;AAC3B,cAAc,oBAAoB,CAAC;AACnC,cAAc,aAAa,CAAC;AAC5B,cAAc,qBAAqB,CAAC"}

package/dist/index.js

@@ -0,0 +1,4 @@
+export * from "./types.js";
+export * from "./defaultStages.js";
+export * from "./client.js";
+export * from "./headless/index.js";