@defai.digital/automatosx 12.1.1 → 12.3.0

package/dist/mcp/index.js

@@ -195,11 +195,7 @@ var init_logger = __esm({
             message: entry.message,
             context: entry.context
           });
-          if (entry.level === "error") {
-            console.error(json);
-          } else {
-            console.log(json);
-          }
+          console.error(json);
           return;
         }
         const timestamp = entry.timestamp.toISOString();
@@ -5367,7 +5363,7 @@ var PRECOMPILED_CONFIG = {
     "enableFreeTierPrioritization": true,
     "enableWorkloadAwareRouting": true
   },
-  "version": "12.1.1"
+  "version": "12.3.0"
 };
 
 // src/core/config/schemas.ts
@@ -14153,6 +14149,7 @@ var ConversationContextStore = class {
   storePath;
   maxEntries;
   ttlMs;
+  destroyed = false;
   constructor(options) {
     this.storePath = options.storePath;
     this.maxEntries = options.maxEntries ?? 100;
@@ -14189,6 +14186,9 @@ var ConversationContextStore = class {
    * Initialize store (create directory if needed)
    */
   async initialize() {
+    if (this.destroyed) {
+      throw new Error("Context store is destroyed");
+    }
     try {
       await mkdir(this.storePath, { recursive: true });
       logger.info("[ContextStore] Initialized", { storePath: this.storePath });
@@ -14201,6 +14201,9 @@ var ConversationContextStore = class {
    * Save conversation context
    */
   async save(context) {
+    if (this.destroyed) {
+      throw new Error("Context store is destroyed");
+    }
     await this.initialize();
     const filePath = this.validateAndResolvePath(context.id);
     const data = JSON.stringify(context, null, 2);
@@ -14244,6 +14247,9 @@ var ConversationContextStore = class {
    * List all context entries (non-expired)
    */
   async list(options) {
+    if (this.destroyed) {
+      return [];
+    }
     try {
       const files = await readdir(this.storePath);
       const contexts = [];
@@ -14346,6 +14352,9 @@ var ConversationContextStore = class {
    * Get storage statistics
    */
   async stats() {
+    if (this.destroyed) {
+      return { totalEntries: 0, bySource: {} };
+    }
     const contexts = await this.list();
     const bySource = {};
     for (const context of contexts) {
@@ -14358,6 +14367,12 @@ var ConversationContextStore = class {
       newestEntry: contexts[0]?.timestamp
     };
   }
+  /**
+   * Destroy store (prevent further I/O)
+   */
+  destroy() {
+    this.destroyed = true;
+  }
 };
 
 // src/mcp/tools/run-agent.ts
@@ -17134,7 +17149,7 @@ async function executeViaMcpPool(provider, agent, task, pool) {
     pool.release(provider, client);
   }
 }
-async function executeViaCli(agent, task, actualProvider, no_memory, deps, isFallback) {
+async function executeViaCli(agent, task, actualProvider, no_memory, deps, isFallback, signal) {
   const context = await deps.contextManager.createContext(agent, task, {
     provider: actualProvider,
     skipMemory: no_memory
@@ -17143,7 +17158,8 @@ async function executeViaCli(agent, task, actualProvider, no_memory, deps, isFal
   const startTime = Date.now();
   const result = await executor.execute(context, {
     showProgress: false,
-    verbose: false
+    verbose: false,
+    signal
   });
   const latencyMs = Date.now() - startTime;
   const executionMode = isFallback ? "cli_fallback" : "cli_spawn";
@@ -17215,8 +17231,11 @@ async function buildAgentContext(agentName, task, deps, callerProvider, bestProv
   };
 }
 function createRunAgentHandler(deps) {
-  return async (input) => {
+  return async (input, context) => {
     const { agent, task, provider, no_memory, mode = "auto" } = input;
+    if (context?.signal?.aborted) {
+      throw new Error("Request was cancelled");
+    }
     validateAgentName(agent);
     validateStringParameter(task, "task", {
       required: true,
@@ -17243,6 +17262,9 @@ function createRunAgentHandler(deps) {
       bestProvider = selectedProvider?.name || "claude-code";
     }
     const shouldReturnContext = mode === "context" || mode === "auto" && callerActual === bestProvider && callerProvider !== "unknown";
+    if (context?.signal?.aborted) {
+      throw new Error("Request was cancelled");
+    }
     logger.info("[Smart Routing] Decision", {
       mode,
       callerProvider,
@@ -17277,6 +17299,7 @@ function createRunAgentHandler(deps) {
     const shouldTryMcp = !!deps.mcpPool;
     if (shouldTryMcp && deps.mcpPool) {
       try {
+        if (context?.signal?.aborted) throw new Error("Request was cancelled");
         const result = await executeViaMcpPool(
           bestProvider,
           agent,
@@ -17306,7 +17329,10 @@ function createRunAgentHandler(deps) {
       }
     }
     try {
-      const result = await executeViaCli(agent, task, actualProvider, no_memory, deps, shouldTryMcp);
+      if (context?.signal?.aborted) {
+        throw new Error("Request was cancelled");
+      }
+      const result = await executeViaCli(agent, task, actualProvider, no_memory, deps, shouldTryMcp, context?.signal);
       logger.info("[MCP] run_agent completed (CLI spawn mode)", {
         agent,
         latencyMs: result.latencyMs,
@@ -18574,6 +18600,11 @@ function compressWithInfo(payload, options = {}) {
 init_esm_shims();
 init_factory();
 init_logger();
+var NATIVE_MODULE_ERROR_PATTERNS = [
+  "NODE_MODULE_VERSION",
+  "was compiled against a different Node.js version",
+  "better_sqlite3.node"
+];
 var DEFAULT_CONFIG3 = {
   dbPath: ".automatosx/tasks/tasks.db",
   maxPayloadBytes: 1024 * 1024,
@@ -18701,6 +18732,28 @@ var SQL = {
     SELECT id FROM task_store WHERE payload_hash = ? AND status = 'completed' LIMIT 1
   `
 };
+function generateTaskId() {
+  const timestamp = Date.now().toString(36);
+  const random = randomBytes(4).toString("hex");
+  return `task_${timestamp}${random}`;
+}
+function hashPayload(json) {
+  return createHash("sha256").update(json).digest("hex").substring(0, 16);
+}
+function estimateEngine(type) {
+  switch (type) {
+    case "web_search":
+      return "gemini";
+    case "code_review":
+    case "code_generation":
+      return "claude";
+    case "analysis":
+      return "claude";
+    case "custom":
+    default:
+      return "auto";
+  }
+}
 var TaskStore = class {
   db;
   config;
@@ -18761,15 +18814,15 @@ var TaskStore = class {
       isCompressed = false;
       compressionRatio = 1;
     }
-    const taskId = this.generateTaskId();
-    const payloadHash = this.hashPayload(payloadJson);
+    const taskId = generateTaskId();
+    const payloadHash = hashPayload(payloadJson);
     const now = Date.now();
     const ttlHours = Math.min(
       validated.ttlHours ?? this.config.defaultTtlHours,
       this.config.maxTtlHours
     );
     const expiresAt = now + ttlHours * 60 * 60 * 1e3;
-    const estimatedEngine = validated.engine === "auto" ? this.estimateEngine(validated.type) : validated.engine;
+    const estimatedEngine = validated.engine === "auto" ? estimateEngine(validated.type) : validated.engine;
     try {
       this.stmtInsert.run({
         id: taskId,
@@ -19112,31 +19165,6 @@ var TaskStore = class {
       throw new TaskEngineError("TaskStore is closed", "STORE_ERROR");
     }
   }
-  generateTaskId() {
-    const timestamp = Date.now().toString(36);
-    const random = randomBytes(4).toString("hex");
-    return `task_${timestamp}${random}`;
-  }
-  hashPayload(json) {
-    return createHash("sha256").update(json).digest("hex").substring(0, 16);
-  }
-  estimateEngine(type) {
-    switch (type) {
-      case "web_search":
-        return "gemini";
-      // Gemini is good for web search
-      case "code_review":
-      case "code_generation":
-        return "claude";
-      // Claude is good for code
-      case "analysis":
-        return "claude";
-      // Claude is good for analysis
-      case "custom":
-      default:
-        return "auto";
-    }
-  }
   rowToTask(row) {
     let payload;
     try {
@@ -19203,8 +19231,248 @@ var TaskStore = class {
     };
   }
 };
+var InMemoryTaskStore = class {
+  tasks = /* @__PURE__ */ new Map();
+  config;
+  closed = false;
+  constructor(config = {}) {
+    this.config = { ...DEFAULT_CONFIG3, ...config };
+    logger.warn("Using in-memory task store fallback (SQLite unavailable)", {
+      nodeVersion: process.version
+    });
+  }
+  createTask(input) {
+    this.ensureOpen();
+    const validated = CreateTaskInputSchema.parse(input);
+    const payloadJson = JSON.stringify(validated.payload);
+    const payloadSize = Buffer.byteLength(payloadJson, "utf-8");
+    if (payloadSize > this.config.maxPayloadBytes) {
+      throw new TaskEngineError(
+        `Payload size ${payloadSize} exceeds limit ${this.config.maxPayloadBytes}`,
+        "PAYLOAD_TOO_LARGE",
+        { payloadSize, limit: this.config.maxPayloadBytes }
+      );
+    }
+    const id = generateTaskId();
+    const now = Date.now();
+    const ttlHours = Math.min(
+      validated.ttlHours ?? this.config.defaultTtlHours,
+      this.config.maxTtlHours
+    );
+    const expiresAt = now + ttlHours * 60 * 60 * 1e3;
+    const estimatedEngine = validated.engine === "auto" ? estimateEngine(validated.type) : validated.engine;
+    const task = {
+      id,
+      type: validated.type,
+      status: "pending",
+      engine: validated.engine === "auto" ? null : validated.engine,
+      priority: validated.priority ?? 5,
+      payload: validated.payload,
+      payloadSize,
+      result: null,
+      context: {
+        originClient: validated.context?.originClient ?? "unknown",
+        callChain: validated.context?.callChain ?? [],
+        depth: validated.context?.depth ?? 0
+      },
+      createdAt: now,
+      startedAt: null,
+      completedAt: null,
+      expiresAt,
+      metrics: null,
+      error: null,
+      retryCount: 0,
+      payloadHash: hashPayload(payloadJson),
+      compressionRatio: 1
+    };
+    this.tasks.set(id, task);
+    return {
+      id,
+      status: "pending",
+      estimatedEngine: estimatedEngine ?? null,
+      expiresAt,
+      payloadSize,
+      compressionRatio: 1
+    };
+  }
+  getTask(taskId) {
+    this.ensureOpen();
+    const task = this.tasks.get(taskId);
+    return task ? structuredClone(task) : null;
+  }
+  updateTaskStatus(taskId, status, error) {
+    this.ensureOpen();
+    const task = this.tasks.get(taskId);
+    if (!task) {
+      throw new TaskEngineError(`Task not found: ${taskId}`, "TASK_NOT_FOUND");
+    }
+    const now = Date.now();
+    task.status = status;
+    task.startedAt = status === "running" ? now : task.startedAt;
+    if (status === "completed" || status === "failed") {
+      task.completedAt = now;
+    }
+    task.error = error ?? null;
+  }
+  updateTaskResult(taskId, result, metrics) {
+    this.ensureOpen();
+    const task = this.tasks.get(taskId);
+    if (!task) {
+      throw new TaskEngineError(`Task not found: ${taskId}`, "TASK_NOT_FOUND");
+    }
+    task.status = "completed";
+    task.result = result;
+    task.metrics = {
+      durationMs: metrics.durationMs ?? 0,
+      tokensPrompt: metrics.tokensPrompt ?? null,
+      tokensCompletion: metrics.tokensCompletion ?? null
+    };
+    task.completedAt = Date.now();
+    task.error = null;
+  }
+  updateTaskFailed(taskId, error, durationMs) {
+    this.ensureOpen();
+    const task = this.tasks.get(taskId);
+    if (!task) {
+      throw new TaskEngineError(`Task not found: ${taskId}`, "TASK_NOT_FOUND");
+    }
+    task.status = "failed";
+    task.error = error;
+    task.metrics = task.metrics ?? {
+      durationMs: durationMs ?? 0,
+      tokensPrompt: null,
+      tokensCompletion: null
+    };
+    task.completedAt = Date.now();
+  }
+  incrementRetry(taskId) {
+    this.ensureOpen();
+    const task = this.tasks.get(taskId);
+    if (task) {
+      task.retryCount += 1;
+    }
+  }
+  deleteTask(taskId) {
+    this.ensureOpen();
+    return this.tasks.delete(taskId);
+  }
+  listTasks(filter = {}) {
+    this.ensureOpen();
+    const validated = TaskFilterSchema.parse(filter);
+    const filtered = Array.from(this.tasks.values()).filter((task) => {
+      if (validated.status && task.status !== validated.status) return false;
+      if (validated.engine && task.engine !== validated.engine) return false;
+      if (validated.type && task.type !== validated.type) return false;
+      if (validated.originClient && task.context.originClient !== validated.originClient) return false;
+      return true;
+    });
+    filtered.sort((a, b) => {
+      if (a.priority !== b.priority) return b.priority - a.priority;
+      return a.createdAt - b.createdAt;
+    });
+    const start = validated.offset ?? 0;
+    const end = start + (validated.limit ?? 20);
+    return filtered.slice(start, end).map((task) => structuredClone(task));
+  }
+  countTasks(filter = {}) {
+    this.ensureOpen();
+    const validated = TaskFilterSchema.parse(filter);
+    return Array.from(this.tasks.values()).filter((task) => {
+      if (validated.status && task.status !== validated.status) return false;
+      if (validated.engine && task.engine !== validated.engine) return false;
+      if (validated.type && task.type !== validated.type) return false;
+      if (validated.originClient && task.context.originClient !== validated.originClient) return false;
+      return true;
+    }).length;
+  }
+  findByPayloadHash(payloadHash) {
+    this.ensureOpen();
+    for (const task of this.tasks.values()) {
+      if (task.status === "completed" && task.payloadHash === payloadHash) {
+        return task.id;
+      }
+    }
+    return null;
+  }
+  cleanupExpired() {
+    this.ensureOpen();
+    const now = Date.now();
+    let removed = 0;
+    for (const [id, task] of this.tasks) {
+      if (task.expiresAt < now && task.status !== "running") {
+        this.tasks.delete(id);
+        removed++;
+      }
+    }
+    return removed;
+  }
+  cleanupZombieRunning() {
+    this.ensureOpen();
+    const now = Date.now();
+    let converted = 0;
+    for (const task of this.tasks.values()) {
+      if (task.status === "running" && task.expiresAt < now) {
+        task.status = "failed";
+        task.error = {
+          code: "ZOMBIE_TASK",
+          message: "Task was stuck in running state past expiry"
+        };
+        task.completedAt = now;
+        converted++;
+      }
+    }
+    return converted;
+  }
+  cleanupAll() {
+    const zombies = this.cleanupZombieRunning();
+    const expired = this.cleanupExpired();
+    return { expired, zombies };
+  }
+  getStats() {
+    this.ensureOpen();
+    const byStatus = {
+      pending: 0,
+      running: 0,
+      completed: 0,
+      failed: 0,
+      expired: 0
+    };
+    for (const task of this.tasks.values()) {
+      byStatus[task.status]++;
+    }
+    return {
+      totalTasks: this.tasks.size,
+      byStatus,
+      dbSizeBytes: 0
+    };
+  }
+  close() {
+    this.closed = true;
+  }
+  ensureOpen() {
+    if (this.closed) {
+      throw new TaskEngineError("TaskStore is closed", "STORE_ERROR");
+    }
+  }
+};
+function isNativeModuleError(error) {
+  if (!(error instanceof Error)) return false;
+  const message = error.message ?? "";
+  return NATIVE_MODULE_ERROR_PATTERNS.some((pattern) => message.includes(pattern));
+}
 function createTaskStore(config) {
-  return new TaskStore(config);
+  try {
+    return new TaskStore(config);
+  } catch (error) {
+    if (isNativeModuleError(error)) {
+      logger.warn("Falling back to in-memory task store (native SQLite unavailable)", {
+        nodeVersion: process.version,
+        error: error instanceof Error ? error.message : String(error)
+      });
+      return new InMemoryTaskStore(config);
+    }
+    throw error;
+  }
 }
 
 // src/core/task-engine/engine.ts
@@ -19295,6 +19563,9 @@ var TaskEngine = class extends EventEmitter {
     if (!task) {
       throw new TaskEngineError(`Task not found: ${taskId}`, "TASK_NOT_FOUND");
     }
+    if (options.abortSignal?.aborted) {
+      throw new TaskEngineError("Task execution aborted", "EXECUTION_TIMEOUT");
+    }
     if (task.status === "running") {
       throw new TaskEngineError(
         `Task is already running: ${taskId}`,
@@ -19460,6 +19731,14 @@ var TaskEngine = class extends EventEmitter {
   async executeTask(task, targetEngine, context, options) {
     const taskId = task.id;
     const abortController = new AbortController();
+    let externalCancelled = false;
+    const externalAbort = options.abortSignal ? () => {
+      externalCancelled = true;
+      abortController.abort();
+    } : null;
+    if (options.abortSignal && externalAbort) {
+      options.abortSignal.addEventListener("abort", externalAbort, { once: true });
+    }
     const startTime = Date.now();
     this.runningTasks.set(taskId, abortController);
     this.store.updateTaskStatus(taskId, "running");
@@ -19500,7 +19779,7 @@ var TaskEngine = class extends EventEmitter {
       const durationMs = Date.now() - startTime;
       const errorObj = error instanceof Error ? error : new Error(String(error));
       if (abortController.signal.aborted) {
-        const taskError2 = { code: "TIMEOUT", message: `Task timed out after ${timeoutMs}ms` };
+        const taskError2 = externalCancelled ? { code: "CANCELLED", message: "Task was cancelled by caller" } : { code: "TIMEOUT", message: `Task timed out after ${timeoutMs}ms` };
         this.store.updateTaskFailed(taskId, taskError2, durationMs);
         this.stats.failed++;
         this.emit("task:failed", taskId, new TaskEngineError(taskError2.message, "EXECUTION_TIMEOUT"));
@@ -19534,6 +19813,9 @@ var TaskEngine = class extends EventEmitter {
     } finally {
       clearTimeout(timeoutId);
       this.runningTasks.delete(taskId);
+      if (options.abortSignal && externalAbort) {
+        options.abortSignal.removeEventListener("abort", externalAbort);
+      }
     }
   }
   async executeWithRetry(task, engine, context, signal) {
@@ -19838,8 +20120,11 @@ var createTaskSchema = {
 init_esm_shims();
 init_logger();
 function createRunTaskHandler(deps) {
-  return async (input) => {
+  return async (input, context) => {
     const startTime = Date.now();
+    if (context?.signal?.aborted) {
+      throw new Error("Request was cancelled");
+    }
     logger.info("[run_task] Executing task", {
       taskId: input.task_id,
       engineOverride: input.engine_override,
@@ -19852,7 +20137,8 @@ function createRunTaskHandler(deps) {
       const options = {
         engineOverride: input.engine_override,
         timeoutMs: input.timeout_ms,
-        skipCache: input.skip_cache
+        skipCache: input.skip_cache,
+        abortSignal: context?.signal
       };
       const result = await taskEngine.runTask(input.task_id, options);
       const output = {
@@ -22178,6 +22464,10 @@ var McpServer = class _McpServer {
   version;
   ajv;
   compiledValidators = /* @__PURE__ */ new Map();
+  cancelledRequests = /* @__PURE__ */ new Set();
+  // Track client-initiated cancellations
+  requestControllers = /* @__PURE__ */ new Map();
+  // Abort long-running handlers
   // v10.5.0: MCP Session for Smart Routing
   session = null;
   // v10.6.0: MCP Client Pool for cross-provider execution
@@ -22456,6 +22746,16 @@ Use this tool first to understand what AutomatosX offers.`,
     if (this.streamingNotifier) {
       this.streamingNotifier.stop();
     }
+    if (this.router) {
+      this.router.destroy();
+    }
+    this.requestControllers.clear();
+    if (this.sessionManager) {
+      await this.sessionManager.destroy();
+    }
+    if (this.contextStore) {
+      this.contextStore.destroy();
+    }
     if (this.eventBridge) {
       this.eventBridge.destroy();
     }
@@ -22573,6 +22873,12 @@ Use this tool first to understand what AutomatosX offers.`,
           return this.handleToolsList(request, responseId);
         case "tools/call":
           return await this.handleToolCall(request, responseId);
+        case "resources/list":
+          return await this.handleResourcesList(request, responseId);
+        case "resources/read":
+          return await this.handleResourceRead(request, responseId);
+        case "$/cancelRequest":
+          return this.handleCancelRequest(request, responseId);
         default:
           return this.createErrorResponse(responseId, -32601 /* MethodNotFound */, `Method not found: ${method}`);
       }
@@ -22628,6 +22934,48 @@ Use this tool first to understand what AutomatosX offers.`,
     const tools = _McpServer.getStaticToolSchemas();
     return { jsonrpc: "2.0", id, result: { tools } };
   }
+  /**
+   * Handle resources/list request (exposes agent profiles as MCP resources)
+   */
+  async handleResourcesList(_request, id) {
+    await this.ensureInitialized();
+    const agents = await this.profileLoader.listProfiles();
+    const resources = agents.map((agent) => ({
+      uri: `agent/${agent}`,
+      name: `Agent: ${agent}`,
+      description: `AutomatosX agent profile for ${agent}`,
+      mimeType: "text/markdown"
+    }));
+    return { jsonrpc: "2.0", id, result: { resources } };
+  }
+  /**
+   * Handle resources/read request
+   */
+  async handleResourceRead(request, id) {
+    await this.ensureInitialized();
+    const uri = request.params?.uri;
+    if (!uri || !uri.startsWith("agent/")) {
+      return this.createErrorResponse(id, -32602 /* InvalidParams */, "Invalid resource URI. Expected agent/{name}.");
+    }
+    const agentName = uri.replace("agent/", "");
+    try {
+      const profile = await this.profileLoader.loadProfile(agentName);
+      const summary = [
+        `# ${agentName}`,
+        profile.role ? `**Role:** ${profile.role}` : "",
+        profile.abilities?.length ? `**Abilities:** ${profile.abilities.join(", ")}` : "",
+        "",
+        profile.systemPrompt || "No system prompt defined."
+      ].filter(Boolean).join("\n");
+      const contents = [
+        { type: "text", text: summary },
+        { type: "application/json", json: profile }
+      ];
+      return { jsonrpc: "2.0", id, result: { uri, mimeType: "text/markdown", contents } };
+    } catch (error) {
+      return this.createErrorResponse(id, -32603 /* InternalError */, `Failed to read resource: ${error.message}`);
+    }
+  }
   /**
    * Validate tool input against its JSON schema.
    * Returns null if valid, or error message string if invalid.
@@ -22639,10 +22987,34 @@ Use this tool first to understand what AutomatosX offers.`,
     return this.ajv.errorsText(validate.errors);
   }
   /** Create MCP tool response wrapper */
-  createToolResponse(id, text, isError = false) {
-    const response = { content: [{ type: "text", text }], ...isError && { isError } };
+  createToolResponse(id, result, isError = false) {
+    let content;
+    if (typeof result === "string") {
+      content = [{ type: "text", text: result }];
+    } else {
+      content = [
+        { type: "application/json", json: result },
+        { type: "text", text: JSON.stringify(result, null, 2) }
+      ];
+    }
+    const response = { content, ...isError && { isError } };
     return { jsonrpc: "2.0", id, result: response };
   }
+  /**
+   * Handle client cancellation ($/cancelRequest)
+   */
+  handleCancelRequest(request, id) {
+    const params = request.params;
+    const cancelId = params?.id ?? params?.requestId;
+    if (cancelId === void 0 || cancelId === null) {
+      return this.createErrorResponse(id, -32602 /* InvalidParams */, "cancelRequest requires an id to cancel");
+    }
+    this.cancelledRequests.add(cancelId);
+    logger.info("[MCP Server] Cancellation requested", { cancelId });
+    const controller = this.requestControllers.get(cancelId);
+    controller?.abort();
+    return { jsonrpc: "2.0", id, result: null };
+  }
   /**
    * Ensure services are initialized (lazy initialization on first call)
    * OPTIMIZATION (v10.3.1): Moves 15-20s initialization from handshake to first request
@@ -22677,6 +23049,16 @@ Use this tool first to understand what AutomatosX offers.`,
   async handleToolCall(request, id) {
     const { name, arguments: args2 } = request.params;
     logger.info("[MCP Server] Tool call", { tool: name });
+    const requestId = id ?? null;
+    const abortController = requestId !== null ? new AbortController() : null;
+    if (requestId !== null && abortController) {
+      this.requestControllers.set(requestId, abortController);
+    }
+    if (requestId !== null && this.cancelledRequests.has(requestId)) {
+      this.cancelledRequests.delete(requestId);
+      this.requestControllers.delete(requestId);
+      return this.createErrorResponse(requestId, -32800 /* RequestCancelled */, "Request was cancelled");
+    }
     await this.ensureInitialized();
     const handler = this.tools.get(name);
     if (!handler) {
@@ -22687,11 +23069,27 @@ Use this tool first to understand what AutomatosX offers.`,
       return this.createErrorResponse(id, -32602 /* InvalidParams */, validationError);
     }
     try {
-      const result = await handler(args2 || {});
-      return this.createToolResponse(id, JSON.stringify(result, null, 2));
+      const result = await handler(args2 || {}, { signal: abortController?.signal });
+      if (requestId !== null && this.cancelledRequests.has(requestId)) {
+        this.cancelledRequests.delete(requestId);
+        this.requestControllers.delete(requestId);
+        return this.createErrorResponse(requestId, -32800 /* RequestCancelled */, "Request was cancelled");
+      }
+      return this.createToolResponse(id, result);
     } catch (error) {
+      const err = error;
+      const cancelled = err?.name === "AbortError" || err?.message?.toLowerCase().includes("cancel");
+      if (cancelled) {
+        logger.info("[MCP Server] Tool execution cancelled", { tool: name, id: requestId ?? void 0 });
+        return this.createErrorResponse(id, -32800 /* RequestCancelled */, "Request was cancelled");
+      }
       logger.error("[MCP Server] Tool execution failed", { tool: name, error });
-      return this.createToolResponse(id, `Error: ${error.message}`, true);
+      return this.createToolResponse(id, `Error: ${err?.message ?? String(error)}`, true);
+    } finally {
+      if (requestId !== null) {
+        this.cancelledRequests.delete(requestId);
+        this.requestControllers.delete(requestId);
+      }
     }
   }
   /**
@@ -22701,26 +23099,34 @@ Use this tool first to understand what AutomatosX offers.`,
     return { jsonrpc: "2.0", id, error: { code, message } };
   }
   /**
-   * Write MCP-compliant response with Content-Length framing
+   * Write MCP-compliant response using newline-delimited framing
+   *
+   * v12.2.0: Changed from Content-Length to newline-delimited framing
+   * per official MCP specification: https://spec.modelcontextprotocol.io/specification/basic/transports/
+   *
+   * Format: JSON message followed by newline character
+   * Reference: @modelcontextprotocol/sdk serializeMessage() uses: JSON.stringify(message) + '\n'
    */
   writeResponse(response) {
     const json = JSON.stringify(response);
-    const contentLength = Buffer.byteLength(json, "utf-8");
-    const message = `Content-Length: ${contentLength}\r
-\r
-${json}`;
-    process.stdout.write(message);
-    logger.debug("[MCP Server] Response sent", { id: response.id, contentLength });
+    process.stdout.write(json + "\n");
+    logger.debug("[MCP Server] Response sent", { id: response.id, length: json.length });
   }
   /**
-   * Start stdio server with Content-Length framing
+   * Start stdio server with newline-delimited framing
+   *
+   * v12.2.0: Changed from Content-Length to newline-delimited framing
+   * per official MCP specification: https://spec.modelcontextprotocol.io/specification/basic/transports/
+   *
+   * Format: Each JSON-RPC message is terminated by a newline character.
+   * Messages MUST NOT contain embedded newlines.
+   * Reference: @modelcontextprotocol/sdk ReadBuffer uses: buffer.indexOf('\n')
    *
    * BUG FIX (v9.0.1): Added iteration limit and buffer size checks to prevent infinite loops
    */
   async start() {
     logger.info("[MCP Server] Starting stdio JSON-RPC server...");
     let buffer = "";
-    let contentLength = null;
     process.stdin.on("data", (chunk) => {
       void this.stdinMutex.runExclusive(async () => {
         buffer += chunk.toString("utf-8");
@@ -22730,49 +23136,34 @@ ${json}`;
             maxSize: STDIO_MAX_BUFFER_SIZE
           });
           buffer = "";
-          contentLength = null;
           return;
         }
         let iterations = 0;
         while (iterations < STDIO_MAX_ITERATIONS) {
           iterations++;
-          if (contentLength === null) {
-            const delimiter2 = buffer.includes("\r\n\r\n") ? "\r\n\r\n" : buffer.includes("\n\n") ? "\n\n" : null;
-            if (!delimiter2) break;
-            const headerEndIndex = buffer.indexOf(delimiter2);
-            const headerBlock = buffer.slice(0, headerEndIndex);
-            for (const line of headerBlock.split(delimiter2 === "\r\n\r\n" ? "\r\n" : "\n")) {
-              const [key, value] = line.split(":", 2).map((s) => s.trim());
-              if (key && key.toLowerCase() === "content-length" && value) {
-                contentLength = parseInt(value, 10);
-                if (isNaN(contentLength) || contentLength <= 0 || contentLength > STDIO_MAX_MESSAGE_SIZE) {
-                  logger.error("[MCP Server] Invalid Content-Length", { contentLength });
-                  this.writeResponse({
-                    jsonrpc: "2.0",
-                    id: null,
-                    error: {
-                      code: -32600 /* InvalidRequest */,
-                      message: `Invalid Content-Length: ${contentLength}`
-                    }
-                  });
-                  buffer = buffer.slice(headerEndIndex + delimiter2.length);
-                  contentLength = null;
-                  continue;
-                }
+          const newlineIndex = buffer.indexOf("\n");
+          if (newlineIndex === -1) break;
+          let jsonMessage = buffer.slice(0, newlineIndex);
+          if (jsonMessage.endsWith("\r")) {
+            jsonMessage = jsonMessage.slice(0, -1);
+          }
+          buffer = buffer.slice(newlineIndex + 1);
+          if (jsonMessage.trim() === "") continue;
+          if (jsonMessage.length > STDIO_MAX_MESSAGE_SIZE) {
+            logger.error("[MCP Server] Message size exceeded maximum", {
+              messageSize: jsonMessage.length,
+              maxSize: STDIO_MAX_MESSAGE_SIZE
+            });
+            this.writeResponse({
+              jsonrpc: "2.0",
+              id: null,
+              error: {
+                code: -32600 /* InvalidRequest */,
+                message: `Message too large: ${jsonMessage.length} bytes`
               }
-            }
-            if (contentLength === null) {
-              logger.error("[MCP Server] No Content-Length header found");
-              buffer = buffer.slice(headerEndIndex + delimiter2.length);
-              continue;
-            }
-            buffer = buffer.slice(headerEndIndex + delimiter2.length);
+            });
+            continue;
           }
-          if (Buffer.byteLength(buffer, "utf-8") < contentLength) break;
-          const messageBuffer = Buffer.from(buffer, "utf-8");
-          const jsonMessage = messageBuffer.slice(0, contentLength).toString("utf-8");
-          buffer = messageBuffer.slice(contentLength).toString("utf-8");
-          contentLength = null;
           try {
             const request = JSON.parse(jsonMessage);
             logger.debug("[MCP Server] Request received", { method: request.method, id: request.id });
@@ -22781,7 +23172,7 @@ ${json}`;
               this.writeResponse(response);
             }
           } catch (error) {
-            logger.error("[MCP Server] Failed to parse or handle request", { jsonMessage, error });
+            logger.error("[MCP Server] Failed to parse or handle request", { error: error.message });
             this.writeResponse({ jsonrpc: "2.0", id: null, error: { code: -32700 /* ParseError */, message: "Parse error: Invalid JSON" } });
           }
         }
@@ -22800,7 +23191,7 @@ ${json}`;
     process.stdin.on("end", () => shutdown("Server stopped (stdin closed)"));
     process.on("SIGINT", () => shutdown("Received SIGINT, shutting down..."));
     process.on("SIGTERM", () => shutdown("Received SIGTERM, shutting down..."));
-    logger.info("[MCP Server] Server started successfully (Content-Length framing)");
+    logger.info("[MCP Server] Server started successfully (newline-delimited framing)");
   }
 };