atabey 0.0.9 → 0.0.11

package/framework-mcp/README.md

@@ -0,0 +1,48 @@
+# Agent Atabey — MCP Server (`atabey-mcp`)
+
+[![Version](https://img.shields.io/npm/v/atabey-mcp.svg)](https://npmjs.com/package/atabey-mcp)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+
+The **Model Context Protocol (MCP)** server for [Agent Atabey](https://npmjs.com/package/atabey). 
+
+This package acts as the bridge between AI Assistants (like Claude Desktop, Cursor, or Antigravity CLI) and your local project environment. It provides a highly governed, type-safe set of tools that allow AI agents to interact with your codebase securely.
+
+## 🚀 Features
+
+- **Strict Governance:** Enforces Zero Type Hole and Zero Console policies via AST parsing.
+- **Surgical Edits:** Uses `patch_file` and `replace_text` instead of full-file rewrites to save tokens and prevent context loss.
+- **Hermes Message Broker:** Facilitates asynchronous communication between specialized agents (`@manager`, `@architect`, `@security`, etc.).
+- **Memory Insights:** Provides agents with targeted, pruned context (last 5 actions, active trace) instead of dumping the entire project history.
+- **Risk Engine:** Automatically blocks or requires human approval for high-risk operations (e.g., deleting databases, touching `.env` files).
+
+## 📦 Installation
+
+Typically, you do not need to install this package manually. It is automatically installed and configured when you initialize an Atabey project:
+
+```bash
+npx atabey init
+```
+
+However, you can install it globally or locally if needed:
+
+```bash
+npm install atabey-mcp
+```
+
+## 🛠️ Provided Tools
+
+The `atabey-mcp` server exposes over 25 specialized tools grouped into the following domains:
+
+- **File System:** `read_file`, `write_file`, `replace_text`, `patch_file`, `batch_surgical_edit`
+- **Control Plane:** `acquire_lock`, `release_lock`, `register_agent`
+- **Framework & Orchestration:** `submit_plan`, `orchestrate_loop`, `update_project_memory`, `audit_dependencies`
+- **Search & Map:** `grep_search`, `list_dir`, `get_architectural_map`, `get_knowledge_gaps`
+- **Quality & Observability:** `check_lint`, `run_tests`, `get_system_health`, `check_ports`
+- **Messaging:** `send_agent_message`, `log_agent_action`
+
+## 📖 Learn More
+
+For full documentation, architecture details, and enterprise inquiries, please visit the main [Agent Atabey Repository](https://github.com/ysf-bkr/atabey).
+
+---
+*Developed by Yusuf BEKAR*

package/framework-mcp/dist/resources/index.js

@@ -1,4 +1,4 @@
-import { Storage } from "../../../src/shared/storage.js";
+import { Storage } from "../utils/storage.js";
 /**
  * [DATA] MCP Resource Definitions
  */
@@ -43,7 +43,7 @@ export async function handleReadResource(uri) {
     if (uri === "atabey://memory/project") {
         const fs = await import("fs");
         const path = await import("path");
-        const { getFrameworkDir } = await import("../../../src/cli/utils/memory.js");
+        const { getFrameworkDir } = await import("../utils/memory.js");
         const projectRoot = process.env.ATABEY_PROJECT_ROOT || process.cwd();
         const fwDir = getFrameworkDir();
         const p = path.isAbsolute(fwDir)

package/framework-mcp/dist/tools/file_system/read_file.js

@@ -26,16 +26,16 @@ export function handleReadFile(projectRoot, args) {
             Metrics.logUsage(projectRoot, "@mcp", `read_file: ${args.path}`, tokens);
             return { content: [{ type: "text", text: sliced }] };
         }
-        // Default protection limit: 1000 lines
-        const DEFAULT_MAX_LINES = 1000;
-        if (lines.length > DEFAULT_MAX_LINES) {
-            const sliced = lines.slice(0, DEFAULT_MAX_LINES).join("\n");
-            const tokens = Metrics.estimateTokens(sliced);
-            Metrics.logUsage(projectRoot, "@mcp", `read_file: ${args.path} (truncated)`, tokens);
+        // ENFORCE TOKEN ECONOMY: Hard Limit for large files
+        const HARD_LIMIT_LINES = 500;
+        if (lines.length > HARD_LIMIT_LINES && (startLine === undefined || endLine === undefined)) {
+            const errMsg = `[TOKEN ECONOMY GUARD] File '${args.path}' is too large (${lines.length} lines). To prevent context overflow and token waste, you MUST provide both 'startLine' and 'endLine' parameters to read specific sections of this file.`;
+            Metrics.logError(projectRoot, "@mcp", `read_file: ${args.path} (blocked)`, errMsg);
             return {
+                isError: true,
                 content: [{
                         type: "text",
-                        text: `${sliced}\n\n... [TRUNCATED - File is too long (${lines.length} lines). Only the first ${DEFAULT_MAX_LINES} lines are shown. Use startLine and endLine parameters to read other parts of the file.]`
+                        text: `[ERROR] ${errMsg}`
                     }]
             };
         }

package/framework-mcp/dist/tools/file_system/write_file.js

@@ -13,6 +13,18 @@ export async function handleWriteFile(projectRoot, args) {
     }
     try {
         const filePath = safePath(projectRoot, args.path);
+        // ENFORCE TOKEN ECONOMY: Prevent full-file rewrites of existing files
+        if (fs.existsSync(filePath)) {
+            const errMsg = `[TOKEN ECONOMY GUARD] The file '${args.path}' already exists. Overwriting entire existing files is FORBIDDEN to save tokens and prevent context drift. You MUST use 'patch_file' or 'replace_text' tools to make surgical edits.`;
+            Metrics.logError(projectRoot, "@mcp", `write_file: ${args.path} (blocked)`, errMsg);
+            return {
+                isError: true,
+                content: [{
+                        type: "text",
+                        text: `[ERROR] ${errMsg}`
+                    }]
+            };
+        }
         const content = args.content;
         // ENFORCE PERMISSION MATRIX
         verifyWritePermission(projectRoot, args.path);

package/framework-mcp/dist/tools/memory/get_insights.js

@@ -1,29 +1,17 @@
-import fs from "fs";
-import path from "path";
-import { resolveFrameworkDir } from "../../utils/security.js";
+import { Storage } from "../../utils/storage.js";
 /**
- * Extracts key insights from the project memory to minimize token usage.
+ * Extracts key insights from the SQLite database to minimize token usage.
  * Returns only the active phase, trace, and the last 5 decisions/tasks.
  */
-export function handleGetMemoryInsights(projectRoot, _args) {
+export function handleGetMemoryInsights(_projectRoot, _args) {
     try {
-        const frameworkDir = resolveFrameworkDir(projectRoot);
-        const memoryPath = path.join(projectRoot, frameworkDir, "memory/PROJECT_MEMORY.md");
-        if (!fs.existsSync(memoryPath)) {
-            return { content: [{ type: "text", text: "New project: No history available." }] };
-        }
-        const content = fs.readFileSync(memoryPath, "utf8");
-        const lines = content.split("\n");
-        const activePhase = lines.find(l => l.includes("**Phase:**"))?.split("**Phase:**")[1]?.trim() || "Unknown";
-        const activeTrace = lines.find(l => l.includes("**Trace ID:**"))?.split("**Trace ID:**")[1]?.trim() || "None";
-        // Find the last 5 history items (heuristic)
-        const historyStartIndex = lines.findIndex(l => l.toUpperCase().includes("HISTORY"));
+        const activePhase = Storage.getMetadata("phase") || "PHASE_0";
+        const activeTrace = Storage.getMetadata("traceId") || "None";
+        // Get the last 5 logs from SQLite
+        const recentLogs = Storage.getLogs().slice(0, 5);
         let recentHistory = "No history found.";
-        if (historyStartIndex !== -1) {
-            recentHistory = lines.slice(historyStartIndex + 1)
-                .filter(l => l.trim().startsWith("-"))
-                .slice(-5)
-                .join("\n");
+        if (recentLogs.length > 0) {
+            recentHistory = recentLogs.map(log => `- [${log.agent}] ${log.action}: ${log.summary}`).join("\n");
         }
         const insights = `[MEMORY] **Memory Insights**\n- **Phase:** ${activePhase}\n- **Trace:** ${activeTrace}\n\n**Recent Actions:**\n${recentHistory}`;
         return { content: [{ type: "text", text: insights }] };

package/framework-mcp/package.json

@@ -1,6 +1,6 @@
 {
   "name": "atabey-mcp",
-  "version": "0.0.9",
+  "version": "0.0.11",
   "description": "Agent Atabey Model Context Protocol (MCP) Server",
   "author": "Yusuf BEKAR",
   "license": "MIT",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "atabey",
-  "version": "0.0.9",
+  "version": "0.0.11",
   "description": "The Supreme AI Governance & Autonomous Orchestration Framework for Enterprise Development. Supports Polyglot Backends (Go, Java, Python, .NET, Node.js) and Multi-Language Communication (TR/EN).",
   "author": "Yusuf BEKAR",
   "license": "MIT",
@@ -68,7 +68,7 @@
     "access": "public"
   },
   "dependencies": {
-    "atabey-mcp": "^0.0.9",
+    "atabey-mcp": "^0.0.11",
     "@modelcontextprotocol/sdk": "^1.29.0",
     "better-sqlite3": "^12.10.1",
     "chalk": "^5.6.2",

package/framework-mcp/dist/framework-mcp/src/constants.js

@@ -1,64 +0,0 @@
-import path from "path";
-/**
- * Agent Atabey — Single Source of Truth for framework constants.
- * Import from here instead of hardcoding paths, phases, or directory names.
- */
-// ─── Framework identity ───────────────────────────────────────────────────
-export const FRAMEWORK = {
-    NAME: "Agent Atabey",
-    CORE_DIR: ".atabey",
-    // This is the hub for unified adapter layouts (e.g. .agents/gemini, .agents/claude)
-    UNIFIED_HUB_DIR: ".agents",
-    // This is the default directory to scaffold new apps into
-    APPS_DIR: "apps",
-    // This is where all skills are stored
-    SKILLS_DIR: "skills",
-};
-export const FRAMEWORK_SUBDIRS = {
-    AGENTS: "agents",
-    SKILLS: "skills",
-    KNOWLEDGE: "knowledge",
-    MESSAGES: "messages",
-    MEMORY: "memory",
-    MEMORY_GRAPH: "memory-graph",
-    LOGS: "logs",
-    CONFIG: "config",
-};
-export const ROOT_CONFIG_FILES = {
-    MCP: "mcp.json",
-    NATIVE_MODULES: "native-modules.json",
-    TSCONFIG: "tsconfig.json",
-    ESLINT: "eslint.config.js",
-};
-export const MCP = {
-    // Environment variable used by MCP to identify project root
-    PROJECT_ROOT_ENV: "ATABEY_PROJECT_ROOT",
-    // Environment variable for test mode
-    TEST_DIR_ENV: "ATABEY_TEST_DIR",
-};
-export const MEMORY_FILES = {
-    STATE: "state.json",
-    SHARED_FACTS: "shared_facts.json",
-};
-export const NATIVE_AGENT_PATHS = {
-    gemini: ".gemini/agents",
-    claude: ".claude/agents",
-    cursor: ".cursor/rules",
-    codex: ".agents/instructions",
-    grok: ".grok",
-    "antigravity-cli": ".agents/agents",
-};
-// ─── Backward-compatible aliases ──────────────────────────────────────────
-export const CORE_FRAMEWORK_DIR = FRAMEWORK.CORE_DIR;
-export const UNIFIED_HUB_DIR = FRAMEWORK.UNIFIED_HUB_DIR;
-export const SKILLS_HUB_PATH = pathJoin(UNIFIED_HUB_DIR, FRAMEWORK_SUBDIRS.SKILLS);
-// ─── Path Helpers ─────────────────────────────────────────────────────────
-function pathJoin(...args) {
-    return path.join(...args);
-}
-function corePath(subdir, filename) {
-    return pathJoin(FRAMEWORK.CORE_DIR, subdir, filename);
-}
-export function knowledgePath(filename) {
-    return corePath(FRAMEWORK_SUBDIRS.KNOWLEDGE, filename);
-}

package/framework-mcp/dist/framework-mcp/src/index.js

@@ -1,144 +0,0 @@
-#!/usr/bin/env node
-import fs from "fs";
-import path from "path";
-import { fileURLToPath } from "url";
-import { Server } from "@modelcontextprotocol/sdk/server/index.js";
-import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
-import { CallToolRequestSchema, ListToolsRequestSchema, ListResourcesRequestSchema, ReadResourceRequestSchema, } from "@modelcontextprotocol/sdk/types.js";
-import { TOOLS, toolHandlers } from "./tools/index.js";
-import { RESOURCES, handleReadResource } from "./resources/index.js";
-// ─── Server Setup ─────────────────────────────────────────────────
-const __dirname = path.dirname(fileURLToPath(import.meta.url));
-// Robustly find package.json by walking up from __dirname
-function findPackageJson(startDir) {
-    let currentDir = startDir;
-    while (currentDir !== path.parse(currentDir).root) {
-        const pkgPath = path.join(currentDir, "package.json");
-        if (fs.existsSync(pkgPath))
-            return pkgPath;
-        currentDir = path.dirname(currentDir);
-    }
-    throw new Error("Could not find package.json for atabey-mcp");
-}
-const pkgPath = findPackageJson(__dirname);
-const pkg = JSON.parse(fs.readFileSync(pkgPath, "utf8"));
-const serverVersion = pkg.version;
-const server = new Server({
-    name: "atabey-mcp",
-    version: serverVersion,
-}, {
-    capabilities: {
-        tools: {},
-        resources: {},
-    },
-});
-// Basic Schema Validator for Required Fields
-function validateArgs(toolName, args) {
-    const definition = TOOLS.find(t => t.name === toolName);
-    if (!definition)
-        return `Unknown tool: ${toolName}`;
-    const required = definition.inputSchema.required || [];
-    for (const field of required) {
-        if (args[field] === undefined || args[field] === null || args[field] === "") {
-            return `Missing required argument: '${field}' for tool '${toolName}'`;
-        }
-    }
-    return null;
-}
-server.setRequestHandler(ListToolsRequestSchema, async (request) => {
-    // 2026 Stateless Spec: Log client info from metadata if available
-    const meta = request._meta;
-    if (meta) {
-        process.stderr.write(`[MCP] Stateless ListTools from ${meta.client?.name || "unknown"} v${meta.client?.version || "?.?"}\n`);
-    }
-    return { tools: TOOLS };
-});
-server.setRequestHandler(ListResourcesRequestSchema, async () => {
-    return { resources: RESOURCES };
-});
-server.setRequestHandler(ReadResourceRequestSchema, async (request) => {
-    const uri = request.params.uri;
-    try {
-        const content = await handleReadResource(uri);
-        return {
-            contents: [
-                {
-                    uri,
-                    mimeType: "text/markdown",
-                    text: content,
-                },
-            ],
-        };
-    }
-    catch (error) {
-        const message = error instanceof Error ? error.message : String(error);
-        throw new Error(`Failed to read resource: ${message}`, { cause: error });
-    }
-});
-server.setRequestHandler(CallToolRequestSchema, async (request) => {
-    const req = request;
-    const { name, arguments: args } = req.params;
-    const meta = request._meta;
-    // 2026 Stateless Spec: Prioritize metadata-driven context
-    if (meta) {
-        process.stderr.write(`[MCP] Stateless CallTool: ${name} (Client: ${meta.client?.name || "unknown"})\n`);
-    }
-    const projectRoot = process.env.ATABEY_PROJECT_ROOT || process.cwd();
-    try {
-        const handler = toolHandlers[name];
-        if (!handler) {
-            return {
-                isError: true,
-                content: [{ type: "text", text: `[ERROR] Unknown tool: ${name}` }],
-            };
-        }
-        // [SECURITY] Runtime Validation
-        const validationError = validateArgs(name, args || {});
-        if (validationError) {
-            return {
-                isError: true,
-                content: [{ type: "text", text: `[ERROR] Validation Error: ${validationError}` }],
-            };
-        }
-        return await handler(projectRoot, args || {});
-    }
-    catch (error) {
-        const message = error instanceof Error ? error.message : "Unknown error occurred";
-        return {
-            isError: true,
-            content: [{ type: "text", text: `[ERROR] Execution failed: ${message}` }],
-        };
-    }
-});
-// ─── Graceful Startup & Shutdown ──────────────────────────────────
-async function run() {
-    const transport = new StdioServerTransport();
-    // Prevent unhandled errors from crashing the MCP stream
-    process.on("uncaughtException", (error) => {
-        process.stderr.write(`[atabey-mcp] Uncaught exception: ${error.message}
-`);
-    });
-    process.on("unhandledRejection", (reason) => {
-        const message = reason instanceof Error ? reason.message : String(reason);
-        process.stderr.write(`[atabey-mcp] Unhandled rejection: ${message}
-`);
-    });
-    // Graceful shutdown on SIGINT/SIGTERM
-    const shutdown = async () => {
-        try {
-            await server.close();
-        }
-        catch {
-            // Already closed or failed — safe to ignore
-        }
-        process.exit(0);
-    };
-    process.on("SIGINT", shutdown);
-    process.on("SIGTERM", shutdown);
-    await server.connect(transport);
-}
-run().catch((error) => {
-    process.stderr.write(`[atabey-mcp] Fatal startup error: ${error.message}
-`);
-    process.exit(1);
-});

package/framework-mcp/dist/framework-mcp/src/resources/index.js

@@ -1,58 +0,0 @@
-import { Storage } from "../utils/storage.js";
-/**
- * [DATA] MCP Resource Definitions
- */
-export const RESOURCES = [
-    {
-        uri: "atabey://army/status",
-        name: "Agent Army Status",
-        description: "Real-time state and active tasks of all specialized agents.",
-        mimeType: "text/markdown"
-    },
-    {
-        uri: "atabey://plan/active",
-        name: "Active Execution Plan",
-        description: "The current DAG of tasks and their completion status.",
-        mimeType: "text/markdown"
-    },
-    {
-        uri: "atabey://memory/project",
-        name: "Project Memory",
-        description: "The central source of truth for project context (PROJECT_MEMORY.md).",
-        mimeType: "text/markdown"
-    }
-];
-export async function handleReadResource(uri) {
-    if (uri === "atabey://army/status") {
-        const agents = Storage.getAllAgents();
-        let md = "# [AI] Agent Army Status\n\n| Agent | State | Active Task | Last Updated |\n| :--- | :--- | :--- | :--- |\n";
-        agents.forEach((a) => {
-            md += `| @${a.name} | ${a.state} | ${a.task} | ${a.last_updated} |\n`;
-        });
-        return md;
-    }
-    if (uri === "atabey://plan/active") {
-        const tasks = Storage.getTasks();
-        let md = "# 📋 Active Execution Plan\n\n| ID | Task | Agent | Status | Dependencies |\n| :--- | :--- | :--- | :--- | :--- |\n";
-        tasks.forEach((t) => {
-            const deps = t.dependencies.join(", ") || "-";
-            md += `| ${t.id} | ${t.description} | ${t.agent} | ${t.status} | ${deps} |\n`;
-        });
-        return md;
-    }
-    if (uri === "atabey://memory/project") {
-        const fs = await import("fs");
-        const path = await import("path");
-        const { getFrameworkDir } = await import("../utils/memory.js");
-        const projectRoot = process.env.ATABEY_PROJECT_ROOT || process.cwd();
-        const fwDir = getFrameworkDir();
-        const p = path.isAbsolute(fwDir)
-            ? path.join(fwDir, "memory", "PROJECT_MEMORY.md")
-            : path.join(projectRoot, fwDir, "memory", "PROJECT_MEMORY.md");
-        if (fs.existsSync(p)) {
-            return fs.readFileSync(p, "utf8");
-        }
-        return "Project memory not found. Run 'atabey init' first.";
-    }
-    throw new Error(`Unknown resource URI: ${uri}`);
-}

package/framework-mcp/dist/framework-mcp/src/tools/control_plane/locking.js

@@ -1,82 +0,0 @@
-import fs from "fs";
-import path from "path";
-import { resolveFrameworkDir } from "../../utils/security.js";
-/**
- * Handles acquiring a stateful lock on a resource.
- */
-export async function handleAcquireLock(projectRoot, args) {
-    const { resource, agent, ttl = 60 } = args;
-    const frameworkDir = resolveFrameworkDir(projectRoot);
-    const lockDir = path.join(projectRoot, frameworkDir, "locks");
-    const lockPath = path.join(lockDir, `${resource}.lock`);
-    try {
-        if (!fs.existsSync(lockDir))
-            fs.mkdirSync(lockDir, { recursive: true });
-        // Check for stale lock first
-        if (fs.existsSync(lockPath)) {
-            const stat = fs.statSync(lockPath);
-            const now = new Date().getTime();
-            const age = (now - stat.mtimeMs) / 1000;
-            if (age < ttl) {
-                return {
-                    isError: true,
-                    content: [{ type: "text", text: `Resource '${resource}' is currently locked by another agent.` }]
-                };
-            }
-            // Lock expired, safe to override by renaming first (POSIX atomic operation)
-            const tempLockPath = `${lockPath}.${Math.random().toString(36).substring(2)}.old`;
-            try {
-                fs.renameSync(lockPath, tempLockPath);
-                fs.unlinkSync(tempLockPath);
-            }
-            catch {
-                // If rename failed, it means another agent already evicting/deleting it.
-                // Do not delete anything else; proceed and let writeFileSync (wx flag) fail if a new lock exists.
-            }
-        }
-        // Use 'wx' flag for atomic file creation
-        const lockData = JSON.stringify({ agent, timestamp: new Date().toISOString() });
-        fs.writeFileSync(lockPath, lockData, { flag: "wx" });
-        return {
-            content: [{ type: "text", text: `[OK] Lock acquired for resource '${resource}' by ${agent}.` }]
-        };
-    }
-    catch (e) {
-        const error = e;
-        if (error.code === "EEXIST") {
-            return {
-                isError: true,
-                content: [{ type: "text", text: `Resource '${resource}' was just acquired by another agent.` }]
-            };
-        }
-        return {
-            isError: true,
-            content: [{ type: "text", text: `Failed to acquire lock: ${String(e)}` }]
-        };
-    }
-}
-/**
- * Handles releasing a lock.
- */
-export async function handleReleaseLock(projectRoot, args) {
-    const { resource, agent } = args;
-    const frameworkDir = resolveFrameworkDir(projectRoot);
-    const lockPath = path.join(projectRoot, frameworkDir, "locks", `${resource}.lock`);
-    try {
-        if (!fs.existsSync(lockPath)) {
-            return { content: [{ type: "text", text: `ℹ️ No lock found for resource '${resource}'.` }] };
-        }
-        const lockData = JSON.parse(fs.readFileSync(lockPath, "utf8"));
-        if (lockData.agent !== agent) {
-            return {
-                isError: true,
-                content: [{ type: "text", text: `[ERROR] Denied: You do not own the lock for '${resource}'. Owned by ${lockData.agent}.` }]
-            };
-        }
-        fs.unlinkSync(lockPath);
-        return { content: [{ type: "text", text: `[OK] Lock released for resource '${resource}' by ${agent}.` }] };
-    }
-    catch (e) {
-        return { isError: true, content: [{ type: "text", text: `Failed to release lock: ${String(e)}` }] };
-    }
-}

package/framework-mcp/dist/framework-mcp/src/tools/control_plane/registry.js

@@ -1,35 +0,0 @@
-import fs from "fs";
-import path from "path";
-import { resolveFrameworkDir } from "../../utils/security.js";
-/**
- * Handles agent registration with the Control Plane.
- * This can be used to validate permissions and active status.
- */
-export async function handleRegisterAgent(projectRoot, args) {
-    const { agent, role, capability = 5, specialties } = args;
-    const frameworkDir = resolveFrameworkDir(projectRoot);
-    const registryDir = path.join(projectRoot, frameworkDir, "registry");
-    const agentFile = path.join(registryDir, `${agent.replace("@", "")}_active.json`);
-    try {
-        if (!fs.existsSync(registryDir))
-            fs.mkdirSync(registryDir, { recursive: true });
-        const agentData = {
-            agent,
-            role,
-            capability,
-            specialties,
-            last_seen: new Date().toISOString(),
-            status: "ACTIVE"
-        };
-        fs.writeFileSync(agentFile, JSON.stringify(agentData, null, 2));
-        return {
-            content: [{ type: "text", text: `[ATABEY] Agent ${agent} (${role}) registered successfully in the Atabey Control Plane.` }]
-        };
-    }
-    catch (e) {
-        return {
-            isError: true,
-            content: [{ type: "text", text: `Failed to register agent: ${String(e)}` }]
-        };
-    }
-}