@johpaz/hive-sdk 0.1.4 → 0.1.5

package/packages/core/src/gateway/lane-queue.ts

@@ -0,0 +1,173 @@
+export type TaskStatus = "pending" | "running" | "completed" | "failed" | "cancelled";
+
+export interface Task {
+  id: string;
+  sessionId: string;
+  status: TaskStatus;
+  priority: number;
+  createdAt: Date;
+  startedAt?: Date;
+  completedAt?: Date;
+  error?: string;
+  abortController: AbortController;
+}
+
+export interface LaneQueueOptions {
+  maxConcurrency?: number;
+  taskTimeoutMs?: number;
+}
+
+type TaskHandler<T> = (task: Task, signal: AbortSignal) => Promise<T>;
+
+class LaneQueue {
+  private queues: Map<string, Task[]> = new Map();
+  private running: Map<string, Task> = new Map();
+  private handlers: Map<string, TaskHandler<unknown>> = new Map();
+  private taskIdCounter = 0;
+  private options: Required<LaneQueueOptions>;
+
+  constructor(options: LaneQueueOptions = {}) {
+    this.options = {
+      maxConcurrency: options.maxConcurrency ?? 1,
+      // Last-resort safety net for a runaway session, not the primary timeout
+      // mechanism — that now lives per-operation in agent-loop.ts (per LLM call)
+      // and tool-runtime/index.ts (per tool call), which can each fail fast
+      // without killing an otherwise-healthy multi-step turn.
+      taskTimeoutMs: options.taskTimeoutMs ?? 30 * 60 * 1000,
+    };
+  }
+
+  private generateTaskId(): string {
+    return `task-${Date.now()}-${++this.taskIdCounter}`;
+  }
+
+  private getQueue(sessionId: string): Task[] {
+    let queue = this.queues.get(sessionId);
+    if (!queue) {
+      queue = [];
+      this.queues.set(sessionId, queue);
+    }
+    return queue;
+  }
+
+  enqueue<T>(
+    sessionId: string,
+    handler: TaskHandler<T>,
+    priority = 0
+  ): Task {
+    const task: Task = {
+      id: this.generateTaskId(),
+      sessionId,
+      status: "pending",
+      priority,
+      createdAt: new Date(),
+      abortController: new AbortController(),
+    };
+
+    this.handlers.set(task.id, handler as TaskHandler<unknown>);
+
+    const queue = this.getQueue(sessionId);
+    queue.push(task);
+    queue.sort((a, b) => b.priority - a.priority);
+
+    this.processQueue(sessionId);
+
+    return task;
+  }
+
+  private async processQueue(sessionId: string): Promise<void> {
+    const running = this.running.get(sessionId);
+    if (running) {
+      return;
+    }
+
+    const queue = this.getQueue(sessionId);
+    if (queue.length === 0) {
+      return;
+    }
+
+    const task = queue.shift();
+    if (!task) return;
+
+    task.status = "running";
+    task.startedAt = new Date();
+    this.running.set(sessionId, task);
+
+    const handler = this.handlers.get(task.id);
+
+    const timeoutId = setTimeout(() => {
+      task.abortController.abort();
+    }, this.options.taskTimeoutMs);
+
+    try {
+      if (handler) {
+        await handler(task, task.abortController.signal);
+      }
+      task.status = "completed";
+      task.completedAt = new Date();
+    } catch (error) {
+      if ((error as Error).name === "AbortError") {
+        task.status = "cancelled";
+      } else {
+        task.status = "failed";
+        task.error = (error as Error).message;
+      }
+      task.completedAt = new Date();
+    } finally {
+      clearTimeout(timeoutId);
+      this.running.delete(sessionId);
+      this.handlers.delete(task.id);
+      
+      if (queue.length > 0) {
+        this.processQueue(sessionId);
+      }
+    }
+  }
+
+  cancel(sessionId: string): boolean {
+    const task = this.running.get(sessionId);
+    if (task) {
+      task.abortController.abort();
+      return true;
+    }
+
+    const queue = this.getQueue(sessionId);
+    const index = queue.findIndex((t) => t.status === "pending");
+    if (index >= 0) {
+      const cancelled = queue.splice(index, 1)[0];
+      if (cancelled) {
+        cancelled.status = "cancelled";
+        cancelled.completedAt = new Date();
+      }
+      return true;
+    }
+
+    return false;
+  }
+
+  getStatus(sessionId: string): {
+    queueLength: number;
+    running?: Task;
+  } {
+    const queue = this.getQueue(sessionId);
+    const running = this.running.get(sessionId);
+
+    return {
+      queueLength: queue.length,
+      running,
+    };
+  }
+
+  isProcessing(sessionId: string): boolean {
+    return this.running.has(sessionId);
+  }
+
+  prune(sessionId: string): void {
+    const queue = this.getQueue(sessionId);
+    if (queue.length === 0 && !this.running.has(sessionId)) {
+      this.queues.delete(sessionId);
+    }
+  }
+}
+
+export const laneQueue = new LaneQueue();

