@iqai/adk-cli 0.1.1 → 0.2.0

package/CHANGELOG.md

@@ -1,5 +1,44 @@
 # @iqai/adk-cli
 
+## 0.2.0
+
+### Minor Changes
+
+- 17341fc: Refactor agent loading and resolution logic with enhanced flexibility and reliability
+
+  This major enhancement improves the ADK CLI server's agent loading capabilities and adds new features to the core framework:
+
+  **CLI Server Improvements:**
+
+  - **Modular Architecture**: Refactored monolithic server file into organized modules (`server/index.ts`, `server/routes.ts`, `server/services.ts`, `server/types.ts`)
+  - **Enhanced Agent Resolution**: New `resolveAgentExport` method supports multiple export patterns:
+    - Direct agent exports: `export const agent = new LlmAgent(...)`
+    - Function factories: `export function agent() { return new LlmAgent(...) }`
+    - Async factories: `export async function agent() { return new LlmAgent(...) }`
+    - Container objects: `export default { agent: ... }`
+    - Primitive exports with fallback scanning
+  - **Improved TypeScript Import Handling**: Better project root detection and module resolution for TypeScript files
+
+  **Core Framework Enhancements:**
+
+  - **New AgentBuilder Method**: Added `withAgent()` method to directly provide existing agent instances with definition locking to prevent accidental configuration overwrites
+  - **Two-Tier Tool Deduplication**: Implemented robust deduplication logic to prevent duplicate function declarations that cause errors with LLM providers (especially Google)
+  - **Better Type Safety**: Improved type definitions and replaced `any[]` usage with proper typed interfaces
+
+  **Testing & Reliability:**
+
+  - **Comprehensive Test Coverage**: New `agent-resolution.test.ts` with extensive fixtures testing various agent export patterns
+  - **Multiple Test Fixtures**: Added 6 different agent export pattern examples for validation
+  - **Edge Case Handling**: Improved error handling and logging throughout the agent loading pipeline
+
+  These changes provide a more flexible, reliable, and maintainable foundation for agent development and deployment while maintaining backward compatibility.
+
+### Patch Changes
+
+- Updated dependencies [17341fc]
+- Updated dependencies [1564b7b]
+  - @iqai/adk@0.2.0
+
 ## 0.1.1
 
 ### Patch Changes

package/dist/index.js

