@artinet/agent-relay-mcp 0.0.1

package/dist/src/relay.js

@@ -0,0 +1,157 @@
+/**
+ * Copyright 2025 The Artinet Project
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { A2AClient, } from "@artinet/sdk";
+import { AgentManager, getAgentCard } from "./manager.js";
+import { scanAgents, DEFAULT_MAX_THREADS } from "./scan.js";
+import { getAgentRuntimePath } from "./sync.js";
+export const DEFAULT_SYNC_INTERVAL = parseInt(process.env.ARTINET_RELAY_SYNC_INTERVAL || "30000");
+/**
+ * @description AgentRelay is a class that manages the agents and their interactions.
+ * It scans for agents on the network and registers them.
+ * It also provides a way to send messages to the agents and get tasks from them.
+ * It also provides a way to get the agent card and search for agents.
+ */
+export class AgentRelay extends AgentManager {
+    config;
+    timeoutId = null;
+    constructor(config) {
+        super(config.agents);
+        this.config = {
+            ...config,
+            abortSignal: config.abortSignal ?? new AbortController().signal,
+            syncInterval: config.syncInterval ?? DEFAULT_SYNC_INTERVAL,
+            configPath: config.configPath ?? getAgentRuntimePath(),
+            scanConfig: {
+                ...(config.scanConfig ?? {}),
+                host: config.scanConfig?.host ?? "localhost",
+                startPort: config.scanConfig?.startPort ?? 3000,
+                endPort: config.scanConfig?.endPort ?? 5000,
+                threads: config.scanConfig?.threads ?? DEFAULT_MAX_THREADS,
+            },
+            agents: config.agents ?? new Map(),
+        };
+    }
+    /**
+     * @description Create a new AgentRelay instance and ensure its ready to use
+     * @param config - The configuration for the AgentRelay
+     * @returns The AgentRelay instance
+     */
+    static async create(config) {
+        const relay = new AgentRelay(config);
+        await relay.findAgents(relay.config.scanConfig);
+        relay.startSync().catch((error) => {
+            console.error("Error running sync: ", error);
+            throw error;
+        });
+        return relay;
+    }
+    getAgent(agentId) {
+        //to avoid recursive calls
+        if (agentId === this.config.callerId) {
+            return undefined;
+        }
+        return super.getAgent(agentId);
+    }
+    async close() {
+        if (this.timeoutId) {
+            clearTimeout(this.timeoutId);
+        }
+        await super.close();
+    }
+    async startSync() {
+        this.timeoutId = setInterval(async () => {
+            await this.findAgents(this.config.scanConfig);
+        }, this.config.syncInterval);
+    }
+    async findAgents(config) {
+        const configs = await scanAgents(config).catch((error) => {
+            console.error(`Error scanning agents: ${error}`);
+            return [];
+        });
+        for (const config of configs) {
+            await this.registerAgent(config).catch((error) => {
+                console.error(`Error registering agent: ${error}`);
+            });
+        }
+    }
+    //todo if agent is not a server, serverfy it?
+    // I think we'll avoid this for now
+    // Because it will allow Relay's to have local environments that are unique to them
+    async registerAgent(agent) {
+        let agentCard = await getAgentCard(agent);
+        if (!agentCard &&
+            "url" in agent &&
+            "headers" in agent &&
+            "fallbackPath" in agent) {
+            try {
+                agent = new A2AClient(agent.url, agent.headers, agent.fallbackPath);
+                agentCard = await agent.agentCard();
+            }
+            catch (error) {
+                console.error("error creating client for agent: ", error);
+                throw error;
+            }
+        }
+        else if (!agentCard) {
+            throw new Error("Invalid agent type");
+        }
+        await super.setAgent(agent);
+        return agentCard;
+    }
+    async deregisterAgent(id) {
+        super.deleteAgent(id);
+    }
+    async sendMessage(agentId, messageParams) {
+        const agent = this.getAgent(agentId);
+        if (!agent) {
+            throw new Error(`Agent ${agentId} not found`);
+        }
+        const sendMessageResult = await agent.sendMessage(messageParams);
+        if (!sendMessageResult) {
+            throw new Error(`Failed to send message to agent ${agentId}`);
+        }
+        return sendMessageResult;
+    }
+    async getTask(agentId, taskQuery) {
+        const agent = this.getAgent(agentId);
+        if (!agent) {
+            throw new Error(`Agent ${agentId} not found`);
+        }
+        const task = await agent.getTask(taskQuery);
+        if (!task) {
+            throw new Error(`Task ${agentId} not found`);
+        }
+        return task;
+    }
+    async cancelTask(agentId, taskId) {
+        const agent = this.getAgent(agentId);
+        if (!agent) {
+            throw new Error(`Agent ${agentId} not found`);
+        }
+        const task = await agent.cancelTask(taskId);
+        if (!task) {
+            throw new Error(`Task ${agentId} not found`);
+        }
+        return task;
+    }
+    async getAgentCard(agentId) {
+        const agent = this.getAgent(agentId);
+        if (!agent) {
+            throw new Error(`Agent ${agentId} not found`);
+        }
+        let agentCard = await getAgentCard(agent);
+        if (!agentCard) {
+            throw new Error(`Invalid agent type`);
+        }
+        return agentCard;
+    }
+    async searchAgents(query) {
+        const agents = this.getAgents();
+        return (await Promise.all(agents.map(async (agent) => agent instanceof A2AClient ? await agent.agentCard() : agent.agentCard))).filter((agentCard) => agentCard.name.toLowerCase().includes(query.toLowerCase()) ||
+            agentCard.description.toLowerCase().includes(query.toLowerCase()) ||
+            agentCard.skills.some((skill) => skill.name.toLowerCase().includes(query.toLowerCase()) ||
+                skill.description.toLowerCase().includes(query.toLowerCase())));
+    }
+}