package/packages/core/src/gateway/notification-inbox.ts

@@ -0,0 +1,57 @@
+import { randomUUID } from "node:crypto";
+import type { NotificationDoc } from "../storage/collections";
+import { col, updateDoc } from "../storage/hive";
+
+export async function createNotification(input: {
+  userId: string;
+  channel: string;
+  message: string;
+}): Promise<NotificationDoc> {
+  const notifications = await col<NotificationDoc>("notifications");
+  const id = randomUUID();
+  const notification: NotificationDoc = {
+    id,
+    user_id: input.userId,
+    channel: input.channel,
+    message: input.message,
+    created_at: Date.now(),
+    delivered_at: null,
+    read_at: null,
+  };
+  await notifications.put(id, notification, { expectedVersion: 0 });
+  return notification;
+}
+
+export async function listPendingNotifications(
+  userId: string,
+  channel: string,
+): Promise<NotificationDoc[]> {
+  const notifications = await col<NotificationDoc>("notifications");
+  const rows = await notifications.findBy("user_id", userId);
+  return rows
+    .map((row) => row.doc)
+    .filter((notification) => notification.channel === channel && notification.read_at === null)
+    .sort((a, b) => a.created_at - b.created_at);
+}
+
+export async function markNotificationDelivered(id: string, userId: string): Promise<boolean> {
+  const notifications = await col<NotificationDoc>("notifications");
+  const existing = await notifications.get(id);
+  if (!existing || existing.doc.user_id !== userId) return false;
+  if (existing.doc.delivered_at !== null) return true;
+  await updateDoc<NotificationDoc>("notifications", id, { delivered_at: Date.now() });
+  return true;
+}
+
+export async function acknowledgeNotification(id: string, userId: string): Promise<boolean> {
+  const notifications = await col<NotificationDoc>("notifications");
+  const existing = await notifications.get(id);
+  if (!existing || existing.doc.user_id !== userId) return false;
+  if (existing.doc.read_at !== null) return true;
+  const now = Date.now();
+  await updateDoc<NotificationDoc>("notifications", id, {
+    delivered_at: existing.doc.delivered_at ?? now,
+    read_at: now,
+  });
+  return true;
+}

package/packages/core/src/gateway/server.ts

@@ -8,7 +8,7 @@
  */
 
 import { logger } from "../utils/logger";
-import { runAgent } from "../agent/AgentRunner";
+import { runAgent } from "../agent/agent-loop.ts";
 import type { MCPClientManager } from "../mcp/index";
 
 const log = logger.child("gateway");

package/packages/core/src/harness/index.ts

@@ -1,34 +1,53 @@
 /**
- * Hive Harness — durable task execution for the Hive Agent SDK.
+ * Hive Harness — ejecución durable de tareas.
  *
- * A generic (non-hive-app-specific) durable job queue + checkpointable run
- * store, backed by HiveDB: retry/backoff on logical failure, lease-based
- * crash recovery, idempotent job submission, goal verification, and proof
- * packets. See docs/HIVE-HARNESS.md for the full write-up.
+ * Cola de jobs con retry/backoff, recuperación por lease tras un crash, envío
+ * idempotente, verificación de objetivos y proof packets. Ver docs/HIVE-HARNESS.md.
  *
- * This module does not wire itself into `AgentRunner` automatically — the
- * host app decides what "durable" means for its own job types and registers
- * executors accordingly via `registerExecutor()`.
+ * **Esto es un barrel, no una implementación.** Hasta 0.1.5 `harness/` tenía su
+ * propia copia de `db-helpers`, `boot-id`, `reconcile`, `collections`, `run-store`,
+ * `run-epoch` y `proof-packet`, en paralelo con las de `storage/` y `agent/`. Dos
+ * almacenes de jobs sobre las mismas colecciones de HiveDB son una sola cosa con
+ * dos estados posibles, así que ahora esto re-exporta la implementación única y el
+ * subpath `@johpaz/hive-sdk/harness` sigue funcionando igual.
+ *
+ * El módulo no se cablea solo dentro del agent loop: la app decide qué significa
+ * "durable" para sus tipos de job y registra ejecutores con `registerExecutor()`.
  */
 
