@mcoda/agent-setup 0.1.66

package/dist/server/inMemoryRuntime.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"inMemoryRuntime.d.ts","sourceRoot":"","sources":["../../src/server/inMemoryRuntime.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EACV,sBAAsB,EAItB,mBAAmB,EACpB,MAAM,aAAa,CAAC;AAErB,MAAM,WAAW,gCAAgC;IAC/C,WAAW,CAAC,EAAE,sBAAsB,EAAE,CAAC;IACvC,gBAAgB,CAAC,EAAE,sBAAsB,EAAE,CAAC;IAC5C,WAAW,CAAC,EAAE,sBAAsB,EAAE,CAAC;CACxC;AAED,wBAAgB,iCAAiC,CAC/C,KAAK,GAAE,gCAAqC,GAC3C,mBAAmB,CAqGrB"}

package/dist/server/inMemoryRuntime.js

@@ -0,0 +1,89 @@
+import { syncedCloudSlug, syncedSelfHostedSlug, } from "../headless/catalog.js";
+export function createInMemoryMcodaRuntimeAdapter(input = {}) {
+    let cloudAgents = input.cloudAgents?.map((agent) => ({ ...agent })) ?? [];
+    let selfHostedAgents = input.selfHostedAgents?.map((agent) => ({ ...agent })) ?? [];
+    let localAgents = input.localAgents?.map((agent) => ({ ...agent })) ?? [];
+    let configuredApiKey = false;
+    const syncRemote = (remoteAgents, slugFor, managedKind) => {
+        const remoteLocalSlugs = new Set(remoteAgents.map(slugFor));
+        localAgents = localAgents.filter((agent) => {
+            if (agent.managedKind !== managedKind)
+                return true;
+            return remoteLocalSlugs.has(agent.slug);
+        });
+        for (const remote of remoteAgents) {
+            const localSlug = slugFor(remote);
+            const next = {
+                ...remote,
+                slug: localSlug,
+                source: "local_registry",
+                synced: true,
+                managedKind,
+                remoteSlug: remote.remoteSlug ?? remote.slug,
+            };
+            const index = localAgents.findIndex((agent) => agent.slug === localSlug);
+            if (index >= 0) {
+                localAgents[index] = next;
+            }
+            else {
+                localAgents.push(next);
+            }
+        }
+        return localAgents.filter((agent) => agent.managedKind === managedKind);
+    };
+    const filterProvider = (agents, options) => options?.provider
+        ? agents.filter((agent) => agent.provider === options.provider)
+        : agents;
+    return {
+        runtime: {
+            mode: "programmatic",
+            requiresMcodaCli: false,
+        },
+        async configureMswarmApiKey(input) {
+            if (!input.apiKey.trim()) {
+                throw new Error("mswarm api key is required");
+            }
+            configuredApiKey = true;
+        },
+        async listCloudAgents(options) {
+            return filterProvider(cloudAgents, options).map((agent) => ({ ...agent }));
+        },
+        async syncCloudAgents(options) {
+            if (!configuredApiKey) {
+                throw new Error("mswarm api key is required");
+            }
+            return syncRemote(filterProvider(cloudAgents, options), syncedCloudSlug, "cloud");
+        },
+        async listSelfHostedAgents(options) {
+            return filterProvider(selfHostedAgents, options).map((agent) => ({
+                ...agent,
+            }));
+        },
+        async syncSelfHostedAgents(options) {
+            if (!configuredApiKey) {
+                throw new Error("mswarm api key is required");
+            }
+            return syncRemote(filterProvider(selfHostedAgents, options), syncedSelfHostedSlug, "self_hosted");
+        },
+        async listLocalAgents(options) {
+            return filterProvider(localAgents, options).map((agent) => ({ ...agent }));
+        },
+        async testAgent(input) {
+            const agent = localAgents.find((candidate) => candidate.slug === input.slug);
+            if (!agent) {
+                return {
+                    slug: input.slug,
+                    ok: false,
+                    error: "agent not found",
+                };
+            }
+            return {
+                slug: input.slug,
+                ok: true,
+                output: `ok:${input.prompt ?? ""}`,
+                model: agent.defaultModel ?? agent.model ?? undefined,
+                adapter: agent.adapter ?? undefined,
+            };
+        },
+    };
+}