package/dist/src/scan.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Copyright 2025 The Artinet Project
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { ClientConfig, ScanConfig } from "./types/index.js";
+export declare const DEFAULT_MAX_THREADS = 250;
+export declare function scanAgents(config: ScanConfig): Promise<ClientConfig[]>;

package/dist/src/scan.js

@@ -0,0 +1,30 @@
+import * as portscanner from "portscanner";
+import pLimit from "p-limit";
+export const DEFAULT_MAX_THREADS = 250;
+export async function scanAgents(config) {
+    //avoid overwhelming the port scanner
+    const limit = pLimit(config.threads ?? DEFAULT_MAX_THREADS);
+    const portChecks = [];
+    for (let port = config.startPort; port <= config.endPort; port++) {
+        portChecks.push(limit(async () => await portscanner
+            .checkPortStatus(port, config.host)
+            .then((status) => ({ port, status }))));
+    }
+    const results = await Promise.all(portChecks);
+    const openPorts = results
+        .filter((r) => r.status === "open")
+        .map((r) => r.port);
+    if (!openPorts?.length) {
+        // console.log("No open ports found");
+        return [];
+    }
+    const configs = [];
+    for (const port of openPorts) {
+        configs.push({
+            url: `http://${config.host}:${port}`,
+            headers: config.headers,
+            fallbackPath: config.fallbackPath,
+        });
+    }
+    return configs;
+}

package/dist/src/server.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Copyright 2025 The Artinet Project
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { ServerOptions } from "@modelcontextprotocol/sdk/server/index.js";
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { Implementation } from "@modelcontextprotocol/sdk/types.js";
+import { AgentRelayConfig } from "./types/index.js";
+declare class RelayServer extends McpServer {
+    private relay;
+    constructor(info?: Implementation, options?: ServerOptions);
+    close(): Promise<void>;
+    init(config: AgentRelayConfig): Promise<void>;
+}
+export { RelayServer };

package/dist/src/server.js