-import { ensureJobStoreIndexes } from "./job-store";
-import { ensureRunStoreIndexes } from "./run-store";
-import { ensureProofPacketIndexes } from "./proof-packet";
-
-export * from "./collections";
-export * from "./job-store";
-export * from "./run-store";
-export * from "./durable-queue";
-export * from "./goal-verifier";
-export * from "./run-epoch";
-export * from "./proof-packet";
-export * from "./reconcile";
-export { getBootId, resetBootId } from "./boot-id";
-export { col, nextId, updateDoc, findByAny, toIndexable, fromIndexable, NO_PARENT } from "./db-helpers";
-
-/** Create the equality indexes the harness collections need. Idempotent — safe to call on every boot. */
+import { ensureHiveDb } from "../storage/bootstrap.ts";
+
+// ─── Cola y almacén de jobs ──────────────────────────────────────────────────
+export * from "../gateway/job-store.ts";
+export * from "../gateway/durable-queue.ts";
+
+// ─── Runs: checkpoint, lease, epoch, proof ───────────────────────────────────
+export * from "../agent/run-store.ts";
+export * from "../agent/run-epoch.ts";
+export * from "../agent/proof-packet.ts";
+
+// ─── Verificación de objetivos ───────────────────────────────────────────────
+export { runGoal, verifyGoal, interpretCheckResult } from "../agent/goal-runner.ts";
+export type { AcceptanceResult, GoalRunOptions, GoalRunResult } from "../agent/goal-runner.ts";
+
+// ─── Durabilidad entre arranques ─────────────────────────────────────────────
+export { getBootId, resetBootId } from "../storage/boot-id.ts";
+export { reconcileOnBoot } from "../storage/reconcile.ts";
+export type { ReconcileResult } from "../storage/reconcile.ts";
+
+// ─── Shapes ──────────────────────────────────────────────────────────────────
+export type { JobDoc, AgentRunDoc, ProofPacketDoc } from "../storage/collections.ts";
+
+// ─── Primitivas de colección ─────────────────────────────────────────────────
+export { col, nextId, updateDoc, findByAny, toIndexable, fromIndexable, NO_PARENT } from "../storage/hive.ts";
+
+/**
+ * Crea los índices que necesitan las colecciones del harness.
+ *
+ * Los índices ahora se declaran en un solo lugar (`INDEXES` en storage/bootstrap.ts)
+ * y los crea `ensureHiveDb()`. Se mantiene la función porque era pública; es
+ * idempotente y llamarla en cada arranque sigue siendo seguro.
+ */
 export async function ensureHarnessIndexes(): Promise<void> {
-  await ensureJobStoreIndexes();
-  await ensureRunStoreIndexes();
-  await ensureProofPacketIndexes();
+  await ensureHiveDb();
 }

package/packages/core/src/index.ts

@@ -8,19 +8,9 @@ export type { ToolDefinition } from "./tools/ToolRegistry.ts";
 export { ToolRegistry } from "./tools/ToolRegistry.ts";
 export { ToolExecutor } from "./tools/ToolExecutor.ts";
 export type { ToolExecutionResult } from "./tools/ToolExecutor.ts";
-export {
-  webSearchTool,
-  webFetchTool,
-  apiRequestTool,
-  browserNavigateTool,
-  browserScreenshotTool,
-  browserClickTool,
-  browserTypeTool,
-  browserExtractTool,
-  browserScriptTool,
-  browserWaitTool,
-} from "./tools/index.ts";
-export type { ApiAuth, HttpMethod, ResponseFormat } from "./tools/web/api-request.ts";
+export { createAllTools, createToolsByCategory, registerAppTool, clearAppTools, listAppTools } from "./tools/index.ts";
+export type { Tool, ToolParameter, ToolResult } from "./tools/types.ts";
+export { apiRequestTool } from "./tools/api/index.ts";
 
 // ─── Skills ──────────────────────────────────────────────────────────────────
 export { defineSkill } from "./skills/defineSkill.ts";