package/dist/server/index.d.ts

@@ -0,0 +1,8 @@
+export * from "./settingsStore.js";
+export * from "./inMemoryRuntime.js";
+export * from "./programmaticRuntime.js";
+export * from "./cliRuntime.js";
+export * from "./service.js";
+export * from "./httpHandlers.js";
+export type * from "../types.js";
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/server/index.ts"],"names":[],"mappings":"AAAA,cAAc,oBAAoB,CAAC;AACnC,cAAc,sBAAsB,CAAC;AACrC,cAAc,0BAA0B,CAAC;AACzC,cAAc,iBAAiB,CAAC;AAChC,cAAc,cAAc,CAAC;AAC7B,cAAc,mBAAmB,CAAC;AAClC,mBAAmB,aAAa,CAAC"}

package/dist/server/index.js

@@ -0,0 +1,6 @@
+export * from "./settingsStore.js";
+export * from "./inMemoryRuntime.js";
+export * from "./programmaticRuntime.js";
+export * from "./cliRuntime.js";
+export * from "./service.js";
+export * from "./httpHandlers.js";

package/dist/server/programmaticRuntime.d.ts

@@ -0,0 +1,15 @@
+import { MswarmConfigStore } from "@mcoda/core";
+import type { McodaRuntimeAdapter } from "../types.js";
+export interface ProgrammaticMcodaRuntimeAdapterInput {
+    mswarm?: {
+        baseUrl?: string;
+        openAiBaseUrl?: string;
+        apiKey?: string;
+        timeoutMs?: number;
+        agentSlugPrefix?: string;
+        selfHostedAgentSlugPrefix?: string;
+    };
+    store?: MswarmConfigStore;
+}
+export declare function createProgrammaticMcodaRuntimeAdapter(input?: ProgrammaticMcodaRuntimeAdapterInput): McodaRuntimeAdapter;
+//# sourceMappingURL=programmaticRuntime.d.ts.map

package/dist/server/programmaticRuntime.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"programmaticRuntime.d.ts","sourceRoot":"","sources":["../../src/server/programmaticRuntime.ts"],"names":[],"mappings":"AAAA,OAAO,EAGL,iBAAiB,EAIlB,MAAM,aAAa,CAAC;AAGrB,OAAO,KAAK,EAIV,mBAAmB,EACpB,MAAM,aAAa,CAAC;AAErB,MAAM,WAAW,oCAAoC;IACnD,MAAM,CAAC,EAAE;QACP,OAAO,CAAC,EAAE,MAAM,CAAC;QACjB,aAAa,CAAC,EAAE,MAAM,CAAC;QACvB,MAAM,CAAC,EAAE,MAAM,CAAC;QAChB,SAAS,CAAC,EAAE,MAAM,CAAC;QACnB,eAAe,CAAC,EAAE,MAAM,CAAC;QACzB,yBAAyB,CAAC,EAAE,MAAM,CAAC;KACpC,CAAC;IACF,KAAK,CAAC,EAAE,iBAAiB,CAAC;CAC3B;AAED,wBAAgB,qCAAqC,CACnD,KAAK,GAAE,oCAAyC,GAC/C,mBAAmB,CAqHrB"}

package/dist/server/programmaticRuntime.js