@@ -0,0 +1,218 @@
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { AgentRelay } from "./relay.js";
+import { v4 as uuidv4 } from "uuid";
+import { TaskSchema, AgentCardSchema, SendMessageSuccessResultSchema, getContent, } from "@artinet/sdk";
+import { z } from "zod";
+class RelayServer extends McpServer {
+    relay = null;
+    constructor(info = {
+        name: "agent-relay-server",
+        version: "0.0.1",
+    }, options = {}) {
+        super(info, {
+            ...options,
+            instructions: options?.instructions +
+                `The relay server is a tool that allows the assistant to:
+    - send messages to other agents
+    - get information about a task that is currently running orcancel a task that is currently running
+    - get information about an agent in the form of an agent card ( which includes the skills of the agent and its capabilities)
+    - view the available agents
+    - and search for agents based on a query
+        
+sendMessage - can be used to send a command to another agent.
+getTask - can be used to get the status of a task.
+cancelTask - can be used to cancel a task that is currently running.
+getAgentCard - can be used to get the agent card of an agent. This is useful to get the skills of an agent and understand its capabilities.
+viewAgents - can be used to view the available agents. This is useful to get the names of the agents and review their information.
+searchAgents - can be used to search for agents based on a query. This is useful to find agents that match a specific skill or name.
+
+The assistant should request viewAgents at the start of a conversation to get the names of the agents and review their information inorder to see if they would be useful for the current request.
+The assistant should recall the taskId when sending a follow-up message to the same agent to continue the conversation.
+The assistant should be clear and concise when making a request of another agent and provide all the necessary information to the agent to fulfill the request.
+If the assistant lacks the ability to fulfill a request it should check if there are any other agents that would be able to fulfill the request and if another agent is available for the task, the assistant should send detailed instructions to the other agent to fulfill the request.
+If no other agent is available for the task, the assistant should return a message to the user indicating that no other agent is available for the task.
+If the assistant determines that the request has not been adequately fulfilled by the other agent, the assistant must determine whether to call the same agent again or call a different agent or to ask the user for clarification.
+Upon completion of the request, the assistant should return the result to the user.
+The assistant should always return the result to the user in a clear and concise manner.
+      `,
+        });
+    }
+    async close() {
+        await this.relay?.close();
+        await super.close();
+    }
+    async init(config) {
+        this.relay = await AgentRelay.create(config);
+        this.registerTool("sendMessage", {
+            title: "Send Message",
+            description: "A message will be sent to the target agent and a response object containing the full details of request will be returned to the assistant. Which contains the task id and the message sent to the agent, the conversation history and the artifacts created by the agent.",
+            inputSchema: z.object({
+                agentId: z
+                    .string()
+                    .describe("The id of the agent to send the message to."),
+                message: z.string().describe("The message to send to the agent."),
+                taskId: z
+                    .string()
+                    .describe("The id of the task that the message is related to. If not provided, a new task will be created.")
+                    .optional(),
+            }).shape,
+            outputSchema: z.object({
+                result: SendMessageSuccessResultSchema,
+            }).shape,
+        }, async (args) => {
+            const result = await this.relay?.sendMessage(args.agentId, {
+                message: {
+                    role: "user",
+                    messageId: uuidv4(),
+                    kind: "message",
+                    parts: [{ text: args.message, kind: "text" }],
+                    taskId: args.taskId ?? uuidv4(),
+                },
+            });
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: getContent(result) ??
+                            "No result from the agent. This may be because the agent is not responding or the message was not sent.",
+                    },
+                ],
+                structuredContent: {
+                    result: result,
+                },
+            };
+        });
+        this.registerTool("getTask", {
+            title: "Get Task",
+            description: "Get the status of a running task from an agent",
+            inputSchema: z
+                .object({
+                agentId: z
+                    .string()
+                    .describe("The id of the agent to get the task from."),
+                taskId: z.string().describe("The id of the task to get."),
+            })
+                .describe("The agent id and task query to get the status of a running task from the agent.").shape,
+            outputSchema: TaskSchema.shape,
+        }, async (args) => {
+            const result = await this.relay?.getTask(args.agentId, {
+                id: args.taskId,
+            });
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: result?.status?.state ??
+                            "No task found. This may be because the task is not running or the agent is not responding.",
+                    },
+                ],
+                structuredContent: result,
+            };
+        });
+        this.registerTool("cancelTask", {
+            title: "Cancel Task",
+            description: "Cancel a running task from an agent",
+            inputSchema: z
+                .object({
+                agentId: z
+                    .string()
+                    .describe("The id of the agent to cancel the task from."),
+                taskId: z.string().describe("The id of the task to cancel."),
+            })
+                .describe("The agent id and task id to cancel a running task from the agent.").shape,
+            outputSchema: TaskSchema.shape,
+        }, async (args) => {
+            const result = await this.relay?.cancelTask(args.agentId, {
+                id: args.taskId,
+            });
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: result?.status?.state ??
+                            "No task found. This may be because the task is not running or the agent is not responding.",
+                    },
+                ],
+                structuredContent: result,
+            };
+        });
+        this.registerTool("getAgentCard", {
+            title: "Get Agent Card",
+            description: "Get the agent card of an agent",
+            inputSchema: z.object({
+                agentId: z
+                    .string()
+                    .describe("The id of the agent to get the agent card from."),
+            }).shape,
+            outputSchema: AgentCardSchema.shape,
+        }, async (args) => {
+            const result = await this.relay?.getAgentCard(args.agentId);
+            const text = result
+                ? JSON.stringify(result, null, 2)
+                : "No agent card found. This may be because the agent is not registered or the agent is not responding.";
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: text,
+                    },
+                ],
+                structuredContent: result,
+            };
+        });
+        this.registerTool("viewAgents", {
+            title: "View Agents",
+            description: "View the agents that are registered with the relay.",
+            outputSchema: z.object({
+                agents: z
+                    .array(AgentCardSchema)
+                    .describe("The agents that are registered with the relay."),
+            }).shape,
+        }, async (_) => {
+            const result = (await this.relay?.getAgentCards()) ?? [];
+            const text = result && result.length > 0
+                ? JSON.stringify({ agents: result }, null, 2)
+                : "No agents registered with the relay.";
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: text,
+                    },
+                ],
+                structuredContent: {
+                    agents: result ?? [],
+                },
+            };
+        });
+        this.registerTool("searchAgents", {
+            title: "Search Agents",
+            description: "Search for agents by name, description, or skills. The query is case insensitive and will match against the entire name, description, and skills of the agents.",
+            inputSchema: z.object({
+                query: z.string().describe("The query to search against."),
+            }).shape,
+            outputSchema: z.object({
+                agents: z
+                    .array(AgentCardSchema)
+                    .describe("The agents that match the query."),
+            }).shape,
+        }, async (args) => {
+            const result = (await this.relay?.searchAgents(args.query)) ?? [];
+            const text = result && result.length > 0
+                ? JSON.stringify({ agents: result }, null, 2)
+                : "No agents found. This may be because the query is not valid or the agents are not responding.";
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: text,
+                    },
+                ],
+                structuredContent: {
+                    agents: result,
+                },
+            };
+        });
+    }
+}
+export { RelayServer };