@@ -29,9 +19,25 @@ export { SkillLoader } from "./skills/index.ts";
 export type { Skill, SkillStep, OutputFormat, SkillsConfig } from "./skills/index.ts";
 
 // ─── Agent ───────────────────────────────────────────────────────────────────
-export { AgentLoop, runAgent, runAgentIsolated, buildAgentLoop, getAgentLoop, rebuildAgentLoop } from "./agent/index.ts";
-export type { AgentLoopOptions, StepEvent, StreamChunk } from "./agent/index.ts";
-export type { Tool, ToolParameter, ToolResult } from "./agent/index.ts";
+export { runAgent, runAgentIsolated, AgentLoop, getAgentLoop, buildAgentLoop, rebuildAgentLoop } from "./agent/agent-loop.ts";
+export type { AgentLoopOptions, StepEvent, StreamChunk } from "./agent/agent-loop.ts";
+export type { Provider } from "./agent/providers/index.ts";
+
+// El cliente LLM es parte de la superficie pública: hasta 0.1.5 sólo se exportaba
+// el wrapper `AgentRunner`, así que no había forma de llamar a un provider ni de
+// leer el error tipado sin importar por ruta profunda.
+export { callLLM, getDefaultLLM, resolveProviderConfig } from "./agent/llm-client.ts";
+export type { LLMMessage, LLMToolCall, LLMToolDef, LLMCallOptions, LLMResponse, ContentPart } from "./agent/llm-client.ts";
+
+// Control de prompt y contexto.
+export { buildSystemPrompt, buildSystemPromptWithProjects } from "./agent/prompt-builder.ts";
+export { compileContext } from "./agent/context-compiler.ts";
+export type { CompiledContext } from "./agent/context-compiler.ts";
+export { maybeCompact, clearOldToolResults } from "./agent/compaction.ts";
+export { selectTools } from "./agent/tool-selector.ts";
+export { selectSkills, getMinimalSkills } from "./agent/skill-selector.ts";
+export { selectPlaybookRules } from "./agent/playbook-selector.ts";
+export { MINIMAL_TOOLS } from "./agent/minimal-loadout.ts";
 
 // ─── Swarm / Scheduler ───────────────────────────────────────────────────────
 export { DAGScheduler } from "./swarm/index.ts";
@@ -54,14 +60,14 @@ export { Scratchpad } from "./memory/index.ts";
 export type { IStorage } from "./memory/index.ts";
 
 // ─── Storage ─────────────────────────────────────────────────────────────────
-export { initializeDatabase, dbService } from "./storage/index.ts";
-// HiveDB-backed catalogs (tools/skills/providers/models/playbook) that the
-// selectors and other HiveDB-backed features read from. Idempotent (upsert-
-// based) — safe to call on every boot, same "reseed so code changes take
-// effect" pattern as `initializeDatabase`. Not required to avoid crashes
-// (selectors degrade to empty results when unseeded), but needed for
-// dynamic skill/playbook discovery.
-export { seedHiveDB } from "./storage/index.ts";
+// `ensureHiveDb()` reemplaza a `initializeDatabase()`: abre HiveDB, crea los
+// índices y siembra el catálogo. Idempotente — se llama en cada arranque.
+export { ensureHiveDb, col, seedAllData, SEED_DATA } from "./storage/index.ts";
+export type { SeedData } from "./storage/index.ts";
+export { catalogModelKey, wireModelId, isResellerProvider } from "./storage/index.ts";
+export { calculateCost, invalidateModelPricingCache, recordUsage, getUsageStats } from "./storage/index.ts";
+export type { UsageRecord, UsageSummary } from "./storage/index.ts";
+export type { AgentDoc, ModelDoc, ProviderDoc, SkillDoc, ToolDoc, EthicsDoc, UserDoc } from "./storage/collections.ts";
 
 // ─── Config ──────────────────────────────────────────────────────────────────
 export { loadConfig, loadEnv, getHiveDir } from "./config/index.ts";
@@ -81,8 +87,8 @@ export { SlackChannel } from "./channels/slack.ts";
 export { WebChatChannel } from "./channels/webchat.ts";
 
 // ─── Canvas ──────────────────────────────────────────────────────────────────