@@ -0,0 +1,136 @@
+import { AgentsApi, MswarmApi, MswarmConfigStore, } from "@mcoda/core";
+import { normalizeAgentCatalogEntry } from "../headless/normalization.js";
+import { isCloudAgent, isSelfHostedAgent } from "../headless/catalog.js";
+export function createProgrammaticMcodaRuntimeAdapter(input = {}) {
+    const createMswarmApi = async () => {
+        if (!input.store)
+            return MswarmApi.create(input.mswarm ?? {});
+        const stored = await input.store.readState();
+        return MswarmApi.create({
+            baseUrl: input.mswarm?.baseUrl ?? stored.baseUrl,
+            openAiBaseUrl: input.mswarm?.openAiBaseUrl,
+            apiKey: input.mswarm?.apiKey ?? stored.apiKey,
+            timeoutMs: input.mswarm?.timeoutMs ?? stored.timeoutMs,
+            agentSlugPrefix: input.mswarm?.agentSlugPrefix ?? stored.agentSlugPrefix,
+            selfHostedAgentSlugPrefix: input.mswarm?.selfHostedAgentSlugPrefix,
+        });
+    };
+    const withMswarmApi = async (fn) => {
+        const api = await createMswarmApi();
+        try {
+            return await fn(api);
+        }
+        finally {
+            await api.close();
+        }
+    };
+    const withAgentsApi = async (fn) => {
+        const api = await AgentsApi.create();
+        try {
+            return await fn(api);
+        }
+        finally {
+            await api.close();
+        }
+    };
+    const listLocal = async (options) => withAgentsApi(async (api) => {
+        const agents = await api.listAgents({
+            refreshHealth: options?.refreshHealth,
+        });
+        return agents.map(normalizeLocalAgent);
+    });
+    return {
+        runtime: {
+            mode: "programmatic",
+            requiresMcodaCli: false,
+        },
+        async configureMswarmApiKey(request) {
+            const store = input.store ?? new MswarmConfigStore();
+            await store.saveApiKey(request.apiKey);
+            await MswarmApi.refreshManagedAgentAuth(request.apiKey);
+        },
+        async listCloudAgents(options) {
+            return withMswarmApi(async (api) => {
+                const agents = await api.listCloudAgents(toCloudOptions(options));
+                return agents.map((agent) => normalizeAgentCatalogEntry(agent, {
+                    source: "cloud_catalog",
+                    synced: false,
+                    managedKind: "cloud",
+                }));
+            });
+        },
+        async syncCloudAgents(options) {
+            await withMswarmApi((api) => api.syncCloudAgents(toCloudSyncOptions(options)));
+            return (await listLocal(options)).filter(isCloudAgent);
+        },
+        async listSelfHostedAgents(options) {
+            return withMswarmApi(async (api) => {
+                const agents = await api.listSelfHostedAgents(toSelfHostedOptions(options));
+                return agents.map((agent) => normalizeAgentCatalogEntry(agent, {
+                    source: "self_hosted_catalog",
+                    synced: false,
+                    managedKind: "self_hosted",
+                }));
+            });
+        },
+        async syncSelfHostedAgents(options) {
+            await withMswarmApi((api) => api.syncSelfHostedAgents(toSelfHostedSyncOptions(options)));
+            return (await listLocal(options)).filter(isSelfHostedAgent);
+        },
+        listLocalAgents: listLocal,
+        async testAgent(input) {
+            try {
+                const result = await withAgentsApi((api) => api.runAgent(input.slug, [input.prompt ?? "Hello from mcoda agent setup test."], {
+                    command: "mcoda-agent-setup-test",
+                    timeoutMs: input.timeoutMs,
+                }));
+                const first = result.responses[0];
+                return {
+                    slug: result.agent.slug,
+                    ok: true,
+                    output: first?.output,
+                    model: first?.model,
+                    adapter: first?.adapter,
+                    metadata: first?.metadata,
+                };
+            }
+            catch (error) {
+                return {
+                    slug: input.slug,
+                    ok: false,
+                    error: error instanceof Error ? error.message : String(error),
+                };
+            }
+        },
+    };
+}
+function normalizeLocalAgent(agent) {
+    return normalizeAgentCatalogEntry(agent, {
+        source: "local_registry",
+        synced: true,
+    });
+}
+function toCloudOptions(options) {
+    return {
+        provider: options?.provider,
+    };
+}
+function toCloudSyncOptions(options) {
+    return {
+        provider: options?.provider,
+        pruneMissing: options?.pruneMissing ?? true,
+    };
+}
+function toSelfHostedOptions(options) {
+    return {
+        provider: options?.provider,
+        includeUnreachable: options?.includeUnreachable ?? true,
+    };
+}
+function toSelfHostedSyncOptions(options) {
+    return {
+        provider: options?.provider,
+        includeUnreachable: options?.includeUnreachable ?? true,
+        pruneMissing: options?.pruneMissing ?? true,
+    };
+}

package/dist/server/service.d.ts

