@dexto/core 1.1.10 → 1.2.0

package/dist/storage/storage-manager.js

@@ -1,142 +1,161 @@
-import { MemoryBackend } from "./backend/memory-backend.js";
+import "../chunk-C6A6W6XS.js";
+import { createCache } from "./cache/factory.js";
+import { createDatabase } from "./database/factory.js";
+import { createBlobStore } from "./blob/factory.js";
+import { StorageError } from "./errors.js";
 import { logger } from "../logger/index.js";
-let SQLiteBackend;
-let RedisBackend;
-let PostgresBackend;
 const HEALTH_CHECK_KEY = "storage_manager_health_check";
 class StorageManager {
   config;
   cache;
   database;
+  blobStore;
+  initialized = false;
   connected = false;
-  constructor(config) {
+  agentId;
+  constructor(config, agentId) {
     this.config = config;
+    this.agentId = agentId;
   }
+  /**
+   * Initialize storage instances without connecting.
+   * This allows configuration and inspection before establishing connections.
+   */
+  async initialize() {
+    if (this.initialized) {
+      return;
+    }
+    this.cache = await createCache(this.config.cache);
+    this.database = await createDatabase(this.config.database, this.agentId);
+    this.blobStore = createBlobStore(this.config.blob, this.agentId);
+    this.initialized = true;
+  }
+  /**
+   * Connect all storage backends.
+   * Must call initialize() first, or use createStorageManager() helper.
+   */
   async connect() {
+    if (!this.initialized) {
+      throw StorageError.managerNotInitialized("connect");
+    }
     if (this.connected) {
-      return {
-        cache: this.cache,
-        database: this.database
-      };
+      return;
+    }
+    const connected = [];
+    try {
+      await this.cache.connect();
+      connected.push("cache");
+      await this.database.connect();
+      connected.push("database");
+      await this.blobStore.connect();
+      connected.push("blob");
+      this.connected = true;
+    } catch (error) {
+      logger.warn(
+        `Storage connection failed, rolling back ${connected.length} connected stores`
+      );
+      for (const store of connected.reverse()) {
+        try {
+          if (store === "cache") await this.cache.disconnect();
+          else if (store === "database") await this.database.disconnect();
+          else if (store === "blob") await this.blobStore.disconnect();
+        } catch (disconnectError) {
+          logger.error(
+            `Failed to rollback ${store} during connection failure: ${disconnectError}`
+          );
+        }
+      }
+      throw error;
     }
-    this.cache = await this.createCacheBackend();
-    await this.cache.connect();
-    this.database = await this.createDatabaseBackend();
-    await this.database.connect();
-    this.connected = true;
-    return {
-      cache: this.cache,
-      database: this.database
-    };
   }
   async disconnect() {
-    if (this.cache) {
-      await this.cache.disconnect();
-      delete this.cache;
-    }
-    if (this.database) {
-      await this.database.disconnect();
-      delete this.database;
-    }
+    if (!this.connected) return;
+    const results = await Promise.allSettled([
+      this.cache.disconnect(),
+      this.database.disconnect(),
+      this.blobStore.disconnect()
+    ]);
+    const errors = [];
+    const storeNames = ["cache", "database", "blob store"];
+    results.forEach((result, index) => {
+      if (result.status === "rejected") {
+        const storeName = storeNames[index];
+        const error = result.reason;
+        logger.error(`Failed to disconnect ${storeName}: ${error}`);
+        errors.push(error instanceof Error ? error : new Error(String(error)));
+      }
+    });
     this.connected = false;
-  }
-  isConnected() {
-    return this.connected && this.cache?.isConnected() === true && this.database?.isConnected() === true;
-  }
-  getBackends() {
-    if (!this.connected) return null;
-    return {
-      cache: this.cache,
-      database: this.database
-    };
-  }
-  async createCacheBackend() {
-    const cacheConfig = this.config.cache;
-    switch (cacheConfig.type) {
-      case "redis":
-        return this.createRedisBackend(cacheConfig);
-      case "in-memory":
-      default:
-        logger.info("Using in-memory cache backend");
-        return new MemoryBackend();
+    if (errors.length > 0) {
+      throw StorageError.connectionFailed(
+        `Failed to disconnect ${errors.length} storage backend(s): ${errors.map((e) => e.message).join(", ")}`
+      );
     }
   }
-  async createDatabaseBackend() {
-    const dbConfig = this.config.database;
-    switch (dbConfig.type) {
-      case "postgres":
-        return this.createPostgresBackend(dbConfig);
-      case "sqlite":
-        return this.createSQLiteBackend(dbConfig);
-      case "in-memory":
-      default:
-        logger.info("Using in-memory database backend");
-        return new MemoryBackend();
-    }
+  isConnected() {
+    return this.connected && this.cache.isConnected() && this.database.isConnected() && this.blobStore.isConnected();
   }
-  async createRedisBackend(config) {
-    try {
-      if (!RedisBackend) {
-        const module = await import("./backend/redis-backend.js");
-        RedisBackend = module.RedisBackend;
-      }
-      logger.info(`Connecting to Redis at ${config.host}:${config.port}`);
-      return new RedisBackend(config);
-    } catch (error) {
-      logger.warn(`Redis not available, falling back to in-memory cache: ${error}`);
-      return new MemoryBackend();
+  /**
+   * Get the cache store instance.
+   * @throws {DextoRuntimeError} if not connected
+   */
+  getCache() {
+    if (!this.connected) {
+      throw StorageError.managerNotConnected("getCache");
     }
+    return this.cache;
   }
-  async createPostgresBackend(config) {
-    try {
-      if (!PostgresBackend) {
-        const module = await import("./backend/postgres-backend.js");
-        PostgresBackend = module.PostgresBackend;
-      }
-      logger.info("Connecting to PostgreSQL database");
-      return new PostgresBackend(config);
-    } catch (error) {
-      logger.warn(`PostgreSQL not available, falling back to in-memory database: ${error}`);
-      return new MemoryBackend();
+  /**
+   * Get the database store instance.
+   * @throws {DextoRuntimeError} if not connected
+   */
+  getDatabase() {
+    if (!this.connected) {
+      throw StorageError.managerNotConnected("getDatabase");
     }
+    return this.database;
   }
-  async createSQLiteBackend(config) {
-    try {
-      if (!SQLiteBackend) {
-        const module = await import("./backend/sqlite-backend.js");
-        SQLiteBackend = module.SQLiteBackend;
-      }
-      logger.info(`Using SQLite database at ${config.path}`);
-      return new SQLiteBackend(config);
-    } catch (error) {
-      logger.error(
-        `SQLite backend failed to load: ${error instanceof Error ? error.message : String(error)}`
-      );
-      logger.error(`Full error details: ${JSON.stringify(error)}`);
-      logger.warn("Falling back to in-memory database backend");
-      return new MemoryBackend();
+  /**
+   * Get the blob store instance.
+   * @throws {DextoRuntimeError} if not connected
+   */
+  getBlobStore() {
+    if (!this.connected) {
+      throw StorageError.managerNotConnected("getBlobStore");
     }
+    return this.blobStore;
   }
   // Utility methods
   async getInfo() {
+    if (!this.connected) {
+      throw StorageError.managerNotConnected("getInfo");
+    }
     return {
       cache: {
-        type: this.cache?.getBackendType() || "none",
-        connected: this.cache?.isConnected() || false
+        type: this.cache.getStoreType(),
+        connected: this.cache.isConnected()
       },
       database: {
-        type: this.database?.getBackendType() || "none",
-        connected: this.database?.isConnected() || false
+        type: this.database.getStoreType(),
+        connected: this.database.isConnected()
+      },
+      blob: {
+        type: this.blobStore.getStoreType(),
+        connected: this.blobStore.isConnected()
       },
       connected: this.connected
     };
   }
   // Health check
   async healthCheck() {
+    if (!this.connected) {
+      throw StorageError.managerNotConnected("healthCheck");
+    }
     let cacheHealthy = false;
     let databaseHealthy = false;
+    let blobHealthy = false;
     try {
-      if (this.cache?.isConnected()) {
+      if (this.cache.isConnected()) {
         await this.cache.set(HEALTH_CHECK_KEY, "ok", 10);
         const result = await this.cache.get(HEALTH_CHECK_KEY);
         cacheHealthy = result === "ok";
@@ -146,7 +165,7 @@ class StorageManager {
       logger.warn(`Cache health check failed: ${error}`);
     }
     try {
-      if (this.database?.isConnected()) {
+      if (this.database.isConnected()) {
         await this.database.set(HEALTH_CHECK_KEY, "ok");
         const result = await this.database.get(HEALTH_CHECK_KEY);
         databaseHealthy = result === "ok";
@@ -155,19 +174,28 @@ class StorageManager {
     } catch (error) {
       logger.warn(`Database health check failed: ${error}`);
     }
+    try {
+      if (this.blobStore.isConnected()) {
+        blobHealthy = this.blobStore.isConnected();
+      }
+    } catch (error) {
+      logger.warn(`Blob store health check failed: ${error}`);
+    }
     return {
       cache: cacheHealthy,
       database: databaseHealthy,
-      overall: cacheHealthy && databaseHealthy
+      blob: blobHealthy,
+      overall: cacheHealthy && databaseHealthy && blobHealthy
     };
   }
 }
-async function createStorageBackends(config) {
-  const manager = new StorageManager(config);
-  const backends = await manager.connect();
-  return { manager, backends };
+async function createStorageManager(config, agentId) {
+  const manager = new StorageManager(config, agentId);
+  await manager.initialize();
+  await manager.connect();
+  return manager;
 }
 export {
   StorageManager,
-  createStorageBackends
+  createStorageManager
 };

package/dist/storage/types.d.ts

@@ -1,5 +1,7 @@
-export { StorageBackends } from './backend/types.js';
-export { CacheBackend } from './backend/cache-backend.js';
-export { DatabaseBackend } from './backend/database-backend.js';
-export { BackendConfig, StorageConfig } from './schemas.js';
-import 'zod';
+/**
+ * Re-export simplified storage types
+ */
+export type { Cache } from './cache/types.js';
+export type { Database } from './database/types.js';
+export type { StorageConfig } from './schemas.js';
+//# sourceMappingURL=types.d.ts.map

package/dist/storage/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/storage/types.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,YAAY,EAAE,KAAK,EAAE,MAAM,kBAAkB,CAAC;AAC9C,YAAY,EAAE,QAAQ,EAAE,MAAM,qBAAqB,CAAC;AACpD,YAAY,EAAE,aAAa,EAAE,MAAM,cAAc,CAAC"}

package/dist/systemPrompt/contributors.cjs

@@ -20,6 +20,7 @@ var contributors_exports = {};
 __export(contributors_exports, {
   DynamicContributor: () => DynamicContributor,
   FileContributor: () => FileContributor,
+  MemoryContributor: () => MemoryContributor,
   StaticContributor: () => StaticContributor
 });
 module.exports = __toCommonJS(contributors_exports);
@@ -138,9 +139,62 @@ ${combinedContent}
     return result;
   }
 }
+class MemoryContributor {
+  constructor(id, priority, memoryManager, options = {}) {
+    this.id = id;
+    this.priority = priority;
+    this.memoryManager = memoryManager;
+    this.options = options;
+    import_logger.logger.debug(
+      `[MemoryContributor] Created "${id}" with options: ${JSON.stringify(options)}`
+    );
+  }
+  async getContent(_context) {
+    const {
+      includeTimestamps = false,
+      includeTags = true,
+      limit,
+      pinnedOnly = false
+    } = this.options;
+    try {
+      const memories = await this.memoryManager.list({
+        ...limit !== void 0 && { limit },
+        ...pinnedOnly && { pinned: true }
+      });
+      if (memories.length === 0) {
+        return "";
+      }
+      const formattedMemories = memories.map((memory) => {
+        let formatted = `- ${memory.content}`;
+        if (includeTags && memory.tags && memory.tags.length > 0) {
+          formatted += ` [Tags: ${memory.tags.join(", ")}]`;
+        }
+        if (includeTimestamps) {
+          const date = new Date(memory.updatedAt).toLocaleDateString();
+          formatted += ` (Updated: ${date})`;
+        }
+        return formatted;
+      });
+      const header = "## User Memories";
+      const memoryList = formattedMemories.join("\n");
+      const result = `${header}
+${memoryList}`;
+      import_logger.logger.debug(
+        `[MemoryContributor] Loaded ${memories.length} memories into system prompt`
+      );
+      return result;
+    } catch (error) {
+      import_logger.logger.error(
+        `[MemoryContributor] Failed to load memories: ${error instanceof Error ? error.message : String(error)}`
+      );
+      return "";
+    }
+  }
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   DynamicContributor,
   FileContributor,
+  MemoryContributor,
   StaticContributor
 });

package/dist/systemPrompt/contributors.d.ts

@@ -1,28 +1,20 @@
 import { SystemPromptContributor, DynamicContributorContext } from './types.js';
-import '../mcp/manager.js';
-import '../mcp/schemas.js';
-import 'zod';
-import '../mcp/types.js';
-import '@modelcontextprotocol/sdk/client/index.js';
-import '../tools/types.js';
-import 'json-schema';
-import '@modelcontextprotocol/sdk/types.js';
-
-declare class StaticContributor implements SystemPromptContributor {
+import type { MemoryManager } from '../memory/index.js';
+export declare class StaticContributor implements SystemPromptContributor {
     id: string;
     priority: number;
     private content;
     constructor(id: string, priority: number, content: string);
     getContent(_context: DynamicContributorContext): Promise<string>;
 }
-declare class DynamicContributor implements SystemPromptContributor {
+export declare class DynamicContributor implements SystemPromptContributor {
     id: string;
     priority: number;
     private promptGenerator;
     constructor(id: string, priority: number, promptGenerator: (context: DynamicContributorContext) => Promise<string>);
     getContent(context: DynamicContributorContext): Promise<string>;
 }
-interface FileContributorOptions {
+export interface FileContributorOptions {
     includeFilenames?: boolean | undefined;
     separator?: string | undefined;
     errorHandling?: 'skip' | 'error' | undefined;
@@ -30,7 +22,7 @@ interface FileContributorOptions {
     includeMetadata?: boolean | undefined;
     cache?: boolean | undefined;
 }
-declare class FileContributor implements SystemPromptContributor {
+export declare class FileContributor implements SystemPromptContributor {
     id: string;
     priority: number;
     private files;
@@ -40,5 +32,28 @@ declare class FileContributor implements SystemPromptContributor {
     constructor(id: string, priority: number, files: string[], options?: FileContributorOptions, configDir?: string);
     getContent(_context: DynamicContributorContext): Promise<string>;
 }
-
-export { DynamicContributor, FileContributor, type FileContributorOptions, StaticContributor };
+export interface MemoryContributorOptions {
+    /** Whether to include timestamps in memory display */
+    includeTimestamps?: boolean | undefined;
+    /** Whether to include tags in memory display */
+    includeTags?: boolean | undefined;
+    /** Maximum number of memories to include */
+    limit?: number | undefined;
+    /** Only include pinned memories (for hybrid approach) */
+    pinnedOnly?: boolean | undefined;
+}
+/**
+ * MemoryContributor loads user memories from the database and formats them
+ * for inclusion in the system prompt.
+ *
+ * This enables memories to be automatically available in every conversation.
+ */
+export declare class MemoryContributor implements SystemPromptContributor {
+    id: string;
+    priority: number;
+    private memoryManager;
+    private options;
+    constructor(id: string, priority: number, memoryManager: MemoryManager, options?: MemoryContributorOptions);
+    getContent(_context: DynamicContributorContext): Promise<string>;
+}
+//# sourceMappingURL=contributors.d.ts.map

package/dist/systemPrompt/contributors.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"contributors.d.ts","sourceRoot":"","sources":["../../src/systemPrompt/contributors.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,uBAAuB,EAAE,yBAAyB,EAAE,MAAM,YAAY,CAAC;AAMhF,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,oBAAoB,CAAC;AAExD,qBAAa,iBAAkB,YAAW,uBAAuB;IAElD,EAAE,EAAE,MAAM;IACV,QAAQ,EAAE,MAAM;IACvB,OAAO,CAAC,OAAO;gBAFR,EAAE,EAAE,MAAM,EACV,QAAQ,EAAE,MAAM,EACf,OAAO,EAAE,MAAM;IAGrB,UAAU,CAAC,QAAQ,EAAE,yBAAyB,GAAG,OAAO,CAAC,MAAM,CAAC;CAGzE;AAED,qBAAa,kBAAmB,YAAW,uBAAuB;IAEnD,EAAE,EAAE,MAAM;IACV,QAAQ,EAAE,MAAM;IACvB,OAAO,CAAC,eAAe;gBAFhB,EAAE,EAAE,MAAM,EACV,QAAQ,EAAE,MAAM,EACf,eAAe,EAAE,CAAC,OAAO,EAAE,yBAAyB,KAAK,OAAO,CAAC,MAAM,CAAC;IAG9E,UAAU,CAAC,OAAO,EAAE,yBAAyB,GAAG,OAAO,CAAC,MAAM,CAAC;CAGxE;AAED,MAAM,WAAW,sBAAsB;IACnC,gBAAgB,CAAC,EAAE,OAAO,GAAG,SAAS,CAAC;IACvC,SAAS,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IAC/B,aAAa,CAAC,EAAE,MAAM,GAAG,OAAO,GAAG,SAAS,CAAC;IAC7C,WAAW,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IACjC,eAAe,CAAC,EAAE,OAAO,GAAG,SAAS,CAAC;IACtC,KAAK,CAAC,EAAE,OAAO,GAAG,SAAS,CAAC;CAC/B;AAED,qBAAa,eAAgB,YAAW,uBAAuB;IAKhD,EAAE,EAAE,MAAM;IACV,QAAQ,EAAE,MAAM;IACvB,OAAO,CAAC,KAAK;IACb,OAAO,CAAC,OAAO;IACf,OAAO,CAAC,SAAS;IAPrB,OAAO,CAAC,KAAK,CAAkC;gBAGpC,EAAE,EAAE,MAAM,EACV,QAAQ,EAAE,MAAM,EACf,KAAK,EAAE,MAAM,EAAE,EACf,OAAO,GAAE,sBAA2B,EACpC,SAAS,GAAE,MAAsB;IAOvC,UAAU,CAAC,QAAQ,EAAE,yBAAyB,GAAG,OAAO,CAAC,MAAM,CAAC;CA8FzE;AAED,MAAM,WAAW,wBAAwB;IACrC,sDAAsD;IACtD,iBAAiB,CAAC,EAAE,OAAO,GAAG,SAAS,CAAC;IACxC,gDAAgD;IAChD,WAAW,CAAC,EAAE,OAAO,GAAG,SAAS,CAAC;IAClC,4CAA4C;IAC5C,KAAK,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IAC3B,yDAAyD;IACzD,UAAU,CAAC,EAAE,OAAO,GAAG,SAAS,CAAC;CACpC;AAED;;;;;GAKG;AACH,qBAAa,iBAAkB,YAAW,uBAAuB;IAElD,EAAE,EAAE,MAAM;IACV,QAAQ,EAAE,MAAM;IACvB,OAAO,CAAC,aAAa;IACrB,OAAO,CAAC,OAAO;gBAHR,EAAE,EAAE,MAAM,EACV,QAAQ,EAAE,MAAM,EACf,aAAa,EAAE,aAAa,EAC5B,OAAO,GAAE,wBAA6B;IAO5C,UAAU,CAAC,QAAQ,EAAE,yBAAyB,GAAG,OAAO,CAAC,MAAM,CAAC;CAmDzE"}

package/dist/systemPrompt/contributors.js

@@ -1,3 +1,4 @@
+import "../chunk-C6A6W6XS.js";
 import { readFile, stat } from "fs/promises";
 import { resolve, extname } from "path";
 import { logger } from "../logger/index.js";
@@ -113,8 +114,61 @@ ${combinedContent}
     return result;
   }
 }
+class MemoryContributor {
+  constructor(id, priority, memoryManager, options = {}) {
+    this.id = id;
+    this.priority = priority;
+    this.memoryManager = memoryManager;
+    this.options = options;
+    logger.debug(
+      `[MemoryContributor] Created "${id}" with options: ${JSON.stringify(options)}`
+    );
+  }
+  async getContent(_context) {
+    const {
+      includeTimestamps = false,
+      includeTags = true,
+      limit,
+      pinnedOnly = false
+    } = this.options;
+    try {
+      const memories = await this.memoryManager.list({
+        ...limit !== void 0 && { limit },
+        ...pinnedOnly && { pinned: true }
+      });
+      if (memories.length === 0) {
+        return "";
+      }
+      const formattedMemories = memories.map((memory) => {
+        let formatted = `- ${memory.content}`;
+        if (includeTags && memory.tags && memory.tags.length > 0) {
+          formatted += ` [Tags: ${memory.tags.join(", ")}]`;
+        }
+        if (includeTimestamps) {
+          const date = new Date(memory.updatedAt).toLocaleDateString();
+          formatted += ` (Updated: ${date})`;
+        }
+        return formatted;
+      });
+      const header = "## User Memories";
+      const memoryList = formattedMemories.join("\n");
+      const result = `${header}
+${memoryList}`;
+      logger.debug(
+        `[MemoryContributor] Loaded ${memories.length} memories into system prompt`
+      );
+      return result;
+    } catch (error) {
+      logger.error(
+        `[MemoryContributor] Failed to load memories: ${error instanceof Error ? error.message : String(error)}`
+      );
+      return "";
+    }
+  }
+}
 export {
   DynamicContributor,
   FileContributor,
+  MemoryContributor,
   StaticContributor
 };

package/dist/systemPrompt/error-codes.d.ts

@@ -2,12 +2,11 @@
  * SystemPrompt-specific error codes
  * Includes file processing and configuration errors
  */
-declare enum SystemPromptErrorCode {
+export declare enum SystemPromptErrorCode {
     FILE_INVALID_TYPE = "systemprompt_file_invalid_type",
     FILE_TOO_LARGE = "systemprompt_file_too_large",
     FILE_READ_FAILED = "systemprompt_file_read_failed",
     CONTRIBUTOR_SOURCE_UNKNOWN = "systemprompt_contributor_source_unknown",
     CONTRIBUTOR_CONFIG_INVALID = "systemprompt_contributor_config_invalid"
 }
-
-export { SystemPromptErrorCode };
+//# sourceMappingURL=error-codes.d.ts.map

package/dist/systemPrompt/error-codes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"error-codes.d.ts","sourceRoot":"","sources":["../../src/systemPrompt/error-codes.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,oBAAY,qBAAqB;IAE7B,iBAAiB,mCAAmC;IACpD,cAAc,gCAAgC;IAC9C,gBAAgB,kCAAkC;IAGlD,0BAA0B,4CAA4C;IACtE,0BAA0B,4CAA4C;CACzE"}

package/dist/systemPrompt/error-codes.js

@@ -1,3 +1,4 @@
+import "../chunk-C6A6W6XS.js";
 var SystemPromptErrorCode = /* @__PURE__ */ ((SystemPromptErrorCode2) => {
   SystemPromptErrorCode2["FILE_INVALID_TYPE"] = "systemprompt_file_invalid_type";
   SystemPromptErrorCode2["FILE_TOO_LARGE"] = "systemprompt_file_too_large";

package/dist/systemPrompt/errors.d.ts

@@ -1,23 +1,9 @@
 import { DextoRuntimeError } from '../errors/DextoRuntimeError.js';
-import '../errors/DextoBaseError.js';
-import '../errors/types.js';
-import '../agent/error-codes.js';
-import '../config/error-codes.js';
-import '../context/error-codes.js';
-import '../llm/error-codes.js';
-import '../mcp/error-codes.js';
-import '../session/error-codes.js';
-import '../storage/error-codes.js';
-import './error-codes.js';
-import '../tools/error-codes.js';
-import '../preferences/error-codes.js';
-import '../agent/registry/error-codes.js';
-
 /**
  * SystemPrompt error factory with typed methods for creating systemPrompt-specific errors
  * Each method creates a properly typed DextoRuntimeError with SYSTEM_PROMPT scope
  */
-declare class SystemPromptError {
+export declare class SystemPromptError {
     /**
      * Invalid file type error
      */
@@ -51,5 +37,4 @@ declare class SystemPromptError {
      */
     static invalidContributorConfig(config: unknown): DextoRuntimeError;
 }
-
-export { SystemPromptError };
+//# sourceMappingURL=errors.d.ts.map

package/dist/systemPrompt/errors.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors.d.ts","sourceRoot":"","sources":["../../src/systemPrompt/errors.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,iBAAiB,EAAE,MAAM,mCAAmC,CAAC;AAKtE;;;GAGG;AACH,qBAAa,iBAAiB;IAC1B;;OAEG;IACH,MAAM,CAAC,eAAe,CAAC,QAAQ,EAAE,MAAM,EAAE,iBAAiB,EAAE,MAAM,EAAE;;;;IAUpE;;OAEG;IACH,MAAM,CAAC,YAAY,CAAC,QAAQ,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM;;;;;IAUvE;;OAEG;IACH,MAAM,CAAC,cAAc,CAAC,QAAQ,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM;;;;IAUtD;;OAEG;IACH,MAAM,CAAC,wBAAwB,CAAC,MAAM,EAAE,MAAM;;;IAU9C;;OAEG;IACH,MAAM,CAAC,wBAAwB,CAAC,MAAM,EAAE,OAAO,GAAG,iBAAiB;CAStE"}

package/dist/systemPrompt/errors.js

@@ -1,3 +1,4 @@
+import "../chunk-C6A6W6XS.js";
 import { DextoRuntimeError } from "../errors/DextoRuntimeError.js";
 import { ErrorScope, ErrorType } from "../errors/types.js";
 import { SystemPromptErrorCode } from "./error-codes.js";

package/dist/systemPrompt/in-built-prompts.cjs

@@ -30,29 +30,27 @@ async function getMemorySummary(_context) {
   return "<memorySummary>Memory summary: [not implemented]</memorySummary>";
 }
 async function getResourceData(context) {
-  const uris = await context.mcpManager.listAllResources();
-  if (!uris || uris.length === 0) {
+  const resources = await context.mcpManager.listAllResources();
+  if (!resources || resources.length === 0) {
     return "<resources></resources>";
   }
   const parts = await Promise.all(
-    uris.map(async (uri) => {
+    resources.map(async (resource) => {
       try {
-        const response = await context.mcpManager.readResource(uri);
+        const response = await context.mcpManager.readResource(resource.key);
+        const first = response?.contents?.[0];
         let content;
-        if (typeof response === "string") {
-          content = response;
-        } else if (response && typeof response === "object") {
-          if ("content" in response && typeof response.content === "string") {
-            content = response.content;
-          } else {
-            content = JSON.stringify(response, null, 2);
-          }
+        if (first?.text && typeof first.text === "string") {
+          content = first.text;
+        } else if (first?.blob && typeof first.blob === "string") {
+          content = first.blob;
         } else {
-          content = String(response);
+          content = JSON.stringify(response, null, 2);
         }
-        return `<resource uri="${uri}">${content}</resource>`;
+        const label = resource.summary.name || resource.summary.uri;
+        return `<resource uri="${resource.key}" name="${label}">${content}</resource>`;
       } catch (error) {
-        return `<resource uri="${uri}">Error loading resource: ${error.message || error}</resource>`;
+        return `<resource uri="${resource.key}">Error loading resource: ${error.message || error}</resource>`;
       }
     })
   );