@@ -31,7 +31,7 @@ var import_commander = require("commander");
 // package.json
 var package_default = {
   name: "@iqai/adk-cli",
-  version: "0.1.1",
+  version: "0.2.0",
   description: "CLI tool for creating, running, and testing ADK agents",
   main: "dist/index.js",
   types: "dist/index.d.ts",
@@ -328,95 +328,70 @@ var import_node_fs3 = require("fs");
 var import_node_path3 = require("path");
 var import_chalk2 = __toESM(require("chalk"));
 
-// src/server.ts
+// src/server/index.ts
+var import_node_server = require("@hono/node-server");
+var import_adk2 = require("@iqai/adk");
+var import_hono = require("hono");
+
+// src/server/routes.ts
+var import_cors = require("hono/cors");
+function setupRoutes(app, agentManager, sessionManager, agentsDir) {
+  app.use("/*", (0, import_cors.cors)());
+  app.get("/health", (c) => c.json({ status: "ok" }));
+  app.get("/api/agents", (c) => {
+    const agentsList = Array.from(
+      agentManager.getAgents().values()
+    ).map((agent) => ({
+      path: agent.absolutePath,
+      name: agent.name,
+      directory: agent.absolutePath,
+      relativePath: agent.relativePath
+    }));
+    return c.json({ agents: agentsList });
+  });
+  app.post("/api/agents/refresh", (c) => {
+    agentManager.scanAgents(agentsDir);
+    const agentsList = Array.from(
+      agentManager.getAgents().values()
+    ).map((agent) => ({
+      path: agent.absolutePath,
+      name: agent.name,
+      directory: agent.absolutePath,
+      relativePath: agent.relativePath
+    }));
+    return c.json({ agents: agentsList });
+  });
+  app.get("/api/agents/:id/messages", async (c) => {
+    const agentPath = decodeURIComponent(c.req.param("id"));
+    const loadedAgent = agentManager.getLoadedAgents().get(agentPath);
+    if (!loadedAgent) {
+      return c.json({ messages: [] });
+    }
+    const messages = await sessionManager.getSessionMessages(loadedAgent);
+    const response = { messages };
+    return c.json(response);
+  });
+  app.post("/api/agents/:id/message", async (c) => {
+    const agentPath = decodeURIComponent(c.req.param("id"));
+    const { message } = await c.req.json();
+    const response = await agentManager.sendMessageToAgent(agentPath, message);
+    const messageResponse = { response };
+    return c.json(messageResponse);
+  });
+}
+
+// src/server/services.ts
 var import_node_fs2 = require("fs");
 var import_node_path2 = require("path");
 var import_node_url = require("url");
-var import_node_server = require("@hono/node-server");
 var import_adk = require("@iqai/adk");
-var import_hono = require("hono");
-var import_cors = require("hono/cors");
-var ADKServer = class {
-  agents = /* @__PURE__ */ new Map();
-  loadedAgents = /* @__PURE__ */ new Map();
-  sessionService;
-  app;
-  server;
-  agentsDir;
-  port;
-  host;
-  quiet;
-  constructor(agentsDir, port = 8042, host = "localhost", quiet = false) {
-    this.agentsDir = agentsDir;
-    this.port = port;
-    this.host = host;
+var AgentScanner = class {
+  constructor(quiet = false) {
     this.quiet = quiet;
-    this.sessionService = new import_adk.InMemorySessionService();
-    this.app = new import_hono.Hono();
-    this.setupRoutes();
-    this.scanAgents();
   }
-  setupRoutes() {
-    this.app.use("/*", (0, import_cors.cors)());
-    this.app.get("/health", (c) => c.json({ status: "ok" }));
-    this.app.get("/api/agents", (c) => {
-      const agentsList = Array.from(this.agents.values()).map((agent) => ({
-        path: agent.absolutePath,
-        name: agent.name,
-        directory: agent.absolutePath,
-        relativePath: agent.relativePath
-      }));
-      return c.json({ agents: agentsList });
-    });
-    this.app.post("/api/agents/refresh", (c) => {
-      this.scanAgents();
-      const agentsList = Array.from(this.agents.values()).map((agent) => ({
-        path: agent.absolutePath,
-        name: agent.name,
-        directory: agent.absolutePath,
-        relativePath: agent.relativePath
-      }));
-      return c.json({ agents: agentsList });
-    });
-    this.app.get("/api/agents/:id/messages", async (c) => {
-      const agentPath = decodeURIComponent(c.req.param("id"));
-      const loadedAgent = this.loadedAgents.get(agentPath);
-      if (!loadedAgent) {
-        return c.json({ messages: [] });
-      }
-      try {
-        const session = await this.sessionService.getSession(
-          loadedAgent.appName,
-          loadedAgent.userId,
-          loadedAgent.sessionId
-        );
-        if (!session || !session.events) {
-          return c.json({ messages: [] });
-        }
-        const messages = session.events.map((event, index) => ({
-          id: index + 1,
-          type: event.author === "user" ? "user" : "assistant",
-          content: event.content?.parts?.map(
-            (part) => typeof part === "object" && "text" in part ? part.text : ""
-          ).join("") || "",
-          timestamp: new Date(event.timestamp || Date.now()).toISOString()
-        }));
-        return c.json({ messages });
-      } catch (error) {
-        console.error("Error fetching messages:", error);
-        return c.json({ messages: [] });
-      }
-    });
-    this.app.post("/api/agents/:id/message", async (c) => {
-      const agentPath = decodeURIComponent(c.req.param("id"));
-      const { message } = await c.req.json();
-      const response = await this.sendMessageToAgent(agentPath, message);
-      return c.json({ response });
-    });
-  }
-  scanAgents() {
-    this.agents.clear();
-    const scanDir = !this.agentsDir || !(0, import_node_fs2.existsSync)(this.agentsDir) ? process.cwd() : this.agentsDir;
+  scanAgents(agentsDir, loadedAgents) {
+    const agents = /* @__PURE__ */ new Map();
+    const scanDir = !agentsDir || !(0, import_node_fs2.existsSync)(agentsDir) ? process.cwd() : agentsDir;
     const shouldSkipDirectory = (dirName) => {
       const skipDirs = [
         "node_modules",
@@ -443,7 +418,7 @@ var ADKServer = class {
           }
         } else if (item === "agent.ts" || item === "agent.js") {
           const relativePath = (0, import_node_path2.relative)(scanDir, dir);
-          const loadedAgent = this.loadedAgents.get(relativePath);
+          const loadedAgent = loadedAgents.get(relativePath);
           let agentName = relativePath.split("/").pop() || "unknown";
           if (loadedAgent?.agent?.name) {
             agentName = loadedAgent.agent.name;
@@ -454,7 +429,7 @@ var ADKServer = class {
             } catch {
             }
           }
-          this.agents.set(relativePath, {
+          agents.set(relativePath, {
             relativePath,
             name: agentName,
             absolutePath: dir,
@@ -465,9 +440,225 @@ var ADKServer = class {
     };
     scanDirectory(scanDir);
     if (!this.quiet) {
-      console.log(`\u2705 Agent scan complete. Found ${this.agents.size} agents.`);
+      console.log(`\u2705 Agent scan complete. Found ${agents.size} agents.`);
+    }
+    return agents;
+  }
+  extractAgentNameFromFile(filePath) {
+    try {
+      const content = (0, import_node_fs2.readFileSync)(filePath, "utf-8");
+      const nameMatch = content.match(/name\s*:\s*["']([^"']+)["']/);
+      if (nameMatch?.[1]) {
+        return nameMatch[1];
+      }
+      return null;
+    } catch {
+      return null;
     }
   }
+};
+var AgentLoader = class {
+  constructor(quiet = false) {
+    this.quiet = quiet;
+  }
+  /**
+   * Import a TypeScript file by compiling it on-demand
+   */
+  async importTypeScriptFile(filePath) {
+    const startDir = (0, import_node_path2.dirname)(filePath);
+    let projectRoot = startDir;
+    while (projectRoot !== "/" && projectRoot !== (0, import_node_path2.dirname)(projectRoot)) {
+      if ((0, import_node_fs2.existsSync)((0, import_node_path2.join)(projectRoot, "package.json")) || (0, import_node_fs2.existsSync)((0, import_node_path2.join)(projectRoot, ".env"))) {
+        break;
+      }
+      projectRoot = (0, import_node_path2.dirname)(projectRoot);
+    }
+    if (projectRoot === "/") {
+      projectRoot = startDir;
+    }
+    try {
+      const { build } = await import("esbuild");
+      const cacheDir = (0, import_node_path2.join)(projectRoot, ".adk-cache");
+      if (!(0, import_node_fs2.existsSync)(cacheDir)) {
+        (0, import_node_fs2.mkdirSync)(cacheDir, { recursive: true });
+      }
+      const outFile = (0, import_node_path2.join)(cacheDir, `agent-${Date.now()}.mjs`);
+      const plugin = {
+        name: "externalize-bare-imports",
+        setup(build2) {
+          build2.onResolve({ filter: /.*/ }, (args) => {
+            if (args.path.startsWith(".") || args.path.startsWith("/") || args.path.startsWith("..")) {
+              return;
+            }
+            return { path: args.path, external: true };
+          });
+        }
+      };
+      const tsconfigPath = (0, import_node_path2.join)(projectRoot, "tsconfig.json");
+      await build({
+        entryPoints: [filePath],
+        outfile: outFile,
+        bundle: true,
+        format: "esm",
+        platform: "node",
+        target: ["node22"],
+        sourcemap: false,
+        logLevel: "silent",
+        plugins: [plugin],
+        absWorkingDir: projectRoot,
+        // Use tsconfig if present for path aliases
+        ...(0, import_node_fs2.existsSync)(tsconfigPath) ? { tsconfig: tsconfigPath } : {}
+      });
+      const mod = await import(`${(0, import_node_url.pathToFileURL)(outFile).href}?t=${Date.now()}`);
+      let agentExport = mod?.agent;
+      if (!agentExport && mod?.default) {
+        agentExport = mod.default.agent ?? mod.default;
+      }
+      try {
+        (0, import_node_fs2.unlinkSync)(outFile);
+      } catch {
+      }
+      if (agentExport) {
+        const isPrimitive = (v) => v == null || ["string", "number", "boolean"].includes(typeof v);
+        if (isPrimitive(agentExport)) {
+          if (!this.quiet) {
+            console.log(
+              `\u2139\uFE0F Ignoring primitive 'agent' export in ${filePath}; scanning module for factory...`
+            );
+          }
+        } else {
+          if (!this.quiet) {
+            console.log(`\u2705 TS agent imported via esbuild: ${filePath}`);
+          }
+          return { agent: agentExport };
+        }
+      }
+      return mod;
+    } catch (e) {
+      throw new Error(
+        `Failed to import TS agent via esbuild: ${e instanceof Error ? e.message : String(e)}`
+      );
+    }
+  }
+  loadEnvironmentVariables(agentFilePath) {
+    let projectRoot = (0, import_node_path2.dirname)(agentFilePath);
+    while (projectRoot !== "/" && projectRoot !== (0, import_node_path2.dirname)(projectRoot)) {
+      if ((0, import_node_fs2.existsSync)((0, import_node_path2.join)(projectRoot, "package.json")) || (0, import_node_fs2.existsSync)((0, import_node_path2.join)(projectRoot, ".env"))) {
+        break;
+      }
+      projectRoot = (0, import_node_path2.dirname)(projectRoot);
+    }
+    const envPath = (0, import_node_path2.join)(projectRoot, ".env");
+    if ((0, import_node_fs2.existsSync)(envPath)) {
+      try {
+        const envContent = (0, import_node_fs2.readFileSync)(envPath, "utf8");
+        const envLines = envContent.split("\n");
+        for (const line of envLines) {
+          const trimmedLine = line.trim();
+          if (trimmedLine && !trimmedLine.startsWith("#")) {
+            const [key, ...valueParts] = trimmedLine.split("=");
+            if (key && valueParts.length > 0) {
+              const value = valueParts.join("=").replace(/^"(.*)"$/, "$1");
+              process.env[key.trim()] = value.trim();
+            }
+          }
+        }
+      } catch (error) {
+        console.warn(
+          `\u26A0\uFE0F Warning: Could not load .env file: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  }
+  // Minimal resolution logic for agent exports: supports
+  // 1) export const agent = new LlmAgent(...)
+  // 2) export function agent() { return new LlmAgent(...) }
+  // 3) export async function agent() { return new LlmAgent(...) }
+  // 4) default export (object or function) returning or containing .agent
+  async resolveAgentExport(mod) {
+    let candidate = mod?.agent ?? mod?.default?.agent ?? mod?.default ?? mod;
+    const isLikelyAgentInstance = (obj) => obj && typeof obj === "object" && typeof obj.name === "string";
+    const isPrimitive = (v) => v == null || ["string", "number", "boolean"].includes(typeof v);
+    const invokeMaybe = async (fn) => {
+      let out = fn();
+      if (out && typeof out === "object" && "then" in out) {
+        out = await out;
+      }
+      return out;
+    };
+    if (!isLikelyAgentInstance(candidate) && isPrimitive(candidate) || !isLikelyAgentInstance(candidate) && candidate && candidate === mod) {
+      candidate = mod;
+      for (const [key, value] of Object.entries(mod)) {
+        if (key === "default") continue;
+        const keyLower = key.toLowerCase();
+        if (isPrimitive(value)) continue;
+        if (isLikelyAgentInstance(value)) {
+          candidate = value;
+          break;
+        }
+        if (value && typeof value === "object" && value.agent && isLikelyAgentInstance(value.agent)) {
+          candidate = value.agent;
+          break;
+        }
+        if (typeof value === "function" && (/(agent|build|create)/i.test(keyLower) || value.name && /(agent|build|create)/i.test(value.name.toLowerCase()))) {
+          try {
+            const maybe = await invokeMaybe(value);
+            if (isLikelyAgentInstance(maybe)) {
+              candidate = maybe;
+              break;
+            }
+            if (maybe && typeof maybe === "object" && maybe.agent && isLikelyAgentInstance(maybe.agent)) {
+              candidate = maybe.agent;
+              break;
+            }
+          } catch (e) {
+          }
+        }
+      }
+    }
+    if (typeof candidate === "function") {
+      try {
+        candidate = await invokeMaybe(candidate);
+      } catch (e) {
+        throw new Error(
+          `Failed executing exported agent function: ${e instanceof Error ? e.message : String(e)}`
+        );
+      }
+    }
+    if (candidate && typeof candidate === "object" && candidate.agent && isLikelyAgentInstance(candidate.agent)) {
+      candidate = candidate.agent;
+    }
+    if (candidate?.agent && isLikelyAgentInstance(candidate.agent)) {
+      candidate = candidate.agent;
+    }
+    if (!candidate || !isLikelyAgentInstance(candidate)) {
+      throw new Error(
+        "No agent export resolved (expected variable, function, or function returning an agent)"
+      );
+    }
+    return { agent: candidate };
+  }
+};
+var AgentManager = class {
+  constructor(sessionService, quiet = false) {
+    this.sessionService = sessionService;
+    this.quiet = quiet;
+    this.scanner = new AgentScanner(quiet);
+    this.loader = new AgentLoader(quiet);
+  }
+  agents = /* @__PURE__ */ new Map();
+  loadedAgents = /* @__PURE__ */ new Map();
+  scanner;
+  loader;
+  getAgents() {
+    return this.agents;
+  }
+  getLoadedAgents() {
+    return this.loadedAgents;
+  }
+  scanAgents(agentsDir) {
+    this.agents = this.scanner.scanAgents(agentsDir, this.loadedAgents);
+  }
   async startAgent(agentPath) {
     const agent = this.agents.get(agentPath);
     if (!agent) {
@@ -486,70 +677,31 @@ var ADKServer = class {
           `No agent.js or agent.ts file found in ${agent.absolutePath}`
         );
       }
-      let projectRoot = (0, import_node_path2.dirname)(agentFilePath);
-      while (projectRoot !== "/" && projectRoot !== (0, import_node_path2.dirname)(projectRoot)) {
-        if ((0, import_node_fs2.existsSync)((0, import_node_path2.join)(projectRoot, "package.json")) || (0, import_node_fs2.existsSync)((0, import_node_path2.join)(projectRoot, ".env"))) {
-          break;
-        }
-        projectRoot = (0, import_node_path2.dirname)(projectRoot);
-      }
-      const envPath = (0, import_node_path2.join)(projectRoot, ".env");
-      if ((0, import_node_fs2.existsSync)(envPath)) {
-        try {
-          const envContent = (0, import_node_fs2.readFileSync)(envPath, "utf8");
-          const envLines = envContent.split("\n");
-          for (const line of envLines) {
-            const trimmedLine = line.trim();
-            if (trimmedLine && !trimmedLine.startsWith("#")) {
-              const [key, ...valueParts] = trimmedLine.split("=");
-              if (key && valueParts.length > 0) {
-                const value = valueParts.join("=").replace(/^"(.*)"$/, "$1");
-                process.env[key.trim()] = value.trim();
-              }
-            }
-          }
-        } catch (error) {
-          console.warn(
-            `\u26A0\uFE0F Warning: Could not load .env file: ${error instanceof Error ? error.message : String(error)}`
-          );
-        }
-      }
+      this.loader.loadEnvironmentVariables(agentFilePath);
       const agentFileUrl = (0, import_node_url.pathToFileURL)(agentFilePath).href;
-      const agentModule = agentFilePath.endsWith(".ts") ? await this.importTypeScriptFile(agentFilePath) : await import(agentFileUrl);
-      if (!agentModule.agent) {
-        throw new Error(`No 'agent' export found in ${agentFilePath}`);
-      }
-      if (!agentModule.agent || typeof agentModule.agent !== "object" || !agentModule.agent.name) {
+      const agentModule = agentFilePath.endsWith(".ts") ? await this.loader.importTypeScriptFile(agentFilePath) : await import(agentFileUrl);
+      const resolved = await this.loader.resolveAgentExport(agentModule);
+      const exportedAgent = resolved.agent;
+      if (!exportedAgent?.name) {
         throw new Error(
           `Invalid agent export in ${agentFilePath}. Expected an LlmAgent instance with a name property.`
         );
       }
-      if (!agentModule.agent.model || !agentModule.agent.instruction) {
-      }
-      const agentBuilder = import_adk.AgentBuilder.create(agentModule.agent.name).withModel(agentModule.agent.model).withDescription(agentModule.agent.description || "").withInstruction(agentModule.agent.instruction || "").withSessionService(this.sessionService, {
+      const agentBuilder = import_adk.AgentBuilder.create(exportedAgent.name).withAgent(exportedAgent).withSessionService(this.sessionService, {
         userId: `user_${agentPath}`,
         appName: "adk-server"
       });
-      if (agentModule.agent.tools && Array.isArray(agentModule.agent.tools) && agentModule.agent.tools.length > 0) {
-        agentBuilder.withTools(...agentModule.agent.tools);
-        if (!this.quiet) {
-          const toolNames = agentModule.agent.tools.map((t) => t?.name || "<unnamed>").join(", ");
-          console.log(
-            `\u{1F9E9} Registered tools for agent "${agentModule.agent.name}": [${toolNames}]`
-          );
-        }
-      }
       const { runner, session } = await agentBuilder.build();
       const loadedAgent = {
-        agent: agentModule.agent,
+        agent: exportedAgent,
         runner,
         sessionId: session.id,
         userId: `user_${agentPath}`,
         appName: "adk-server"
       };
       this.loadedAgents.set(agentPath, loadedAgent);
-      agent.instance = agentModule.agent;
-      agent.name = agentModule.agent.name;
+      agent.instance = exportedAgent;
+      agent.name = exportedAgent.name;
     } catch (error) {
       console.error(`\u274C Failed to load agent "${agent.name}":`, error);
       throw new Error(
@@ -584,78 +736,65 @@ var ADKServer = class {
       throw new Error(`Failed to send message to agent: ${errorMessage}`);
     }
   }
-  /**
-   * Import a TypeScript file by compiling it on-demand
-   */
-  async importTypeScriptFile(filePath) {
-    let projectRoot = (0, import_node_path2.dirname)(filePath);
-    while (projectRoot !== "/" && projectRoot !== (0, import_node_path2.dirname)(projectRoot)) {
-      if ((0, import_node_fs2.existsSync)((0, import_node_path2.join)(projectRoot, "package.json")) || (0, import_node_fs2.existsSync)((0, import_node_path2.join)(projectRoot, ".env"))) {
-        break;
-      }
-      projectRoot = (0, import_node_path2.dirname)(projectRoot);
+  stopAllAgents() {
+    for (const [agentPath] of this.loadedAgents.entries()) {
+      this.stopAgent(agentPath);
     }
+  }
+};
+var SessionManager = class {
+  constructor(sessionService) {
+    this.sessionService = sessionService;
+  }
+  async getSessionMessages(loadedAgent) {
     try {
-      const { build } = await import("esbuild");
-      const cacheDir = (0, import_node_path2.join)(projectRoot, ".adk-cache");
-      if (!(0, import_node_fs2.existsSync)(cacheDir)) {
-        (0, import_node_fs2.mkdirSync)(cacheDir, { recursive: true });
-      }
-      const outFile = (0, import_node_path2.join)(cacheDir, `agent-${Date.now()}.mjs`);
-      const plugin = {
-        name: "externalize-bare-imports",
-        setup(build2) {
-          build2.onResolve({ filter: /.*/ }, (args) => {
-            if (args.path.startsWith(".") || args.path.startsWith("/") || args.path.startsWith("..")) {
-              return;
-            }
-            return { path: args.path, external: true };
-          });
-        }
-      };
-      const tsconfigPath = (0, import_node_path2.join)(projectRoot, "tsconfig.json");
-      await build({
-        entryPoints: [filePath],
-        outfile: outFile,
-        bundle: true,
-        format: "esm",
-        platform: "node",
-        target: ["node22"],
-        sourcemap: false,
-        logLevel: "silent",
-        plugins: [plugin],
-        absWorkingDir: projectRoot,
-        // Use tsconfig if present for path aliases
-        ...(0, import_node_fs2.existsSync)(tsconfigPath) ? { tsconfig: tsconfigPath } : {}
-      });
-      const mod = await import(`${(0, import_node_url.pathToFileURL)(outFile).href}?t=${Date.now()}`);
-      let agentExport = mod?.agent;
-      if (!agentExport && mod?.default) {
-        agentExport = mod.default.agent ?? mod.default;
-      }
-      try {
-        (0, import_node_fs2.unlinkSync)(outFile);
-      } catch {
-      }
-      if (agentExport) {
-        if (!this.quiet) {
-          console.log(`\u2705 TS agent imported via esbuild: ${filePath}`);
-        }
-        return { agent: agentExport };
-      }
-    } catch (e) {
-      throw new Error(
-        `Failed to import TS agent via esbuild: ${e instanceof Error ? e.message : String(e)}`
+      const session = await this.sessionService.getSession(
+        loadedAgent.appName,
+        loadedAgent.userId,
+        loadedAgent.sessionId
       );
+      if (!session || !session.events) {
+        return [];
+      }
+      const messages = session.events.map((event, index) => ({
+        id: index + 1,
+        type: event.author === "user" ? "user" : "assistant",
+        content: event.content?.parts?.map(
+          (part) => typeof part === "object" && "text" in part ? part.text : ""
+        ).join("") || "",
+        timestamp: new Date(event.timestamp || Date.now()).toISOString()
+      }));
+      return messages;
+    } catch (error) {
+      console.error("Error fetching messages:", error);
+      return [];
     }
-    throw new Error("No 'agent' export found in TypeScript module");
+  }
+};
+
+// src/server/index.ts
+var ADKServer = class {
+  agentManager;
+  sessionManager;
+  sessionService;
+  app;
+  server;
+  config;
+  constructor(agentsDir, port = 8042, host = "localhost", quiet = false) {
+    this.config = { agentsDir, port, host, quiet };
+    this.sessionService = new import_adk2.InMemorySessionService();
+    this.agentManager = new AgentManager(this.sessionService, quiet);
+    this.sessionManager = new SessionManager(this.sessionService);
+    this.app = new import_hono.Hono();
+    setupRoutes(this.app, this.agentManager, this.sessionManager, agentsDir);
+    this.agentManager.scanAgents(agentsDir);
   }
   async start() {
-    return new Promise((resolve2, reject) => {
+    return new Promise((resolve2) => {
       this.server = (0, import_node_server.serve)({
         fetch: this.app.fetch,
-        port: this.port,
-        hostname: this.host
+        port: this.config.port,
+        hostname: this.config.host
       });
       setTimeout(() => {
         resolve2();
@@ -664,9 +803,7 @@ var ADKServer = class {
   }
   async stop() {
     return new Promise((resolve2) => {
-      for (const [agentPath] of this.loadedAgents) {
-        this.stopAgent(agentPath);
-      }
+      this.agentManager.stopAllAgents();
       if (this.server) {
         this.server.close();
       }
@@ -674,19 +811,7 @@ var ADKServer = class {
     });
   }
   getPort() {
-    return this.port;
-  }
-  extractAgentNameFromFile(filePath) {
-    try {
-      const content = (0, import_node_fs2.readFileSync)(filePath, "utf-8");
-      const nameMatch = content.match(/name\s*:\s*["']([^"']+)["']/);
-      if (nameMatch?.[1]) {
-        return nameMatch[1];
-      }
-      return null;
-    } catch {
-      return null;
-    }
+    return this.config.port;
   }
 };