@@ -0,0 +1,3 @@
+import type { McodaAgentSetupServerOptions, McodaAgentSetupService } from "../types.js";
+export declare function createMcodaAgentSetupService(options: McodaAgentSetupServerOptions): McodaAgentSetupService;
+//# sourceMappingURL=service.d.ts.map

package/dist/server/service.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"service.d.ts","sourceRoot":"","sources":["../../src/server/service.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAGV,4BAA4B,EAC5B,sBAAsB,EAGvB,MAAM,aAAa,CAAC;AAErB,wBAAgB,4BAA4B,CAC1C,OAAO,EAAE,4BAA4B,GACpC,sBAAsB,CAqJxB"}

package/dist/server/service.js

@@ -0,0 +1,143 @@
+import { defaultMcodaStageDefinitions } from "../defaultStages.js";
+import { buildCloudAgentOptions, buildSelfHostedServerOptions, } from "../headless/catalog.js";
+import { createProgrammaticMcodaRuntimeAdapter } from "./programmaticRuntime.js";
+export function createMcodaAgentSetupService(options) {
+    const runtime = options.mcoda ?? createProgrammaticMcodaRuntimeAdapter();
+    const stages = options.defaultStages ?? defaultMcodaStageDefinitions;
+    const provider = options.provider ?? "mcoda_mswarm";
+    const authorize = async (request) => {
+        await options.authorize?.(request);
+    };
+    const capture = async (errors, key, fn, fallback) => {
+        try {
+            return await fn();
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            errors[key] = message;
+            options.logger?.warn?.(`mcoda agent setup ${key} failed`, {
+                error: message,
+            });
+            return fallback;
+        }
+    };
+    const buildSnapshot = async (extraErrors = {}) => {
+        const settings = await options.settingsStore.load();
+        const errors = { ...extraErrors };
+        const [localAgents, cloudCatalogAgents, selfHostedCatalogAgents] = await Promise.all([
+            capture(errors, "local_agents", () => runtime.listLocalAgents({ refreshHealth: true }), []),
+            capture(errors, "cloud_agents", () => runtime.listCloudAgents(), []),
+            capture(errors, "self_hosted_agents", () => runtime.listSelfHostedAgents({ includeUnreachable: true }), []),
+        ]);
+        const cloudAgents = buildCloudAgentOptions(localAgents, cloudCatalogAgents);
+        const selfHostedServers = buildSelfHostedServerOptions(localAgents, selfHostedCatalogAgents);
+        const catalog = {
+            localAgents,
+            cloudAgents,
+            selfHostedAgents: selfHostedCatalogAgents,
+            selfHostedServers,
+            errors,
+            generatedAt: new Date().toISOString(),
+        };
+        return {
+            provider,
+            runtime: runtime.runtime,
+            mswarmApiKeyConfigured: settings.mswarmApiKeyConfigured,
+            mswarmApiKeyLast4: settings.mswarmApiKeyLast4,
+            mswarmConfiguredAt: settings.mswarmConfiguredAt,
+            stages,
+            assignments: {
+                ...initialAssignments(stages),
+                ...settings.assignments,
+            },
+            catalog,
+            updatedAt: settings.updatedAt,
+            fetchedAt: new Date().toISOString(),
+        };
+    };
+    return {
+        async fetchSnapshot(request) {
+            await authorize(request);
+            return buildSnapshot();
+        },
+        async configureMswarmApiKey(input, request) {
+            await authorize(request);
+            const apiKey = input.apiKey.trim();
+            if (!apiKey) {
+                throw new Error("mswarm api key is required");
+            }
+            await runtime.configureMswarmApiKey(input);
+            const configuredAt = new Date().toISOString();
+            await options.settingsStore.saveMswarmKeyMetadata({
+                configured: true,
+                last4: apiKey.slice(-4),
+                configuredAt,
+                actor: input.actor,
+                reasonCode: input.reasonCode,
+            });
+            const errors = await syncCatalogs();
+            return buildSnapshot(errors);
+        },
+        async syncAgents(input = {}, request) {
+            await authorize(request);
+            const errors = await syncCatalogs();
+            options.logger?.info?.("mcoda agent setup sync completed", {
+                reasonCode: input.reasonCode,
+                errors,
+            });
+            return buildSnapshot(errors);
+        },
+        async updateAssignments(input, request) {
+            await authorize(request);
+            const localAgents = await runtime.listLocalAgents({ refreshHealth: true });
+            const nextAssignments = {
+                ...initialAssignments(stages),
+                ...input.assignments,
+            };
+            validateAssignments(nextAssignments, stages, localAgents);
+            await options.settingsStore.saveAssignments({
+                assignments: nextAssignments,
+                actor: input.actor,
+                reasonCode: input.reasonCode,
+            });
+            return buildSnapshot();
+        },
+        async testAgent(input, request) {
+            await authorize(request);
+            if (!runtime.testAgent) {
+                throw new Error("The configured mcoda runtime adapter does not support agent tests");
+            }
+            return runtime.testAgent(input);
+        },
+    };
+    async function syncCatalogs() {
+        const errors = {};
+        await capture(errors, "cloud_agent_sync", () => runtime.syncCloudAgents({ pruneMissing: true }), []);
+        await capture(errors, "self_hosted_agent_sync", () => runtime.syncSelfHostedAgents({
+            pruneMissing: true,
+            includeUnreachable: true,
+        }), []);
+        return errors;
+    }
+}
+function initialAssignments(stages) {
+    return Object.fromEntries(stages.map((stage) => [stage.stageKey, stage.defaultAgentSlug ?? null]));
+}
+function validateAssignments(assignments, stages, localAgents) {
+    const stageByKey = new Map(stages.map((stage) => [stage.stageKey, stage]));
+    const validSlugs = new Set(localAgents.map((agent) => agent.slug));
+    for (const [stageKey, slug] of Object.entries(assignments)) {
+        const stage = stageByKey.get(stageKey);
+        if (!stage) {
+            throw new Error(`Unknown mcoda stage: ${stageKey}`);
+        }
+        if (!slug) {
+            if (stage.nullable || stage.fallbackStageKey)
+                continue;
+            throw new Error(`Stage ${stageKey} requires an agent assignment`);
+        }
+        if (!validSlugs.has(slug)) {
+            throw new Error(`Selected agent ${slug} is not present in the local registry`);
+        }
+    }
+}

