@artinet/agent-relay-mcp 0.0.1 → 0.0.2

package/README.md

@@ -8,15 +8,15 @@
 
 # Agent Relay MCP Server
 
-A [Model Context Protocol (MCP)](https://modelcontextprotocol.io) server that enables AI agents to discover and communicate with other [A2A (Agent-to-Agent)](https://github.com/a2aproject/A2A) enabled AI agents through the [@artinet/sdk](https://github.com/the-artinet-project/artinet-sdk).
+A [Model Context Protocol (MCP)](https://modelcontextprotocol.io) server that enables AI agents to discover and communicate with other [A2A (Agent-to-Agent)](https://github.com/a2aproject/A2A) enabled AI agents through the [@artinet/sdk](https://github.com/the-artinet-project/artinet-sdk) and [@artinet/agent-relay](https://github.com/the-artinet-project/agent-relay).
 
 ## Features
 
 - **Automatic Agent Discovery**: Scans network ports to discover available agents
+- **Multi-Agent Orchestration**: Coordinate workflows across multiple specialized agents
 - **Message Relay**: Send messages to agents and receive responses with full task context
 - **Task Management**: Query task status and cancel running tasks
 - **Agent Discovery**: View and search agents by name, description, or skills
-- **Multi-Agent Orchestration**: Coordinate workflows across multiple specialized agents
 
 ## Installation
 
@@ -38,7 +38,7 @@ Example:
 npx @artinet/agent-relay-mcp my-assistant 3000 3100 10
 ```
 
-\*we recommend allocating a small port range because port scanning is resource intensive.
+\*We recommend allocating a small port range because port scanning is resource intensive.
 
 ### As an MCP Server
 

package/dist/src/index.d.ts

@@ -1,2 +1,2 @@
 export * from "./server.js";
-export * from "./types/index.js";
+export * from "@artinet/agent-relay";

package/dist/src/index.js

@@ -1,2 +1,32 @@
+// import * as z from "zod";
+// import { ScanConfigSchema } from "@artinet/agent-relay";
+// import { RelayServer } from "./server.js";
+//for smithery
+// export const configSchema = z.object({
+//   callerId: z.string(),
+//   syncInterval: z.number().optional(),
+//   scanConfig: ScanConfigSchema.optional(),
+// });
+// type Config = z.infer<typeof configSchema>;
+// export default async function createServer({ config }: { config: Config }) {
+//   const server = new RelayServer({
+//     name: "agent-relay-server",
+//     version: "0.0.1",
+//   });
+//   await server.init({
+//     callerId: config.callerId,
+//     syncInterval: config.syncInterval ?? 2500,
+//     scanConfig: {
+//       ...(config.scanConfig ?? {}),
+//       host: config.scanConfig?.host ?? "localhost",
+//       startPort: config.scanConfig?.startPort ?? 3000,
+//       endPort: config.scanConfig?.endPort ?? 3100,
+//       threads: config.scanConfig?.threads ?? 10,
+//       fallbackPath:
+//         config.scanConfig?.fallbackPath ?? "/.well-known/agent-card.json",
+//     },
+//   });
+//   return server.server;
+// }
 export * from "./server.js";
-export * from "./types/index.js";
+export * from "@artinet/agent-relay";

package/dist/src/server.d.ts

@@ -5,7 +5,7 @@
 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";
+import { AgentRelayConfig } from "@artinet/agent-relay";
 declare class RelayServer extends McpServer {
     private relay;
     constructor(info?: Implementation, options?: ServerOptions);

package/dist/src/server.js

@@ -1,5 +1,5 @@
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
-import { AgentRelay } from "./relay.js";
+import { AgentRelay } from "@artinet/agent-relay";
 import { v4 as uuidv4 } from "uuid";
 import { TaskSchema, AgentCardSchema, SendMessageSuccessResultSchema, getContent, } from "@artinet/sdk";
 import { z } from "zod";
@@ -138,7 +138,7 @@ The assistant should always return the result to the user in a clear and concise
         });
         this.registerTool("getAgentCard", {
             title: "Get Agent Card",
-            description: "Get the agent card of an agent",
+            description: "Get the AgentCard that describes the capabilities and skills of an agent",
             inputSchema: z.object({
                 agentId: z
                     .string()

package/package.json

@@ -1,12 +1,12 @@
 {
   "name": "@artinet/agent-relay-mcp",
-  "version": "0.0.1",
+  "version": "0.0.2",
   "description": "A Model Context Protocol (MCP) server for relaying messages between A2A enabled AI agents.",
   "author": "artinet",
   "license": "Apache-2.0",
   "repository": {
     "type": "git",
-    "url": "https://github.com/the-artinet-project/mcp/tree/main/servers/relay"
+    "url": "git+https://github.com/the-artinet-project/mcp.git#main"
   },
   "issues": {
     "url": "https://github.com/the-artinet-project/mcp/issues"
@@ -18,7 +18,7 @@
     "LICENSE"
   ],
   "bin": {
-    "agent-relay-mcp": "./dist/bin/stdio.js"
+    "agent-relay-mcp": "dist/bin/stdio.js"
   },
   "keywords": [
     "artinet",
@@ -45,19 +45,19 @@
     "build": "tsc --project tsconfig.json",
     "clean": "rimraf dist",
     "clean:all": "rimraf dist node_modules package-lock.json",
-    "dev": "tsc --watch",
     "start": "node dist/bin/stdio.js",
     "test": "NODE_OPTIONS=--experimental-vm-modules jest",
     "prepublishOnly": "npm run clean:all && npm i && npm run build && npm test"
   },
   "dependencies": {
-    "@artinet/sdk": "^0.5.11",
-    "@artinet/types": "^0.0.4",
-    "@modelcontextprotocol/sdk": "^1.20.0",
+    "@artinet/sdk": "^0.5.13",
+    "@artinet/agent-relay": "^0.0.3",
+    "@artinet/types": "^0.0.5",
+    "@modelcontextprotocol/sdk": "1.20.0",
     "p-limit": "^7.2.0",
     "portscanner": "^2.2.0",
-    "zod": "^3.23.8",
-    "uuid": "^11.1.0"
+    "uuid": "^11.1.0",
+    "zod": "^3.23.8"
   },
   "devDependencies": {
     "@types/node": "^20.17.50",

package/dist/src/manager.d.ts

@@ -1,19 +0,0 @@
-/**
- * Copyright 2025 The Artinet Project
- * SPDX-License-Identifier: Apache-2.0
- */
-import { AgentCard } from "@artinet/sdk";
-import { IAgentManager, AgentType, ClientConfig } from "./types/index.js";
-export declare function getAgentCard(agent: AgentType | ClientConfig): Promise<AgentCard | undefined>;
-export declare class AgentManager implements IAgentManager {
-    private agents;
-    constructor(agents?: Map<string, AgentType>);
-    getAgent(id: string): AgentType | undefined;
-    setAgent(agent: AgentType): Promise<void>;
-    deleteAgent(id: string): void;
-    getAgents(): AgentType[];
-    getAgentCards(): Promise<AgentCard[]>;
-    getAgentCount(): number;
-    getAgentIds(): string[];
-    close(): Promise<void>;
-}

package/dist/src/manager.js

@@ -1,56 +0,0 @@
-/**
- * Copyright 2025 The Artinet Project
- * SPDX-License-Identifier: Apache-2.0
- */
-import { A2AClient, A2AService } from "@artinet/sdk";
-export async function getAgentCard(agent) {
-    if (agent instanceof A2AClient) {
-        return await agent.agentCard();
-    }
-    else if (agent instanceof A2AService) {
-        return agent.agentCard;
-    }
-    return undefined;
-}
-export class AgentManager {
-    agents = new Map();
-    constructor(agents = new Map()) {
-        this.agents = agents;
-    }
-    getAgent(id) {
-        return this.agents.get(id);
-    }
-    async setAgent(agent) {
-        if (agent instanceof A2AClient) {
-            const agentCard = await agent.agentCard();
-            this.agents.set(agentCard.name, agent);
-        }
-        else {
-            this.agents.set(agent.agentCard.name, agent);
-        }
-    }
-    deleteAgent(id) {
-        this.agents.delete(id);
-    }
-    getAgents() {
-        return Array.from(this.agents.values());
-    }
-    async getAgentCards() {
-        const agents = this.getAgents();
-        const agentCards = await Promise.all(agents.map(async (agent) => await getAgentCard(agent)));
-        return agentCards.filter((agentCard) => agentCard !== undefined);
-    }
-    getAgentCount() {
-        return this.agents.size;
-    }
-    getAgentIds() {
-        return Array.from(this.agents.keys());
-    }
-    async close() {
-        await Promise.all(Array.from(this.agents.values()).map(async (agent) => {
-            if ("stop" in agent) {
-                await agent.stop();
-            }
-        }));
-    }
-}

package/dist/src/relay.d.ts

@@ -1,36 +0,0 @@
-/**
- * Copyright 2025 The Artinet Project
- * SPDX-License-Identifier: Apache-2.0
- */
-import { AgentCard, MessageSendParams, SendMessageSuccessResult, TaskQueryParams, Task, TaskIdParams } from "@artinet/sdk";
-import { AgentType, IAgentRelay, ClientConfig, AgentRelayConfig } from "./types/index.js";
-import { AgentManager } from "./manager.js";
-export declare const DEFAULT_SYNC_INTERVAL: number;
-/**
- * @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 declare class AgentRelay extends AgentManager implements IAgentRelay {
-    private config;
-    private timeoutId;
-    constructor(config: AgentRelayConfig);
-    /**
-     * @description Create a new AgentRelay instance and ensure its ready to use
-     * @param config - The configuration for the AgentRelay
-     * @returns The AgentRelay instance
-     */
-    static create(config: AgentRelayConfig): Promise<AgentRelay>;
-    getAgent(agentId: string): AgentType | undefined;
-    close(): Promise<void>;
-    private startSync;
-    private findAgents;
-    registerAgent(agent: AgentType | ClientConfig): Promise<AgentCard>;
-    deregisterAgent(id: string): Promise<void>;
-    sendMessage(agentId: string, messageParams: MessageSendParams): Promise<SendMessageSuccessResult>;
-    getTask(agentId: string, taskQuery: TaskQueryParams): Promise<Task>;
-    cancelTask(agentId: string, taskId: TaskIdParams): Promise<Task>;
-    getAgentCard(agentId: string): Promise<AgentCard>;
-    searchAgents(query: string): Promise<AgentCard[]>;
-}

package/dist/src/relay.js

@@ -1,157 +0,0 @@
-/**
- * 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

@@ -1,7 +0,0 @@
-/**
- * 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

@@ -1,30 +0,0 @@
-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/sync.d.ts

@@ -1,26 +0,0 @@
-/**
- * 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

@@ -1,98 +0,0 @@
-/**
- * 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

@@ -1,76 +0,0 @@
-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

@@ -1,12 +0,0 @@
-/**
- * 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

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

package/dist/src/types/index.js

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

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

@@ -1,14 +0,0 @@
-/**
- * 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

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

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

@@ -1,16 +0,0 @@
-/**
- * Copyright 2025 The Artinet Project
- * SPDX-License-Identifier: Apache-2.0
- */
-import { AgentType, IAgentManager } from "./manager.js";
-import { ClientConfig } from "./schema.js";
-import { AgentCard, TaskQueryParams, Task, TaskIdParams, MessageSendParams, SendMessageSuccessResult } from "@artinet/sdk";
-export interface IAgentRelay extends IAgentManager {
-    registerAgent(agent: AgentType | ClientConfig): Promise<AgentCard>;
-    deregisterAgent(agentId: string): Promise<void>;
-    sendMessage(agentId: string, messageParams: MessageSendParams): Promise<SendMessageSuccessResult>;
-    getTask(agentId: string, taskQuery: TaskQueryParams): Promise<Task>;
-    cancelTask(agentId: string, taskId: TaskIdParams): Promise<Task>;
-    getAgentCard(agentId: string): Promise<AgentCard | undefined>;
-    searchAgents(query: string): Promise<AgentCard[]>;
-}

package/dist/src/types/relay.js

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

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

@@ -1,19 +0,0 @@
-/**
- * Copyright 2025 The Artinet Project
- * SPDX-License-Identifier: Apache-2.0
- */
-import z from "zod";
-export declare const ClientConfigSchema: z.ZodObject<{
-    url: z.ZodString;
-    headers: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
-    fallbackPath: z.ZodOptional<z.ZodString>;
-}, "strip", z.ZodTypeAny, {
-    url: string;
-    headers?: Record<string, string> | undefined;
-    fallbackPath?: string | undefined;
-}, {
-    url: string;
-    headers?: Record<string, string> | undefined;
-    fallbackPath?: string | undefined;
-}>;
-export type ClientConfig = z.infer<typeof ClientConfigSchema>;

package/dist/src/types/schema.js

@@ -1,16 +0,0 @@
-/**
- * Copyright 2025 The Artinet Project
- * SPDX-License-Identifier: Apache-2.0
- */
-import z from "zod";
-export const ClientConfigSchema = z.object({
-    url: z.string().url().describe("The URL of the agent to register."),
-    headers: z
-        .record(z.string(), z.string())
-        .optional()
-        .describe("The headers to send to the agent."),
-    fallbackPath: z
-        .string()
-        .optional()
-        .describe("The fallback path to use if the agent does not support the request."),
-});