@iqai/adk 0.0.4 → 0.0.6

package/dist/index.mjs

@@ -19,24 +19,60 @@ var __copyProps = (to, from, except, desc) => {
 };
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
+// src/helpers/debug.ts
+var isDebugEnabled, debugLog;
+var init_debug = __esm({
+  "src/helpers/debug.ts"() {
+    isDebugEnabled = () => {
+      return process.env.NODE_ENV === "development" || process.env.DEBUG === "true";
+    };
+    debugLog = (message, ...args) => {
+      const time = (/* @__PURE__ */ new Date()).toLocaleTimeString();
+      if (isDebugEnabled()) {
+        console.log(`[DEBUG] ${time}: ${message}`, ...args);
+      }
+    };
+  }
+});
+
 // src/tools/base/base-tool.ts
 var BaseTool;
 var init_base_tool = __esm({
   "src/tools/base/base-tool.ts"() {
-    "use strict";
+    init_debug();
     BaseTool = class {
+      /**
+       * Name of the tool
+       */
+      name;
+      /**
+       * Description of the tool
+       */
+      description;
+      /**
+       * Whether the tool is a long running operation
+       */
+      isLongRunning;
+      /**
+       * Whether the tool execution should be retried on failure
+       */
+      shouldRetryOnFailure;
+      /**
+       * Maximum retry attempts
+       */
+      maxRetryAttempts;
+      /**
+       * Base delay for retry in ms (will be used with exponential backoff)
+       */
+      baseRetryDelay = 1e3;
+      /**
+       * Maximum delay for retry in ms
+       */
+      maxRetryDelay = 1e4;
       /**
        * Constructor for BaseTool
        */
       constructor(config) {
-        /**
-         * Base delay for retry in ms (will be used with exponential backoff)
-         */
-        this.baseRetryDelay = 1e3;
-        /**
-         * Maximum delay for retry in ms
-         */
-        this.maxRetryDelay = 1e4;
         this.name = config.name;
         this.description = config.description;
         this.isLongRunning = config.isLongRunning || false;
@@ -93,11 +129,9 @@ var init_base_tool = __esm({
         while (attempts <= (this.shouldRetryOnFailure ? this.maxRetryAttempts : 0)) {
           try {
             if (attempts > 0) {
-              if (process.env.DEBUG === "true") {
-                console.log(
-                  `Retrying tool ${this.name} (attempt ${attempts} of ${this.maxRetryAttempts})...`
-                );
-              }
+              debugLog(
+                `[BaseTool] Retrying tool ${this.name} (attempt ${attempts} of ${this.maxRetryAttempts})...`
+              );
               const delay = Math.min(
                 this.baseRetryDelay * 2 ** (attempts - 1) + Math.random() * 1e3,
                 this.maxRetryDelay
@@ -231,7 +265,6 @@ function extractJSDocParams(funcStr) {
 }
 var init_function_utils = __esm({
   "src/tools/function/function-utils.ts"() {
-    "use strict";
   }
 });
 
@@ -243,10 +276,11 @@ __export(function_tool_exports, {
 var FunctionTool;
 var init_function_tool = __esm({
   "src/tools/function/function-tool.ts"() {
-    "use strict";
     init_base_tool();
     init_function_utils();
     FunctionTool = class extends BaseTool {
+      func;
+      mandatoryArgs = [];
       /**
        * Creates a new FunctionTool wrapping the provided function.
        *
@@ -263,7 +297,6 @@ var init_function_tool = __esm({
           shouldRetryOnFailure: options?.shouldRetryOnFailure || false,
           maxRetryAttempts: options?.maxRetryAttempts || 3
         });
-        this.mandatoryArgs = [];
         this.func = func;
         this.mandatoryArgs = this.getMandatoryArgs(func);
       }
@@ -359,6 +392,25 @@ __export(agents_exports, {
 
 // src/agents/base-agent.ts
 var BaseAgent = class {
+  /**
+   * The agent's name
+   * Agent name must be a unique identifier within the agent tree
+   */
+  name;
+  /**
+   * Description about the agent's capability
+   * The LLM uses this to determine whether to delegate control to the agent
+   */
+  description;
+  /**
+   * The parent agent of this agent
+   * Note that an agent can ONLY be added as sub-agent once
+   */
+  parentAgent;
+  /**
+   * The sub-agents of this agent
+   */
+  subAgents;
   /**
    * Constructs a new BaseAgent
    */
@@ -422,8 +474,16 @@ var BaseAgent = class {
   }
 };
 
+// src/agents/llm-agent.ts
+init_debug();
+
 // src/models/llm-registry.ts
-var _LLMRegistry = class _LLMRegistry {
+init_debug();
+var LLMRegistry = class _LLMRegistry {
+  /**
+   * Map of model name regex to LLM class
+   */
+  static llmRegistry = /* @__PURE__ */ new Map();
   /**
    * Creates a new LLM instance
    *
@@ -475,22 +535,23 @@ var _LLMRegistry = class _LLMRegistry {
    * Logs all registered models for debugging
    */
   static logRegisteredModels() {
-    if (process.env.DEBUG === "true") {
-      console.log("Registered LLM models:");
-      for (const [regex, llmClass] of _LLMRegistry.llmRegistry.entries()) {
-        console.log(`  - Pattern: ${regex.toString()}`);
-      }
-    }
+    debugLog(
+      "Registered LLM models:",
+      [..._LLMRegistry.llmRegistry.entries()].map(([regex]) => regex.toString())
+    );
   }
 };
-/**
- * Map of model name regex to LLM class
- */
-_LLMRegistry.llmRegistry = /* @__PURE__ */ new Map();
-var LLMRegistry = _LLMRegistry;
 
 // src/models/llm-request.ts
 var LLMRequest = class {
+  /**
+   * The conversation history
+   */
+  messages;
+  /**
+   * LLM configuration parameters
+   */
+  config;
   constructor(data) {
     this.messages = data.messages;
     this.config = data.config || {};
@@ -499,18 +560,34 @@ var LLMRequest = class {
 
 // src/tools/tool-context.ts
 var ToolContext = class {
+  /**
+   * The parent invocation context
+   */
+  invocationContext;
+  /**
+   * Authentication handler for the tool
+   */
+  auth;
+  /**
+   * Additional parameters for the tool
+   */
+  parameters;
+  /**
+   * Tool name
+   */
+  toolName = "";
+  /**
+   * Tool ID
+   */
+  toolId = "";
+  /**
+   * Variables stored in the context
+   */
+  _variables;
   /**
    * Constructor for ToolContext
    */
   constructor(options) {
-    /**
-     * Tool name
-     */
-    this.toolName = "";
-    /**
-     * Tool ID
-     */
-    this.toolId = "";
     this.invocationContext = options.invocationContext;
     this.auth = options.auth;
     this.parameters = options.parameters || {};
@@ -586,6 +663,36 @@ var StreamingMode = /* @__PURE__ */ ((StreamingMode2) => {
   return StreamingMode2;
 })(StreamingMode || {});
 var RunConfig = class {
+  /**
+   * Speech configuration for the live agent
+   */
+  speechConfig;
+  /**
+   * The output modalities
+   */
+  responseModalities;
+  /**
+   * Whether to save input blobs as artifacts
+   */
+  saveInputBlobsAsArtifacts;
+  /**
+   * Whether to support Compositional Function Calling
+   * Only applicable for StreamingMode.SSE
+   */
+  supportCFC;
+  /**
+   * Streaming mode
+   */
+  streamingMode;
+  /**
+   * Whether to stream the response
+   * This is derived from streamingMode and used by LLM implementations
+   */
+  stream;
+  /**
+   * Output audio transcription configuration
+   */
+  outputAudioTranscription;
   constructor(config) {
     this.speechConfig = config?.speechConfig;
     this.responseModalities = config?.responseModalities;
@@ -599,14 +706,50 @@ var RunConfig = class {
 
 // src/agents/invocation-context.ts
 var InvocationContext = class _InvocationContext {
+  /**
+   * Unique session ID for the current conversation
+   */
+  sessionId;
+  /**
+   * Current conversation history
+   */
+  messages;
+  /**
+   * Run configuration
+   */
+  config;
+  /**
+   * User identifier associated with the session
+   */
+  userId;
+  /**
+   * Application name (for multi-app environments)
+   */
+  appName;
+  /**
+   * Memory service for long-term storage
+   */
+  memoryService;
+  /**
+   * Session service for session management
+   */
+  sessionService;
+  /**
+   * Additional context metadata
+   */
+  metadata;
+  /**
+   * Variables stored in the context
+   */
+  variables;
+  /**
+   * In-memory storage for node execution results
+   */
+  memory = /* @__PURE__ */ new Map();
   /**
    * Constructor for InvocationContext
    */
   constructor(options = {}) {
-    /**
-     * In-memory storage for node execution results
-     */
-    this.memory = /* @__PURE__ */ new Map();
     this.sessionId = options.sessionId || this.generateSessionId();
     this.messages = options.messages || [];
     this.config = options.config || new RunConfig();
@@ -713,6 +856,54 @@ var InvocationContext = class _InvocationContext {
 
 // src/agents/llm-agent.ts
 var Agent = class extends BaseAgent {
+  /**
+   * The LLM model to use
+   */
+  model;
+  /**
+   * The LLM instance
+   */
+  llm;
+  /**
+   * Instructions for the agent
+   */
+  instructions;
+  /**
+   * Tools available to the agent
+   */
+  tools;
+  /**
+   * Maximum number of tool execution steps to prevent infinite loops
+   */
+  maxToolExecutionSteps;
+  /**
+   * Memory service for long-term storage and retrieval
+   */
+  memoryService;
+  /**
+   * Session service for managing conversations
+   */
+  sessionService;
+  /**
+   * User ID for the session
+   */
+  userId;
+  /**
+   * Application name
+   */
+  appName;
+  /**
+   * Whether to automatically augment prompts with relevant memory
+   */
+  useMemoryAugmentation;
+  /**
+   * The maximum number of memory items to include in augmentation
+   */
+  maxMemoryItems;
+  /**
+   * The minimum relevance score for memory augmentation (0-1)
+   */
+  memoryRelevanceThreshold;
   /**
    * Constructor for Agent
    */
@@ -745,9 +936,7 @@ var Agent = class extends BaseAgent {
    */
   async executeTool(toolCall, context) {
     const { name, arguments: argsString } = toolCall.function;
-    if (process.env.DEBUG === "true") {
-      console.log(`Executing tool: ${name}`);
-    }
+    debugLog(`Executing tool: ${name}`);
     const tool = this.findTool(name);
     if (!tool) {
       console.warn(`Tool '${name}' not found`);
@@ -765,9 +954,7 @@ var Agent = class extends BaseAgent {
       toolContext.toolName = name;
       toolContext.toolId = toolCall.id;
       const result = await tool.runAsync(args, toolContext);
-      if (process.env.DEBUG === "true") {
-        console.log(`Tool ${name} execution complete`);
-      }
+      debugLog(`Tool ${name} execution complete`);
       return {
         name,
         result: typeof result === "string" ? result : JSON.stringify(result)
@@ -936,10 +1123,7 @@ ${relevantInfo.join("\n\n")}`
       let stepCount = 0;
       while (stepCount < this.maxToolExecutionSteps) {
         stepCount++;
-        if (process.env.DEBUG === "true") {
-          console.log(`
-[Agent] Step ${stepCount}: Thinking...`);
-        }
+        debugLog(`Step ${stepCount}: Thinking...`);
         const llmRequest = new LLMRequest({
           messages: context.messages,
           config: {
@@ -956,9 +1140,7 @@ ${relevantInfo.join("\n\n")}`
           throw new Error("No response from LLM");
         }
         if (currentResponse.tool_calls && currentResponse.tool_calls.length > 0) {
-          if (process.env.DEBUG === "true") {
-            console.log("[Agent] Executing tools...");
-          }
+          debugLog(`Tool calls: ${JSON.stringify(currentResponse.tool_calls)}`);
           context.addMessage({
             role: "assistant",
             content: currentResponse.content || "",
@@ -977,9 +1159,7 @@ ${relevantInfo.join("\n\n")}`
             });
           }
         } else {
-          if (process.env.DEBUG === "true") {
-            console.log("[Agent] No tool calls, finishing...");
-          }
+          debugLog("[Agent] No tool calls, finishing...");
           context.addMessage({
             role: "assistant",
             content: currentResponse.content || ""
@@ -1017,10 +1197,7 @@ ${relevantInfo.join("\n\n")}`
     let stepCount = 0;
     let hadToolCalls = false;
     while (stepCount < this.maxToolExecutionSteps) {
-      if (process.env.DEBUG === "true") {
-        console.log(`
-[Agent] Step ${stepCount + 1}: Thinking...`);
-      }
+      debugLog(`[Agent] Step ${stepCount}: Thinking...`);
       const toolDeclarations = this.tools.map((tool) => tool.getDeclaration()).filter((declaration) => declaration !== null);
       const request = {
         messages: context.messages,
@@ -1049,14 +1226,10 @@ ${relevantInfo.join("\n\n")}`
         function_call: finalResponse.function_call
       });
       if (!hadToolCalls) {
-        if (process.env.DEBUG === "true") {
-          console.log("[Agent] No tool calls, finishing...");
-        }
+        debugLog("[Agent] No tool calls, finishing...");
         break;
       }
-      if (process.env.DEBUG === "true") {
-        console.log("[Agent] Executing tools...");
-      }
+      debugLog(`[Agent] Step ${stepCount + 1}: Executing tools...`);
       stepCount++;
       if (finalResponse.function_call) {
         const toolCall = {
@@ -1073,11 +1246,9 @@ ${relevantInfo.join("\n\n")}`
           content: JSON.stringify(result.result)
         });
       } else if (finalResponse.tool_calls && finalResponse.tool_calls.length > 0) {
-        if (process.env.DEBUG === "true") {
-          console.log(
-            `[Agent] Executing ${finalResponse.tool_calls.length} tool(s)...`
-          );
-        }
+        debugLog(
+          `[Agent] Step ${stepCount + 1}: Executing ${finalResponse.tool_calls.length} tool(s)...`
+        );
         context.messages.pop();
         context.addMessage({
           role: "assistant",
@@ -1102,6 +1273,7 @@ ${relevantInfo.join("\n\n")}`
 };
 
 // src/agents/sequential-agent.ts
+init_debug();
 var SequentialAgent = class extends BaseAgent {
   /**
    * Constructor for SequentialAgent
@@ -1122,11 +1294,9 @@ var SequentialAgent = class extends BaseAgent {
    * Executes sub-agents sequentially, passing output from one to the next
    */
   async run(options) {
-    if (process.env.DEBUG === "true") {
-      console.log(
-        `[SequentialAgent] Running ${this.subAgents.length} sub-agents in sequence`
-      );
-    }
+    debugLog(
+      `[SequentialAgent] Running ${this.subAgents.length} sub-agents in sequence`
+    );
     if (this.subAgents.length === 0) {
       return {
         content: "No sub-agents defined for sequential execution.",
@@ -1142,11 +1312,9 @@ var SequentialAgent = class extends BaseAgent {
     let finalResponse = null;
     for (let i = 0; i < this.subAgents.length; i++) {
       const agent = this.subAgents[i];
-      if (process.env.DEBUG === "true") {
-        console.log(
-          `[SequentialAgent] Running sub-agent ${i + 1}/${this.subAgents.length}: ${agent.name}`
-        );
-      }
+      debugLog(
+        `[SequentialAgent] Running sub-agent ${i + 1}/${this.subAgents.length}: ${agent.name}`
+      );
       try {
         const response = await agent.run({
           messages: currentMessages,
@@ -1202,11 +1370,9 @@ var SequentialAgent = class extends BaseAgent {
    * Streams responses from each sub-agent in sequence
    */
   async *runStreaming(options) {
-    if (process.env.DEBUG === "true") {
-      console.log(
-        `[SequentialAgent] Streaming ${this.subAgents.length} sub-agents in sequence`
-      );
-    }
+    debugLog(
+      `[SequentialAgent] Streaming ${this.subAgents.length} sub-agents in sequence`
+    );
     if (this.subAgents.length === 0) {
       yield {
         content: "No sub-agents defined for sequential execution.",
@@ -1222,11 +1388,9 @@ var SequentialAgent = class extends BaseAgent {
     const currentMessages = [...options.messages];
     for (let i = 0; i < this.subAgents.length; i++) {
       const agent = this.subAgents[i];
-      if (process.env.DEBUG === "true") {
-        console.log(
-          `[SequentialAgent] Streaming sub-agent ${i + 1}/${this.subAgents.length}: ${agent.name}`
-        );
-      }
+      debugLog(
+        `[SequentialAgent] Streaming sub-agent ${i + 1}/${this.subAgents.length}: ${agent.name}`
+      );
       try {
         const streamGenerator = agent.runStreaming({
           messages: currentMessages,
@@ -1279,6 +1443,7 @@ var SequentialAgent = class extends BaseAgent {
 };
 
 // src/agents/parallel-agent.ts
+init_debug();
 var ParallelAgent = class extends BaseAgent {
   /**
    * Constructor for ParallelAgent
@@ -1299,11 +1464,9 @@ var ParallelAgent = class extends BaseAgent {
    * Executes all sub-agents in parallel
    */
   async run(options) {
-    if (process.env.DEBUG === "true") {
-      console.log(
-        `[ParallelAgent] Running ${this.subAgents.length} sub-agents in parallel`
-      );
-    }
+    debugLog(
+      `[ParallelAgent] Running ${this.subAgents.length} sub-agents in parallel`
+    );
     if (this.subAgents.length === 0) {
       return {
         content: "No sub-agents defined for parallel execution.",
@@ -1346,11 +1509,9 @@ ${result.content || "No content"}
    * Collects streaming responses from all sub-agents
    */
   async *runStreaming(options) {
-    if (process.env.DEBUG === "true") {
-      console.log(
-        `[ParallelAgent] Streaming ${this.subAgents.length} sub-agents in parallel`
-      );
-    }
+    debugLog(
+      `[ParallelAgent] Streaming ${this.subAgents.length} sub-agents in parallel`
+    );
     if (this.subAgents.length === 0) {
       yield {
         content: "No sub-agents defined for parallel execution.",
@@ -1416,7 +1577,20 @@ ${response.content || "No content"}
 };
 
 // src/agents/loop-agent.ts
+init_debug();
 var LoopAgent = class extends BaseAgent {
+  /**
+   * Maximum number of iterations to prevent infinite loops
+   */
+  maxIterations;
+  /**
+   * Agent that decides whether to continue the loop
+   */
+  conditionAgent;
+  /**
+   * Custom condition check function
+   */
+  conditionCheck;
   /**
    * Constructor for LoopAgent
    */
@@ -1444,28 +1618,20 @@ var LoopAgent = class extends BaseAgent {
    */
   async shouldContinue(response, iterationCount, messages, config) {
     if (iterationCount >= this.maxIterations) {
-      if (process.env.DEBUG === "true") {
-        console.log(
-          `[LoopAgent] Maximum iterations (${this.maxIterations}) reached. Stopping loop.`
-        );
-      }
+      debugLog(
+        `[LoopAgent] Maximum iterations (${this.maxIterations}) reached. Stopping loop.`
+      );
       return false;
     }
     if (this.conditionCheck) {
       const shouldContinue = await this.conditionCheck(response);
-      if (process.env.DEBUG === "true") {
-        console.log(
-          `[LoopAgent] Custom condition check result: ${shouldContinue}`
-        );
-      }
+      debugLog(`[LoopAgent] Custom condition check result: ${shouldContinue}`);
       return shouldContinue;
     }
     if (this.conditionAgent) {
-      if (process.env.DEBUG === "true") {
-        console.log(
-          `[LoopAgent] Using condition agent ${this.conditionAgent.name} to check loop condition`
-        );
-      }
+      debugLog(
+        `[LoopAgent] Using condition agent ${this.conditionAgent.name} to check loop condition`
+      );
       const conditionMessages = [
         ...messages,
         {
@@ -1484,11 +1650,9 @@ var LoopAgent = class extends BaseAgent {
         });
         const content = conditionResponse.content?.toLowerCase() || "";
         const shouldContinue = content.includes("yes") && !content.includes("no");
-        if (process.env.DEBUG === "true") {
-          console.log(
-            `[LoopAgent] Condition agent result: ${shouldContinue ? "Continue loop" : "Stop loop"}`
-          );
-        }
+        debugLog(
+          `[LoopAgent] Condition agent result: ${shouldContinue ? "Continue loop" : "Stop loop"}`
+        );
         return shouldContinue;
       } catch (error) {
         console.error("[LoopAgent] Error in condition agent:", error);
@@ -1502,11 +1666,9 @@ var LoopAgent = class extends BaseAgent {
    * Executes the sub-agent in a loop until the condition is met
    */
   async run(options) {
-    if (process.env.DEBUG === "true") {
-      console.log(
-        `[LoopAgent] Starting loop with max ${this.maxIterations} iterations`
-      );
-    }
+    debugLog(
+      `[LoopAgent] Starting loop with max ${this.maxIterations} iterations`
+    );
     if (this.subAgents.length === 0) {
       return {
         content: "No sub-agent defined for loop execution.",
@@ -1520,11 +1682,9 @@ var LoopAgent = class extends BaseAgent {
     let shouldContinueLoop = true;
     while (shouldContinueLoop && iterationCount < this.maxIterations) {
       iterationCount++;
-      if (process.env.DEBUG === "true") {
-        console.log(
-          `[LoopAgent] Running iteration ${iterationCount}/${this.maxIterations}`
-        );
-      }
+      debugLog(
+        `[LoopAgent] Running iteration ${iterationCount}/${this.maxIterations}`
+      );
       try {
         const response = await subAgent.run({
           messages: currentMessages,
@@ -1572,11 +1732,9 @@ ${lastResponse.content || ""}`,
    * Runs the agent with streaming support
    */
   async *runStreaming(options) {
-    if (process.env.DEBUG === "true") {
-      console.log(
-        `[LoopAgent] Starting loop with max ${this.maxIterations} iterations (streaming)`
-      );
-    }
+    debugLog(
+      `[LoopAgent] Starting loop with max ${this.maxIterations} iterations (streaming)`
+    );
     if (this.subAgents.length === 0) {
       yield {
         content: "No sub-agent defined for loop execution.",
@@ -1595,11 +1753,9 @@ ${lastResponse.content || ""}`,
     };
     while (shouldContinueLoop && iterationCount < this.maxIterations) {
       iterationCount++;
-      if (process.env.DEBUG === "true") {
-        console.log(
-          `[LoopAgent] Running iteration ${iterationCount}/${this.maxIterations} (streaming)`
-        );
-      }
+      debugLog(
+        `[LoopAgent] Running iteration ${iterationCount}/${this.maxIterations} (streaming)`
+      );
       yield {
         content: `Running iteration ${iterationCount}/${this.maxIterations}...`,
         role: "assistant",
@@ -1623,11 +1779,9 @@ ${lastResponse.content || ""}`,
           }
         }
         if (!lastChunk) {
-          if (process.env.DEBUG === "true") {
-            console.warn(
-              `[LoopAgent] No complete chunk received from iteration ${iterationCount}`
-            );
-          }
+          debugLog(
+            `[LoopAgent] No complete chunk received from iteration ${iterationCount}`
+          );
           shouldContinueLoop = false;
           continue;
         }
@@ -1653,9 +1807,8 @@ ${lastResponse.content || ""}`,
           };
         }
       } catch (error) {
-        console.error(
-          `[LoopAgent] Error in loop iteration ${iterationCount}:`,
-          error
+        debugLog(
+          `[LoopAgent] Error in loop iteration ${iterationCount}: ${error instanceof Error ? error.message : String(error)}`
         );
         yield {
           content: `Error in loop iteration ${iterationCount}: ${error instanceof Error ? error.message : String(error)}`,
@@ -1672,7 +1825,24 @@ ${lastResponse.content || ""}`,
 };
 
 // src/agents/lang-graph-agent.ts
+init_debug();
 var LangGraphAgent = class extends BaseAgent {
+  /**
+   * Graph nodes (agents and their connections)
+   */
+  nodes;
+  /**
+   * Root node to start execution from
+   */
+  rootNode;
+  /**
+   * Maximum number of steps to prevent infinite loops
+   */
+  maxSteps;
+  /**
+   * Results from node executions
+   */
+  results = [];
   /**
    * Constructor for LangGraphAgent
    */
@@ -1681,10 +1851,6 @@ var LangGraphAgent = class extends BaseAgent {
       name: config.name,
       description: config.description
     });
-    /**
-     * Results from node executions
-     */
-    this.results = [];
     this.nodes = /* @__PURE__ */ new Map();
     for (const node of config.nodes) {
       if (this.nodes.has(node.name)) {
@@ -1757,11 +1923,9 @@ var LangGraphAgent = class extends BaseAgent {
       if (targetNode.condition) {
         const shouldExecute = await targetNode.condition(result, context);
         if (!shouldExecute) {
-          if (process.env.DEBUG === "true") {
-            console.log(
-              `[LangGraphAgent] Skipping node "${targetName}" due to condition`
-            );
-          }
+          debugLog(
+            `[LangGraphAgent] Skipping node "${targetName}" due to condition`
+          );
           continue;
         }
       }
@@ -1786,11 +1950,9 @@ var LangGraphAgent = class extends BaseAgent {
     };
     const shouldExecute = await node.condition(mockResponse, mockContext);
     if (!shouldExecute) {
-      if (process.env.DEBUG === "true") {
-        console.log(
-          `[LangGraphAgent] Skipping node "${targetName}" due to condition`
-        );
-      }
+      debugLog(
+        `[LangGraphAgent] Skipping node "${targetName}" due to condition`
+      );
     }
     return { shouldExecute };
   }
@@ -1803,11 +1965,9 @@ var LangGraphAgent = class extends BaseAgent {
       messages: options.messages,
       config: options.config
     });
-    if (process.env.DEBUG === "true") {
-      console.log(
-        `[LangGraphAgent] Starting graph execution from root node "${this.rootNode}"`
-      );
-    }
+    debugLog(
+      `[LangGraphAgent] Starting graph execution from root node "${this.rootNode}"`
+    );
     if (this.nodes.size === 0) {
       return {
         content: "No nodes defined in the graph.",
@@ -1827,11 +1987,9 @@ var LangGraphAgent = class extends BaseAgent {
     while (nodesToExecute.length > 0 && stepCount < this.maxSteps) {
       stepCount++;
       const { node, messages } = nodesToExecute.shift();
-      if (process.env.DEBUG === "true") {
-        console.log(
-          `[LangGraphAgent] Step ${stepCount}: Executing node "${node.name}"`
-        );
-      }
+      debugLog(
+        `[LangGraphAgent] Step ${stepCount}: Executing node "${node.name}"`
+      );
       executedNodes.push(node.name);
       try {
         const result = await node.agent.run({
@@ -1903,11 +2061,9 @@ var LangGraphAgent = class extends BaseAgent {
       messages: options.messages,
       config: options.config
     });
-    if (process.env.DEBUG === "true") {
-      console.log(
-        `[LangGraphAgent] Starting graph execution from root node "${this.rootNode}" (streaming)`
-      );
-    }
+    debugLog(
+      `[LangGraphAgent] Starting graph execution from root node "${this.rootNode}" (streaming)`
+    );
     if (this.nodes.size === 0) {
       yield {
         content: "No nodes defined in the graph.",
@@ -1934,11 +2090,9 @@ var LangGraphAgent = class extends BaseAgent {
     while (nodesToExecute.length > 0 && stepCount < this.maxSteps) {
       stepCount++;
       const { node, messages } = nodesToExecute.shift();
-      if (process.env.DEBUG === "true") {
-        console.log(
-          `[LangGraphAgent] Step ${stepCount}: Executing node "${node.name}" (streaming)`
-        );
-      }
+      debugLog(
+        `[LangGraphAgent] Step ${stepCount}: Executing node "${node.name}" (streaming)`
+      );
       executedNodes.push(node.name);
       try {
         const result = await node.agent.run({
@@ -2052,6 +2206,7 @@ function createFunctionTool(func, options) {
 init_function_utils();
 
 // src/tools/common/google-search.ts
+init_debug();
 init_base_tool();
 var GoogleSearch = class extends BaseTool {
   /**
@@ -2092,9 +2247,7 @@ var GoogleSearch = class extends BaseTool {
    * This is a simplified implementation that doesn't actually search, just returns mock results
    */
   async runAsync(args, _context) {
-    if (process.env.DEBUG === "true") {
-      console.log(`Executing Google search for: ${args.query}`);
-    }
+    debugLog(`[GoogleSearch] Executing Google search for: ${args.query}`);
     return {
       results: [
         {
@@ -2236,6 +2389,7 @@ init_base_tool();
 import fs from "fs/promises";
 import path from "path";
 var FileOperationsTool = class extends BaseTool {
+  basePath;
   constructor(options) {
     super({
       name: "file_operations",
@@ -2556,6 +2710,7 @@ var UserInteractionTool = class extends BaseTool {
 };
 
 // src/tools/common/exit-loop-tool.ts
+init_debug();
 init_base_tool();
 var ExitLoopTool = class extends BaseTool {
   /**
@@ -2585,9 +2740,7 @@ var ExitLoopTool = class extends BaseTool {
    * Execute the exit loop action
    */
   async runAsync(_args, context) {
-    if (process.env.DEBUG === "true") {
-      console.log("Executing exit loop tool");
-    }
+    debugLog("[ExitLoopTool] Executing exit loop tool");
     if (context.actions) {
       context.actions.escalate = true;
     } else {
@@ -2602,6 +2755,7 @@ var ExitLoopTool = class extends BaseTool {
 };
 
 // src/tools/common/get-user-choice-tool.ts
+init_debug();
 init_base_tool();
 var GetUserChoiceTool = class extends BaseTool {
   /**
@@ -2646,13 +2800,13 @@ var GetUserChoiceTool = class extends BaseTool {
    * and the actual choice will be provided asynchronously
    */
   async runAsync(args, context) {
-    if (process.env.DEBUG === "true") {
-      console.log(
-        `Executing get_user_choice with options: ${args.options.join(", ")}`
-      );
-      if (args.question) {
-        console.log(`Question: ${args.question}`);
-      }
+    debugLog(
+      `[GetUserChoiceTool] Executing get_user_choice with options: ${args.options.join(
+        ", "
+      )}`
+    );
+    if (args.question) {
+      debugLog(`[GetUserChoiceTool] Question: ${args.question}`);
     }
     if (context.actions) {
       context.actions.skip_summarization = true;
@@ -2666,6 +2820,7 @@ var GetUserChoiceTool = class extends BaseTool {
 };
 
 // src/tools/common/transfer-to-agent-tool.ts
+init_debug();
 init_base_tool();
 var TransferToAgentTool = class extends BaseTool {
   /**
@@ -2700,9 +2855,9 @@ var TransferToAgentTool = class extends BaseTool {
    * Execute the transfer to agent action
    */
   async runAsync(args, context) {
-    if (process.env.DEBUG === "true") {
-      console.log(`Executing transfer to agent: ${args.agent_name}`);
-    }
+    debugLog(
+      `[TransferToAgentTool] Executing transfer to agent: ${args.agent_name}`
+    );
     if (context.actions) {
       context.actions.transfer_to_agent = args.agent_name;
     } else {
@@ -2717,6 +2872,7 @@ var TransferToAgentTool = class extends BaseTool {
 };
 
 // src/tools/common/load-memory-tool.ts
+init_debug();
 init_base_tool();
 var LoadMemoryTool = class extends BaseTool {
   /**
@@ -2751,9 +2907,9 @@ var LoadMemoryTool = class extends BaseTool {
    * Execute the memory loading action
    */
   async runAsync(args, context) {
-    if (process.env.DEBUG === "true") {
-      console.log(`Executing load_memory with query: ${args.query}`);
-    }
+    debugLog(
+      `[LoadMemoryTool] Executing load_memory with query: ${args.query}`
+    );
     if (!context.memoryService) {
       return {
         error: "Memory service is not available",
@@ -2791,6 +2947,8 @@ var McpErrorType = /* @__PURE__ */ ((McpErrorType2) => {
   return McpErrorType2;
 })(McpErrorType || {});
 var McpError = class extends Error {
+  type;
+  originalError;
   constructor(message, type, originalError) {
     super(message);
     this.name = "McpError";
@@ -2829,10 +2987,11 @@ function withRetry(fn, instance, reinitMethod, maxRetries = 1) {
 
 // src/tools/mcp/client.ts
 var McpClientService = class {
+  config;
+  client = null;
+  transport = null;
+  isClosing = false;
   constructor(config) {
-    this.client = null;
-    this.transport = null;
-    this.isClosing = false;
     this.config = config;
   }
   /**
@@ -3036,6 +3195,7 @@ var McpClientService = class {
 };
 
 // src/tools/mcp/create-tool.ts
+init_debug();
 init_base_tool();
 
 // src/tools/mcp/schema-conversion.ts
@@ -3235,6 +3395,9 @@ async function createTool(mcpTool, client) {
   }
 }
 var McpToolAdapter = class extends BaseTool {
+  mcpTool;
+  client;
+  clientService = null;
   constructor(mcpTool, client) {
     const metadata = mcpTool.metadata || {};
     super({
@@ -3244,7 +3407,6 @@ var McpToolAdapter = class extends BaseTool {
       shouldRetryOnFailure: metadata.shouldRetryOnFailure ?? false,
       maxRetryAttempts: metadata.maxRetryAttempts ?? 3
     });
-    this.clientService = null;
     this.mcpTool = mcpTool;
     this.client = client;
     if (client.reinitialize && typeof client.reinitialize === "function") {
@@ -3268,9 +3430,10 @@ var McpToolAdapter = class extends BaseTool {
     }
   }
   async runAsync(args, _context) {
-    if (process.env.DEBUG === "true") {
-      console.log(`Executing MCP tool ${this.name} with args:`, args);
-    }
+    debugLog(
+      `[McpToolAdapter] Executing MCP tool ${this.name} with args:`,
+      args
+    );
     try {
       if (typeof this.mcpTool.execute === "function") {
         return await this.mcpTool.execute(args);
@@ -3323,11 +3486,12 @@ var McpToolAdapter = class extends BaseTool {
 
 // src/tools/mcp/index.ts
 var McpToolset = class {
+  config;
+  clientService = null;
+  toolFilter = null;
+  tools = [];
+  isClosing = false;
   constructor(config, toolFilter = null) {
-    this.clientService = null;
-    this.toolFilter = null;
-    this.tools = [];
-    this.isClosing = false;
     this.config = config;
     this.toolFilter = toolFilter;
     this.clientService = new McpClientService(config);
@@ -3505,6 +3669,30 @@ __export(models_exports, {
 
 // src/models/llm-response.ts
 var LLMResponse = class {
+  /**
+   * Content of the response
+   */
+  content;
+  /**
+   * Function calls in the response
+   */
+  function_call;
+  /**
+   * Tool calls in the response
+   */
+  tool_calls;
+  /**
+   * Role of the message (usually 'assistant')
+   */
+  role;
+  /**
+   * Whether this is a partial response in a stream
+   */
+  is_partial;
+  /**
+   * Raw provider response
+   */
+  raw_response;
   constructor(data) {
     this.content = data.content;
     this.function_call = data.function_call;
@@ -3517,6 +3705,10 @@ var LLMResponse = class {
 
 // src/models/base-llm.ts
 var BaseLLM = class {
+  /**
+   * The name of the LLM model
+   */
+  model;
   /**
    * Constructor for BaseLLM
    */
@@ -3542,12 +3734,10 @@ var BaseLLM = class {
 
 // src/models/base-llm-connection.ts
 var BaseLLMConnection = class {
-  constructor() {
-    /**
-     * Whether the connection is active
-     */
-    this._isActive = true;
-  }
+  /**
+   * Whether the connection is active
+   */
+  _isActive = true;
   /**
    * Gets whether the connection is active
    */
@@ -3563,22 +3753,50 @@ var BaseLLMConnection = class {
 };
 
 // src/models/anthropic-llm.ts
+init_debug();
 import axios from "axios";
 
 // src/models/anthropic-llm-connection.ts
+init_debug();
 var AnthropicLLMConnection = class extends BaseLLMConnection {
   /**
-   * Constructor
+   * Axios instance for API calls
    */
-  constructor(client, model, initialRequest, defaultParams) {
-    super();
-    this.client = client;
-    this.model = model;
-    this.defaultParams = defaultParams;
-    this.systemMessage = this.extractSystemMessage(initialRequest.messages);
-    this.messages = this.convertMessages(
-      this.filterSystemMessages(initialRequest.messages)
-    );
+  client;
+  /**
+   * Current model to use
+   */
+  model;
+  /**
+   * Current messages in the conversation
+   */
+  messages;
+  /**
+   * System message if present
+   */
+  systemMessage;
+  /**
+   * Default parameters for requests
+   */
+  defaultParams;
+  /**
+   * Callbacks for handling responses, errors, and connection end
+   */
+  responseCallback;
+  errorCallback;
+  endCallback;
+  /**
+   * Constructor
+   */
+  constructor(client, model, initialRequest, defaultParams) {
+    super();
+    this.client = client;
+    this.model = model;
+    this.defaultParams = defaultParams;
+    this.systemMessage = this.extractSystemMessage(initialRequest.messages);
+    this.messages = this.convertMessages(
+      this.filterSystemMessages(initialRequest.messages)
+    );
   }
   /**
    * Extract the system message from messages array
@@ -3669,19 +3887,14 @@ ${typeof message.content === "string" ? message.content : JSON.stringify(message
     if (!content?.length) return [];
     const toolUses = [];
     for (const block of content) {
-      if (process.env.DEBUG === "true") {
-        console.log(
-          "Connection - Processing content block of type:",
-          block.type
-        );
-      }
+      debugLog(
+        `[AnthropicLLMConnection] Processing content block of type: ${block.type}`
+      );
       if (block.type === "tool_use") {
-        if (process.env.DEBUG === "true") {
-          console.log(
-            "Connection - Found tool_use block:",
-            JSON.stringify(block, null, 2)
-          );
-        }
+        debugLog(
+          "[AnthropicLLMConnection] Found tool_use block:",
+          JSON.stringify(block, null, 2)
+        );
         toolUses.push({
           id: block.id || "unknown-id",
           name: block.name || "unknown-name",
@@ -3689,14 +3902,14 @@ ${typeof message.content === "string" ? message.content : JSON.stringify(message
         });
       }
     }
-    if (process.env.DEBUG === "true") {
-      console.log(`Connection - Found ${toolUses.length} tool uses in content`);
-      if (toolUses.length > 0) {
-        console.log(
-          "Connection - Extracted tool uses:",
-          JSON.stringify(toolUses, null, 2)
-        );
-      }
+    debugLog(
+      `[AnthropicLLMConnection] Found ${toolUses.length} tool uses in content`
+    );
+    if (toolUses.length > 0) {
+      debugLog(
+        "[AnthropicLLMConnection] Extracted tool uses:",
+        JSON.stringify(toolUses, null, 2)
+      );
     }
     return toolUses;
   }
@@ -3790,43 +4003,30 @@ ${typeof message.content === "string" ? message.content : JSON.stringify(message
       }
       const toolUses = this.extractToolUses(apiResponse.content);
       const toolCalls = this.convertToolCalls(toolUses);
-      if (process.env.DEBUG === "true") {
-        if (toolUses.length > 0) {
-          console.log(
-            "Connection - Extracted Tool Uses:",
-            JSON.stringify(toolUses, null, 2)
-          );
-          console.log(
-            "Connection - Converted Tool Calls:",
-            JSON.stringify(toolCalls, null, 2)
-          );
-        }
-      }
+      debugLog(
+        `[AnthropicLLMConnection] - Extracted ${toolUses.length} tool uses in content and converted ${toolCalls?.length || 0} tool calls`
+      );
       const llmResponse = new LLMResponse({
         role: "assistant",
         content,
         tool_calls: toolCalls?.length ? toolCalls : void 0,
         raw_response: apiResponse
       });
-      if (process.env.DEBUG === "true") {
-        console.log(
-          "Connection - Final LLMResponse object:",
-          JSON.stringify(
-            {
-              role: llmResponse.role,
-              content: llmResponse.content?.substring(0, 50) + (llmResponse.content && llmResponse.content.length > 50 ? "..." : ""),
-              tool_calls: llmResponse.tool_calls ? `[${llmResponse.tool_calls.length} calls]` : "undefined"
-            },
-            null,
-            2
-          )
-        );
-      }
+      const logObject = {
+        role: llmResponse.role,
+        content: llmResponse.content?.substring(0, 50) + (llmResponse.content && llmResponse.content.length > 50 ? "..." : ""),
+        tool_calls: llmResponse.tool_calls ? `[${llmResponse.tool_calls.length} calls]` : "undefined"
+      };
+      debugLog(
+        "[AnthropicLLMConnection] Final LLMResponse object:",
+        JSON.stringify(logObject, null, 2)
+      );
       return llmResponse;
     } catch (error) {
-      if (process.env.DEBUG === "true") {
-        console.error("Error sending message to Anthropic:", error);
-      }
+      debugLog(
+        "[AnthropicLLMConnection] Error sending message to Anthropic:",
+        error
+      );
       throw error;
     }
   }
@@ -3834,6 +4034,18 @@ ${typeof message.content === "string" ? message.content : JSON.stringify(message
 
 // src/models/anthropic-llm.ts
 var AnthropicLLM = class extends BaseLLM {
+  /**
+   * Anthropic API key
+   */
+  apiKey;
+  /**
+   * Anthropic API base URL
+   */
+  baseURL;
+  /**
+   * Default parameters for requests
+   */
+  defaultParams;
   /**
    * Constructor for AnthropicLLM
    */
@@ -3966,13 +4178,13 @@ ${typeof message.content === "string" ? message.content : JSON.stringify(message
     if (!content?.length) return [];
     const toolUses = [];
     for (const block of content) {
-      if (process.env.DEBUG === "true") {
-        console.log("Processing content block of type:", block.type);
-      }
+      debugLog(
+        `[AnthropicLLM] Processing content block of type: ${block.type}`
+      );
       if (block.type === "tool_use") {
-        if (process.env.DEBUG === "true") {
-          console.log("Found tool_use block:", JSON.stringify(block, null, 2));
-        }
+        debugLog(
+          `[AnthropicLLM] Found tool_use block: ${JSON.stringify(block, null, 2)}`
+        );
         toolUses.push({
           id: block.id || "unknown-id",
           name: block.name || "unknown-name",
@@ -3980,12 +4192,10 @@ ${typeof message.content === "string" ? message.content : JSON.stringify(message
         });
       }
     }
-    if (process.env.DEBUG === "true") {
-      console.log(`Found ${toolUses.length} tool uses in content`);
-      if (toolUses.length > 0) {
-        console.log("Extracted tool uses:", JSON.stringify(toolUses, null, 2));
-      }
-    }
+    debugLog(
+      `[AnthropicLLM] Found ${toolUses.length} tool uses in content`,
+      toolUses
+    );
     return toolUses;
   }
   /**
@@ -4007,16 +4217,14 @@ ${typeof message.content === "string" ? message.content : JSON.stringify(message
         },
         responseType: stream ? "stream" : "json"
       });
-      if (process.env.DEBUG === "true") {
-        console.log("Anthropic API Response Status:", response.status);
-        if (!stream) {
-          console.log("Response Data Structure:", Object.keys(response.data));
-          console.log(
-            "Response Content Structure:",
-            response.data.content.map((block) => ({ type: block.type }))
-          );
-        }
-      }
+      debugLog(
+        `[AnthropicLLM] API Response done with ${response.status}:`,
+        response.data
+      );
+      debugLog(
+        "[AnthropicLLM] API Response content:",
+        response.data.content.map((block) => ({ type: block.type }))
+      );
       return response.data;
     } catch (error) {
       console.error("Error calling Anthropic API:", error);
@@ -4042,24 +4250,17 @@ ${typeof message.content === "string" ? message.content : JSON.stringify(message
         top_p: llmRequest.config.top_p ?? this.defaultParams.top_p,
         tools: tools?.length ? tools : void 0
       };
-      if (process.env.DEBUG === "true") {
-        console.log("Anthropic API Request:", {
-          model: params.model,
-          messageCount: params.messages.length,
-          systemMessage: params.system ? "present" : "none",
-          tools: params.tools ? params.tools.map((t) => t.name) : "none"
-        });
-      }
+      debugLog("[AnthropicLLM] API Request:", {
+        model: params.model,
+        messageCount: params.messages.length,
+        systemMessage: params.system ? "present" : "none",
+        tools: params.tools ? params.tools.map((t) => t.name) : "none"
+      });
       if (stream) {
         throw new Error("Streaming is not supported in this implementation");
       }
       const response = await this.callAnthropicAPI(params);
-      if (process.env.DEBUG === "true") {
-        console.log(
-          "Full Response Content:",
-          JSON.stringify(response.content, null, 2)
-        );
-      }
+      debugLog("[AnthropicLLM] Full Response Content:", response.content);
       let content = "";
       for (const block of response.content) {
         if (block.type === "text") {
@@ -4068,43 +4269,26 @@ ${typeof message.content === "string" ? message.content : JSON.stringify(message
       }
       const toolUses = this.extractToolUses(response.content);
       const toolCalls = this.convertToolUses(toolUses);
-      if (process.env.DEBUG === "true") {
-        if (toolUses.length > 0) {
-          console.log(
-            "Extracted Tool Uses:",
-            JSON.stringify(toolUses, null, 2)
-          );
-          console.log(
-            "Converted Tool Calls:",
-            JSON.stringify(toolCalls, null, 2)
-          );
-        }
-      }
+      debugLog("[AnthropicLLM] Extracted Tool Uses:", toolUses);
+      debugLog("[AnthropicLLM] Converted Tool Calls:", toolCalls);
       const llmResponse = new LLMResponse({
         role: "assistant",
         content,
         tool_calls: toolCalls.length > 0 ? toolCalls : void 0,
         raw_response: response
       });
-      if (process.env.DEBUG === "true") {
-        console.log(
-          "Final LLMResponse object:",
-          JSON.stringify(
-            {
-              role: llmResponse.role,
-              content: llmResponse.content?.substring(0, 50) + (llmResponse.content && llmResponse.content.length > 50 ? "..." : ""),
-              tool_calls: llmResponse.tool_calls ? `[${llmResponse.tool_calls.length} calls]` : "undefined"
-            },
-            null,
-            2
-          )
-        );
-      }
+      const logObject = {
+        role: llmResponse.role,
+        content: llmResponse.content?.substring(0, 50) + (llmResponse.content && llmResponse.content.length > 50 ? "..." : ""),
+        tool_calls: llmResponse.tool_calls ? `[${llmResponse.tool_calls.length} calls]` : "undefined"
+      };
+      debugLog(
+        "[AnthropicLLM] Final LLMResponse object:",
+        JSON.stringify(logObject, null, 2)
+      );
       yield llmResponse;
     } catch (error) {
-      if (process.env.DEBUG === "true") {
-        console.error("Error calling Anthropic:", error);
-      }
+      debugLog("[AnthropicLLM] Error:", error);
       throw error;
     }
   }
@@ -4134,6 +4318,14 @@ import {
   GoogleGenAI
 } from "@google/genai";
 var GoogleLLM = class extends BaseLLM {
+  /**
+   * Generative model instance
+   */
+  ai;
+  /**
+   * Default parameters for requests
+   */
+  defaultParams;
   /**
    * Constructor for GoogleLLM
    */
@@ -4491,19 +4683,48 @@ var GoogleLLM = class extends BaseLLM {
 };
 
 // src/models/openai-llm.ts
+init_debug();
 import OpenAI from "openai";
 
 // src/models/openai-llm-connection.ts
 var OpenAILLMConnection = class extends BaseLLMConnection {
+  /**
+   * OpenAI client
+   */
+  client;
+  /**
+   * The model name
+   */
+  model;
+  /**
+   * The initial request
+   */
+  initialRequest;
+  /**
+   * Default parameters
+   */
+  defaultParams;
+  /**
+   * Response callback
+   */
+  responseCallback;
+  /**
+   * Error callback
+   */
+  errorCallback;
+  /**
+   * End callback
+   */
+  endCallback;
+  /**
+   * Ongoing chat history
+   */
+  messages = [];
   /**
    * Constructor for OpenAILLMConnection
    */
   constructor(client, model, initialRequest, defaultParams) {
     super();
-    /**
-     * Ongoing chat history
-     */
-    this.messages = [];
     this.client = client;
     this.model = model;
     this.initialRequest = initialRequest;
@@ -4714,6 +4935,14 @@ var OpenAILLMConnection = class extends BaseLLMConnection {
 
 // src/models/openai-llm.ts
 var OpenAILLM = class extends BaseLLM {
+  /**
+   * OpenAI client instance
+   */
+  client;
+  /**
+   * Default parameters for requests
+   */
+  defaultParams;
   /**
    * Constructor for OpenAILLM
    */
@@ -4863,11 +5092,9 @@ var OpenAILLM = class extends BaseLLM {
    * Convert OpenAI streaming chunk to LLMResponse
    */
   convertChunk(chunk) {
-    if (process.env.DEBUG === "true") {
-      console.log(
-        `OpenAI: Converting chunk - delta: ${JSON.stringify(chunk.delta || {})}`
-      );
-    }
+    debugLog(
+      `[OpenAILLM]: Converting chunk - delta: ${JSON.stringify(chunk.delta || {})}`
+    );
     const content = chunk.delta?.content;
     const result = new LLMResponse({
       content: content !== void 0 ? content : null,
@@ -4908,32 +5135,24 @@ var OpenAILLM = class extends BaseLLM {
       presence_penalty: llmRequest.config.presence_penalty ?? this.defaultParams.presence_penalty,
       stream: shouldStream
     };
-    if (process.env.DEBUG === "true") {
-      console.log(
-        `OpenAI: Streaming mode ${shouldStream ? "enabled" : "disabled"}`
-      );
-    }
+    debugLog(
+      `[OpenAILLM] Request parameters - model: ${params.model}, messages: ${params.messages.length}, functions: ${params.tools ? params.tools.length : 0}, streaming: ${shouldStream}`
+    );
     if (tools && tools.length > 0) {
       params.tools = tools;
     }
     try {
       if (shouldStream) {
-        if (process.env.DEBUG === "true") {
-          console.log("OpenAI: Starting streaming request");
-        }
+        debugLog("[OpenAILLM] Starting streaming request");
         const streamResponse = await this.client.chat.completions.create(params);
         let partialFunctionCall;
         const partialToolCalls = /* @__PURE__ */ new Map();
         let accumulatedContent = "";
         const asyncIterable = streamResponse;
-        if (process.env.DEBUG === "true") {
-          console.log("OpenAI: Stream response received, processing chunks");
-        }
+        debugLog("[OpenAILLM] Stream response received, processing chunks");
         for await (const chunk of asyncIterable) {
           if (!chunk.choices || chunk.choices.length === 0) {
-            if (process.env.DEBUG === "true") {
-              console.log("OpenAI: Empty chunk received, skipping");
-            }
+            debugLog("[OpenAILLM] Empty chunk received, skipping");
             continue;
           }
           const choice = chunk.choices[0];
@@ -4941,14 +5160,12 @@ var OpenAILLM = class extends BaseLLM {
           if (responseChunk.content !== null) {
             accumulatedContent += responseChunk.content;
           }
-          if (process.env.DEBUG === "true") {
-            console.log(
-              `OpenAI: Chunk received - delta: "${choice.delta?.content || ""}"`,
-              `responseChunk content: "${responseChunk.content || ""}"`,
-              `is_partial: ${responseChunk.is_partial}`,
-              `accumulated: "${accumulatedContent.substring(0, 30)}${accumulatedContent.length > 30 ? "..." : ""}"`
-            );
-          }
+          debugLog(
+            `[OpenAILLM] Chunk received - delta: "${choice.delta?.content || ""}"`,
+            `responseChunk content: "${responseChunk.content || ""}"`,
+            `is_partial: ${responseChunk.is_partial}`,
+            `accumulated: "${accumulatedContent.substring(0, 30)}${accumulatedContent.length > 30 ? "..." : ""}"`
+          );
           if (responseChunk.function_call) {
             if (!partialFunctionCall) {
               partialFunctionCall = {
@@ -4973,37 +5190,27 @@ var OpenAILLM = class extends BaseLLM {
             }
             responseChunk.tool_calls = Array.from(partialToolCalls.values());
           }
-          if (process.env.DEBUG === "true") {
-            console.log("OpenAI: Yielding chunk to caller");
-          }
+          debugLog("[OpenAILLM] Yielding chunk to caller");
           yield responseChunk;
         }
         if (accumulatedContent.length > 0) {
-          if (process.env.DEBUG === "true") {
-            console.log(
-              `OpenAI: Yielding final accumulated content: "${accumulatedContent.substring(0, 30)}${accumulatedContent.length > 30 ? "..." : ""}"`
-            );
-          }
+          debugLog(
+            `[OpenAILLM] Yielding final accumulated content: "${accumulatedContent.substring(0, 30)}${accumulatedContent.length > 30 ? "..." : ""}"`
+          );
           yield new LLMResponse({
             content: accumulatedContent,
             role: "assistant",
             is_partial: false
           });
         }
-        if (process.env.DEBUG === "true") {
-          console.log("OpenAI: Finished processing all stream chunks");
-        }
+        debugLog("[OpenAILLM] Finished processing all stream chunks");
       } else {
-        if (process.env.DEBUG === "true") {
-          console.log("OpenAI: Making non-streaming request");
-        }
+        debugLog("[OpenAILLM] Making non-streaming request");
         const response = await this.client.chat.completions.create(params);
         if (!response.choices || response.choices.length === 0) {
           throw new Error("No response from OpenAI");
         }
-        if (process.env.DEBUG === "true") {
-          console.log("OpenAI: Non-streaming response received");
-        }
+        debugLog("[OpenAILLM] Non-streaming response received");
         yield this.convertResponse(response.choices[0]);
       }
     } catch (error) {
@@ -5042,6 +5249,10 @@ var AuthCredentialType = /* @__PURE__ */ ((AuthCredentialType2) => {
   return AuthCredentialType2;
 })(AuthCredentialType || {});
 var AuthCredential = class {
+  /**
+   * Type of credential
+   */
+  type;
   /**
    * Constructor for AuthCredential
    */
@@ -5062,6 +5273,10 @@ var AuthCredential = class {
   }
 };
 var ApiKeyCredential = class extends AuthCredential {
+  /**
+   * The API key
+   */
+  apiKey;
   /**
    * Constructor for ApiKeyCredential
    */
@@ -5087,6 +5302,14 @@ var ApiKeyCredential = class extends AuthCredential {
   }
 };
 var BasicAuthCredential = class extends AuthCredential {
+  /**
+   * The username
+   */
+  username;
+  /**
+   * The password
+   */
+  password;
   /**
    * Constructor for BasicAuthCredential
    */
@@ -5111,6 +5334,10 @@ var BasicAuthCredential = class extends AuthCredential {
   }
 };
 var BearerTokenCredential = class extends AuthCredential {
+  /**
+   * The bearer token
+   */
+  token;
   /**
    * Constructor for BearerTokenCredential
    */
@@ -5134,6 +5361,22 @@ var BearerTokenCredential = class extends AuthCredential {
   }
 };
 var OAuth2Credential = class extends AuthCredential {
+  /**
+   * The access token
+   */
+  accessToken;
+  /**
+   * The refresh token
+   */
+  refreshToken;
+  /**
+   * When the token expires
+   */
+  expiresAt;
+  /**
+   * Function to refresh the token
+   */
+  refreshFunction;
   /**
    * Constructor for OAuth2Credential
    */
@@ -5200,6 +5443,14 @@ var OAuth2Credential = class extends AuthCredential {
 
 // src/auth/auth-config.ts
 var AuthConfig = class {
+  /**
+   * The authentication scheme
+   */
+  authScheme;
+  /**
+   * Additional context properties
+   */
+  context;
   /**
    * Constructor for AuthConfig
    */
@@ -5211,6 +5462,14 @@ var AuthConfig = class {
 
 // src/auth/auth-handler.ts
 var AuthHandler = class {
+  /**
+   * The authentication configuration
+   */
+  authConfig;
+  /**
+   * The authentication credential
+   */
+  credential;
   /**
    * Constructor for AuthHandler
    */
@@ -5252,11 +5511,27 @@ var AuthSchemeType = /* @__PURE__ */ ((AuthSchemeType2) => {
   return AuthSchemeType2;
 })(AuthSchemeType || {});
 var AuthScheme = class {
+  /**
+   * The type of authentication scheme
+   */
+  type;
   constructor(type) {
     this.type = type;
   }
 };
 var ApiKeyScheme = class extends AuthScheme {
+  /**
+   * Where the API key is sent
+   */
+  in;
+  /**
+   * Name of the parameter
+   */
+  name;
+  /**
+   * Description of the API key
+   */
+  description;
   /**
    * Constructor for ApiKeyScheme
    */
@@ -5268,6 +5543,18 @@ var ApiKeyScheme = class extends AuthScheme {
   }
 };
 var HttpScheme = class extends AuthScheme {
+  /**
+   * The HTTP authentication scheme
+   */
+  scheme;
+  /**
+   * Bearer format when scheme is 'bearer'
+   */
+  bearerFormat;
+  /**
+   * Description of the scheme
+   */
+  description;
   /**
    * Constructor for HttpScheme
    */
@@ -5279,6 +5566,14 @@ var HttpScheme = class extends AuthScheme {
   }
 };
 var OAuth2Scheme = class extends AuthScheme {
+  /**
+   * OAuth flows
+   */
+  flows;
+  /**
+   * Description of the scheme
+   */
+  description;
   /**
    * Constructor for OAuth2Scheme
    */
@@ -5289,6 +5584,14 @@ var OAuth2Scheme = class extends AuthScheme {
   }
 };
 var OpenIdConnectScheme = class extends AuthScheme {
+  /**
+   * OpenID Connect URL
+   */
+  openIdConnectUrl;
+  /**
+   * Description of the scheme
+   */
+  description;
   /**
    * Constructor for OpenIdConnectScheme
    */
@@ -5301,6 +5604,8 @@ var OpenIdConnectScheme = class extends AuthScheme {
 
 // src/sessions/state.ts
 var SessionState = class _SessionState {
+  state;
+  dirty;
   constructor() {
     this.state = /* @__PURE__ */ new Map();
     this.dirty = /* @__PURE__ */ new Set();
@@ -5388,6 +5693,10 @@ __export(memory_exports, {
 
 // src/memory/in-memory-memory-service.ts
 var InMemoryMemoryService = class {
+  /**
+   * Map of sessions by ID
+   */
+  sessions;
   /**
    * Constructor for InMemoryMemoryService
    */
@@ -5488,9 +5797,22 @@ var InMemoryMemoryService = class {
 };
 
 // src/memory/persistent-memory-service.ts
+init_debug();
 import fs2 from "fs";
 import path2 from "path";
 var PersistentMemoryService = class {
+  /**
+   * In-memory service used for search operations
+   */
+  inMemoryService;
+  /**
+   * Directory where memory files will be stored
+   */
+  storageDir;
+  /**
+   * File prefix for memory files
+   */
+  filePrefix;
   /**
    * Constructor for PersistentMemoryService
    */
@@ -5579,11 +5901,9 @@ var PersistentMemoryService = class {
           }
         }
       }
-      if (process.env.DEBUG === "true") {
-        console.log(
-          `Loaded ${this.inMemoryService.getAllSessions().length} sessions from persistent storage`
-        );
-      }
+      debugLog(
+        `Loaded ${this.inMemoryService.getAllSessions().length} sessions from persistent storage`
+      );
     } catch (error) {
       console.error("Error loading memory files:", error);
     }
@@ -5647,6 +5967,7 @@ __export(sessions_exports, {
   PgLiteSessionService: () => PgLiteSessionService,
   PostgresSessionService: () => PostgresSessionService,
   SessionState: () => SessionState,
+  SqliteSessionService: () => SqliteSessionService,
   cloneSession: () => cloneSession,
   generateSessionId: () => generateSessionId,
   validateSession: () => validateSession
@@ -5654,6 +5975,10 @@ __export(sessions_exports, {
 
 // src/sessions/in-memory-session-service.ts
 var InMemorySessionService = class {
+  /**
+   * Map of sessions by ID
+   */
+  sessions;
   /**
    * Constructor for InMemorySessionService
    */
@@ -5799,6 +6124,8 @@ var sessionsSchema = pgTable("sessions", {
   // Store serialized SessionState as JSONB
 });
 var PostgresSessionService = class {
+  db;
+  sessionsTable;
   constructor(config) {
     this.db = config.db;
     this.sessionsTable = config.sessionsTable || sessionsSchema;
@@ -5921,22 +6248,25 @@ var PostgresSessionService = class {
 // src/sessions/pglite-session-service.ts
 import { eq as eq2 } from "drizzle-orm";
 import { jsonb as jsonb2, pgTable as pgTable2, timestamp as timestamp2, varchar as varchar2 } from "drizzle-orm/pg-core";
+import { drizzle } from "drizzle-orm/pglite";
 var sessionsSchema2 = pgTable2("sessions", {
   id: varchar2("id", { length: 255 }).primaryKey(),
   userId: varchar2("user_id", { length: 255 }).notNull(),
   messages: jsonb2("messages").default("[]").$type(),
-  // Store Message array as JSONB
   metadata: jsonb2("metadata").default("{}").$type(),
   createdAt: timestamp2("created_at", { withTimezone: true }).defaultNow().notNull(),
   updatedAt: timestamp2("updated_at", { withTimezone: true }).defaultNow().notNull(),
   state: jsonb2("state").default("{}").$type()
-  // Store serialized SessionState as JSONB
 });
 var PgLiteSessionService = class {
+  db;
+  sessionsTable;
+  initialized = false;
   constructor(config) {
-    this.initialized = false;
-    this.db = config.db;
-    this.sessionsTable = config.sessionsTable || sessionsSchema2;
+    this.db = drizzle(config.pglite, {
+      schema: { sessions: sessionsSchema2 }
+    });
+    this.sessionsTable = sessionsSchema2;
     if (!config.skipTableCreation) {
       this.initializeDatabase().catch((error) => {
         console.error("Failed to initialize PgLite database:", error);
@@ -5991,9 +6321,7 @@ var PgLiteSessionService = class {
       metadata,
       createdAt: now,
       updatedAt: now,
-      // Drizzle's defaultNow() on schema handles this, but explicit is fine
       state: sessionState.toObject()
-      // Serialize SessionState
     };
     const results = await this.db.insert(this.sessionsTable).values(newSessionData).returning();
     const result = results[0];
@@ -6008,7 +6336,6 @@ var PgLiteSessionService = class {
       messages: Array.isArray(result.messages) ? result.messages : [],
       metadata: result.metadata || {},
       state: SessionState.fromObject(result.state || {}),
-      // Ensure dates are Date objects if Drizzle returns strings for some drivers/configs
       createdAt: new Date(result.createdAt),
       updatedAt: new Date(result.updatedAt)
     };
@@ -6036,7 +6363,6 @@ var PgLiteSessionService = class {
       userId: session.userId,
       messages: session.messages,
       metadata: session.metadata,
-      // createdAt should typically not be updated after creation
       updatedAt: /* @__PURE__ */ new Date(),
       state: session.state.toObject()
     };
@@ -6063,12 +6389,191 @@ var PgLiteSessionService = class {
     await this.ensureInitialized();
     await this.db.delete(this.sessionsTable).where(eq2(this.sessionsTable.id, sessionId));
   }
+  async appendEvent(session, event) {
+    await this.ensureInitialized();
+    if (event.is_partial) {
+      return event;
+    }
+    if (event.actions?.stateDelta) {
+      for (const [key, value] of Object.entries(event.actions.stateDelta)) {
+        if (key.startsWith("_temp_")) {
+          continue;
+        }
+        session.state?.set(key, value);
+      }
+    }
+    if (!session.events) {
+      session.events = [];
+    }
+    session.events.push(event);
+    session.updatedAt = /* @__PURE__ */ new Date();
+    await this.updateSession(session);
+    return event;
+  }
+};
+
+// src/sessions/sqlite-session-service.ts
+import * as fs3 from "fs";
+import * as path3 from "path";
+import { eq as eq3 } from "drizzle-orm";
+import {
+  drizzle as drizzle2
+} from "drizzle-orm/better-sqlite3";
+import { integer, text } from "drizzle-orm/sqlite-core";
+import { sqliteTable } from "drizzle-orm/sqlite-core";
+var sessionsSchema3 = sqliteTable("sessions", {
+  id: text("id").primaryKey(),
+  userId: text("user_id").notNull(),
+  messages: text("messages", { mode: "json" }).default("[]").$type(),
+  metadata: text("metadata", { mode: "json" }).default("{}").$type(),
+  createdAt: integer("created_at", { mode: "timestamp" }).notNull(),
+  updatedAt: integer("updated_at", { mode: "timestamp" }).notNull(),
+  state: text("state", { mode: "json" }).default("{}").$type()
+});
+var SqliteSessionService = class {
+  db;
+  sessionsTable;
+  initialized = false;
+  sqliteInstance;
+  constructor(config) {
+    this.sqliteInstance = config.sqlite;
+    const dbPath = this.sqliteInstance.name;
+    if (dbPath && dbPath !== ":memory:") {
+      const dbDir = path3.dirname(dbPath);
+      if (!fs3.existsSync(dbDir)) {
+        fs3.mkdirSync(dbDir, { recursive: true });
+      }
+    }
+    this.db = drizzle2(config.sqlite, {
+      schema: { sessions: sessionsSchema3 }
+    });
+    this.sessionsTable = sessionsSchema3;
+    if (!config.skipTableCreation) {
+      this.initializeDatabase().catch((error) => {
+        console.error("Failed to initialize SQLite database:", error);
+      });
+    }
+  }
   /**
-   * Appends an event to a session object
-   * @param session The session to append the event to
-   * @param event The event to append
-   * @returns The appended event
+   * Initialize the database by creating required tables if they don't exist
+   */
+  async initializeDatabase() {
+    if (this.initialized) {
+      return;
+    }
+    try {
+      this.sqliteInstance.pragma("journal_mode = WAL");
+      this.sqliteInstance.exec(`
+				CREATE TABLE IF NOT EXISTS sessions (
+					id TEXT PRIMARY KEY,
+					user_id TEXT NOT NULL,
+					messages TEXT DEFAULT '[]',
+					metadata TEXT DEFAULT '{}',
+					created_at INTEGER NOT NULL,
+					updated_at INTEGER NOT NULL,
+					state TEXT DEFAULT '{}'
+				);
+			`);
+      this.sqliteInstance.exec(`
+				CREATE INDEX IF NOT EXISTS idx_sessions_user_id ON sessions(user_id);
+			`);
+      this.initialized = true;
+    } catch (error) {
+      console.error("Error initializing SQLite database:", error);
+      throw error;
+    }
+  }
+  /**
+   * Ensure database is initialized before any operation
    */
+  async ensureInitialized() {
+    if (!this.initialized) {
+      await this.initializeDatabase();
+    }
+  }
+  generateSessionId() {
+    return `session-${Date.now()}-${Math.random().toString(36).substring(2, 9)}`;
+  }
+  async createSession(userId, metadata = {}) {
+    await this.ensureInitialized();
+    const sessionId = this.generateSessionId();
+    const now = /* @__PURE__ */ new Date();
+    const sessionState = new SessionState();
+    const newSessionData = {
+      id: sessionId,
+      userId,
+      messages: [],
+      metadata,
+      createdAt: now,
+      updatedAt: now,
+      state: sessionState.toObject()
+    };
+    const results = await this.db.insert(this.sessionsTable).values(newSessionData).returning();
+    const result = results[0];
+    if (!result) {
+      throw new Error(
+        "Failed to create session, no data returned from insert."
+      );
+    }
+    return {
+      id: result.id,
+      userId: result.userId,
+      messages: Array.isArray(result.messages) ? result.messages : [],
+      metadata: result.metadata || {},
+      state: SessionState.fromObject(result.state || {}),
+      createdAt: result.createdAt,
+      updatedAt: result.updatedAt
+    };
+  }
+  async getSession(sessionId) {
+    await this.ensureInitialized();
+    const results = await this.db.select().from(this.sessionsTable).where(eq3(this.sessionsTable.id, sessionId)).limit(1);
+    const sessionData = results[0];
+    if (!sessionData) {
+      return void 0;
+    }
+    return {
+      id: sessionData.id,
+      userId: sessionData.userId,
+      messages: Array.isArray(sessionData.messages) ? sessionData.messages : [],
+      metadata: sessionData.metadata || {},
+      state: SessionState.fromObject(sessionData.state || {}),
+      createdAt: sessionData.createdAt,
+      updatedAt: sessionData.updatedAt
+    };
+  }
+  async updateSession(session) {
+    await this.ensureInitialized();
+    const updateData = {
+      userId: session.userId,
+      messages: session.messages,
+      metadata: session.metadata,
+      updatedAt: /* @__PURE__ */ new Date(),
+      state: session.state.toObject()
+    };
+    await this.db.update(this.sessionsTable).set(updateData).where(eq3(this.sessionsTable.id, session.id));
+  }
+  async listSessions(userId, options) {
+    await this.ensureInitialized();
+    let query = this.db.select().from(this.sessionsTable).where(eq3(this.sessionsTable.userId, userId));
+    if (options?.limit !== void 0 && options.limit > 0) {
+      query = query.limit(options.limit);
+    }
+    const results = await query;
+    return results.map((sessionData) => ({
+      id: sessionData.id,
+      userId: sessionData.userId,
+      messages: Array.isArray(sessionData.messages) ? sessionData.messages : [],
+      metadata: sessionData.metadata || {},
+      state: SessionState.fromObject(sessionData.state || {}),
+      createdAt: sessionData.createdAt,
+      updatedAt: sessionData.updatedAt
+    }));
+  }
+  async deleteSession(sessionId) {
+    await this.ensureInitialized();
+    await this.db.delete(this.sessionsTable).where(eq3(this.sessionsTable.id, sessionId));
+  }
   async appendEvent(session, event) {
     await this.ensureInitialized();
     if (event.is_partial) {
@@ -6090,11 +6595,6 @@ var PgLiteSessionService = class {
     await this.updateSession(session);
     return event;
   }
-  // TODO: Consider if table creation/migration logic is needed here or handled externally (e.g., drizzle-kit migrations)
-  // TODO: Implement methods corresponding to Python's append_event, list_events,
-  // get_app_state, update_app_state, get_user_state, update_user_state
-  // if full parity with Python's DatabaseSessionService is desired.
-  // This would require defining corresponding Drizzle schemas for Events, AppState, UserState.
 };
 
 // src/sessions/session-util.ts
@@ -6132,19 +6632,32 @@ import { v4 as uuidv4 } from "uuid";
 
 // src/events/event-actions.ts
 var EventActions = class {
+  /**
+   * If true, it won't call model to summarize function response.
+   * Only used for function_response event.
+   */
+  skipSummarization;
+  /**
+   * Indicates that the event is updating the state with the given delta.
+   */
+  stateDelta = {};
+  /**
+   * Indicates that the event is updating an artifact. key is the filename,
+   * value is the version.
+   */
+  artifactDelta = {};
+  /**
+   * If set, the event transfers to the specified agent.
+   */
+  transferToAgent;
+  /**
+   * The agent is escalating to a higher level agent.
+   */
+  escalate;
   /**
    * Constructor for EventActions
    */
   constructor(options = {}) {
-    /**
-     * Indicates that the event is updating the state with the given delta.
-     */
-    this.stateDelta = {};
-    /**
-     * Indicates that the event is updating an artifact. key is the filename,
-     * value is the version.
-     */
-    this.artifactDelta = {};
     this.skipSummarization = options.skipSummarization;
     this.stateDelta = options.stateDelta || {};
     this.artifactDelta = options.artifactDelta || {};
@@ -6155,6 +6668,40 @@ var EventActions = class {
 
 // src/events/event.ts
 var Event = class _Event extends LLMResponse {
+  /**
+   * The invocation ID of the event.
+   */
+  invocationId = "";
+  /**
+   * 'user' or the name of the agent, indicating who appended the event to the session.
+   */
+  author;
+  /**
+   * The actions taken by the agent.
+   */
+  actions = new EventActions();
+  /**
+   * Set of ids of the long running function calls.
+   * Agent client will know from this field about which function call is long running.
+   * Only valid for function call event.
+   */
+  longRunningToolIds;
+  /**
+   * The branch of the event.
+   * The format is like agent_1.agent_2.agent_3, where agent_1 is the parent of
+   * agent_2, and agent_2 is the parent of agent_3.
+   * Branch is used when multiple sub-agent shouldn't see their peer agents'
+   * conversation history.
+   */
+  branch;
+  /**
+   * The unique identifier of the event.
+   */
+  id = "";
+  /**
+   * The timestamp of the event.
+   */
+  timestamp;
   /**
    * Constructor for Event
    */
@@ -6181,18 +6728,6 @@ var Event = class _Event extends LLMResponse {
       is_partial: partial,
       raw_response
     });
-    /**
-     * The invocation ID of the event.
-     */
-    this.invocationId = "";
-    /**
-     * The actions taken by the agent.
-     */
-    this.actions = new EventActions();
-    /**
-     * The unique identifier of the event.
-     */
-    this.id = "";
     this.invocationId = invocationId;
     this.author = author;
     this.actions = actions;
@@ -6230,6 +6765,22 @@ var Event = class _Event extends LLMResponse {
 
 // src/runners.ts
 var Runner = class {
+  /**
+   * The app name of the runner.
+   */
+  appName;
+  /**
+   * The root agent to run.
+   */
+  agent;
+  /**
+   * The session service for the runner.
+   */
+  sessionService;
+  /**
+   * The memory service for the runner.
+   */
+  memoryService;
   /**
    * Initializes the Runner.
    */
@@ -6413,6 +6964,7 @@ export {
   SequentialAgent,
   SessionState,
   sessions_exports as Sessions,
+  SqliteSessionService,
   StreamingMode,
   ToolContext,
   tools_exports as Tools,