package/dist/src/sync.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Copyright 2025 The Artinet Project
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { IRuntimeSync, SyncConfig } from "./types/index.js";
+import { AgentRuntime } from "./types/config.js";
+export declare const DEFAULT_RELAY_CONFIG_PATH: string;
+export declare function getAgentRuntimePath(configPath?: string): string;
+export declare class RuntimeLoader {
+    private configPath;
+    constructor(configPath?: string);
+    loadAgentRuntime(): Promise<AgentRuntime>;
+    saveAgentRuntime(agentRuntime: AgentRuntime): Promise<void>;
+}
+export declare class Sync extends RuntimeLoader implements IRuntimeSync {
+    private syncInterval;
+    private runtime;
+    private abortSignal;
+    private _isRunning;
+    constructor(config: SyncConfig);
+    private initializeSync;
+    getRuntime(): Promise<AgentRuntime>;
+    updateRuntime(data: AgentRuntime): Promise<boolean>;
+    isRunning(): boolean;
+    close(): void;
+}

package/dist/src/sync.js

@@ -0,0 +1,98 @@
+/**
+ * Copyright 2025 The Artinet Project
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { AgentRuntimeSchema, } from "./types/index.js";
+import { join } from "path";
+import { homedir } from "os";
+import fs from "fs/promises";
+import { dirname } from "path";
+export const DEFAULT_RELAY_CONFIG_PATH = process.env.ARTINET_RELAY_CONFIG_DIR ||
+    (process.env.XDG_CONFIG_HOME
+        ? join(process.env.XDG_CONFIG_HOME, "symphony")
+        : join(homedir(), ".config", "symphony"));
+export function getAgentRuntimePath(configPath = DEFAULT_RELAY_CONFIG_PATH) {
+    return join(configPath, "agent-runtime.json");
+}
+export class RuntimeLoader {
+    configPath;
+    constructor(configPath = DEFAULT_RELAY_CONFIG_PATH) {
+        this.configPath = configPath;
+    }
+    async loadAgentRuntime() {
+        const runtimeFilePath = getAgentRuntimePath(this.configPath);
+        const dir = dirname(runtimeFilePath);
+        try {
+            await fs.access(dir);
+        }
+        catch {
+            await fs.mkdir(dir, { recursive: true });
+        }
+        try {
+            await fs.access(runtimeFilePath);
+        }
+        catch {
+            await fs.writeFile(runtimeFilePath, "{}", "utf8");
+        }
+        try {
+            await fs.access(runtimeFilePath);
+        }
+        catch {
+            throw new Error(`agent runtime file does not exist or is not accessible: ${runtimeFilePath}`);
+        }
+        const agentRuntime = await fs.readFile(runtimeFilePath, "utf8");
+        if (agentRuntime.trim() === "") {
+            throw new Error("agent runtime file is empty");
+        }
+        const parsedRuntime = AgentRuntimeSchema.safeParse(JSON.parse(agentRuntime));
+        if (parsedRuntime.error) {
+            throw new Error("invalid agent runtime file: " + parsedRuntime.error.message);
+        }
+        // filter out removed agents
+        // we do this here so that all runtimes know not to add the removed agent to their runtime
+        const runtime = Object.fromEntries(Object.entries(parsedRuntime.data).filter(([_, value]) => value.removed === undefined ? true : value.removed !== true));
+        return runtime;
+    }
+    async saveAgentRuntime(agentRuntime) {
+        const runtimeFilePath = getAgentRuntimePath(this.configPath);
+        const currentRuntime = await this.loadAgentRuntime();
+        const newRuntime = { ...currentRuntime, ...agentRuntime };
+        await fs.writeFile(runtimeFilePath, JSON.stringify(newRuntime, null, 2), "utf8");
+    }
+}
+export class Sync extends RuntimeLoader {
+    syncInterval;
+    runtime = {};
+    abortSignal;
+    _isRunning = false;
+    constructor(config) {
+        super(config.configPath);
+        this.syncInterval = config.syncInterval;
+        this.abortSignal = config.abortSignal;
+        this.initializeSync().catch((error) => {
+            console.error("Error syncing runtime: ", error);
+        });
+    }
+    async initializeSync() {
+        this._isRunning = true;
+        while (!this.abortSignal.aborted && this._isRunning) {
+            this.runtime = await this.loadAgentRuntime();
+            await new Promise((resolve) => setTimeout(resolve, this.syncInterval));
+        }
+    }
+    async getRuntime() {
+        this.runtime = await this.loadAgentRuntime();
+        return this.runtime;
+    }
+    async updateRuntime(data) {
+        this.runtime = { ...this.runtime, ...data };
+        await this.saveAgentRuntime(this.runtime);
+        return true;
+    }
+    isRunning() {
+        return this._isRunning;
+    }
+    close() {
+        this._isRunning = false;
+    }
+}

package/dist/src/types/config.d.ts

@@ -0,0 +1,76 @@
+import { AgentType } from "./manager.js";
+import { z } from "zod";
+export declare const RuntimeServerConfigSchema: z.ZodObject<{
+    id: z.ZodOptional<z.ZodString>;
+    url: z.ZodString;
+} & {
+    blocklist: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+} & {
+    removed: z.ZodOptional<z.ZodBoolean>;
+    headers: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    fallbackPath: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    url: string;
+    id?: string | undefined;
+    headers?: Record<string, string> | undefined;
+    blocklist?: string[] | undefined;
+    removed?: boolean | undefined;
+    fallbackPath?: string | undefined;
+}, {
+    url: string;
+    id?: string | undefined;
+    headers?: Record<string, string> | undefined;
+    blocklist?: string[] | undefined;
+    removed?: boolean | undefined;
+    fallbackPath?: string | undefined;
+}>;
+export type RuntimeServerConfig = z.infer<typeof RuntimeServerConfigSchema>;
+export declare const AgentRuntimeSchema: z.ZodRecord<z.ZodString, z.ZodObject<{
+    id: z.ZodOptional<z.ZodString>;
+    url: z.ZodString;
+} & {
+    blocklist: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+} & {
+    removed: z.ZodOptional<z.ZodBoolean>;
+    headers: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    fallbackPath: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    url: string;
+    id?: string | undefined;
+    headers?: Record<string, string> | undefined;
+    blocklist?: string[] | undefined;
+    removed?: boolean | undefined;
+    fallbackPath?: string | undefined;
+}, {
+    url: string;
+    id?: string | undefined;
+    headers?: Record<string, string> | undefined;
+    blocklist?: string[] | undefined;
+    removed?: boolean | undefined;
+    fallbackPath?: string | undefined;
+}>>;
+export type AgentRuntime = z.infer<typeof AgentRuntimeSchema>;
+export interface IRuntimeSync {
+    getRuntime(): Promise<AgentRuntime>;
+    updateRuntime(data: AgentRuntime): Promise<boolean>;
+}
+export interface RuntimeLoaderConfig {
+    configPath: string;
+}
+export interface SyncConfig extends Partial<RuntimeLoaderConfig> {
+    abortSignal: AbortSignal;
+    syncInterval: number;
+}
+export interface ScanConfig {
+    host: string;
+    startPort: number;
+    endPort: number;
+    headers?: Record<string, string>;
+    fallbackPath?: string;
+    threads?: number;
+}
+export interface AgentRelayConfig extends Partial<SyncConfig> {
+    callerId: string;
+    scanConfig?: ScanConfig;
+    agents?: Map<string, AgentType>;
+}

package/dist/src/types/config.js

@@ -0,0 +1,12 @@
+/**
+ * Copyright 2025 The Artinet Project
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { RemoteServerConfigSchema } from "@artinet/types";
+import { z } from "zod";
+export const RuntimeServerConfigSchema = RemoteServerConfigSchema.extend({
+    removed: z.boolean().optional(),
+    headers: z.record(z.string(), z.string()).optional(),
+    fallbackPath: z.string().optional(),
+});
+export const AgentRuntimeSchema = z.record(z.string(), RuntimeServerConfigSchema);

package/dist/src/types/index.d.ts

@@ -0,0 +1,4 @@
+export * from "./manager.js";
+export * from "./config.js";
+export * from "./relay.js";
+export * from "./schema.js";

package/dist/src/types/index.js

@@ -0,0 +1,4 @@
+export * from "./manager.js";
+export * from "./config.js";
+export * from "./relay.js";
+export * from "./schema.js";

package/dist/src/types/manager.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Copyright 2025 The Artinet Project
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { Agent, A2AClient } from "@artinet/sdk";
+export type AgentType = Agent | A2AClient;
+export interface IAgentManager {
+    getAgent(id: string): AgentType | undefined;
+    setAgent(agent: AgentType): Promise<void>;
+    deleteAgent(id: string): void;
+    getAgents(): AgentType[];
+    getAgentCount(): number;
+    getAgentIds(): string[];
+}

package/dist/src/types/manager.js

@@ -0,0 +1 @@
+export {};