package/dist/server/settingsStore.d.ts

@@ -0,0 +1,3 @@
+import type { McodaAgentSettingsSnapshot, McodaAgentSettingsStore } from "../types.js";
+export declare function createInMemoryMcodaAgentSettingsStore(initial?: Partial<McodaAgentSettingsSnapshot>): McodaAgentSettingsStore;
+//# sourceMappingURL=settingsStore.d.ts.map

package/dist/server/settingsStore.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"settingsStore.d.ts","sourceRoot":"","sources":["../../src/server/settingsStore.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,0BAA0B,EAC1B,uBAAuB,EACxB,MAAM,aAAa,CAAC;AAErB,wBAAgB,qCAAqC,CACnD,OAAO,GAAE,OAAO,CAAC,0BAA0B,CAAM,GAChD,uBAAuB,CAkCzB"}

package/dist/server/settingsStore.js

@@ -0,0 +1,34 @@
+export function createInMemoryMcodaAgentSettingsStore(initial = {}) {
+    let state = {
+        assignments: { ...(initial.assignments ?? {}) },
+        mswarmApiKeyConfigured: initial.mswarmApiKeyConfigured ?? false,
+        mswarmApiKeyLast4: initial.mswarmApiKeyLast4 ?? null,
+        mswarmConfiguredAt: initial.mswarmConfiguredAt ?? null,
+        updatedAt: initial.updatedAt ?? null,
+    };
+    return {
+        async load() {
+            return {
+                ...state,
+                assignments: { ...state.assignments },
+            };
+        },
+        async saveMswarmKeyMetadata(input) {
+            const updatedAt = new Date().toISOString();
+            state = {
+                ...state,
+                mswarmApiKeyConfigured: input.configured,
+                mswarmApiKeyLast4: input.last4,
+                mswarmConfiguredAt: input.configuredAt,
+                updatedAt,
+            };
+        },
+        async saveAssignments(input) {
+            state = {
+                ...state,
+                assignments: { ...input.assignments },
+                updatedAt: new Date().toISOString(),
+            };
+        },
+    };
+}