-export { CanvasManager } from "./canvas/CanvasManager.ts";
-export { emitCanvas, subscribeCanvas, unsubscribeCanvas } from "./canvas/emitter.ts";
+export { CanvasManager } from "./canvas/canvas-manager.ts";
+export { emitCanvas } from "./canvas/emitter.ts";
 
 // ─── Tool Runtime ────────────────────────────────────────────────────────────
 export { executeToolBatch } from "./tool-runtime/index.ts";
@@ -97,7 +103,7 @@ export { createWorker, WorkerPool } from "./workers/index.ts";
 export type { WorkerConfig, WorkerInstance, WorkerChunk, WorkerPoolConfig, PoolTask, PoolTaskResult } from "./workers/index.ts";
 
 // ─── Utils ───────────────────────────────────────────────────────────────────
-export { logger } from "./utils/index.ts";
+export { logger } from "./utils/logger.ts";
 export { retry } from "./utils/retry.ts";
 
 // ─── Harness (durable task execution) ───────────────────────────────────────

package/packages/core/src/mcp/hot-reload.ts

@@ -2,17 +2,18 @@
  * MCP Hot Reload
  *
  * Watches for MCP server changes in DB and updates MCP Manager automatically
- * 
+ *
  * Architecture: Direct Connection
- * - MCP servers are tracked in DB (mcp_servers table)
+ * - MCP servers are tracked in the `mcpServers` HiveDB collection
  * - MCP tools are loaded at runtime from connected servers (not stored in DB)
  */
 
-import { getDb } from "../storage/SQLiteStorage.ts";
-import { logger } from "../utils/logger.ts";
-import { decryptConfig } from "../storage/crypto.ts";
-import { syncMCPToolsToDB, syncMCPToolsToFTS, clearMCPToolsFromDB } from "./MCPToolAdapter.ts";
-import type { MCPClientManager } from "../mcp/index.ts";
+import { col, updateDoc } from "../storage/hive";
+import type { McpServerDoc } from "../storage/collections";
+import { logger } from "../utils/logger";
+import { loadMcpHeaders } from "../storage/crypto";
+import { syncMCPToolsToDB, syncMCPToolsToIndex, clearMCPToolsFromDB } from "./tool-sync";
+import type { MCPClientManager } from "./MCPClient.ts";
 
 const log = logger.child("mcp:hot-reload");
 
