@dexto/core 1.1.10 → 1.2.0

package/dist/storage/{backend/memory-backend.js → database/memory-database-store.js}

@@ -1,8 +1,8 @@
+import "../../chunk-C6A6W6XS.js";
 import { StorageError } from "../errors.js";
-class MemoryBackend {
+class MemoryDatabaseStore {
   data = /* @__PURE__ */ new Map();
   lists = /* @__PURE__ */ new Map();
-  ttls = /* @__PURE__ */ new Map();
   connected = false;
   constructor() {
   }
@@ -13,19 +13,16 @@ class MemoryBackend {
     this.connected = false;
     this.data.clear();
     this.lists.clear();
-    this.ttls.clear();
   }
   isConnected() {
     return this.connected;
   }
-  getBackendType() {
+  getStoreType() {
     return "memory";
   }
-  // Core operations
   async get(key) {
     this.checkConnection();
     try {
-      this.checkTTL(key);
       return this.data.get(key);
     } catch (error) {
       throw StorageError.readFailed(
@@ -35,15 +32,10 @@ class MemoryBackend {
       );
     }
   }
-  async set(key, value, ttlSeconds) {
+  async set(key, value) {
     this.checkConnection();
     try {
       this.data.set(key, value);
-      if (ttlSeconds) {
-        this.ttls.set(key, Date.now() + ttlSeconds * 1e3);
-      } else {
-        this.ttls.delete(key);
-      }
     } catch (error) {
       throw StorageError.writeFailed(
         "set",
@@ -56,10 +48,9 @@ class MemoryBackend {
     this.checkConnection();
     this.data.delete(key);
     this.lists.delete(key);
-    this.ttls.delete(key);
   }
-  // List operations (DatabaseBackend)
   async list(prefix) {
+    this.checkConnection();
     const keys = [];
     for (const key of Array.from(this.data.keys())) {
       if (key.startsWith(prefix)) {
@@ -88,21 +79,13 @@ class MemoryBackend {
   // Helper methods
   checkConnection() {
     if (!this.connected) {
-      throw StorageError.notConnected("MemoryBackend");
-    }
-  }
-  checkTTL(key) {
-    const expiry = this.ttls.get(key);
-    if (expiry && Date.now() > expiry) {
-      this.data.delete(key);
-      this.ttls.delete(key);
+      throw StorageError.notConnected("MemoryDatabaseStore");
     }
   }
   // Development helpers
   async clear() {
     this.data.clear();
     this.lists.clear();
-    this.ttls.clear();
   }
   async dump() {
     return {
@@ -112,5 +95,5 @@ class MemoryBackend {
   }
 }
 export {
-  MemoryBackend
+  MemoryDatabaseStore
 };

package/dist/storage/{backend/postgres-backend.cjs → database/postgres-store.cjs}

@@ -16,14 +16,14 @@ var __copyProps = (to, from, except, desc) => {
   return to;
 };
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var postgres_backend_exports = {};
-__export(postgres_backend_exports, {
-  PostgresBackend: () => PostgresBackend
+var postgres_store_exports = {};
+__export(postgres_store_exports, {
+  PostgresStore: () => PostgresStore
 });
-module.exports = __toCommonJS(postgres_backend_exports);
+module.exports = __toCommonJS(postgres_store_exports);
 var import_pg = require("pg");
 var import_errors = require("../errors.js");
-class PostgresBackend {
+class PostgresStore {
   constructor(config) {
     this.config = config;
   }
@@ -57,7 +57,7 @@ class PostgresBackend {
   isConnected() {
     return this.connected && this.pool !== null;
   }
-  getBackendType() {
+  getStoreType() {
     return "postgres";
   }
   // Core operations
@@ -83,7 +83,7 @@ class PostgresBackend {
     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, JSON.stringify(value), /* @__PURE__ */ new Date()]
+        [key, value, /* @__PURE__ */ new Date()]
       );
     } finally {
       client.release();
@@ -131,7 +131,7 @@ class PostgresBackend {
     try {
       await client.query("INSERT INTO lists (key, item, created_at) VALUES ($1, $2, $3)", [
         key,
-        JSON.stringify(item),
+        item,
         /* @__PURE__ */ new Date()
       ]);
     } finally {
@@ -146,7 +146,7 @@ class PostgresBackend {
         "SELECT item FROM lists WHERE key = $1 ORDER BY created_at ASC LIMIT $2 OFFSET $3",
         [key, count, start]
       );
-      return result.rows.map((row) => JSON.parse(row.item));
+      return result.rows.map((row) => row.item);
     } finally {
       client.release();
     }
@@ -176,7 +176,7 @@ class PostgresBackend {
   }
   checkConnection() {
     if (!this.connected || !this.pool) {
-      throw import_errors.StorageError.notConnected("PostgresBackend");
+      throw import_errors.StorageError.notConnected("PostgresStore");
     }
   }
   // Advanced operations
@@ -227,5 +227,5 @@ class PostgresBackend {
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  PostgresBackend
+  PostgresStore
 });

package/dist/storage/{backend/postgres-backend.d.ts → database/postgres-store.d.ts}

@@ -1,22 +1,20 @@
 import { PoolClient } from 'pg';
-import { DatabaseBackend } from './database-backend.js';
-import { PostgresBackendConfig } from '../schemas.js';
-import 'zod';
-
+import type { Database } from './types.js';
+import type { PostgresDatabaseConfig } from './schemas.js';
 /**
- * PostgreSQL storage backend for production database operations.
- * Implements the DatabaseBackend interface with connection pooling and JSONB support.
+ * PostgreSQL database store for production database operations.
+ * Implements the Database interface with connection pooling and JSONB support.
  * EXPERIMENTAL - NOT FULLY TESTED YET
  */
-declare class PostgresBackend implements DatabaseBackend {
+export declare class PostgresStore implements Database {
     private config;
     private pool;
     private connected;
-    constructor(config: PostgresBackendConfig);
+    constructor(config: PostgresDatabaseConfig);
     connect(): Promise<void>;
     disconnect(): Promise<void>;
     isConnected(): boolean;
-    getBackendType(): string;
+    getStoreType(): string;
     get<T>(key: string): Promise<T | undefined>;
     set<T>(key: string, value: T): Promise<void>;
     delete(key: string): Promise<void>;
@@ -33,5 +31,4 @@ declare class PostgresBackend implements DatabaseBackend {
     }>;
     vacuum(): Promise<void>;
 }
-
-export { PostgresBackend };
+//# sourceMappingURL=postgres-store.d.ts.map

package/dist/storage/database/postgres-store.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"postgres-store.d.ts","sourceRoot":"","sources":["../../../src/storage/database/postgres-store.ts"],"names":[],"mappings":"AAAA,OAAO,EAAQ,UAAU,EAAE,MAAM,IAAI,CAAC;AACtC,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AAC3C,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,cAAc,CAAC;AAG3D;;;;GAIG;AACH,qBAAa,aAAc,YAAW,QAAQ;IAI9B,OAAO,CAAC,MAAM;IAH1B,OAAO,CAAC,IAAI,CAAqB;IACjC,OAAO,CAAC,SAAS,CAAS;gBAEN,MAAM,EAAE,sBAAsB;IAE5C,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC;IAsBxB,UAAU,IAAI,OAAO,CAAC,IAAI,CAAC;IAQjC,WAAW,IAAI,OAAO;IAItB,YAAY,IAAI,MAAM;IAKhB,GAAG,CAAC,CAAC,EAAE,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,CAAC,GAAG,SAAS,CAAC;IAiB3C,GAAG,CAAC,CAAC,EAAE,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,CAAC,GAAG,OAAO,CAAC,IAAI,CAAC;IAa5C,MAAM,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAiBlC,IAAI,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,EAAE,CAAC;IAuBvC,MAAM,CAAC,CAAC,EAAE,GAAG,EAAE,MAAM,EAAE,IAAI,EAAE,CAAC,GAAG,OAAO,CAAC,IAAI,CAAC;IAc9C,QAAQ,CAAC,CAAC,EAAE,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,CAAC,EAAE,CAAC;YAe5D,YAAY;IA4B1B,OAAO,CAAC,eAAe;IAOjB,WAAW,CAAC,CAAC,EAAE,QAAQ,EAAE,CAAC,MAAM,EAAE,UAAU,KAAK,OAAO,CAAC,CAAC,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC;IAgBxE,QAAQ,IAAI,OAAO,CAAC;QACtB,OAAO,EAAE,MAAM,CAAC;QAChB,SAAS,EAAE,MAAM,CAAC;QAClB,SAAS,EAAE,MAAM,CAAC;KACrB,CAAC;IAsBI,MAAM,IAAI,OAAO,CAAC,IAAI,CAAC;CAShC"}

package/dist/storage/{backend/postgres-backend.js → database/postgres-store.js}

@@ -1,6 +1,7 @@
+import "../../chunk-C6A6W6XS.js";
 import { Pool } from "pg";
 import { StorageError } from "../errors.js";
-class PostgresBackend {
+class PostgresStore {
   constructor(config) {
     this.config = config;
   }
@@ -34,7 +35,7 @@ class PostgresBackend {
   isConnected() {
     return this.connected && this.pool !== null;
   }
-  getBackendType() {
+  getStoreType() {
     return "postgres";
   }
   // Core operations
@@ -60,7 +61,7 @@ class PostgresBackend {
     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, JSON.stringify(value), /* @__PURE__ */ new Date()]
+        [key, value, /* @__PURE__ */ new Date()]
       );
     } finally {
       client.release();
@@ -108,7 +109,7 @@ class PostgresBackend {
     try {
       await client.query("INSERT INTO lists (key, item, created_at) VALUES ($1, $2, $3)", [
         key,
-        JSON.stringify(item),
+        item,
         /* @__PURE__ */ new Date()
       ]);
     } finally {
@@ -123,7 +124,7 @@ class PostgresBackend {
         "SELECT item FROM lists WHERE key = $1 ORDER BY created_at ASC LIMIT $2 OFFSET $3",
         [key, count, start]
       );
-      return result.rows.map((row) => JSON.parse(row.item));
+      return result.rows.map((row) => row.item);
     } finally {
       client.release();
     }
@@ -153,7 +154,7 @@ class PostgresBackend {
   }
   checkConnection() {
     if (!this.connected || !this.pool) {
-      throw StorageError.notConnected("PostgresBackend");
+      throw StorageError.notConnected("PostgresStore");
     }
   }
   // Advanced operations
@@ -203,5 +204,5 @@ class PostgresBackend {
   }
 }
 export {
-  PostgresBackend
+  PostgresStore
 };

package/dist/storage/database/schemas.cjs

@@ -0,0 +1,89 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var schemas_exports = {};
+__export(schemas_exports, {
+  DATABASE_TYPES: () => DATABASE_TYPES,
+  DatabaseConfigSchema: () => DatabaseConfigSchema
+});
+module.exports = __toCommonJS(schemas_exports);
+var import_zod = require("zod");
+var import_result = require("../../utils/result.cjs");
+var import_error_codes = require("../error-codes.js");
+var import_types = require("../../errors/types.cjs");
+const DATABASE_TYPES = ["in-memory", "sqlite", "postgres"];
+const BaseDatabaseSchema = import_zod.z.object({
+  maxConnections: import_zod.z.number().int().positive().optional().describe("Maximum connections"),
+  idleTimeoutMillis: import_zod.z.number().int().positive().optional().describe("Idle timeout in milliseconds"),
+  connectionTimeoutMillis: import_zod.z.number().int().positive().optional().describe("Connection timeout in milliseconds"),
+  options: import_zod.z.record(import_zod.z.any()).optional().describe("Backend-specific options")
+});
+const InMemoryDatabaseSchema = BaseDatabaseSchema.extend({
+  type: import_zod.z.literal("in-memory")
+  // In-memory database doesn't need connection options, but inherits pool options for consistency
+}).strict();
+const SqliteDatabaseSchema = BaseDatabaseSchema.extend({
+  type: import_zod.z.literal("sqlite"),
+  path: import_zod.z.string().optional().describe(
+    "SQLite database file path (optional, will auto-detect using path resolver if not provided)"
+  ),
+  database: import_zod.z.string().optional().describe("Database filename (default: <agent-id>.db)")
+}).strict();
+const PostgresDatabaseSchema = BaseDatabaseSchema.extend({
+  type: import_zod.z.literal("postgres"),
+  url: (0, import_result.EnvExpandedString)().optional().describe("PostgreSQL connection URL (postgresql://...)"),
+  connectionString: (0, import_result.EnvExpandedString)().optional().describe("PostgreSQL connection string"),
+  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")
+}).strict();
+const DatabaseConfigSchema = import_zod.z.discriminatedUnion(
+  "type",
+  [InMemoryDatabaseSchema, SqliteDatabaseSchema, PostgresDatabaseSchema],
+  {
+    errorMap: (issue, ctx) => {
+      if (issue.code === import_zod.z.ZodIssueCode.invalid_union_discriminator) {
+        return {
+          message: `Invalid database type. Expected 'in-memory', 'sqlite', or 'postgres'.`
+        };
+      }
+      return { message: ctx.defaultError };
+    }
+  }
+).describe("Database configuration").superRefine((data, ctx) => {
+  if (data.type === "postgres") {
+    if (!data.url && !data.connectionString && !data.host) {
+      ctx.addIssue({
+        code: import_zod.z.ZodIssueCode.custom,
+        message: "PostgreSQL database requires one of 'url', 'connectionString', or 'host' to be specified",
+        path: ["url"],
+        params: {
+          code: import_error_codes.StorageErrorCode.CONNECTION_CONFIG_MISSING,
+          scope: import_types.ErrorScope.STORAGE,
+          type: import_types.ErrorType.USER
+        }
+      });
+    }
+  }
+});
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  DATABASE_TYPES,
+  DatabaseConfigSchema
+});

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

@@ -0,0 +1,227 @@
+import { z } from 'zod';
+export declare const DATABASE_TYPES: readonly ["in-memory", "sqlite", "postgres"];
+export type DatabaseType = (typeof DATABASE_TYPES)[number];
+declare const InMemoryDatabaseSchema: z.ZodObject<{
+    maxConnections: z.ZodOptional<z.ZodNumber>;
+    idleTimeoutMillis: z.ZodOptional<z.ZodNumber>;
+    connectionTimeoutMillis: z.ZodOptional<z.ZodNumber>;
+    options: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+} & {
+    type: z.ZodLiteral<"in-memory">;
+}, "strict", z.ZodTypeAny, {
+    type: "in-memory";
+    options?: Record<string, any> | undefined;
+    maxConnections?: number | undefined;
+    idleTimeoutMillis?: number | undefined;
+    connectionTimeoutMillis?: number | undefined;
+}, {
+    type: "in-memory";
+    options?: Record<string, any> | undefined;
+    maxConnections?: number | undefined;
+    idleTimeoutMillis?: number | undefined;
+    connectionTimeoutMillis?: number | undefined;
+}>;
+export type InMemoryDatabaseConfig = z.output<typeof InMemoryDatabaseSchema>;
+declare const SqliteDatabaseSchema: z.ZodObject<{
+    maxConnections: z.ZodOptional<z.ZodNumber>;
+    idleTimeoutMillis: z.ZodOptional<z.ZodNumber>;
+    connectionTimeoutMillis: z.ZodOptional<z.ZodNumber>;
+    options: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+} & {
+    type: z.ZodLiteral<"sqlite">;
+    path: z.ZodOptional<z.ZodString>;
+    database: z.ZodOptional<z.ZodString>;
+}, "strict", z.ZodTypeAny, {
+    type: "sqlite";
+    path?: string | undefined;
+    options?: Record<string, any> | undefined;
+    maxConnections?: number | undefined;
+    idleTimeoutMillis?: number | undefined;
+    connectionTimeoutMillis?: number | undefined;
+    database?: string | undefined;
+}, {
+    type: "sqlite";
+    path?: string | undefined;
+    options?: Record<string, any> | undefined;
+    maxConnections?: number | undefined;
+    idleTimeoutMillis?: number | undefined;
+    connectionTimeoutMillis?: number | undefined;
+    database?: string | undefined;
+}>;
+export type SqliteDatabaseConfig = z.output<typeof SqliteDatabaseSchema>;
+declare const PostgresDatabaseSchema: z.ZodObject<{
+    maxConnections: z.ZodOptional<z.ZodNumber>;
+    idleTimeoutMillis: z.ZodOptional<z.ZodNumber>;
+    connectionTimeoutMillis: z.ZodOptional<z.ZodNumber>;
+    options: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+} & {
+    type: z.ZodLiteral<"postgres">;
+    url: z.ZodOptional<z.ZodEffects<z.ZodString, string, string>>;
+    connectionString: z.ZodOptional<z.ZodEffects<z.ZodString, string, string>>;
+    host: z.ZodOptional<z.ZodString>;
+    port: z.ZodOptional<z.ZodNumber>;
+    database: z.ZodOptional<z.ZodString>;
+    password: z.ZodOptional<z.ZodString>;
+}, "strict", z.ZodTypeAny, {
+    type: "postgres";
+    password?: string | undefined;
+    options?: Record<string, any> | undefined;
+    url?: string | undefined;
+    maxConnections?: number | undefined;
+    idleTimeoutMillis?: number | undefined;
+    connectionTimeoutMillis?: number | undefined;
+    host?: string | undefined;
+    port?: number | undefined;
+    database?: string | undefined;
+    connectionString?: string | undefined;
+}, {
+    type: "postgres";
+    password?: string | undefined;
+    options?: Record<string, any> | undefined;
+    url?: string | undefined;
+    maxConnections?: number | undefined;
+    idleTimeoutMillis?: number | undefined;
+    connectionTimeoutMillis?: number | undefined;
+    host?: string | undefined;
+    port?: number | undefined;
+    database?: string | undefined;
+    connectionString?: string | undefined;
+}>;
+export type PostgresDatabaseConfig = z.output<typeof PostgresDatabaseSchema>;
+export declare const DatabaseConfigSchema: z.ZodEffects<z.ZodDiscriminatedUnion<"type", [z.ZodObject<{
+    maxConnections: z.ZodOptional<z.ZodNumber>;
+    idleTimeoutMillis: z.ZodOptional<z.ZodNumber>;
+    connectionTimeoutMillis: z.ZodOptional<z.ZodNumber>;
+    options: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+} & {
+    type: z.ZodLiteral<"in-memory">;
+}, "strict", z.ZodTypeAny, {
+    type: "in-memory";
+    options?: Record<string, any> | undefined;
+    maxConnections?: number | undefined;
+    idleTimeoutMillis?: number | undefined;
+    connectionTimeoutMillis?: number | undefined;
+}, {
+    type: "in-memory";
+    options?: Record<string, any> | undefined;
+    maxConnections?: number | undefined;
+    idleTimeoutMillis?: number | undefined;
+    connectionTimeoutMillis?: number | undefined;
+}>, z.ZodObject<{
+    maxConnections: z.ZodOptional<z.ZodNumber>;
+    idleTimeoutMillis: z.ZodOptional<z.ZodNumber>;
+    connectionTimeoutMillis: z.ZodOptional<z.ZodNumber>;
+    options: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+} & {
+    type: z.ZodLiteral<"sqlite">;
+    path: z.ZodOptional<z.ZodString>;
+    database: z.ZodOptional<z.ZodString>;
+}, "strict", z.ZodTypeAny, {
+    type: "sqlite";
+    path?: string | undefined;
+    options?: Record<string, any> | undefined;
+    maxConnections?: number | undefined;
+    idleTimeoutMillis?: number | undefined;
+    connectionTimeoutMillis?: number | undefined;
+    database?: string | undefined;
+}, {
+    type: "sqlite";
+    path?: string | undefined;
+    options?: Record<string, any> | undefined;
+    maxConnections?: number | undefined;
+    idleTimeoutMillis?: number | undefined;
+    connectionTimeoutMillis?: number | undefined;
+    database?: string | undefined;
+}>, z.ZodObject<{
+    maxConnections: z.ZodOptional<z.ZodNumber>;
+    idleTimeoutMillis: z.ZodOptional<z.ZodNumber>;
+    connectionTimeoutMillis: z.ZodOptional<z.ZodNumber>;
+    options: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+} & {
+    type: z.ZodLiteral<"postgres">;
+    url: z.ZodOptional<z.ZodEffects<z.ZodString, string, string>>;
+    connectionString: z.ZodOptional<z.ZodEffects<z.ZodString, string, string>>;
+    host: z.ZodOptional<z.ZodString>;
+    port: z.ZodOptional<z.ZodNumber>;
+    database: z.ZodOptional<z.ZodString>;
+    password: z.ZodOptional<z.ZodString>;
+}, "strict", z.ZodTypeAny, {
+    type: "postgres";
+    password?: string | undefined;
+    options?: Record<string, any> | undefined;
+    url?: string | undefined;
+    maxConnections?: number | undefined;
+    idleTimeoutMillis?: number | undefined;
+    connectionTimeoutMillis?: number | undefined;
+    host?: string | undefined;
+    port?: number | undefined;
+    database?: string | undefined;
+    connectionString?: string | undefined;
+}, {
+    type: "postgres";
+    password?: string | undefined;
+    options?: Record<string, any> | undefined;
+    url?: string | undefined;
+    maxConnections?: number | undefined;
+    idleTimeoutMillis?: number | undefined;
+    connectionTimeoutMillis?: number | undefined;
+    host?: string | undefined;
+    port?: number | undefined;
+    database?: string | undefined;
+    connectionString?: string | undefined;
+}>]>, {
+    type: "in-memory";
+    options?: Record<string, any> | undefined;
+    maxConnections?: number | undefined;
+    idleTimeoutMillis?: number | undefined;
+    connectionTimeoutMillis?: number | undefined;
+} | {
+    type: "sqlite";
+    path?: string | undefined;
+    options?: Record<string, any> | undefined;
+    maxConnections?: number | undefined;
+    idleTimeoutMillis?: number | undefined;
+    connectionTimeoutMillis?: number | undefined;
+    database?: string | undefined;
+} | {
+    type: "postgres";
+    password?: string | undefined;
+    options?: Record<string, any> | undefined;
+    url?: string | undefined;
+    maxConnections?: number | undefined;
+    idleTimeoutMillis?: number | undefined;
+    connectionTimeoutMillis?: number | undefined;
+    host?: string | undefined;
+    port?: number | undefined;
+    database?: string | undefined;
+    connectionString?: string | undefined;
+}, {
+    type: "in-memory";
+    options?: Record<string, any> | undefined;
+    maxConnections?: number | undefined;
+    idleTimeoutMillis?: number | undefined;
+    connectionTimeoutMillis?: number | undefined;
+} | {
+    type: "sqlite";
+    path?: string | undefined;
+    options?: Record<string, any> | undefined;
+    maxConnections?: number | undefined;
+    idleTimeoutMillis?: number | undefined;
+    connectionTimeoutMillis?: number | undefined;
+    database?: string | undefined;
+} | {
+    type: "postgres";
+    password?: string | undefined;
+    options?: Record<string, any> | undefined;
+    url?: string | undefined;
+    maxConnections?: number | undefined;
+    idleTimeoutMillis?: number | undefined;
+    connectionTimeoutMillis?: number | undefined;
+    host?: string | undefined;
+    port?: number | undefined;
+    database?: string | undefined;
+    connectionString?: string | undefined;
+}>;
+export type DatabaseConfig = z.output<typeof DatabaseConfigSchema>;
+export {};
+//# sourceMappingURL=schemas.d.ts.map

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

@@ -0,0 +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,QAAA,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;;EAGjB,CAAC;AAEZ,MAAM,MAAM,sBAAsB,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,sBAAsB,CAAC,CAAC;AAG7E,QAAA,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;EASf,CAAC;AAEZ,MAAM,MAAM,oBAAoB,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,oBAAoB,CAAC,CAAC;AAGzE,QAAA,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAQjB,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

@@ -0,0 +1,65 @@
+import "../../chunk-C6A6W6XS.js";
+import { z } from "zod";
+import { EnvExpandedString } from "../../utils/result.js";
+import { StorageErrorCode } from "../error-codes.js";
+import { ErrorScope, ErrorType } from "../../errors/types.js";
+const DATABASE_TYPES = ["in-memory", "sqlite", "postgres"];
+const BaseDatabaseSchema = z.object({
+  maxConnections: z.number().int().positive().optional().describe("Maximum connections"),
+  idleTimeoutMillis: z.number().int().positive().optional().describe("Idle timeout in milliseconds"),
+  connectionTimeoutMillis: z.number().int().positive().optional().describe("Connection timeout in milliseconds"),
+  options: z.record(z.any()).optional().describe("Backend-specific options")
+});
+const InMemoryDatabaseSchema = BaseDatabaseSchema.extend({
+  type: z.literal("in-memory")
+  // In-memory database doesn't need connection options, but inherits pool options for consistency
+}).strict();
+const SqliteDatabaseSchema = BaseDatabaseSchema.extend({
+  type: z.literal("sqlite"),
+  path: z.string().optional().describe(
+    "SQLite database file path (optional, will auto-detect using path resolver if not provided)"
+  ),
+  database: z.string().optional().describe("Database filename (default: <agent-id>.db)")
+}).strict();
+const PostgresDatabaseSchema = BaseDatabaseSchema.extend({
+  type: z.literal("postgres"),
+  url: EnvExpandedString().optional().describe("PostgreSQL connection URL (postgresql://...)"),
+  connectionString: EnvExpandedString().optional().describe("PostgreSQL connection string"),
+  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")
+}).strict();
+const DatabaseConfigSchema = z.discriminatedUnion(
+  "type",
+  [InMemoryDatabaseSchema, SqliteDatabaseSchema, PostgresDatabaseSchema],
+  {
+    errorMap: (issue, ctx) => {
+      if (issue.code === z.ZodIssueCode.invalid_union_discriminator) {
+        return {
+          message: `Invalid database type. Expected 'in-memory', 'sqlite', or 'postgres'.`
+        };
+      }
+      return { message: ctx.defaultError };
+    }
+  }
+).describe("Database configuration").superRefine((data, ctx) => {
+  if (data.type === "postgres") {
+    if (!data.url && !data.connectionString && !data.host) {
+      ctx.addIssue({
+        code: z.ZodIssueCode.custom,
+        message: "PostgreSQL database requires one of 'url', 'connectionString', or 'host' to be specified",
+        path: ["url"],
+        params: {
+          code: StorageErrorCode.CONNECTION_CONFIG_MISSING,
+          scope: ErrorScope.STORAGE,
+          type: ErrorType.USER
+        }
+      });
+    }
+  }
+});
+export {
+  DATABASE_TYPES,
+  DatabaseConfigSchema
+};