package/dist/types.d.ts

@@ -0,0 +1,207 @@
+export type McodaRuntimeMode = "programmatic" | "cli_fallback" | "custom";
+export interface McodaRuntimeInfo {
+    mode: McodaRuntimeMode;
+    requiresMcodaCli: boolean;
+}
+export type McodaAgentSource = "local_registry" | "cloud_catalog" | "self_hosted_catalog";
+export type McodaAgentManagedKind = "cloud" | "self_hosted" | null;
+export type McodaPreferredSource = "cloud" | "self_hosted" | "cloud_or_self_hosted" | null;
+export interface McodaStageDefinition {
+    stageKey: string;
+    displayName: string;
+    description?: string;
+    defaultAgentSlug?: string | null;
+    recommendedUsage?: string | null;
+    preferredSource?: McodaPreferredSource;
+    fallbackStageKey?: string | null;
+    nullable?: boolean;
+}
+export interface McodaAgentCatalogEntry {
+    slug: string;
+    source: McodaAgentSource;
+    synced: boolean;
+    remoteSlug: string | null;
+    managedKind?: McodaAgentManagedKind;
+    nodeId?: string | null;
+    serverName?: string | null;
+    serverId?: string | null;
+    serverLabel?: string | null;
+    displayName: string | null;
+    provider: string | null;
+    adapter: string | null;
+    model: string | null;
+    defaultModel: string | null;
+    healthStatus: string | null;
+    supportsTools: boolean | null;
+    rating: number | null;
+    reasoningRating: number | null;
+    maxComplexity: number | null;
+    costPerMillion: number | null;
+    contextWindow?: number | null;
+    maxOutputTokens?: number | null;
+    bestUsage?: string | null;
+    capabilities?: string[];
+    metadata?: Record<string, unknown>;
+}
+export interface McodaSelfHostedServer {
+    id: string;
+    label: string;
+    nodeId?: string | null;
+    serverName?: string | null;
+    status?: string | null;
+    remoteSlugPrefix?: string | null;
+    agentCount: number;
+    agents: McodaAgentCatalogEntry[];
+}
+export interface McodaAgentCatalog {
+    localAgents: McodaAgentCatalogEntry[];
+    cloudAgents: McodaAgentCatalogEntry[];
+    selfHostedAgents: McodaAgentCatalogEntry[];
+    selfHostedServers: McodaSelfHostedServer[];
+    errors: Record<string, string>;
+    generatedAt: string;
+}
+export interface McodaAgentSetupSnapshot {
+    provider: "mcoda_mswarm" | string;
+    runtime: McodaRuntimeInfo;
+    mswarmApiKeyConfigured: boolean;
+    mswarmApiKeyLast4: string | null;
+    mswarmConfiguredAt: string | null;
+    stages: McodaStageDefinition[];
+    assignments: Record<string, string | null>;
+    catalog: McodaAgentCatalog;
+    updatedAt: string | null;
+    fetchedAt: string;
+}
+export interface McodaAgentTestResult {
+    slug: string;
+    ok: boolean;
+    output?: string;
+    model?: string;
+    adapter?: string;
+    metadata?: Record<string, unknown>;
+    error?: string;
+}
+export interface McodaAgentSetupClient {
+    fetchSnapshot(): Promise<McodaAgentSetupSnapshot>;
+    configureMswarmApiKey(input: {
+        apiKey: string;
+        reasonCode?: string;
+        metadata?: Record<string, unknown>;
+    }): Promise<McodaAgentSetupSnapshot>;
+    syncAgents(input?: {
+        reasonCode?: string;
+        metadata?: Record<string, unknown>;
+    }): Promise<McodaAgentSetupSnapshot>;
+    updateAssignments(input: {
+        assignments: Record<string, string | null>;
+        reasonCode?: string;
+        metadata?: Record<string, unknown>;
+    }): Promise<McodaAgentSetupSnapshot>;
+    testAgent?(input: {
+        slug: string;
+        prompt?: string;
+        timeoutMs?: number;
+    }): Promise<McodaAgentTestResult>;
+}
+export interface McodaAgentListInput {
+    provider?: string;
+    refreshHealth?: boolean;
+    includeUnreachable?: boolean;
+}
+export interface McodaAgentSyncInput extends McodaAgentListInput {
+    pruneMissing?: boolean;
+}
+export interface McodaRuntimeAdapter {
+    runtime: McodaRuntimeInfo;
+    configureMswarmApiKey(input: {
+        apiKey: string;
+        actor?: string;
+        reasonCode?: string;
+        metadata?: Record<string, unknown>;
+    }): Promise<void>;
+    listCloudAgents(input?: McodaAgentListInput): Promise<McodaAgentCatalogEntry[]>;
+    syncCloudAgents(input?: McodaAgentSyncInput): Promise<McodaAgentCatalogEntry[]>;
+    listSelfHostedAgents(input?: McodaAgentListInput): Promise<McodaAgentCatalogEntry[]>;
+    syncSelfHostedAgents(input?: McodaAgentSyncInput): Promise<McodaAgentCatalogEntry[]>;
+    listLocalAgents(input?: McodaAgentListInput): Promise<McodaAgentCatalogEntry[]>;
+    testAgent?(input: {
+        slug: string;
+        prompt?: string;
+        timeoutMs?: number;
+    }): Promise<McodaAgentTestResult>;
+}
+export interface McodaAgentSettingsSnapshot {
+    assignments: Record<string, string | null>;
+    mswarmApiKeyConfigured: boolean;
+    mswarmApiKeyLast4: string | null;
+    mswarmConfiguredAt: string | null;
+    updatedAt: string | null;
+}
+export interface McodaAgentSettingsStore {
+    load(): Promise<McodaAgentSettingsSnapshot>;
+    saveMswarmKeyMetadata(input: {
+        configured: boolean;
+        last4: string | null;
+        configuredAt: string;
+        actor?: string;
+        reasonCode?: string;
+    }): Promise<void>;
+    saveAssignments(input: {
+        assignments: Record<string, string | null>;
+        actor?: string;
+        reasonCode?: string;
+    }): Promise<void>;
+}
+export interface McodaSetupLogger {
+    info?(message: string, metadata?: Record<string, unknown>): void;
+    warn?(message: string, metadata?: Record<string, unknown>): void;
+    error?(message: string, metadata?: Record<string, unknown>): void;
+}
+export interface McodaAgentSetupServerOptions {
+    settingsStore: McodaAgentSettingsStore;
+    authorize?: (request: unknown) => Promise<void> | void;
+    mcoda?: McodaRuntimeAdapter;
+    logger?: McodaSetupLogger;
+    defaultStages?: McodaStageDefinition[];
+    operationTimeoutMs?: number;
+    provider?: string;
+}
+export interface McodaAgentSetupService {
+    fetchSnapshot(request?: unknown): Promise<McodaAgentSetupSnapshot>;
+    configureMswarmApiKey(input: {
+        apiKey: string;
+        actor?: string;
+        reasonCode?: string;
+        metadata?: Record<string, unknown>;
+    }, request?: unknown): Promise<McodaAgentSetupSnapshot>;
+    syncAgents(input?: {
+        actor?: string;
+        reasonCode?: string;
+        metadata?: Record<string, unknown>;
+    }, request?: unknown): Promise<McodaAgentSetupSnapshot>;
+    updateAssignments(input: {
+        assignments: Record<string, string | null>;
+        actor?: string;
+        reasonCode?: string;
+        metadata?: Record<string, unknown>;
+    }, request?: unknown): Promise<McodaAgentSetupSnapshot>;
+    testAgent(input: {
+        slug: string;
+        prompt?: string;
+        timeoutMs?: number;
+    }, request?: unknown): Promise<McodaAgentTestResult>;
+}
+export interface McodaAgentSetupHttpRequest {
+    method: string;
+    path?: string;
+    url?: string;
+    body?: unknown;
+    raw?: unknown;
+}
+export interface McodaAgentSetupHttpResponse {
+    status: number;
+    headers: Record<string, string>;
+    body: unknown;
+}
+//# sourceMappingURL=types.d.ts.map