@@ -61,8 +62,8 @@ export function stopMCPHotReload(): void {
  */
 async function syncMCPServers(mcpManager: MCPClientManager): Promise<void> {
   try {
-    const db = getDb();
-    const dbServers = db.query(`SELECT * FROM mcp_servers WHERE enabled = 1`).all() as Record<string, any>[];
+    const mcpServersCol = await col<McpServerDoc>("mcpServers");
+    const dbServers = (await mcpServersCol.scan({})).map(e => e.doc).filter(s => s.enabled);
 
     const currentServerNames = new Set(dbServers.map(s => s.id || s.name));
 
@@ -82,11 +83,12 @@ async function syncMCPServers(mcpManager: MCPClientManager): Promise<void> {
             enabled: true,
           };
 
-          if (server.headers_encrypted && server.headers_iv) {
-            mcpServerConfig.headers = decryptConfig(server.headers_encrypted, server.headers_iv);
+          const mcpHeaders = await loadMcpHeaders(server.id || server.name);
+          if (Object.keys(mcpHeaders).length > 0) {
+            mcpServerConfig.headers = mcpHeaders;
           }
 
-          // Update MCP Manager config (auto-connects new servers)
+          // Register (or refresh) the server's config in the manager.
           const currentConfig = (mcpManager as any).config || { servers: {} };
           await mcpManager.updateConfig({
             ...currentConfig,
@@ -96,22 +98,29 @@ async function syncMCPServers(mcpManager: MCPClientManager): Promise<void> {
             },
           });
 
-          // Wait a bit for connection to establish
-          await new Promise(resolve => setTimeout(resolve, 500));
+          // updateConfig() only reconnects a server whose config changed AND was
+          // already connected — it never connects a server that's merely registered
+          // (true for both a brand-new server and one restored from DB on boot).
+          // Connect explicitly so "new to this process" always means "usable now".
+          await mcpManager.connectServer(serverName).catch((err) => {
+            log.error(`Failed to connect MCP server ${serverName}: ${err.message}`);
+          });
 
-          // Get tools count and update status
+          // Get tools count and update status from the manager's real state —
+          // never assume success.
           const tools = mcpManager.getServerTools(serverName) || [];
-          db.query(`UPDATE mcp_servers SET status = ?, tools_count = ? WHERE id = ?`).run("connected", tools.length, serverName);
+          const connected = mcpManager.getServerStatus(serverName) === "connected";
+          await updateDoc<McpServerDoc>("mcpServers", server.id, { status: connected ? "connected" : "error", tools_count: tools.length }).catch(() => { /* not found */ });
 
-          // Persist MCP tool definitions to DB and FTS5
+          // Persist MCP tool definitions to DB and the HiveDB index
           // Use server.name (human-readable) for mcpToolId consistency with context-compiler
-          syncMCPToolsToDB(server.id || server.name, server.name || serverName, tools);
-          await syncMCPToolsToFTS();
+          await syncMCPToolsToDB(server.id || server.name, server.name || serverName, tools);
+          await syncMCPToolsToIndex();
 
           log.info(`MCP server ${serverName} connected: ${tools.length} tools available`);
         } catch (err) {
           log.error(`Failed to connect MCP server ${serverName}: ${(err as Error).message}`);
-          db.query(`UPDATE mcp_servers SET status = ? WHERE id = ?`).run("error", serverName);
+          await updateDoc<McpServerDoc>("mcpServers", server.id, { status: "error" }).catch(() => { /* not found */ });
         }
       }
     }
@@ -127,11 +136,11 @@ async function syncMCPServers(mcpManager: MCPClientManager): Promise<void> {
           delete currentConfig.servers[oldServerName];
           await mcpManager.updateConfig(currentConfig);
 
-          // Delete MCP tool definitions from DB and FTS5
-          clearMCPToolsFromDB(oldServerName);
+          // Delete MCP tool definitions from DB and the HiveDB index
+          await clearMCPToolsFromDB(oldServerName);
 
           // Update DB status
-          db.query(`UPDATE mcp_servers SET status = ?, tools_count = 0 WHERE id = ?`).run("disconnected", oldServerName);
+          await updateDoc<McpServerDoc>("mcpServers", oldServerName, { status: "disconnected", tools_count: 0 }).catch(() => { /* not found */ });
 
           log.info(`MCP server ${oldServerName} disconnected`);
         } catch (err) {

package/packages/core/src/mcp/index.ts

@@ -1,9 +1,12 @@
 export type { MCPTool, MCPResource, MCPPrompt } from "./MCPClient.ts";
 export { MCPClientManager } from "./MCPClient.ts";
-export type { MCPToolDefinition } from "./MCPToolAdapter.ts";
-export { mcpToolId, syncMCPToolsToDB, syncMCPToolsToFTS, clearMCPToolsFromDB } from "./MCPToolAdapter.ts";
+// `tool-sync.ts` reemplaza al viejo `MCPToolAdapter.ts`: aquel escribía a SQLite
+// y sincronizaba a FTS5; éste escribe a la colección `mcpTools` de HiveDB y
+// reindexa con `syncMCPToolsToIndex`.
+export type { MCPToolDefinition } from "./tool-sync.ts";
+export { syncMCPToolsToDB, syncMCPToolsToIndex, clearMCPToolsFromDB } from "./tool-sync.ts";
 export type { MCPConfig, MCPServerConfig } from "./config.ts";
-export { setMCPManager, getMCPManager, hasMCPManager } from "./singleton.ts";
+export { setMCPManager, getMCPManager } from "./singleton.ts";
 export { startMCPHotReload, stopMCPHotReload } from "./hot-reload.ts";
 export type { LogLevel as MCPLogLevel, LogHandler as MCPLogHandler } from "./logger.ts";
 export { logger as mcpLogger } from "./logger.ts";

package/packages/core/src/mcp/singleton.ts

@@ -4,7 +4,7 @@
  * Provides global access to the MCP Manager instance
  */
 
-import type { MCPClientManager } from "../mcp/index.ts";
+import type { MCPClientManager } from "./MCPClient.ts";
 
 let _mcpManager: MCPClientManager | null = null;
 
@@ -16,6 +16,3 @@ export function getMCPManager(): MCPClientManager | null {
   return _mcpManager;
 }
 
-export function hasMCPManager(): boolean {
-  return _mcpManager !== null;
-}