@dexto/core 1.2.4 → 1.2.6

package/dist/mcp/mcp-client.js

@@ -5,15 +5,17 @@ import { SSEClientTransport } from "@modelcontextprotocol/sdk/client/sse.js";
 import { StreamableHTTPClientTransport } from "@modelcontextprotocol/sdk/client/streamableHttp.js";
 import { EventEmitter } from "events";
 import { z } from "zod";
-import { logger } from "../logger/index.js";
+import { DextoLogComponent } from "../logger/v2/types.js";
 import { ApprovalStatus } from "../approval/types.js";
-import { resolveBundledScript } from "../utils/path.js";
 import { MCPError } from "./errors.js";
 import {
   ResourceUpdatedNotificationSchema,
   PromptListChangedNotificationSchema,
   ToolListChangedNotificationSchema
 } from "@modelcontextprotocol/sdk/types.js";
+import { trace, context, SpanStatusCode, SpanKind } from "@opentelemetry/api";
+import { hasActiveTelemetry, addBaggageAttributesToSpan } from "../telemetry/utils.js";
+import { safeStringify } from "../utils/safe-stringify.js";
 class MCPClient extends EventEmitter {
   client = null;
   transport = null;
@@ -29,6 +31,11 @@ class MCPClient extends EventEmitter {
   // Default timeout value
   approvalManager = null;
   // Will be set by MCPManager
+  logger;
+  constructor(logger) {
+    super();
+    this.logger = logger.createChild(DextoLogComponent.MCP);
+  }
   async connect(config, serverName) {
     this.timeout = config.timeout ?? 3e4;
     if (config.type === "stdio") {
@@ -62,30 +69,17 @@ class MCPClient extends EventEmitter {
     this.resolvedArgs = [...this.originalArgs];
     this.serverEnv = env || null;
     this.serverAlias = serverAlias || null;
-    if (command === "node" && this.resolvedArgs && this.resolvedArgs.length > 0 && this.resolvedArgs[0]?.startsWith("dist/")) {
-      try {
-        const scriptRelativePath = this.resolvedArgs[0];
-        this.resolvedArgs[0] = resolveBundledScript(scriptRelativePath);
-        logger.debug(
-          `Resolved bundled script path: ${scriptRelativePath} -> ${this.resolvedArgs[0]}`
-        );
-      } catch (e) {
-        logger.warn(
-          `Failed to resolve path for bundled script ${this.resolvedArgs[0]}: ${JSON.stringify(e, null, 2)}`
-        );
-      }
-    }
-    logger.info("=======================================");
-    logger.info(`MCP SERVER: ${command} ${this.resolvedArgs.join(" ")}`, null, "magenta");
+    this.logger.info("=======================================");
+    this.logger.info(`MCP SERVER: ${command} ${this.resolvedArgs.join(" ")}`);
     if (env) {
-      logger.info("Environment:");
+      this.logger.info("Environment:");
       Object.entries(env).forEach(([key, _]) => {
-        logger.info(`  ${key}= [value hidden]`);
+        this.logger.info(`  ${key}= [value hidden]`);
       });
     }
-    logger.info("=======================================\n");
+    this.logger.info("=======================================\n");
     const serverName = this.serverAlias ? `"${this.serverAlias}" (${command} ${this.resolvedArgs.join(" ")})` : `${command} ${this.resolvedArgs.join(" ")}`;
-    logger.info(`Connecting to MCP server: ${serverName}`);
+    this.logger.info(`Connecting to MCP server: ${serverName}`);
     const expandedEnv = {
       ...process.env,
       ...env || {}
@@ -109,24 +103,24 @@ class MCPClient extends EventEmitter {
       }
     );
     try {
-      logger.info("Establishing connection...");
+      this.logger.info("Establishing connection...");
       await this.client.connect(this.transport);
       this.serverSpawned = true;
-      logger.info(`\u2705 Stdio SERVER ${serverName} SPAWNED`);
-      logger.info("Connection established!\n\n");
+      this.logger.info(`\u2705 Stdio SERVER ${serverName} SPAWNED`);
+      this.logger.info("Connection established!\n\n");
       this.isConnected = true;
       this.setupNotificationHandlers();
       this.setupElicitationHandler();
       return this.client;
     } catch (error) {
-      logger.error(
+      this.logger.error(
         `Failed to connect to MCP server ${serverName}: ${JSON.stringify(error.message, null, 2)}`
       );
       throw error;
     }
   }
   async connectViaSSE(url, headers = {}, serverName) {
-    logger.debug(`Connecting to SSE MCP server at url: ${url}`);
+    this.logger.debug(`Connecting to SSE MCP server at url: ${url}`);
     this.transport = new SSEClientTransport(new URL(url), {
       // For regular HTTP requests
       requestInit: {
@@ -134,7 +128,7 @@ class MCPClient extends EventEmitter {
       }
       // Need to implement eventSourceInit for SSE events.
     });
-    logger.debug("[connectViaSSE] SSE transport initialized");
+    this.logger.debug("[connectViaSSE] SSE transport initialized");
     this.client = new Client(
       {
         name: "Dexto-sse-mcp-client",
@@ -149,17 +143,17 @@ class MCPClient extends EventEmitter {
       }
     );
     try {
-      logger.info("Establishing connection...");
+      this.logger.info("Establishing connection...");
       await this.client.connect(this.transport);
       this.serverSpawned = true;
-      logger.info(`\u2705 ${serverName} SSE SERVER SPAWNED`);
-      logger.info("Connection established!\n\n");
+      this.logger.info(`\u2705 ${serverName} SSE SERVER SPAWNED`);
+      this.logger.info("Connection established!\n\n");
       this.isConnected = true;
       this.setupNotificationHandlers();
       this.setupElicitationHandler();
       return this.client;
     } catch (error) {
-      logger.error(
+      this.logger.error(
         `Failed to connect to SSE MCP server ${url}: ${JSON.stringify(error.message, null, 2)}`
       );
       throw error;
@@ -169,9 +163,13 @@ class MCPClient extends EventEmitter {
    * Connect to an MCP server via Streamable HTTP transport
    */
   async connectViaHttp(url, headers = {}, serverAlias) {
-    logger.info(`Connecting to HTTP MCP server at ${url}`);
+    this.logger.info(`Connecting to HTTP MCP server at ${url}`);
+    const defaultHeaders = {
+      Accept: "application/json, text/event-stream"
+    };
+    const mergedHeaders = { ...defaultHeaders, ...headers };
     this.transport = new StreamableHTTPClientTransport(new URL(url), {
-      requestInit: { headers: headers || {} }
+      requestInit: { headers: mergedHeaders }
     });
     this.client = new Client(
       { name: "Dexto-http-mcp-client", version: "1.0.0" },
@@ -184,15 +182,15 @@ class MCPClient extends EventEmitter {
       }
     );
     try {
-      logger.info("Establishing HTTP connection...");
+      this.logger.info("Establishing HTTP connection...");
       await this.client.connect(this.transport);
       this.isConnected = true;
-      logger.info(`\u2705 HTTP SERVER ${serverAlias ?? url} CONNECTED`);
+      this.logger.info(`\u2705 HTTP SERVER ${serverAlias ?? url} CONNECTED`);
       this.setupNotificationHandlers();
       this.setupElicitationHandler();
       return this.client;
     } catch (error) {
-      logger.error(
+      this.logger.error(
         `Failed to connect to HTTP MCP server ${url}: ${JSON.stringify(error.message, null, 2)}`
       );
       throw error;
@@ -207,9 +205,9 @@ class MCPClient extends EventEmitter {
         await this.transport.close();
         this.isConnected = false;
         this.serverSpawned = false;
-        logger.info("Disconnected from MCP server");
+        this.logger.info("Disconnected from MCP server");
       } catch (error) {
-        logger.error(
+        this.logger.error(
           `Error disconnecting from MCP server: ${JSON.stringify(error.message, null, 2)}`
         );
       }
@@ -223,8 +221,21 @@ class MCPClient extends EventEmitter {
    */
   async callTool(name, args) {
     this.ensureConnected();
+    const shouldTrace = hasActiveTelemetry();
+    const tracer = shouldTrace ? trace.getTracer("dexto") : null;
+    const span = tracer?.startSpan(`mcp.tool.${name}`, {
+      kind: SpanKind.CLIENT
+    });
     try {
-      logger.debug(`Calling tool '${name}' with args: ${JSON.stringify(args, null, 2)}`);
+      if (span) {
+        const ctx = trace.setSpan(context.active(), span);
+        addBaggageAttributesToSpan(span, ctx, this.logger);
+        span.setAttribute("tool.name", name);
+        span.setAttribute("tool.server", this.serverAlias || "unknown");
+        span.setAttribute("tool.timeout", this.timeout);
+        span.setAttribute("tool.arguments", safeStringify(args, 4096));
+      }
+      this.logger.debug(`Calling tool '${name}' with args: ${JSON.stringify(args, null, 2)}`);
       let toolArgs = args;
       if (typeof args === "string") {
         try {
@@ -233,7 +244,7 @@ class MCPClient extends EventEmitter {
           toolArgs = { input: args };
         }
       }
-      logger.debug(`Using timeout: ${this.timeout}`);
+      this.logger.debug(`Using timeout: ${this.timeout}`);
       const result = await this.client.callTool(
         { name, arguments: toolArgs },
         void 0,
@@ -251,14 +262,27 @@ class MCPClient extends EventEmitter {
         },
         2
       );
-      logger.debug(`Tool '${name}' result: ${logResult}`);
+      this.logger.debug(`Tool '${name}' result: ${logResult}`);
+      if (span) {
+        span.setAttribute("tool.result", safeStringify(result, 4096));
+        span.setStatus({ code: SpanStatusCode.OK });
+      }
       if (result === null || result === void 0) {
         return "Tool executed successfully with no result data.";
       }
       return result;
     } catch (error) {
-      logger.error(`Tool call '${name}' failed: ${JSON.stringify(error, null, 2)}`);
+      this.logger.error(`Tool call '${name}' failed: ${JSON.stringify(error, null, 2)}`);
+      if (span) {
+        span.recordException(error);
+        span.setStatus({
+          code: SpanStatusCode.ERROR,
+          message: error instanceof Error ? error.message : String(error)
+        });
+      }
       return `Error executing tool '${name}': ${error instanceof Error ? error.message : String(error)}`;
+    } finally {
+      span?.end();
     }
   }
   /**
@@ -270,11 +294,11 @@ class MCPClient extends EventEmitter {
     const tools = {};
     try {
       const listToolResult = await this.client.listTools({});
-      logger.silly(`listTools result: ${JSON.stringify(listToolResult, null, 2)}`);
+      this.logger.silly(`listTools result: ${JSON.stringify(listToolResult, null, 2)}`);
       if (listToolResult && listToolResult.tools) {
         listToolResult.tools.forEach((tool) => {
           if (!tool.description) {
-            logger.warn(`Tool '${tool.name}' is missing a description`);
+            this.logger.warn(`Tool '${tool.name}' is missing a description`);
           }
           if (!tool.inputSchema) {
             throw MCPError.invalidToolSchema(tool.name, "missing input schema");
@@ -290,7 +314,7 @@ class MCPClient extends EventEmitter {
         );
       }
     } catch (error) {
-      logger.warn(
+      this.logger.warn(
         `Failed to get tools from MCP server, proceeding with zero tools: ${JSON.stringify(error, null, 2)}`
       );
       return tools;
@@ -305,10 +329,10 @@ class MCPClient extends EventEmitter {
     this.ensureConnected();
     try {
       const response = await this.client.listPrompts();
-      logger.debug(`listPrompts response: ${JSON.stringify(response, null, 2)}`);
+      this.logger.debug(`listPrompts response: ${JSON.stringify(response, null, 2)}`);
       return response.prompts;
     } catch (error) {
-      logger.debug(
+      this.logger.debug(
         `Failed to list prompts from MCP server (optional feature), skipping: ${JSON.stringify(error, null, 2)}`
       );
       return [];
@@ -324,15 +348,17 @@ class MCPClient extends EventEmitter {
   async getPrompt(name, args) {
     this.ensureConnected();
     try {
-      logger.debug(`Getting prompt '${name}' with args: ${JSON.stringify(args, null, 2)}`);
+      this.logger.debug(
+        `Getting prompt '${name}' with args: ${JSON.stringify(args, null, 2)}`
+      );
       const response = await this.client.getPrompt(
         { name, arguments: args },
         { timeout: this.timeout }
       );
-      logger.debug(`getPrompt '${name}' response: ${JSON.stringify(response, null, 2)}`);
+      this.logger.debug(`getPrompt '${name}' response: ${JSON.stringify(response, null, 2)}`);
       return response;
     } catch (error) {
-      logger.debug(
+      this.logger.debug(
         `Failed to get prompt '${name}' from MCP server: ${JSON.stringify(error, null, 2)}`
       );
       throw MCPError.protocolError(
@@ -349,7 +375,7 @@ class MCPClient extends EventEmitter {
     this.ensureConnected();
     try {
       const response = await this.client.listResources();
-      logger.debug(`listResources response: ${JSON.stringify(response, null, 2)}`);
+      this.logger.debug(`listResources response: ${JSON.stringify(response, null, 2)}`);
       return response.resources.map(
         (r) => ({
           uri: r.uri,
@@ -359,7 +385,7 @@ class MCPClient extends EventEmitter {
         })
       );
     } catch (error) {
-      logger.debug(
+      this.logger.debug(
         `Failed to list resources from MCP server (optional feature), skipping: ${JSON.stringify(error, null, 2)}`
       );
       return [];
@@ -373,12 +399,14 @@ class MCPClient extends EventEmitter {
   async readResource(uri) {
     this.ensureConnected();
     try {
-      logger.debug(`Reading resource '${uri}'`);
+      this.logger.debug(`Reading resource '${uri}'`);
       const response = await this.client.readResource({ uri }, { timeout: this.timeout });
-      logger.debug(`readResource '${uri}' response: ${JSON.stringify(response, null, 2)}`);
+      this.logger.debug(
+        `readResource '${uri}' response: ${JSON.stringify(response, null, 2)}`
+      );
       return response;
     } catch (error) {
-      logger.debug(
+      this.logger.debug(
         `Failed to read resource '${uri}' from MCP server: ${JSON.stringify(error, null, 2)}`
       );
       throw MCPError.protocolError(
@@ -442,43 +470,43 @@ class MCPClient extends EventEmitter {
         }
       );
     } catch (error) {
-      logger.warn(`Could not set resources/updated notification handler: ${error}`);
+      this.logger.warn(`Could not set resources/updated notification handler: ${error}`);
     }
     try {
       this.client.setNotificationHandler(PromptListChangedNotificationSchema, () => {
         this.handlePromptsListChanged();
       });
     } catch (error) {
-      logger.warn(`Could not set prompts/list_changed notification handler: ${error}`);
+      this.logger.warn(`Could not set prompts/list_changed notification handler: ${error}`);
     }
     try {
       this.client.setNotificationHandler(ToolListChangedNotificationSchema, () => {
         this.handleToolsListChanged();
       });
     } catch (error) {
-      logger.warn(`Could not set tools/list_changed notification handler: ${error}`);
+      this.logger.warn(`Could not set tools/list_changed notification handler: ${error}`);
     }
-    logger.debug("MCP notification handlers registered (resources, prompts, tools)");
+    this.logger.debug("MCP notification handlers registered (resources, prompts, tools)");
   }
   /**
    * Handle resource updated notification
    */
   handleResourceUpdated(params) {
-    logger.debug(`Resource updated: ${params.uri}`);
+    this.logger.debug(`Resource updated: ${params.uri}`);
     this.emit("resourceUpdated", params);
   }
   /**
    * Handle prompts list changed notification
    */
   handlePromptsListChanged() {
-    logger.debug("Prompts list changed");
+    this.logger.debug("Prompts list changed");
     this.emit("promptsListChanged");
   }
   /**
    * Handle tools list changed notification
    */
   handleToolsListChanged() {
-    logger.debug("Tools list changed");
+    this.logger.debug("Tools list changed");
     this.emit("toolsListChanged");
   }
   /**
@@ -495,11 +523,11 @@ class MCPClient extends EventEmitter {
    */
   setupElicitationHandler() {
     if (!this.client) {
-      logger.warn("Cannot setup elicitation handler: client not initialized");
+      this.logger.warn("Cannot setup elicitation handler: client not initialized");
       return;
     }
     if (!this.approvalManager) {
-      logger.warn("Cannot setup elicitation handler: approval manager not set");
+      this.logger.warn("Cannot setup elicitation handler: approval manager not set");
       return;
     }
     const ElicitationCreateRequestSchema = z.object({
@@ -511,16 +539,16 @@ class MCPClient extends EventEmitter {
     }).passthrough();
     this.client.setRequestHandler(ElicitationCreateRequestSchema, async (request) => {
       const params = request.params;
-      logger.info(
+      this.logger.info(
         `Elicitation request from MCP server '${this.serverAlias}': ${params.message}`
       );
       try {
         if (!this.approvalManager) {
-          logger.error("Approval manager not available for elicitation request");
+          this.logger.error("Approval manager not available for elicitation request");
           return { action: "decline" };
         }
         if (typeof params.requestedSchema !== "object" || params.requestedSchema === null || Array.isArray(params.requestedSchema)) {
-          logger.error(
+          this.logger.error(
             `Invalid elicitation schema from '${this.serverAlias}': expected object, got ${typeof params.requestedSchema}`
           );
           return { action: "decline" };
@@ -532,30 +560,32 @@ class MCPClient extends EventEmitter {
         });
         if (response.status === ApprovalStatus.APPROVED && response.data) {
           const formData = response.data && typeof response.data === "object" && "formData" in response.data ? response.data.formData : {};
-          logger.info(`Elicitation approved for '${this.serverAlias}', returning data`);
+          this.logger.info(
+            `Elicitation approved for '${this.serverAlias}', returning data`
+          );
           return {
             action: "accept",
             content: formData
           };
         } else if (response.status === ApprovalStatus.DENIED) {
-          logger.info(`Elicitation declined for '${this.serverAlias}'`);
+          this.logger.info(`Elicitation declined for '${this.serverAlias}'`);
           return {
             action: "decline"
           };
         } else {
-          logger.info(`Elicitation cancelled for '${this.serverAlias}'`);
+          this.logger.info(`Elicitation cancelled for '${this.serverAlias}'`);
           return {
             action: "cancel"
           };
         }
       } catch (error) {
-        logger.error(`Elicitation error for '${this.serverAlias}': ${error}`);
+        this.logger.error(`Elicitation error for '${this.serverAlias}': ${error}`);
         return {
           action: "decline"
         };
       }
     });
-    logger.debug(`Elicitation handler registered for MCP server '${this.serverAlias}'`);
+    this.logger.debug(`Elicitation handler registered for MCP server '${this.serverAlias}'`);
   }
 }
 export {

package/dist/memory/index.cjs

@@ -20,6 +20,7 @@ var memory_exports = {};
 __export(memory_exports, {
   CreateMemoryInputSchema: () => import_schemas.CreateMemoryInputSchema,
   ListMemoriesOptionsSchema: () => import_schemas.ListMemoriesOptionsSchema,
+  MemoriesConfigSchema: () => import_schemas.MemoriesConfigSchema,
   MemoryError: () => import_errors.MemoryError,
   MemoryErrorCode: () => import_error_codes.MemoryErrorCode,
   MemoryManager: () => import_manager.MemoryManager,
@@ -35,6 +36,7 @@ var import_error_codes = require("./error-codes.js");
 0 && (module.exports = {
   CreateMemoryInputSchema,
   ListMemoriesOptionsSchema,
+  MemoriesConfigSchema,
   MemoryError,
   MemoryErrorCode,
   MemoryManager,

package/dist/memory/index.d.ts

@@ -1,6 +1,6 @@
 export { MemoryManager } from './manager.js';
 export type { Memory, CreateMemoryInput, UpdateMemoryInput, ListMemoriesOptions, MemorySource, } from './types.js';
-export { MemorySchema, CreateMemoryInputSchema, UpdateMemoryInputSchema, ListMemoriesOptionsSchema, type ValidatedMemory, type ValidatedCreateMemoryInput, type ValidatedUpdateMemoryInput, type ValidatedListMemoriesOptions, } from './schemas.js';
+export { MemorySchema, CreateMemoryInputSchema, UpdateMemoryInputSchema, ListMemoriesOptionsSchema, MemoriesConfigSchema, type ValidatedMemory, type ValidatedCreateMemoryInput, type ValidatedUpdateMemoryInput, type ValidatedListMemoriesOptions, type MemoriesConfig, type ValidatedMemoriesConfig, } from './schemas.js';
 export { MemoryError } from './errors.js';
 export { MemoryErrorCode } from './error-codes.js';
 //# sourceMappingURL=index.d.ts.map

package/dist/memory/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/memory/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,cAAc,CAAC;AAC7C,YAAY,EACR,MAAM,EACN,iBAAiB,EACjB,iBAAiB,EACjB,mBAAmB,EACnB,YAAY,GACf,MAAM,YAAY,CAAC;AACpB,OAAO,EACH,YAAY,EACZ,uBAAuB,EACvB,uBAAuB,EACvB,yBAAyB,EACzB,KAAK,eAAe,EACpB,KAAK,0BAA0B,EAC/B,KAAK,0BAA0B,EAC/B,KAAK,4BAA4B,GACpC,MAAM,cAAc,CAAC;AACtB,OAAO,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC;AAC1C,OAAO,EAAE,eAAe,EAAE,MAAM,kBAAkB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/memory/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,cAAc,CAAC;AAC7C,YAAY,EACR,MAAM,EACN,iBAAiB,EACjB,iBAAiB,EACjB,mBAAmB,EACnB,YAAY,GACf,MAAM,YAAY,CAAC;AACpB,OAAO,EACH,YAAY,EACZ,uBAAuB,EACvB,uBAAuB,EACvB,yBAAyB,EACzB,oBAAoB,EACpB,KAAK,eAAe,EACpB,KAAK,0BAA0B,EAC/B,KAAK,0BAA0B,EAC/B,KAAK,4BAA4B,EACjC,KAAK,cAAc,EACnB,KAAK,uBAAuB,GAC/B,MAAM,cAAc,CAAC;AACtB,OAAO,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC;AAC1C,OAAO,EAAE,eAAe,EAAE,MAAM,kBAAkB,CAAC"}

package/dist/memory/index.js

@@ -4,13 +4,15 @@ import {
   MemorySchema,
   CreateMemoryInputSchema,
   UpdateMemoryInputSchema,
-  ListMemoriesOptionsSchema
+  ListMemoriesOptionsSchema,
+  MemoriesConfigSchema
 } from "./schemas.js";
 import { MemoryError } from "./errors.js";
 import { MemoryErrorCode } from "./error-codes.js";
 export {
   CreateMemoryInputSchema,
   ListMemoriesOptionsSchema,
+  MemoriesConfigSchema,
   MemoryError,
   MemoryErrorCode,
   MemoryManager,

package/dist/memory/manager.cjs

@@ -25,14 +25,16 @@ var import_schemas = require("./schemas.js");
 var import_errors = require("./errors.js");
 var import_error_codes = require("./error-codes.js");
 var import_DextoRuntimeError = require("../errors/DextoRuntimeError.js");
-var import_logger = require("../logger/index.js");
+var import_types = require("../logger/v2/types.js");
 var import_nanoid = require("nanoid");
 const MEMORY_KEY_PREFIX = "memory:item:";
 class MemoryManager {
-  constructor(database) {
+  constructor(database, logger) {
     this.database = database;
-    import_logger.logger.debug("MemoryManager initialized");
+    this.logger = logger.createChild(import_types.DextoLogComponent.MEMORY);
+    this.logger.debug("MemoryManager initialized");
   }
+  logger;
   /**
    * Create a new memory
    */
@@ -51,7 +53,7 @@ class MemoryManager {
     const validatedMemory = import_schemas.MemorySchema.parse(memory);
     try {
       await this.database.set(this.toKey(id), validatedMemory);
-      import_logger.logger.info(`Created memory: ${id}`);
+      this.logger.info(`Created memory: ${id}`);
       return validatedMemory;
     } catch (error) {
       throw import_errors.MemoryError.storageError(
@@ -107,7 +109,7 @@ class MemoryManager {
     const validatedMemory = import_schemas.MemorySchema.parse(updated);
     try {
       await this.database.set(this.toKey(id), validatedMemory);
-      import_logger.logger.info(`Updated memory: ${id}`);
+      this.logger.info(`Updated memory: ${id}`);
       return validatedMemory;
     } catch (error) {
       throw import_errors.MemoryError.storageError(
@@ -126,7 +128,7 @@ class MemoryManager {
     await this.get(id);
     try {
       await this.database.delete(this.toKey(id));
-      import_logger.logger.info(`Deleted memory: ${id}`);
+      this.logger.info(`Deleted memory: ${id}`);
     } catch (error) {
       throw import_errors.MemoryError.deleteError(
         `Failed to delete memory: ${error instanceof Error ? error.message : String(error)}`,
@@ -149,7 +151,7 @@ class MemoryManager {
             memories.push(memory);
           }
         } catch (error) {
-          import_logger.logger.warn(
+          this.logger.warn(
             `Failed to retrieve memory from key ${key}: ${error instanceof Error ? error.message : String(error)}`
           );
         }

package/dist/memory/manager.d.ts

@@ -1,5 +1,6 @@
 import type { Database } from '../storage/database/types.js';
 import type { Memory, CreateMemoryInput, UpdateMemoryInput, ListMemoriesOptions } from './types.js';
+import type { IDextoLogger } from '../logger/v2/types.js';
 /**
  * MemoryManager handles CRUD operations for user memories
  *
@@ -19,7 +20,8 @@ import type { Memory, CreateMemoryInput, UpdateMemoryInput, ListMemoriesOptions
  */
 export declare class MemoryManager {
     private database;
-    constructor(database: Database);
+    private logger;
+    constructor(database: Database, logger: IDextoLogger);
     /**
      * Create a new memory
      */

package/dist/memory/manager.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"manager.d.ts","sourceRoot":"","sources":["../../src/memory/manager.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,8BAA8B,CAAC;AAC7D,OAAO,KAAK,EAAE,MAAM,EAAE,iBAAiB,EAAE,iBAAiB,EAAE,mBAAmB,EAAE,MAAM,YAAY,CAAC;AAepG;;;;;;;;;;;;;;;;GAgBG;AACH,qBAAa,aAAa;IACV,OAAO,CAAC,QAAQ;gBAAR,QAAQ,EAAE,QAAQ;IAItC;;OAEG;IACG,MAAM,CAAC,KAAK,EAAE,iBAAiB,GAAG,OAAO,CAAC,MAAM,CAAC;IAiCvD;;OAEG;IACG,GAAG,CAAC,EAAE,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC;IAyBtC;;OAEG;IACG,MAAM,CAAC,EAAE,EAAE,MAAM,EAAE,KAAK,EAAE,iBAAiB,GAAG,OAAO,CAAC,MAAM,CAAC;IA2CnE;;OAEG;IACG,MAAM,CAAC,EAAE,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAmBvC;;OAEG;IACG,IAAI,CAAC,OAAO,GAAE,mBAAwB,GAAG,OAAO,CAAC,MAAM,EAAE,CAAC;IA8DhE;;OAEG;IACG,GAAG,CAAC,EAAE,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC;IAevC;;OAEG;IACG,KAAK,CAAC,OAAO,GAAE,mBAAwB,GAAG,OAAO,CAAC,MAAM,CAAC;IAK/D;;OAEG;IACH,OAAO,CAAC,KAAK;CAGhB"}
+{"version":3,"file":"manager.d.ts","sourceRoot":"","sources":["../../src/memory/manager.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,8BAA8B,CAAC;AAC7D,OAAO,KAAK,EAAE,MAAM,EAAE,iBAAiB,EAAE,iBAAiB,EAAE,mBAAmB,EAAE,MAAM,YAAY,CAAC;AAUpG,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,uBAAuB,CAAC;AAM1D;;;;;;;;;;;;;;;;GAgBG;AACH,qBAAa,aAAa;IAIlB,OAAO,CAAC,QAAQ;IAHpB,OAAO,CAAC,MAAM,CAAe;gBAGjB,QAAQ,EAAE,QAAQ,EAC1B,MAAM,EAAE,YAAY;IAMxB;;OAEG;IACG,MAAM,CAAC,KAAK,EAAE,iBAAiB,GAAG,OAAO,CAAC,MAAM,CAAC;IAiCvD;;OAEG;IACG,GAAG,CAAC,EAAE,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC;IAyBtC;;OAEG;IACG,MAAM,CAAC,EAAE,EAAE,MAAM,EAAE,KAAK,EAAE,iBAAiB,GAAG,OAAO,CAAC,MAAM,CAAC;IA2CnE;;OAEG;IACG,MAAM,CAAC,EAAE,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAmBvC;;OAEG;IACG,IAAI,CAAC,OAAO,GAAE,mBAAwB,GAAG,OAAO,CAAC,MAAM,EAAE,CAAC;IA8DhE;;OAEG;IACG,GAAG,CAAC,EAAE,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC;IAevC;;OAEG;IACG,KAAK,CAAC,OAAO,GAAE,mBAAwB,GAAG,OAAO,CAAC,MAAM,CAAC;IAK/D;;OAEG;IACH,OAAO,CAAC,KAAK;CAGhB"}

package/dist/memory/manager.js

@@ -8,14 +8,16 @@ import {
 import { MemoryError } from "./errors.js";
 import { MemoryErrorCode } from "./error-codes.js";
 import { DextoRuntimeError } from "../errors/DextoRuntimeError.js";
-import { logger } from "../logger/index.js";
+import { DextoLogComponent } from "../logger/v2/types.js";
 import { nanoid } from "nanoid";
 const MEMORY_KEY_PREFIX = "memory:item:";
 class MemoryManager {
-  constructor(database) {
+  constructor(database, logger) {
     this.database = database;
-    logger.debug("MemoryManager initialized");
+    this.logger = logger.createChild(DextoLogComponent.MEMORY);
+    this.logger.debug("MemoryManager initialized");
   }
+  logger;
   /**
    * Create a new memory
    */
@@ -34,7 +36,7 @@ class MemoryManager {
     const validatedMemory = MemorySchema.parse(memory);
     try {
       await this.database.set(this.toKey(id), validatedMemory);
-      logger.info(`Created memory: ${id}`);
+      this.logger.info(`Created memory: ${id}`);
       return validatedMemory;
     } catch (error) {
       throw MemoryError.storageError(
@@ -90,7 +92,7 @@ class MemoryManager {
     const validatedMemory = MemorySchema.parse(updated);
     try {
       await this.database.set(this.toKey(id), validatedMemory);
-      logger.info(`Updated memory: ${id}`);
+      this.logger.info(`Updated memory: ${id}`);
       return validatedMemory;
     } catch (error) {
       throw MemoryError.storageError(
@@ -109,7 +111,7 @@ class MemoryManager {
     await this.get(id);
     try {
       await this.database.delete(this.toKey(id));
-      logger.info(`Deleted memory: ${id}`);
+      this.logger.info(`Deleted memory: ${id}`);
     } catch (error) {
       throw MemoryError.deleteError(
         `Failed to delete memory: ${error instanceof Error ? error.message : String(error)}`,
@@ -132,7 +134,7 @@ class MemoryManager {
             memories.push(memory);
           }
         } catch (error) {
-          logger.warn(
+          this.logger.warn(
             `Failed to retrieve memory from key ${key}: ${error instanceof Error ? error.message : String(error)}`
           );
         }

package/dist/memory/schemas.cjs

@@ -20,6 +20,7 @@ var schemas_exports = {};
 __export(schemas_exports, {
   CreateMemoryInputSchema: () => CreateMemoryInputSchema,
   ListMemoriesOptionsSchema: () => ListMemoriesOptionsSchema,
+  MemoriesConfigSchema: () => MemoriesConfigSchema,
   MemoryMetadataSchema: () => MemoryMetadataSchema,
   MemorySchema: () => MemorySchema,
   MemorySourceSchema: () => MemorySourceSchema,
@@ -71,10 +72,19 @@ const ListMemoriesOptionsSchema = import_zod.z.object({
   limit: import_zod.z.number().int().positive().optional().describe("Limit number of results"),
   offset: import_zod.z.number().int().nonnegative().optional().describe("Skip first N results")
 }).strict().describe("Options for listing memories");
+const MemoriesConfigSchema = import_zod.z.object({
+  enabled: import_zod.z.boolean().default(false).describe("Whether to include memories in system prompt (optional"),
+  priority: import_zod.z.number().int().nonnegative().default(40).describe("Priority in system prompt (lower = earlier)"),
+  includeTimestamps: import_zod.z.boolean().default(false).describe("Whether to include timestamps in memory display"),
+  includeTags: import_zod.z.boolean().default(true).describe("Whether to include tags in memory display"),
+  limit: import_zod.z.number().int().positive().optional().describe("Maximum number of memories to include"),
+  pinnedOnly: import_zod.z.boolean().default(false).describe("Only include pinned memories")
+}).strict().describe("Memory configuration for system prompt inclusion");
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   CreateMemoryInputSchema,
   ListMemoriesOptionsSchema,
+  MemoriesConfigSchema,
   MemoryMetadataSchema,
   MemorySchema,
   MemorySourceSchema,