@dexto/core 1.5.0 → 1.5.1

package/dist/storage/database/postgres-store.js

@@ -12,20 +12,89 @@ class PostgresStore {
   logger;
   async connect() {
     if (this.connected) return;
+    const connectionString = this.config.connectionString || this.config.url;
+    if (connectionString?.startsWith("$")) {
+      throw StorageError.connectionFailed(
+        `PostgreSQL: Connection string contains unexpanded environment variable: ${connectionString}. Ensure the environment variable is set in your .env file.`
+      );
+    }
+    if (!connectionString) {
+      throw StorageError.connectionFailed(
+        "PostgreSQL: No connection string provided. Set url or connectionString in database config."
+      );
+    }
+    const { schema, ...pgOptions } = this.config.options || {};
+    this.logger.info("Connecting to PostgreSQL database...");
     this.pool = new Pool({
-      connectionString: this.config.connectionString || this.config.url,
+      connectionString,
       max: this.config.maxConnections || 20,
-      idleTimeoutMillis: this.config.idleTimeoutMillis || 3e4,
-      connectionTimeoutMillis: this.config.connectionTimeoutMillis || 2e3,
-      ...this.config.options
+      // Shorter idle timeout for serverless DBs (Neon) - connections go stale quickly
+      idleTimeoutMillis: this.config.idleTimeoutMillis || 1e4,
+      connectionTimeoutMillis: this.config.connectionTimeoutMillis || 1e4,
+      // Enable TCP keepalive to detect dead connections
+      keepAlive: true,
+      keepAliveInitialDelayMillis: 1e4,
+      ...pgOptions
     });
-    const client = await this.pool.connect();
+    this.pool.on("error", (err) => {
+      this.logger.warn(`PostgreSQL pool error (will retry on next query): ${err.message}`);
+    });
+    if (schema) {
+      if (!/^[a-zA-Z_][a-zA-Z0-9_]*$/.test(schema)) {
+        throw StorageError.connectionFailed(
+          `PostgreSQL: Invalid schema name "${schema}". Schema names must start with a letter or underscore and contain only alphanumeric characters and underscores.`
+        );
+      }
+      this.pool.on("connect", async (client2) => {
+        try {
+          await client2.query(`SET search_path TO "${schema}", public`);
+        } catch (err) {
+          this.logger.error(`Failed to set search_path to "${schema}": ${err}`);
+        }
+      });
+      this.logger.info(`Using custom schema: "${schema}"`);
+    }
+    let client;
     try {
+      client = await this.pool.connect();
       await client.query("SELECT NOW()");
+      if (schema) {
+        await this.createSchema(client, schema);
+      }
       await this.createTables(client);
       this.connected = true;
+      this.logger.info("PostgreSQL database connected successfully");
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : String(error);
+      this.logger.error(`PostgreSQL connection failed: ${errorMessage}`);
+      if (this.pool) {
+        await this.pool.end().catch(() => {
+        });
+        this.pool = null;
+      }
+      throw StorageError.connectionFailed(`PostgreSQL: ${errorMessage}`);
     } finally {
-      client.release();
+      if (client) {
+        client.release();
+      }
+    }
+  }
+  /**
+   * Creates a PostgreSQL schema if it doesn't exist.
+   */
+  async createSchema(client, schemaName) {
+    if (!/^[a-zA-Z_][a-zA-Z0-9_]*$/.test(schemaName)) {
+      throw StorageError.connectionFailed(
+        `PostgreSQL: Invalid schema name "${schemaName}". Schema names must start with a letter or underscore and contain only alphanumeric characters and underscores.`
+      );
+    }
+    try {
+      await client.query(`CREATE SCHEMA IF NOT EXISTS "${schemaName}"`);
+      this.logger.debug(`Schema "${schemaName}" ready`);
+    } catch (error) {
+      this.logger.warn(
+        `Could not create schema "${schemaName}": ${error}. Assuming it exists.`
+      );
     }
   }
   async disconnect() {
@@ -41,61 +110,54 @@ class PostgresStore {
   getStoreType() {
     return "postgres";
   }
-  // Core operations
+  // Core operations - all use withRetry for serverless DB resilience
   async get(key) {
-    this.checkConnection();
-    const client = await this.pool.connect();
     try {
-      const result = await client.query("SELECT value FROM kv WHERE key = $1", [key]);
-      return result.rows[0] ? result.rows[0].value : void 0;
+      return await this.withRetry("get", async (client) => {
+        const result = await client.query("SELECT value FROM kv WHERE key = $1", [key]);
+        return result.rows[0] ? result.rows[0].value : void 0;
+      });
     } catch (error) {
       throw StorageError.readFailed(
         "get",
         error instanceof Error ? error.message : String(error),
         { key }
       );
-    } finally {
-      client.release();
     }
   }
   async set(key, value) {
-    this.checkConnection();
-    const client = await this.pool.connect();
     try {
-      await client.query(
-        "INSERT INTO kv (key, value, updated_at) VALUES ($1, $2, $3) ON CONFLICT (key) DO UPDATE SET value = $2, updated_at = $3",
-        [key, value, /* @__PURE__ */ new Date()]
-      );
+      await this.withRetry("set", async (client) => {
+        const jsonValue = JSON.stringify(value);
+        await client.query(
+          "INSERT INTO kv (key, value, updated_at) VALUES ($1, $2::jsonb, $3) ON CONFLICT (key) DO UPDATE SET value = $2::jsonb, updated_at = $3",
+          [key, jsonValue, /* @__PURE__ */ new Date()]
+        );
+      });
     } catch (error) {
       throw StorageError.writeFailed(
         "set",
         error instanceof Error ? error.message : String(error),
         { key }
       );
-    } finally {
-      client.release();
     }
   }
   async delete(key) {
-    this.checkConnection();
-    const client = await this.pool.connect();
-    try {
+    await this.withRetry("delete", async (client) => {
       await client.query("BEGIN");
-      await client.query("DELETE FROM kv WHERE key = $1", [key]);
-      await client.query("DELETE FROM lists WHERE key = $1", [key]);
-      await client.query("COMMIT");
-    } catch (error) {
-      await client.query("ROLLBACK");
-      throw error;
-    } finally {
-      client.release();
-    }
+      try {
+        await client.query("DELETE FROM kv WHERE key = $1", [key]);
+        await client.query("DELETE FROM lists WHERE key = $1", [key]);
+        await client.query("COMMIT");
+      } catch (error) {
+        await client.query("ROLLBACK");
+        throw error;
+      }
+    });
   }
   // List operations
   async list(prefix) {
-    this.checkConnection();
-    const client = await this.pool.connect();
-    try {
+    return await this.withRetry("list", async (client) => {
       const kvResult = await client.query("SELECT key FROM kv WHERE key LIKE $1", [
         `${prefix}%`
       ]);
@@ -108,41 +170,33 @@ class PostgresStore {
         ...listResult.rows.map((row) => row.key)
       ]);
       return Array.from(allKeys).sort();
-    } finally {
-      client.release();
-    }
+    });
   }
   async append(key, item) {
-    this.checkConnection();
-    const client = await this.pool.connect();
     try {
-      await client.query("INSERT INTO lists (key, item, created_at) VALUES ($1, $2, $3)", [
-        key,
-        item,
-        /* @__PURE__ */ new Date()
-      ]);
+      await this.withRetry("append", async (client) => {
+        const jsonItem = JSON.stringify(item);
+        await client.query(
+          "INSERT INTO lists (key, item, created_at) VALUES ($1, $2::jsonb, $3)",
+          [key, jsonItem, /* @__PURE__ */ new Date()]
+        );
+      });
     } catch (error) {
       throw StorageError.writeFailed(
         "append",
         error instanceof Error ? error.message : String(error),
         { key }
       );
-    } finally {
-      client.release();
     }
   }
   async getRange(key, start, count) {
-    this.checkConnection();
-    const client = await this.pool.connect();
-    try {
+    return await this.withRetry("getRange", async (client) => {
       const result = await client.query(
         "SELECT item FROM lists WHERE key = $1 ORDER BY created_at ASC LIMIT $2 OFFSET $3",
         [key, count, start]
       );
       return result.rows.map((row) => row.item);
-    } finally {
-      client.release();
-    }
+    });
   }
   // Schema management
   async createTables(client) {
@@ -172,26 +226,74 @@ class PostgresStore {
       throw StorageError.notConnected("PostgresStore");
     }
   }
+  /**
+   * Check if an error is a connection error that should trigger a retry.
+   * Common with serverless databases (Neon) where connections go stale.
+   */
+  isConnectionError(error) {
+    if (!(error instanceof Error)) return false;
+    const code = error.code;
+    return code === "ETIMEDOUT" || code === "ECONNRESET" || code === "ECONNREFUSED" || code === "EPIPE" || code === "57P01" || // admin_shutdown
+    code === "57P02" || // crash_shutdown
+    code === "57P03" || // cannot_connect_now
+    error.message.includes("Connection terminated") || error.message.includes("connection lost");
+  }
+  /**
+   * Execute a database operation with automatic retry on connection errors.
+   * Handles serverless DB connection issues (Neon cold starts, stale connections).
+   */
+  async withRetry(operation, fn, maxRetries = 2) {
+    this.checkConnection();
+    let lastError;
+    for (let attempt = 0; attempt <= maxRetries; attempt++) {
+      let client;
+      try {
+        client = await this.pool.connect();
+        const result = await fn(client);
+        return result;
+      } catch (error) {
+        lastError = error instanceof Error ? error : new Error(String(error));
+        if (client) {
+          client.release(true);
+          client = void 0;
+        }
+        if (this.isConnectionError(error) && attempt < maxRetries) {
+          this.logger.warn(
+            `PostgreSQL ${operation} failed with connection error (attempt ${attempt + 1}/${maxRetries + 1}): ${lastError.message}. Retrying...`
+          );
+          await new Promise((resolve) => setTimeout(resolve, 100 * (attempt + 1)));
+          continue;
+        }
+        throw error;
+      } finally {
+        if (client) {
+          client.release();
+        }
+      }
+    }
+    throw lastError;
+  }
   // Advanced operations
+  /**
+   * Execute a callback within a database transaction.
+   * Note: On connection failure, the entire callback will be retried on a new connection.
+   * Ensure callback operations are idempotent or use this only for read operations.
+   */
   async transaction(callback) {
-    this.checkConnection();
-    const client = await this.pool.connect();
-    try {
+    return await this.withRetry("transaction", async (client) => {
       await client.query("BEGIN");
-      const result = await callback(client);
-      await client.query("COMMIT");
-      return result;
-    } catch (error) {
-      await client.query("ROLLBACK");
-      throw error;
-    } finally {
-      client.release();
-    }
+      try {
+        const result = await callback(client);
+        await client.query("COMMIT");
+        return result;
+      } catch (error) {
+        await client.query("ROLLBACK");
+        throw error;
+      }
+    });
   }
   async getStats() {
-    this.checkConnection();
-    const client = await this.pool.connect();
-    try {
+    return await this.withRetry("getStats", async (client) => {
       const kvResult = await client.query("SELECT COUNT(*) as count FROM kv");
       const listResult = await client.query("SELECT COUNT(*) as count FROM lists");
       const sizeResult = await client.query(
@@ -203,19 +305,13 @@ class PostgresStore {
         listCount: parseInt(listResult.rows[0].count),
         totalSize: sizeResult.rows[0].size
       };
-    } finally {
-      client.release();
-    }
+    });
   }
   // Maintenance operations
   async vacuum() {
-    this.checkConnection();
-    const client = await this.pool.connect();
-    try {
+    await this.withRetry("vacuum", async (client) => {
       await client.query("VACUUM ANALYZE kv, lists");
-    } finally {
-      client.release();
-    }
+    });
   }
 }
 export {

package/dist/storage/database/schemas.cjs

@@ -53,7 +53,10 @@ const PostgresDatabaseSchema = BaseDatabaseSchema.extend({
   host: import_zod.z.string().optional().describe("PostgreSQL host"),
   port: import_zod.z.number().int().positive().optional().describe("PostgreSQL port"),
   database: import_zod.z.string().optional().describe("PostgreSQL database name"),
-  password: import_zod.z.string().optional().describe("PostgreSQL password")
+  password: import_zod.z.string().optional().describe("PostgreSQL password"),
+  // TODO: keyPrefix is reserved for future use - allows namespacing keys when multiple
+  // agents or environments share the same database (e.g., "dev:agent1:" vs "prod:agent2:")
+  keyPrefix: import_zod.z.string().optional().describe('Optional key prefix for namespacing (e.g., "dev:myagent:")')
 }).strict();
 const DatabaseConfigSchema = import_zod.z.discriminatedUnion(
   "type",

package/dist/storage/database/schemas.d.ts

@@ -59,6 +59,7 @@ export declare const PostgresDatabaseSchema: z.ZodObject<{
     port: z.ZodOptional<z.ZodNumber>;
     database: z.ZodOptional<z.ZodString>;
     password: z.ZodOptional<z.ZodString>;
+    keyPrefix: z.ZodOptional<z.ZodString>;
 }, "strict", z.ZodTypeAny, {
     type: "postgres";
     password?: string | undefined;
@@ -71,6 +72,7 @@ export declare const PostgresDatabaseSchema: z.ZodObject<{
     port?: number | undefined;
     database?: string | undefined;
     connectionString?: string | undefined;
+    keyPrefix?: string | undefined;
 }, {
     type: "postgres";
     password?: string | undefined;
@@ -83,6 +85,7 @@ export declare const PostgresDatabaseSchema: z.ZodObject<{
     port?: number | undefined;
     database?: string | undefined;
     connectionString?: string | undefined;
+    keyPrefix?: string | undefined;
 }>;
 export type PostgresDatabaseConfig = z.output<typeof PostgresDatabaseSchema>;
 export declare const DatabaseConfigSchema: z.ZodEffects<z.ZodDiscriminatedUnion<"type", [z.ZodObject<{
@@ -139,6 +142,7 @@ export declare const DatabaseConfigSchema: z.ZodEffects<z.ZodDiscriminatedUnion<
     port: z.ZodOptional<z.ZodNumber>;
     database: z.ZodOptional<z.ZodString>;
     password: z.ZodOptional<z.ZodString>;
+    keyPrefix: z.ZodOptional<z.ZodString>;
 }, "strict", z.ZodTypeAny, {
     type: "postgres";
     password?: string | undefined;
@@ -151,6 +155,7 @@ export declare const DatabaseConfigSchema: z.ZodEffects<z.ZodDiscriminatedUnion<
     port?: number | undefined;
     database?: string | undefined;
     connectionString?: string | undefined;
+    keyPrefix?: string | undefined;
 }, {
     type: "postgres";
     password?: string | undefined;
@@ -163,6 +168,7 @@ export declare const DatabaseConfigSchema: z.ZodEffects<z.ZodDiscriminatedUnion<
     port?: number | undefined;
     database?: string | undefined;
     connectionString?: string | undefined;
+    keyPrefix?: string | undefined;
 }>]>, {
     type: "in-memory";
     options?: Record<string, any> | undefined;
@@ -188,6 +194,7 @@ export declare const DatabaseConfigSchema: z.ZodEffects<z.ZodDiscriminatedUnion<
     port?: number | undefined;
     database?: string | undefined;
     connectionString?: string | undefined;
+    keyPrefix?: string | undefined;
 }, {
     type: "in-memory";
     options?: Record<string, any> | undefined;
@@ -213,6 +220,7 @@ export declare const DatabaseConfigSchema: z.ZodEffects<z.ZodDiscriminatedUnion<
     port?: number | undefined;
     database?: string | undefined;
     connectionString?: string | undefined;
+    keyPrefix?: string | undefined;
 }>;
 export type DatabaseConfig = z.output<typeof DatabaseConfigSchema>;
 //# sourceMappingURL=schemas.d.ts.map

package/dist/storage/database/schemas.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"schemas.d.ts","sourceRoot":"","sources":["../../../src/storage/database/schemas.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAKxB,eAAO,MAAM,cAAc,8CAA+C,CAAC;AAC3E,MAAM,MAAM,YAAY,GAAG,CAAC,OAAO,cAAc,CAAC,CAAC,MAAM,CAAC,CAAC;AAoB3D,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;;EAGxB,CAAC;AAEZ,MAAM,MAAM,sBAAsB,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,sBAAsB,CAAC,CAAC;AAG7E,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;EAOtB,CAAC;AAEZ,MAAM,MAAM,oBAAoB,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,oBAAoB,CAAC,CAAC;AAGzE,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAQxB,CAAC;AAEZ,MAAM,MAAM,sBAAsB,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,sBAAsB,CAAC,CAAC;AAG7E,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAiC3B,CAAC;AAEP,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,oBAAoB,CAAC,CAAC"}
+{"version":3,"file":"schemas.d.ts","sourceRoot":"","sources":["../../../src/storage/database/schemas.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAKxB,eAAO,MAAM,cAAc,8CAA+C,CAAC;AAC3E,MAAM,MAAM,YAAY,GAAG,CAAC,OAAO,cAAc,CAAC,CAAC,MAAM,CAAC,CAAC;AAoB3D,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;;EAGxB,CAAC;AAEZ,MAAM,MAAM,sBAAsB,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,sBAAsB,CAAC,CAAC;AAG7E,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;EAOtB,CAAC;AAEZ,MAAM,MAAM,oBAAoB,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,oBAAoB,CAAC,CAAC;AAGzE,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAcxB,CAAC;AAEZ,MAAM,MAAM,sBAAsB,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,sBAAsB,CAAC,CAAC;AAG7E,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAiC3B,CAAC;AAEP,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,oBAAoB,CAAC,CAAC"}

package/dist/storage/database/schemas.js

@@ -27,7 +27,10 @@ const PostgresDatabaseSchema = BaseDatabaseSchema.extend({
   host: z.string().optional().describe("PostgreSQL host"),
   port: z.number().int().positive().optional().describe("PostgreSQL port"),
   database: z.string().optional().describe("PostgreSQL database name"),
-  password: z.string().optional().describe("PostgreSQL password")
+  password: z.string().optional().describe("PostgreSQL password"),
+  // TODO: keyPrefix is reserved for future use - allows namespacing keys when multiple
+  // agents or environments share the same database (e.g., "dev:agent1:" vs "prod:agent2:")
+  keyPrefix: z.string().optional().describe('Optional key prefix for namespacing (e.g., "dev:myagent:")')
 }).strict();
 const DatabaseConfigSchema = z.discriminatedUnion(
   "type",

package/dist/storage/schemas.d.ts

@@ -152,6 +152,7 @@ export declare const StorageSchema: z.ZodBranded<z.ZodObject<{
         port: z.ZodOptional<z.ZodNumber>;
         database: z.ZodOptional<z.ZodString>;
         password: z.ZodOptional<z.ZodString>;
+        keyPrefix: z.ZodOptional<z.ZodString>;
     }, "strict", z.ZodTypeAny, {
         type: "postgres";
         password?: string | undefined;
@@ -164,6 +165,7 @@ export declare const StorageSchema: z.ZodBranded<z.ZodObject<{
         port?: number | undefined;
         database?: string | undefined;
         connectionString?: string | undefined;
+        keyPrefix?: string | undefined;
     }, {
         type: "postgres";
         password?: string | undefined;
@@ -176,6 +178,7 @@ export declare const StorageSchema: z.ZodBranded<z.ZodObject<{
         port?: number | undefined;
         database?: string | undefined;
         connectionString?: string | undefined;
+        keyPrefix?: string | undefined;
     }>]>, {
         type: "in-memory";
         options?: Record<string, any> | undefined;
@@ -201,6 +204,7 @@ export declare const StorageSchema: z.ZodBranded<z.ZodObject<{
         port?: number | undefined;
         database?: string | undefined;
         connectionString?: string | undefined;
+        keyPrefix?: string | undefined;
     }, {
         type: "in-memory";
         options?: Record<string, any> | undefined;
@@ -226,6 +230,7 @@ export declare const StorageSchema: z.ZodBranded<z.ZodObject<{
         port?: number | undefined;
         database?: string | undefined;
         connectionString?: string | undefined;
+        keyPrefix?: string | undefined;
     }>;
     blob: z.ZodObject<{
         type: z.ZodString;
@@ -260,6 +265,7 @@ export declare const StorageSchema: z.ZodBranded<z.ZodObject<{
         port?: number | undefined;
         database?: string | undefined;
         connectionString?: string | undefined;
+        keyPrefix?: string | undefined;
     };
     cache: {
         type: "in-memory";
@@ -310,6 +316,7 @@ export declare const StorageSchema: z.ZodBranded<z.ZodObject<{
         port?: number | undefined;
         database?: string | undefined;
         connectionString?: string | undefined;
+        keyPrefix?: string | undefined;
     };
     cache: {
         type: "in-memory";

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

@@ -1 +1 @@
-{"version":3,"file":"schemas.d.ts","sourceRoot":"","sources":["../../src/storage/schemas.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAGxB,OAAO,EACH,WAAW,EACX,iBAAiB,EACjB,KAAK,SAAS,EACd,KAAK,WAAW,EAChB,KAAK,mBAAmB,EACxB,KAAK,gBAAgB,GACxB,MAAM,oBAAoB,CAAC;AAG5B,OAAO,EACH,cAAc,EACd,oBAAoB,EACpB,KAAK,YAAY,EACjB,KAAK,cAAc,EACnB,KAAK,sBAAsB,EAC3B,KAAK,oBAAoB,EACzB,KAAK,sBAAsB,GAC9B,MAAM,uBAAuB,CAAC;AAG/B,OAAO,EACH,gBAAgB,EAChB,qBAAqB,EACrB,uBAAuB,EACvB,oBAAoB,EACpB,KAAK,aAAa,EAClB,KAAK,eAAe,EACpB,KAAK,uBAAuB,EAC5B,KAAK,oBAAoB,GAC5B,MAAM,mBAAmB,CAAC;AAO3B;;;;;;GAMG;AACH,eAAO,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;6BAUY,CAAC;AAEvC,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,aAAa,CAAC,CAAC;AAC1D,MAAM,MAAM,sBAAsB,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,aAAa,CAAC,CAAC"}
+{"version":3,"file":"schemas.d.ts","sourceRoot":"","sources":["../../src/storage/schemas.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAGxB,OAAO,EACH,WAAW,EACX,iBAAiB,EACjB,KAAK,SAAS,EACd,KAAK,WAAW,EAChB,KAAK,mBAAmB,EACxB,KAAK,gBAAgB,GACxB,MAAM,oBAAoB,CAAC;AAG5B,OAAO,EACH,cAAc,EACd,oBAAoB,EACpB,KAAK,YAAY,EACjB,KAAK,cAAc,EACnB,KAAK,sBAAsB,EAC3B,KAAK,oBAAoB,EACzB,KAAK,sBAAsB,GAC9B,MAAM,uBAAuB,CAAC;AAG/B,OAAO,EACH,gBAAgB,EAChB,qBAAqB,EACrB,uBAAuB,EACvB,oBAAoB,EACpB,KAAK,aAAa,EAClB,KAAK,eAAe,EACpB,KAAK,uBAAuB,EAC5B,KAAK,oBAAoB,GAC5B,MAAM,mBAAmB,CAAC;AAO3B;;;;;;GAMG;AACH,eAAO,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;6BAUY,CAAC;AAEvC,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,aAAa,CAAC,CAAC;AAC1D,MAAM,MAAM,sBAAsB,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,aAAa,CAAC,CAAC"}

package/dist/tools/custom-tool-registry.d.ts

@@ -40,14 +40,20 @@ export interface ToolCreationContext {
     agent: DextoAgent;
     /**
      * Optional services available to custom tool providers.
-     * Includes approvalManager for tools that need approval flows.
+     *
+     * Core services (provided by agent):
+     * - approvalManager: For tools that need approval flows
+     * - storageManager: For tools that need persistence
+     * - resourceManager: For tools that need resource access
+     * - searchService: For tools that need search capabilities
+     *
+     * External tool providers can add their own services using the index signature.
      */
     services?: {
         searchService?: any;
         approvalManager?: any;
-        fileSystemService?: any;
-        processService?: any;
         resourceManager?: any;
+        storageManager?: import('../storage/index.js').StorageManager;
         [key: string]: any;
     };
 }

package/dist/tools/custom-tool-registry.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"custom-tool-registry.d.ts","sourceRoot":"","sources":["../../src/tools/custom-tool-registry.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,YAAY,CAAC;AAC/C,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,uBAAuB,CAAC;AAC1D,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,wBAAwB,CAAC;AACzD,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,EAAE,YAAY,EAA6B,MAAM,+BAA+B,CAAC;AAGxF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AACH,MAAM,WAAW,mBAAmB;IAChC,MAAM,EAAE,YAAY,CAAC;IACrB,KAAK,EAAE,UAAU,CAAC;IAClB;;;OAGG;IACH,QAAQ,CAAC,EAAE;QACP,aAAa,CAAC,EAAE,GAAG,CAAC;QACpB,eAAe,CAAC,EAAE,GAAG,CAAC;QACtB,iBAAiB,CAAC,EAAE,GAAG,CAAC;QACxB,cAAc,CAAC,EAAE,GAAG,CAAC;QACrB,eAAe,CAAC,EAAE,GAAG,CAAC;QACtB,CAAC,GAAG,EAAE,MAAM,GAAG,GAAG,CAAC;KACtB,CAAC;CACL;AAED;;;;;;;GAOG;AACH,MAAM,WAAW,kBAAkB,CAC/B,KAAK,SAAS,MAAM,GAAG,MAAM,EAC7B,OAAO,SAAS;IAAE,IAAI,EAAE,KAAK,CAAA;CAAE,GAAG,GAAG;IAErC,kEAAkE;IAClE,IAAI,EAAE,KAAK,CAAC;IAEZ,kEAAkE;IAClE,YAAY,EAAE,CAAC,CAAC,OAAO,CAAC,OAAO,EAAE,GAAG,EAAE,GAAG,CAAC,CAAC;IAE3C;;;;;OAKG;IACH,MAAM,CAAC,MAAM,EAAE,OAAO,EAAE,OAAO,EAAE,mBAAmB,GAAG,YAAY,EAAE,CAAC;IAEtE,uDAAuD;IACvD,QAAQ,CAAC,EAAE;QACP,WAAW,EAAE,MAAM,CAAC;QACpB,WAAW,EAAE,MAAM,CAAC;QACpB,QAAQ,CAAC,EAAE,MAAM,CAAC;KACrB,CAAC;CACL;AAYD;;;;;;;;;;;GAWG;AACH,qBAAa,kBAAmB,SAAQ,YAAY,CAAC,kBAAkB,CAAC;;IAKpE;;;;;;OAMG;IACM,QAAQ,CAAC,QAAQ,EAAE,kBAAkB,GAAG,IAAI;IAQrD;;;;;;;OAOG;IACM,UAAU,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO;CAK7C;AAED;;;GAGG;AACH,eAAO,MAAM,kBAAkB,oBAA2B,CAAC"}
+{"version":3,"file":"custom-tool-registry.d.ts","sourceRoot":"","sources":["../../src/tools/custom-tool-registry.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,YAAY,CAAC;AAC/C,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,uBAAuB,CAAC;AAC1D,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,wBAAwB,CAAC;AACzD,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,EAAE,YAAY,EAA6B,MAAM,+BAA+B,CAAC;AAGxF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AACH,MAAM,WAAW,mBAAmB;IAChC,MAAM,EAAE,YAAY,CAAC;IACrB,KAAK,EAAE,UAAU,CAAC;IAClB;;;;;;;;;;OAUG;IACH,QAAQ,CAAC,EAAE;QACP,aAAa,CAAC,EAAE,GAAG,CAAC;QACpB,eAAe,CAAC,EAAE,GAAG,CAAC;QACtB,eAAe,CAAC,EAAE,GAAG,CAAC;QACtB,cAAc,CAAC,EAAE,OAAO,qBAAqB,EAAE,cAAc,CAAC;QAC9D,CAAC,GAAG,EAAE,MAAM,GAAG,GAAG,CAAC;KACtB,CAAC;CACL;AAED;;;;;;;GAOG;AACH,MAAM,WAAW,kBAAkB,CAC/B,KAAK,SAAS,MAAM,GAAG,MAAM,EAC7B,OAAO,SAAS;IAAE,IAAI,EAAE,KAAK,CAAA;CAAE,GAAG,GAAG;IAErC,kEAAkE;IAClE,IAAI,EAAE,KAAK,CAAC;IAEZ,kEAAkE;IAClE,YAAY,EAAE,CAAC,CAAC,OAAO,CAAC,OAAO,EAAE,GAAG,EAAE,GAAG,CAAC,CAAC;IAE3C;;;;;OAKG;IACH,MAAM,CAAC,MAAM,EAAE,OAAO,EAAE,OAAO,EAAE,mBAAmB,GAAG,YAAY,EAAE,CAAC;IAEtE,uDAAuD;IACvD,QAAQ,CAAC,EAAE;QACP,WAAW,EAAE,MAAM,CAAC;QACpB,WAAW,EAAE,MAAM,CAAC;QACpB,QAAQ,CAAC,EAAE,MAAM,CAAC;KACrB,CAAC;CACL;AAYD;;;;;;;;;;;GAWG;AACH,qBAAa,kBAAmB,SAAQ,YAAY,CAAC,kBAAkB,CAAC;;IAKpE;;;;;;OAMG;IACM,QAAQ,CAAC,QAAQ,EAAE,kBAAkB,GAAG,IAAI;IAQrD;;;;;;;OAOG;IACM,UAAU,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO;CAK7C;AAED;;;GAGG;AACH,eAAO,MAAM,kBAAkB,oBAA2B,CAAC"}

package/dist/tools/internal-tools/provider.cjs

@@ -136,8 +136,11 @@ class InternalToolsProvider {
     const context = {
       logger: this.logger,
       agent: this.agent,
-      services: this.services
-      // Includes approvalManager for tools that need approval flows
+      services: {
+        ...this.services,
+        // Include storageManager from agent services for custom tools that need persistence
+        storageManager: this.agent.services?.storageManager
+      }
     };
     for (const toolConfig of this.customToolConfigs) {
       try {

package/dist/tools/internal-tools/provider.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"provider.d.ts","sourceRoot":"","sources":["../../../src/tools/internal-tools/provider.ts"],"names":[],"mappings":"AAAA,OAAO,EAAwB,OAAO,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAC1E,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,0BAA0B,CAAC;AAC7D,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,2BAA2B,CAAC;AAG5D,OAAO,EAAE,qBAAqB,EAA0C,MAAM,eAAe,CAAC;AAC9F,OAAO,KAAK,EAAE,mBAAmB,EAAE,iBAAiB,EAAE,MAAM,eAAe,CAAC;AAK5E;;;;;;;;;;;;;GAaG;AACH,qBAAa,qBAAqB;IAC9B,OAAO,CAAC,QAAQ,CAAwB;IACxC,OAAO,CAAC,aAAa,CAAwC;IAC7D,OAAO,CAAC,WAAW,CAAwC;IAC3D,OAAO,CAAC,MAAM,CAAsB;IACpC,OAAO,CAAC,iBAAiB,CAAoB;IAC7C,OAAO,CAAC,MAAM,CAAe;IAC7B,OAAO,CAAC,KAAK,CAAC,CAAa;gBAGvB,QAAQ,EAAE,qBAAqB,EAC/B,MAAM,EAAE,mBAAmB,YAAK,EAChC,iBAAiB,EAAE,iBAAiB,YAAK,EACzC,MAAM,EAAE,YAAY;IAYxB;;;OAGG;IACH,QAAQ,CAAC,KAAK,EAAE,UAAU,GAAG,IAAI;IAIjC;;;OAGG;IACG,UAAU,IAAI,OAAO,CAAC,IAAI,CAAC;IA+BjC;;OAEG;IACH,OAAO,CAAC,qBAAqB;IAgD7B;;;OAGG;IACH,OAAO,CAAC,mBAAmB;IA4D3B;;OAEG;IACH,OAAO,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO;IAIlC;;OAEG;IACH,eAAe,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO;IAI1C;;OAEG;IACH,aAAa,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO;IAIxC;;;OAGG;IACH,OAAO,CAAC,QAAQ,EAAE,MAAM,GAAG,YAAY,GAAG,SAAS;IAInD;;OAEG;IACG,WAAW,CACb,QAAQ,EAAE,MAAM,EAChB,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAC7B,SAAS,CAAC,EAAE,MAAM,EAClB,WAAW,CAAC,EAAE,WAAW,GAC1B,OAAO,CAAC,OAAO,CAAC;IAyCnB;;OAEG;IACH,gBAAgB,IAAI,OAAO;IAc3B;;OAEG;IACH,cAAc,IAAI,OAAO;IAczB;;OAEG;IACH,oBAAoB,IAAI,MAAM,EAAE;IAIhC;;OAEG;IACH,kBAAkB,IAAI,MAAM,EAAE;IAI9B;;OAEG;IACH,YAAY,IAAI,MAAM,EAAE;IAIxB;;OAEG;IACH,YAAY,IAAI,MAAM;IAItB;;OAEG;IACH,oBAAoB,IAAI,MAAM;IAI9B;;OAEG;IACH,kBAAkB,IAAI,MAAM;CAG/B"}
+{"version":3,"file":"provider.d.ts","sourceRoot":"","sources":["../../../src/tools/internal-tools/provider.ts"],"names":[],"mappings":"AAAA,OAAO,EAAwB,OAAO,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAC1E,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,0BAA0B,CAAC;AAC7D,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,2BAA2B,CAAC;AAG5D,OAAO,EAAE,qBAAqB,EAA0C,MAAM,eAAe,CAAC;AAC9F,OAAO,KAAK,EAAE,mBAAmB,EAAE,iBAAiB,EAAE,MAAM,eAAe,CAAC;AAK5E;;;;;;;;;;;;;GAaG;AACH,qBAAa,qBAAqB;IAC9B,OAAO,CAAC,QAAQ,CAAwB;IACxC,OAAO,CAAC,aAAa,CAAwC;IAC7D,OAAO,CAAC,WAAW,CAAwC;IAC3D,OAAO,CAAC,MAAM,CAAsB;IACpC,OAAO,CAAC,iBAAiB,CAAoB;IAC7C,OAAO,CAAC,MAAM,CAAe;IAC7B,OAAO,CAAC,KAAK,CAAC,CAAa;gBAGvB,QAAQ,EAAE,qBAAqB,EAC/B,MAAM,EAAE,mBAAmB,YAAK,EAChC,iBAAiB,EAAE,iBAAiB,YAAK,EACzC,MAAM,EAAE,YAAY;IAYxB;;;OAGG;IACH,QAAQ,CAAC,KAAK,EAAE,UAAU,GAAG,IAAI;IAIjC;;;OAGG;IACG,UAAU,IAAI,OAAO,CAAC,IAAI,CAAC;IA+BjC;;OAEG;IACH,OAAO,CAAC,qBAAqB;IAgD7B;;;OAGG;IACH,OAAO,CAAC,mBAAmB;IAgE3B;;OAEG;IACH,OAAO,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO;IAIlC;;OAEG;IACH,eAAe,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO;IAI1C;;OAEG;IACH,aAAa,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO;IAIxC;;;OAGG;IACH,OAAO,CAAC,QAAQ,EAAE,MAAM,GAAG,YAAY,GAAG,SAAS;IAInD;;OAEG;IACG,WAAW,CACb,QAAQ,EAAE,MAAM,EAChB,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAC7B,SAAS,CAAC,EAAE,MAAM,EAClB,WAAW,CAAC,EAAE,WAAW,GAC1B,OAAO,CAAC,OAAO,CAAC;IAyCnB;;OAEG;IACH,gBAAgB,IAAI,OAAO;IAc3B;;OAEG;IACH,cAAc,IAAI,OAAO;IAczB;;OAEG;IACH,oBAAoB,IAAI,MAAM,EAAE;IAIhC;;OAEG;IACH,kBAAkB,IAAI,MAAM,EAAE;IAI9B;;OAEG;IACH,YAAY,IAAI,MAAM,EAAE;IAIxB;;OAEG;IACH,YAAY,IAAI,MAAM;IAItB;;OAEG;IACH,oBAAoB,IAAI,MAAM;IAI9B;;OAEG;IACH,kBAAkB,IAAI,MAAM;CAG/B"}

package/dist/tools/internal-tools/provider.js

@@ -114,8 +114,11 @@ class InternalToolsProvider {
     const context = {
       logger: this.logger,
       agent: this.agent,
-      services: this.services
-      // Includes approvalManager for tools that need approval flows
+      services: {
+        ...this.services,
+        // Include storageManager from agent services for custom tools that need persistence
+        storageManager: this.agent.services?.storageManager
+      }
     };
     for (const toolConfig of this.customToolConfigs) {
       try {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dexto/core",
-  "version": "1.5.0",
+  "version": "1.5.1",
   "private": false,
   "type": "module",
   "main": "./dist/index.js",