@axiom-lattice/core 2.1.13 → 2.1.15

package/dist/index.mjs

@@ -588,6 +588,538 @@ registerToolLattice(
   }
 );
 
+// src/tool_lattice/sql/list_tables_sql.ts
+import z3 from "zod";
+
+// src/tool_lattice/sql/SqlDatabaseManager.ts
+var PostgresDatabase = class {
+  constructor(config) {
+    // pg.Pool
+    this.connected = false;
+    this.config = config;
+  }
+  async connect() {
+    if (this.connected) return;
+    try {
+      const { Pool } = await import("pg");
+      const poolConfig = this.config.connectionString ? { connectionString: this.config.connectionString } : {
+        host: this.config.host || "localhost",
+        port: this.config.port || 5432,
+        database: this.config.database,
+        user: this.config.user,
+        password: this.config.password,
+        ssl: this.config.ssl ? { rejectUnauthorized: false } : void 0
+      };
+      this.pool = new Pool(poolConfig);
+      const client = await this.pool.connect();
+      client.release();
+      this.connected = true;
+    } catch (error) {
+      throw new Error(`Failed to connect to PostgreSQL: ${error}`);
+    }
+  }
+  async disconnect() {
+    if (this.pool) {
+      await this.pool.end();
+      this.connected = false;
+    }
+  }
+  async listTables() {
+    await this.ensureConnected();
+    const query = `
+      SELECT table_name, table_schema
+      FROM information_schema.tables
+      WHERE table_schema NOT IN ('pg_catalog', 'information_schema')
+        AND table_type = 'BASE TABLE'
+      ORDER BY table_schema, table_name;
+    `;
+    const result = await this.pool.query(query);
+    return result.rows.map((row) => ({
+      name: row.table_name,
+      schema: row.table_schema
+    }));
+  }
+  async getTableInfo(tables) {
+    await this.ensureConnected();
+    const schemas = [];
+    for (const tableName of tables) {
+      const columnQuery = `
+        SELECT 
+          c.column_name,
+          c.data_type,
+          c.is_nullable,
+          c.column_default,
+          CASE WHEN pk.column_name IS NOT NULL THEN true ELSE false END as is_primary_key,
+          CASE WHEN fk.column_name IS NOT NULL THEN true ELSE false END as is_foreign_key,
+          fk.foreign_table_name,
+          fk.foreign_column_name
+        FROM information_schema.columns c
+        LEFT JOIN (
+          SELECT ku.column_name, ku.table_name
+          FROM information_schema.table_constraints tc
+          JOIN information_schema.key_column_usage ku
+            ON tc.constraint_name = ku.constraint_name
+          WHERE tc.constraint_type = 'PRIMARY KEY'
+        ) pk ON c.column_name = pk.column_name AND c.table_name = pk.table_name
+        LEFT JOIN (
+          SELECT 
+            kcu.column_name,
+            kcu.table_name,
+            ccu.table_name as foreign_table_name,
+            ccu.column_name as foreign_column_name
+          FROM information_schema.table_constraints tc
+          JOIN information_schema.key_column_usage kcu
+            ON tc.constraint_name = kcu.constraint_name
+          JOIN information_schema.constraint_column_usage ccu
+            ON tc.constraint_name = ccu.constraint_name
+          WHERE tc.constraint_type = 'FOREIGN KEY'
+        ) fk ON c.column_name = fk.column_name AND c.table_name = fk.table_name
+        WHERE c.table_name = $1
+        ORDER BY c.ordinal_position;
+      `;
+      const columnResult = await this.pool.query(columnQuery, [tableName]);
+      const columns = columnResult.rows.map((row) => ({
+        name: row.column_name,
+        type: row.data_type,
+        nullable: row.is_nullable === "YES",
+        default: row.column_default,
+        isPrimaryKey: row.is_primary_key,
+        isForeignKey: row.is_foreign_key,
+        foreignKeyRef: row.is_foreign_key ? `${row.foreign_table_name}.${row.foreign_column_name}` : void 0
+      }));
+      let sampleRows = [];
+      try {
+        const sampleQuery = `SELECT * FROM "${tableName}" LIMIT 3`;
+        const sampleResult = await this.pool.query(sampleQuery);
+        sampleRows = sampleResult.rows;
+      } catch {
+      }
+      schemas.push({
+        tableName,
+        columns,
+        sampleRows
+      });
+    }
+    return schemas;
+  }
+  async executeQuery(query) {
+    await this.ensureConnected();
+    const result = await this.pool.query(query);
+    return {
+      rows: result.rows,
+      rowCount: result.rowCount || result.rows.length,
+      fields: result.fields?.map((f) => f.name)
+    };
+  }
+  getDatabaseType() {
+    return "postgres";
+  }
+  async ensureConnected() {
+    if (!this.connected) {
+      await this.connect();
+    }
+  }
+};
+var SqlDatabaseManager = class _SqlDatabaseManager {
+  constructor() {
+    this.databases = /* @__PURE__ */ new Map();
+    this.defaultDatabaseKey = null;
+  }
+  /**
+   * Get the singleton instance
+   */
+  static getInstance() {
+    if (!_SqlDatabaseManager.instance) {
+      _SqlDatabaseManager.instance = new _SqlDatabaseManager();
+    }
+    return _SqlDatabaseManager.instance;
+  }
+  /**
+   * Register a database connection
+   * @param key - Unique identifier for the database
+   * @param config - Database configuration
+   */
+  registerDatabase(key, config) {
+    let database;
+    switch (config.type) {
+      case "postgres":
+        database = new PostgresDatabase(config);
+        break;
+      case "mysql":
+        throw new Error("MySQL support not yet implemented");
+      case "sqlite":
+        throw new Error("SQLite support not yet implemented");
+      default:
+        throw new Error(`Unsupported database type: ${config.type}`);
+    }
+    this.databases.set(key, database);
+    if (this.defaultDatabaseKey === null) {
+      this.defaultDatabaseKey = key;
+    }
+  }
+  /**
+   * Set the default database
+   * @param key - Database key to set as default
+   */
+  setDefaultDatabase(key) {
+    if (!this.databases.has(key)) {
+      throw new Error(`Database '${key}' not found`);
+    }
+    this.defaultDatabaseKey = key;
+  }
+  /**
+   * Get a database by key
+   * @param key - Database key (optional, uses default if not provided)
+   */
+  getDatabase(key) {
+    const dbKey = key || this.defaultDatabaseKey;
+    if (!dbKey) {
+      throw new Error("No database registered");
+    }
+    const database = this.databases.get(dbKey);
+    if (!database) {
+      throw new Error(`Database '${dbKey}' not found`);
+    }
+    return database;
+  }
+  /**
+   * Check if a database is registered
+   * @param key - Database key
+   */
+  hasDatabase(key) {
+    return this.databases.has(key);
+  }
+  /**
+   * Get all registered database keys
+   */
+  getDatabaseKeys() {
+    return Array.from(this.databases.keys());
+  }
+  /**
+   * Remove a database connection
+   * @param key - Database key
+   */
+  async removeDatabase(key) {
+    const database = this.databases.get(key);
+    if (database) {
+      await database.disconnect();
+      this.databases.delete(key);
+      if (this.defaultDatabaseKey === key) {
+        this.defaultDatabaseKey = this.databases.size > 0 ? this.databases.keys().next().value || null : null;
+      }
+    }
+  }
+  /**
+   * Disconnect all databases
+   */
+  async disconnectAll() {
+    for (const database of this.databases.values()) {
+      await database.disconnect();
+    }
+  }
+};
+var sqlDatabaseManager = SqlDatabaseManager.getInstance();
+
+// src/tool_lattice/sql/list_tables_sql.ts
+function getDatabaseKeyFromConfig(config) {
+  const runConfig = config.configurable?.runConfig;
+  return runConfig?.databaseKey;
+}
+registerToolLattice(
+  "list_tables_sql",
+  {
+    name: "list_tables_sql",
+    description: "List all tables in the connected SQL database. Returns a comma-separated list of table names. Use this tool first to understand what tables are available before querying the database.",
+    needUserApprove: false,
+    schema: z3.object({})
+  },
+  async (_input, config) => {
+    try {
+      const databaseKey = getDatabaseKeyFromConfig(config);
+      const database = sqlDatabaseManager.getDatabase(databaseKey);
+      const tables = await database.listTables();
+      if (tables.length === 0) {
+        return "No tables found in the database.";
+      }
+      const tableNames = tables.map(
+        (t) => t.schema && t.schema !== "public" ? `${t.schema}.${t.name}` : t.name
+      );
+      return tableNames.join(", ");
+    } catch (error) {
+      return `Error listing tables: ${error instanceof Error ? error.message : String(error)}`;
+    }
+  }
+);
+
+// src/tool_lattice/sql/info_sql.ts
+import z4 from "zod";
+function getDatabaseKeyFromConfig2(config) {
+  const runConfig = config.configurable?.runConfig;
+  return runConfig?.databaseKey;
+}
+function formatTableSchema(schema) {
+  const lines = [];
+  lines.push(`
+Table: ${schema.tableName}`);
+  lines.push("-".repeat(40));
+  lines.push("Columns:");
+  for (const col of schema.columns) {
+    const constraints = [];
+    if (col.isPrimaryKey) constraints.push("PRIMARY KEY");
+    if (col.isForeignKey && col.foreignKeyRef)
+      constraints.push(`FK -> ${col.foreignKeyRef}`);
+    if (!col.nullable) constraints.push("NOT NULL");
+    const constraintStr = constraints.length > 0 ? ` [${constraints.join(", ")}]` : "";
+    lines.push(`  - ${col.name}: ${col.type}${constraintStr}`);
+  }
+  if (schema.sampleRows && schema.sampleRows.length > 0) {
+    lines.push("\nSample Rows (up to 3):");
+    for (const row of schema.sampleRows) {
+      const rowStr = Object.entries(row).map(([k, v]) => `${k}=${JSON.stringify(v)}`).join(", ");
+      lines.push(`  ${rowStr}`);
+    }
+  }
+  return lines.join("\n");
+}
+registerToolLattice(
+  "info_sql",
+  {
+    name: "info_sql",
+    description: "Get detailed schema information for specified tables, including column names, types, constraints (primary keys, foreign keys), and sample rows. Input should be a comma-separated list of table names.",
+    needUserApprove: false,
+    schema: z4.object({
+      tables: z4.string().describe(
+        "Comma-separated list of table names to get information for. Example: 'users, orders, products'"
+      )
+    })
+  },
+  async ({
+    tables
+  }, config) => {
+    try {
+      const databaseKey = getDatabaseKeyFromConfig2(config);
+      const database = sqlDatabaseManager.getDatabase(databaseKey);
+      const tableNames = tables.split(",").map((t) => t.trim()).filter((t) => t.length > 0);
+      if (tableNames.length === 0) {
+        return "Error: No table names provided. Please provide a comma-separated list of table names.";
+      }
+      const schemas = await database.getTableInfo(tableNames);
+      if (schemas.length === 0) {
+        return `No schema information found for tables: ${tableNames.join(", ")}`;
+      }
+      const output = schemas.map(formatTableSchema).join("\n");
+      return output;
+    } catch (error) {
+      return `Error getting table info: ${error instanceof Error ? error.message : String(error)}`;
+    }
+  }
+);
+
+// src/tool_lattice/sql/query_sql.ts
+import z5 from "zod";
+function getDatabaseKeyFromConfig3(config) {
+  const runConfig = config.configurable?.runConfig;
+  return runConfig?.databaseKey;
+}
+function formatQueryResult(rows, fields) {
+  if (rows.length === 0) {
+    return "Query executed successfully. No rows returned.";
+  }
+  const lines = [];
+  const columns = fields || Object.keys(rows[0]);
+  lines.push(columns.join(" | "));
+  lines.push("-".repeat(columns.join(" | ").length));
+  const maxRows = 50;
+  const displayRows = rows.slice(0, maxRows);
+  for (const row of displayRows) {
+    const values = columns.map((col) => {
+      const val = row[col];
+      if (val === null) return "NULL";
+      if (typeof val === "object") return JSON.stringify(val);
+      return String(val);
+    });
+    lines.push(values.join(" | "));
+  }
+  if (rows.length > maxRows) {
+    lines.push(`
+... (${rows.length - maxRows} more rows not shown)`);
+  }
+  lines.push(`
+Total rows: ${rows.length}`);
+  return lines.join("\n");
+}
+registerToolLattice(
+  "query_sql",
+  {
+    name: "query_sql",
+    description: "Execute a SQL query against the database and return the results. Input should be a valid SQL query. Use this tool to retrieve data from the database. For complex queries, first use list_tables_sql and info_sql to understand the database schema.",
+    needUserApprove: false,
+    // SQL queries should require user approval for safety
+    schema: z5.object({
+      query: z5.string().describe(
+        "The SQL query to execute. Should be a valid SELECT, INSERT, UPDATE, or DELETE statement."
+      )
+    })
+  },
+  async ({
+    query
+  }, config) => {
+    try {
+      const databaseKey = getDatabaseKeyFromConfig3(config);
+      const database = sqlDatabaseManager.getDatabase(databaseKey);
+      const trimmedQuery = query.trim();
+      if (!trimmedQuery) {
+        return "Error: Empty query provided. Please provide a valid SQL query.";
+      }
+      const result = await database.executeQuery(trimmedQuery);
+      return formatQueryResult(result.rows, result.fields);
+    } catch (error) {
+      return `Error executing query: ${error instanceof Error ? error.message : String(error)}`;
+    }
+  }
+);
+
+// src/tool_lattice/sql/query_checker_sql.ts
+import z6 from "zod";
+function getDatabaseKeyFromConfig4(config) {
+  const runConfig = config.configurable?.runConfig;
+  return runConfig?.databaseKey;
+}
+var DANGEROUS_KEYWORDS = [
+  "DROP",
+  "TRUNCATE",
+  "DELETE",
+  "ALTER",
+  "CREATE",
+  "GRANT",
+  "REVOKE"
+];
+function checkSyntax(query) {
+  const issues = [];
+  const upperQuery = query.toUpperCase();
+  let parenCount = 0;
+  for (const char of query) {
+    if (char === "(") parenCount++;
+    if (char === ")") parenCount--;
+    if (parenCount < 0) {
+      issues.push("Unbalanced parentheses: found closing ) without matching (");
+      break;
+    }
+  }
+  if (parenCount > 0) {
+    issues.push("Unbalanced parentheses: missing closing )");
+  }
+  const singleQuotes = (query.match(/'/g) || []).length;
+  if (singleQuotes % 2 !== 0) {
+    issues.push("Unbalanced single quotes");
+  }
+  if (upperQuery.includes("SELECT *") && upperQuery.includes("JOIN")) {
+    issues.push(
+      "Warning: SELECT * with JOIN may return duplicate column names. Consider specifying columns explicitly."
+    );
+  }
+  if ((upperQuery.includes("UPDATE ") || upperQuery.includes("DELETE FROM ")) && !upperQuery.includes("WHERE ")) {
+    issues.push(
+      "Warning: UPDATE or DELETE without WHERE clause will affect all rows in the table."
+    );
+  }
+  if (upperQuery.includes("GROUP BY") && !upperQuery.match(/\b(COUNT|SUM|AVG|MAX|MIN|ARRAY_AGG|STRING_AGG)\s*\(/i)) {
+    issues.push(
+      "Warning: GROUP BY used but no aggregate functions found. Make sure all non-aggregated columns are in GROUP BY."
+    );
+  }
+  return issues;
+}
+function checkDangerousOperations(query) {
+  const warnings = [];
+  const upperQuery = query.toUpperCase();
+  for (const keyword of DANGEROUS_KEYWORDS) {
+    if (upperQuery.includes(keyword)) {
+      warnings.push(
+        `Warning: Query contains potentially dangerous operation: ${keyword}`
+      );
+    }
+  }
+  return warnings;
+}
+registerToolLattice(
+  "query_checker_sql",
+  {
+    name: "query_checker_sql",
+    description: "Check a SQL query for common issues before execution. This tool validates syntax, checks for dangerous operations, and provides suggestions for improvement. Use this before executing queries to ensure they are safe and correct.",
+    needUserApprove: false,
+    schema: z6.object({
+      query: z6.string().describe("The SQL query to check and validate.")
+    })
+  },
+  async ({
+    query
+  }, config) => {
+    try {
+      const trimmedQuery = query.trim();
+      if (!trimmedQuery) {
+        return "Error: Empty query provided. Please provide a SQL query to check.";
+      }
+      const results = [];
+      results.push("SQL Query Check Results:");
+      results.push("=".repeat(40));
+      results.push(`
+Query:
+${trimmedQuery}
+`);
+      const syntaxIssues = checkSyntax(trimmedQuery);
+      if (syntaxIssues.length > 0) {
+        results.push("Syntax Issues:");
+        for (const issue of syntaxIssues) {
+          results.push(`  - ${issue}`);
+        }
+      } else {
+        results.push("Syntax: \u2713 No obvious syntax issues found");
+      }
+      const dangerWarnings = checkDangerousOperations(trimmedQuery);
+      if (dangerWarnings.length > 0) {
+        results.push("\nSafety Warnings:");
+        for (const warning of dangerWarnings) {
+          results.push(`  - ${warning}`);
+        }
+      } else {
+        results.push("Safety: \u2713 No dangerous operations detected");
+      }
+      try {
+        const databaseKey = getDatabaseKeyFromConfig4(config);
+        const database = sqlDatabaseManager.getDatabase(databaseKey);
+        const dbType = database.getDatabaseType();
+        if (dbType === "postgres") {
+          try {
+            await database.executeQuery(`EXPLAIN ${trimmedQuery}`);
+            results.push("Database Validation: \u2713 Query is valid against database schema");
+          } catch (explainError) {
+            results.push(
+              `Database Validation: \u2717 ${explainError instanceof Error ? explainError.message : String(explainError)}`
+            );
+          }
+        }
+      } catch {
+        results.push(
+          "Database Validation: Skipped (no database connection available)"
+        );
+      }
+      const hasErrors = syntaxIssues.some((i) => !i.startsWith("Warning:")) || dangerWarnings.length > 0;
+      results.push("\n" + "=".repeat(40));
+      if (hasErrors) {
+        results.push(
+          "Overall: \u26A0\uFE0F Query has potential issues. Review warnings before execution."
+        );
+      } else {
+        results.push("Overall: \u2713 Query appears to be safe to execute.");
+      }
+      return results.join("\n");
+    } catch (error) {
+      return `Error checking query: ${error instanceof Error ? error.message : String(error)}`;
+    }
+  }
+);
+
 // src/agent_lattice/types.ts
 import {
   AgentType,
@@ -729,7 +1261,7 @@ import {
 // src/deep_agent_new/middleware/fs.ts
 import { createMiddleware, tool as tool2, ToolMessage } from "langchain";
 import { Command, isCommand, getCurrentTaskInput } from "@langchain/langgraph";
-import { z as z3 } from "zod/v3";
+import { z as z32 } from "zod/v3";
 import { withLangGraph } from "@langchain/langgraph/zod";
 
 // src/deep_agent_new/backends/utils.ts
@@ -1072,10 +1604,10 @@ var StateBackend = class {
 };
 
 // src/deep_agent_new/middleware/fs.ts
-var FileDataSchema = z3.object({
-  content: z3.array(z3.string()),
-  created_at: z3.string(),
-  modified_at: z3.string()
+var FileDataSchema = z32.object({
+  content: z32.array(z32.string()),
+  created_at: z32.string(),
+  modified_at: z32.string()
 });
 function fileDataReducer(left, right) {
   if (left === void 0) {
@@ -1097,13 +1629,13 @@ function fileDataReducer(left, right) {
   }
   return result;
 }
-var FilesystemStateSchema = z3.object({
+var FilesystemStateSchema = z32.object({
   files: withLangGraph(
-    z3.record(z3.string(), FileDataSchema).default({}),
+    z32.record(z32.string(), FileDataSchema).default({}),
     {
       reducer: {
         fn: fileDataReducer,
-        schema: z3.record(z3.string(), FileDataSchema.nullable())
+        schema: z32.record(z32.string(), FileDataSchema.nullable())
       }
     }
   )
@@ -1156,8 +1688,8 @@ function createLsTool(backend, options) {
     {
       name: "ls",
       description: customDescription || LS_TOOL_DESCRIPTION,
-      schema: z3.object({
-        path: z3.string().optional().default("/").describe("Directory path to list (default: /)")
+      schema: z32.object({
+        path: z32.string().optional().default("/").describe("Directory path to list (default: /)")
       })
     }
   );
@@ -1177,10 +1709,10 @@ function createReadFileTool(backend, options) {
     {
       name: "read_file",
       description: customDescription || READ_FILE_TOOL_DESCRIPTION,
-      schema: z3.object({
-        file_path: z3.string().describe("Absolute path to the file to read"),
-        offset: z3.number({ coerce: true }).optional().default(0).describe("Line offset to start reading from (0-indexed)"),
-        limit: z3.number({ coerce: true }).optional().default(2e3).describe("Maximum number of lines to read")
+      schema: z32.object({
+        file_path: z32.string().describe("Absolute path to the file to read"),
+        offset: z32.number({ coerce: true }).optional().default(0).describe("Line offset to start reading from (0-indexed)"),
+        limit: z32.number({ coerce: true }).optional().default(2e3).describe("Maximum number of lines to read")
       })
     }
   );
@@ -1215,9 +1747,9 @@ function createWriteFileTool(backend, options) {
     {
       name: "write_file",
       description: customDescription || WRITE_FILE_TOOL_DESCRIPTION,
-      schema: z3.object({
-        file_path: z3.string().describe("Absolute path to the file to write"),
-        content: z3.string().describe("Content to write to the file")
+      schema: z32.object({
+        file_path: z32.string().describe("Absolute path to the file to write"),
+        content: z32.string().describe("Content to write to the file")
       })
     }
   );
@@ -1257,11 +1789,11 @@ function createEditFileTool(backend, options) {
     {
       name: "edit_file",
       description: customDescription || EDIT_FILE_TOOL_DESCRIPTION,
-      schema: z3.object({
-        file_path: z3.string().describe("Absolute path to the file to edit"),
-        old_string: z3.string().describe("String to be replaced (must match exactly)"),
-        new_string: z3.string().describe("String to replace with"),
-        replace_all: z3.boolean().optional().default(false).describe("Whether to replace all occurrences")
+      schema: z32.object({
+        file_path: z32.string().describe("Absolute path to the file to edit"),
+        old_string: z32.string().describe("String to be replaced (must match exactly)"),
+        new_string: z32.string().describe("String to replace with"),
+        replace_all: z32.boolean().optional().default(false).describe("Whether to replace all occurrences")
       })
     }
   );
@@ -1285,9 +1817,9 @@ function createGlobTool(backend, options) {
     {
       name: "glob",
       description: customDescription || GLOB_TOOL_DESCRIPTION,
-      schema: z3.object({
-        pattern: z3.string().describe("Glob pattern (e.g., '*.py', '**/*.ts')"),
-        path: z3.string().optional().default("/").describe("Base path to search from (default: /)")
+      schema: z32.object({
+        pattern: z32.string().describe("Glob pattern (e.g., '*.py', '**/*.ts')"),
+        path: z32.string().optional().default("/").describe("Base path to search from (default: /)")
       })
     }
   );
@@ -1324,10 +1856,10 @@ ${currentFile}:`);
     {
       name: "grep",
       description: customDescription || GREP_TOOL_DESCRIPTION,
-      schema: z3.object({
-        pattern: z3.string().describe("Regex pattern to search for"),
-        path: z3.string().optional().default("/").describe("Base path to search from (default: /)"),
-        glob: z3.string().optional().nullable().describe("Optional glob pattern to filter files (e.g., '*.py')")
+      schema: z32.object({
+        pattern: z32.string().describe("Regex pattern to search for"),
+        path: z32.string().optional().default("/").describe("Base path to search from (default: /)"),
+        glob: z32.string().optional().nullable().describe("Optional glob pattern to filter files (e.g., '*.py')")
       })
     }
   );
@@ -1455,7 +1987,7 @@ ${systemPrompt}` : systemPrompt;
 }
 
 // src/deep_agent_new/middleware/subagents.ts
-import { z as z4 } from "zod/v3";
+import { z as z7 } from "zod/v3";
 import {
   createMiddleware as createMiddleware2,
   createAgent as createAgent2,
@@ -2132,9 +2664,9 @@ function createTaskTool(options) {
     {
       name: "task",
       description: finalTaskDescription,
-      schema: z4.object({
-        description: z4.string().describe("The task to execute with the selected agent"),
-        subagent_type: z4.string().describe(
+      schema: z7.object({
+        description: z7.string().describe("The task to execute with the selected agent"),
+        subagent_type: z7.string().describe(
           `Name of the agent to use. Available: ${Object.keys(
             subagentGraphs
           ).join(", ")}`
@@ -2238,7 +2770,7 @@ var SUPPORTS_NOFOLLOW = fsSync.constants.O_NOFOLLOW !== void 0;
 
 // src/deep_agent_new/middleware/todos.ts
 import { Command as Command3 } from "@langchain/langgraph";
-import { z as z5 } from "zod";
+import { z as z8 } from "zod";
 import { createMiddleware as createMiddleware4, tool as tool4, ToolMessage as ToolMessage4 } from "langchain";
 var WRITE_TODOS_DESCRIPTION = `Use this tool to create and manage a structured task list for your current work session. This helps you track progress, organize complex tasks, and demonstrate thoroughness to the user.
 It also helps the user understand the progress of the task and overall progress of their requests.
@@ -2466,12 +2998,12 @@ Writing todos takes time and tokens, use it when it is helpful for managing comp
 ## Important To-Do List Usage Notes to Remember
 - The \`write_todos\` tool should never be called multiple times in parallel.
 - Don't be afraid to revise the To-Do list as you go. New information may reveal new tasks that need to be done, or old tasks that are irrelevant.`;
-var TodoStatus = z5.enum(["pending", "in_progress", "completed"]).describe("Status of the todo");
-var TodoSchema = z5.object({
-  content: z5.string().describe("Content of the todo item"),
+var TodoStatus = z8.enum(["pending", "in_progress", "completed"]).describe("Status of the todo");
+var TodoSchema = z8.object({
+  content: z8.string().describe("Content of the todo item"),
   status: TodoStatus
 });
-var stateSchema = z5.object({ todos: z5.array(TodoSchema).default([]) });
+var stateSchema = z8.object({ todos: z8.array(TodoSchema).default([]) });
 function todoListMiddleware(options) {
   const writeTodos = tool4(
     ({ todos }, config) => {
@@ -2490,8 +3022,8 @@ function todoListMiddleware(options) {
     {
       name: "write_todos",
       description: options?.toolDescription ?? WRITE_TODOS_DESCRIPTION,
-      schema: z5.object({
-        todos: z5.array(TodoSchema).describe("List of todo items to update")
+      schema: z8.object({
+        todos: z8.array(TodoSchema).describe("List of todo items to update")
       })
     }
   );
@@ -3231,200 +3763,931 @@ import {
   ScheduleType
 } from "@axiom-lattice/protocols";
 
-// src/schedule_lattice/MemoryScheduleClient.ts
-var _MemoryScheduleClient = class _MemoryScheduleClient {
+// src/schedule_lattice/DefaultScheduleClient.ts
+import {
+  ScheduledTaskStatus as ScheduledTaskStatus2,
+  ScheduleExecutionType as ScheduleExecutionType2
+} from "@axiom-lattice/protocols";
+
+// src/schedule_lattice/MemoryScheduleStorage.ts
+import {
+  ScheduledTaskStatus
+} from "@axiom-lattice/protocols";
+var MemoryScheduleStorage = class {
   constructor() {
     this.tasks = /* @__PURE__ */ new Map();
   }
   /**
-   * Get the singleton instance of MemoryScheduleClient
+   * Save a new task
    */
-  static getInstance() {
-    if (!_MemoryScheduleClient.instance) {
-      _MemoryScheduleClient.instance = new _MemoryScheduleClient();
-    }
-    return _MemoryScheduleClient.instance;
+  async save(task) {
+    this.tasks.set(task.taskId, { ...task });
   }
   /**
-   * Register a function to be executed after the specified timeout
-   * @param taskId - Unique identifier for the task
-   * @param callback - Function to execute when timeout expires
-   * @param timeoutMs - Delay in milliseconds before execution
-   * @returns true if registered successfully
+   * Get task by ID
    */
-  register(taskId, callback, timeoutMs) {
-    if (this.tasks.has(taskId)) {
-      this.cancel(taskId);
-    }
-    const timerId = setTimeout(async () => {
-      try {
-        console.log("scheduler callback", taskId, "start");
-        await callback();
-        console.log("scheduler callback", taskId, "success");
-      } catch (error) {
-        console.error(`Scheduler: Error executing task "${taskId}":`, error);
-      } finally {
-        this.tasks.delete(taskId);
-        console.log("scheduler callback", taskId, "end");
-      }
-    }, timeoutMs);
-    this.tasks.set(taskId, {
-      timerId,
-      callback,
-      scheduledAt: Date.now(),
-      timeoutMs
-    });
-    console.log("scheduler register", taskId);
-    return true;
+  async get(taskId) {
+    const task = this.tasks.get(taskId);
+    return task ? { ...task } : null;
   }
   /**
-   * Cancel a scheduled task by its ID
-   * @param taskId - The task identifier to cancel
-   * @returns true if task was found and cancelled, false otherwise
+   * Update task
    */
-  cancel(taskId) {
-    console.log("scheduler cancel", taskId);
+  async update(taskId, updates) {
     const task = this.tasks.get(taskId);
     if (task) {
-      clearTimeout(task.timerId);
-      this.tasks.delete(taskId);
-      return true;
+      this.tasks.set(taskId, {
+        ...task,
+        ...updates,
+        updatedAt: Date.now()
+      });
     }
-    return false;
   }
   /**
-   * Check if a task is currently scheduled
-   * @param taskId - The task identifier to check
+   * Delete task
    */
-  has(taskId) {
-    return this.tasks.has(taskId);
+  async delete(taskId) {
+    this.tasks.delete(taskId);
   }
   /**
-   * Get the remaining time in milliseconds for a scheduled task
-   * @param taskId - The task identifier
-   * @returns Remaining time in ms, or -1 if task not found
+   * Get all active tasks (pending or paused)
    */
-  getRemainingTime(taskId) {
-    const task = this.tasks.get(taskId);
-    if (!task) {
-      return -1;
+  async getActiveTasks() {
+    const result = [];
+    for (const task of this.tasks.values()) {
+      if (task.status === ScheduledTaskStatus.PENDING || task.status === ScheduledTaskStatus.PAUSED) {
+        result.push({ ...task });
+      }
     }
-    const elapsed = Date.now() - task.scheduledAt;
-    return Math.max(0, task.timeoutMs - elapsed);
+    return result;
   }
   /**
-   * Get the count of currently scheduled tasks
+   * Get tasks by type
    */
-  getTaskCount() {
-    return this.tasks.size;
+  async getTasksByType(taskType) {
+    const result = [];
+    for (const task of this.tasks.values()) {
+      if (task.taskType === taskType) {
+        result.push({ ...task });
+      }
+    }
+    return result;
   }
   /**
-   * Get all scheduled task IDs
+   * Get tasks by status
    */
-  getTaskIds() {
-    return Array.from(this.tasks.keys());
+  async getTasksByStatus(status) {
+    const result = [];
+    for (const task of this.tasks.values()) {
+      if (task.status === status) {
+        result.push({ ...task });
+      }
+    }
+    return result;
   }
   /**
-   * Cancel all scheduled tasks
+   * Get tasks by execution type
    */
-  cancelAll() {
-    for (const [taskId, task] of this.tasks) {
-      clearTimeout(task.timerId);
+  async getTasksByExecutionType(executionType) {
+    const result = [];
+    for (const task of this.tasks.values()) {
+      if (task.executionType === executionType) {
+        result.push({ ...task });
+      }
     }
-    this.tasks.clear();
+    return result;
   }
   /**
-   * Get task information
-   * @param taskId - The task identifier
-   * @returns Task info or null if not found
+   * Get tasks by assistant ID
    */
-  getTaskInfo(taskId) {
-    const task = this.tasks.get(taskId);
-    if (!task) {
-      return null;
+  async getTasksByAssistantId(assistantId) {
+    const result = [];
+    for (const task of this.tasks.values()) {
+      if (task.assistantId === assistantId) {
+        result.push({ ...task });
+      }
     }
-    return {
-      taskId,
-      scheduledAt: task.scheduledAt,
-      timeoutMs: task.timeoutMs,
-      remainingMs: this.getRemainingTime(taskId)
-    };
+    return result;
   }
   /**
-   * Reset the singleton instance (useful for testing)
+   * Get tasks by thread ID
    */
-  static resetInstance() {
-    if (_MemoryScheduleClient.instance) {
-      _MemoryScheduleClient.instance.cancelAll();
-      _MemoryScheduleClient.instance = null;
+  async getTasksByThreadId(threadId) {
+    const result = [];
+    for (const task of this.tasks.values()) {
+      if (task.threadId === threadId) {
+        result.push({ ...task });
+      }
     }
+    return result;
   }
-};
-_MemoryScheduleClient.instance = null;
-var MemoryScheduleClient = _MemoryScheduleClient;
-
-// src/schedule_lattice/ScheduleLatticeManager.ts
-var ScheduleLatticeManager = class _ScheduleLatticeManager extends BaseLatticeManager {
   /**
-   * Get ScheduleLatticeManager singleton instance
+   * Get all tasks with optional filters
    */
-  static getInstance() {
-    if (!_ScheduleLatticeManager._instance) {
-      _ScheduleLatticeManager._instance = new _ScheduleLatticeManager();
+  async getAllTasks(filters) {
+    let result = [];
+    for (const task of this.tasks.values()) {
+      let match = true;
+      if (filters?.status !== void 0 && task.status !== filters.status) {
+        match = false;
+      }
+      if (filters?.executionType !== void 0 && task.executionType !== filters.executionType) {
+        match = false;
+      }
+      if (filters?.taskType !== void 0 && task.taskType !== filters.taskType) {
+        match = false;
+      }
+      if (filters?.assistantId !== void 0 && task.assistantId !== filters.assistantId) {
+        match = false;
+      }
+      if (filters?.threadId !== void 0 && task.threadId !== filters.threadId) {
+        match = false;
+      }
+      if (match) {
+        result.push({ ...task });
+      }
     }
-    return _ScheduleLatticeManager._instance;
+    result.sort((a, b) => b.createdAt - a.createdAt);
+    const offset = filters?.offset || 0;
+    const limit = filters?.limit;
+    if (limit !== void 0) {
+      result = result.slice(offset, offset + limit);
+    } else if (offset > 0) {
+      result = result.slice(offset);
+    }
+    return result;
   }
   /**
-   * Get Lattice type prefix
+   * Count tasks with optional filters
    */
-  getLatticeType() {
-    return "schedules";
+  async countTasks(filters) {
+    let count = 0;
+    for (const task of this.tasks.values()) {
+      let match = true;
+      if (filters?.status !== void 0 && task.status !== filters.status) {
+        match = false;
+      }
+      if (filters?.executionType !== void 0 && task.executionType !== filters.executionType) {
+        match = false;
+      }
+      if (filters?.taskType !== void 0 && task.taskType !== filters.taskType) {
+        match = false;
+      }
+      if (filters?.assistantId !== void 0 && task.assistantId !== filters.assistantId) {
+        match = false;
+      }
+      if (filters?.threadId !== void 0 && task.threadId !== filters.threadId) {
+        match = false;
+      }
+      if (match) {
+        count++;
+      }
+    }
+    return count;
   }
   /**
-   * Register schedule Lattice
-   * @param key Lattice key name
-   * @param config Schedule configuration
-   * @param client Optional schedule client. If not provided, will create based on config type.
+   * Delete completed/cancelled tasks older than specified time
    */
-  registerLattice(key, config, client) {
-    let scheduleClient;
-    if (client) {
-      scheduleClient = client;
-    } else {
-      if (config.type === ScheduleType.MEMORY) {
-        scheduleClient = MemoryScheduleClient.getInstance();
-      } else {
-        scheduleClient = MemoryScheduleClient.getInstance();
+  async deleteOldTasks(olderThanMs) {
+    const cutoff = Date.now() - olderThanMs;
+    let deleted = 0;
+    for (const [taskId, task] of this.tasks.entries()) {
+      if ((task.status === ScheduledTaskStatus.COMPLETED || task.status === ScheduledTaskStatus.CANCELLED || task.status === ScheduledTaskStatus.FAILED) && task.updatedAt < cutoff) {
+        this.tasks.delete(taskId);
+        deleted++;
       }
     }
-    const scheduleLattice = {
-      key,
-      config,
-      client: scheduleClient,
-      register: (taskId, callback, timeoutMs) => {
-        return scheduleClient.register(taskId, callback, timeoutMs);
-      },
-      cancel: (taskId) => {
-        return scheduleClient.cancel(taskId);
+    return deleted;
+  }
+  /**
+   * Clear all tasks (useful for testing)
+   */
+  clear() {
+    this.tasks.clear();
+  }
+  /**
+   * Get total task count (useful for debugging)
+   */
+  size() {
+    return this.tasks.size;
+  }
+};
+
+// src/schedule_lattice/CronParser.ts
+function parseCronExpression(expression) {
+  const parts = expression.trim().split(/\s+/);
+  if (parts.length !== 5) {
+    throw new Error(
+      `Invalid cron expression: expected 5 fields, got ${parts.length}`
+    );
+  }
+  return {
+    minute: parseField(parts[0], 0, 59),
+    hour: parseField(parts[1], 0, 23),
+    dayOfMonth: parseField(parts[2], 1, 31),
+    month: parseField(parts[3], 1, 12),
+    dayOfWeek: parseField(parts[4], 0, 7).map((d) => d === 7 ? 0 : d)
+    // Normalize Sunday
+  };
+}
+function parseField(field, min, max) {
+  const values = /* @__PURE__ */ new Set();
+  const segments = field.split(",");
+  for (const segment of segments) {
+    const [range, stepStr] = segment.split("/");
+    const step = stepStr ? parseInt(stepStr, 10) : 1;
+    if (isNaN(step) || step < 1) {
+      throw new Error(`Invalid step value: ${stepStr}`);
+    }
+    let rangeStart;
+    let rangeEnd;
+    if (range === "*") {
+      rangeStart = min;
+      rangeEnd = max;
+    } else if (range.includes("-")) {
+      const [startStr, endStr] = range.split("-");
+      rangeStart = parseInt(startStr, 10);
+      rangeEnd = parseInt(endStr, 10);
+      if (isNaN(rangeStart) || isNaN(rangeEnd)) {
+        throw new Error(`Invalid range: ${range}`);
+      }
+    } else {
+      const value = parseInt(range, 10);
+      if (isNaN(value)) {
+        throw new Error(`Invalid value: ${range}`);
+      }
+      rangeStart = value;
+      rangeEnd = value;
+    }
+    if (rangeStart < min || rangeEnd > max || rangeStart > rangeEnd) {
+      throw new Error(`Value out of range: ${range} (expected ${min}-${max})`);
+    }
+    for (let i = rangeStart; i <= rangeEnd; i += step) {
+      values.add(i);
+    }
+  }
+  return Array.from(values).sort((a, b) => a - b);
+}
+function getNextCronTime(expression, after = /* @__PURE__ */ new Date(), timezone) {
+  const fields = parseCronExpression(expression);
+  const next = new Date(after.getTime());
+  next.setSeconds(0, 0);
+  next.setMinutes(next.getMinutes() + 1);
+  const maxIterations = 366 * 24 * 60;
+  let iterations = 0;
+  while (iterations < maxIterations) {
+    iterations++;
+    const month = next.getMonth() + 1;
+    if (!fields.month.includes(month)) {
+      const nextMonth = fields.month.find((m) => m > month);
+      if (nextMonth !== void 0) {
+        next.setMonth(nextMonth - 1, 1);
+      } else {
+        next.setFullYear(next.getFullYear() + 1);
+        next.setMonth(fields.month[0] - 1, 1);
+      }
+      next.setHours(fields.hour[0], fields.minute[0], 0, 0);
+      continue;
+    }
+    const dayOfMonth = next.getDate();
+    const maxDayOfMonth = new Date(
+      next.getFullYear(),
+      next.getMonth() + 1,
+      0
+    ).getDate();
+    const dayOfWeek = next.getDay();
+    const dayOfMonthMatch = fields.dayOfMonth.includes(dayOfMonth);
+    const dayOfWeekMatch = fields.dayOfWeek.includes(dayOfWeek);
+    const dayOfMonthWildcard = fields.dayOfMonth.length === 31 && fields.dayOfMonth[0] === 1 && fields.dayOfMonth[30] === 31;
+    const dayOfWeekWildcard = fields.dayOfWeek.length >= 7 || fields.dayOfWeek.length === 1 && fields.dayOfWeek.includes(0);
+    let dayMatch;
+    if (dayOfMonthWildcard && dayOfWeekWildcard) {
+      dayMatch = true;
+    } else if (dayOfMonthWildcard) {
+      dayMatch = dayOfWeekMatch;
+    } else if (dayOfWeekWildcard) {
+      dayMatch = dayOfMonthMatch;
+    } else {
+      dayMatch = dayOfMonthMatch || dayOfWeekMatch;
+    }
+    if (!dayMatch || dayOfMonth > maxDayOfMonth) {
+      next.setDate(next.getDate() + 1);
+      next.setHours(fields.hour[0], fields.minute[0], 0, 0);
+      continue;
+    }
+    const hour = next.getHours();
+    if (!fields.hour.includes(hour)) {
+      const nextHour = fields.hour.find((h) => h > hour);
+      if (nextHour !== void 0) {
+        next.setHours(nextHour, fields.minute[0], 0, 0);
+      } else {
+        next.setDate(next.getDate() + 1);
+        next.setHours(fields.hour[0], fields.minute[0], 0, 0);
+      }
+      continue;
+    }
+    const minute = next.getMinutes();
+    if (!fields.minute.includes(minute)) {
+      const nextMinute = fields.minute.find((m) => m > minute);
+      if (nextMinute !== void 0) {
+        next.setMinutes(nextMinute, 0, 0);
+      } else {
+        next.setHours(next.getHours() + 1, fields.minute[0], 0, 0);
+      }
+      continue;
+    }
+    return next;
+  }
+  throw new Error("Could not find next cron time within 1 year");
+}
+function isValidCronExpression(expression) {
+  try {
+    parseCronExpression(expression);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function describeCronExpression(expression) {
+  const fields = parseCronExpression(expression);
+  const parts = [];
+  if (fields.minute.length === 60) {
+    parts.push("every minute");
+  } else if (fields.minute.length === 1) {
+    parts.push(`at minute ${fields.minute[0]}`);
+  } else {
+    parts.push(`at minutes ${fields.minute.join(", ")}`);
+  }
+  if (fields.hour.length === 24) {
+    parts.push("of every hour");
+  } else if (fields.hour.length === 1) {
+    parts.push(`of hour ${fields.hour[0]}`);
+  } else {
+    parts.push(`of hours ${fields.hour.join(", ")}`);
+  }
+  if (fields.dayOfMonth.length < 31) {
+    if (fields.dayOfMonth.length === 1) {
+      parts.push(`on day ${fields.dayOfMonth[0]}`);
+    } else {
+      parts.push(`on days ${fields.dayOfMonth.join(", ")}`);
+    }
+  }
+  const monthNames = [
+    "",
+    "Jan",
+    "Feb",
+    "Mar",
+    "Apr",
+    "May",
+    "Jun",
+    "Jul",
+    "Aug",
+    "Sep",
+    "Oct",
+    "Nov",
+    "Dec"
+  ];
+  if (fields.month.length < 12) {
+    const months = fields.month.map((m) => monthNames[m]);
+    parts.push(`in ${months.join(", ")}`);
+  }
+  const dayNames = ["Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"];
+  const uniqueDays = [...new Set(fields.dayOfWeek)];
+  if (uniqueDays.length < 7) {
+    const days = uniqueDays.map((d) => dayNames[d]);
+    parts.push(`on ${days.join(", ")}`);
+  }
+  return parts.join(" ");
+}
+
+// src/schedule_lattice/DefaultScheduleClient.ts
+var _DefaultScheduleClient = class _DefaultScheduleClient {
+  constructor(storage) {
+    this.handlers = /* @__PURE__ */ new Map();
+    this.timers = /* @__PURE__ */ new Map();
+    this.storage = storage || new MemoryScheduleStorage();
+  }
+  /**
+   * Get the singleton instance of DefaultScheduleClient
+   */
+  static getInstance(storage) {
+    if (!_DefaultScheduleClient.instance) {
+      _DefaultScheduleClient.instance = new _DefaultScheduleClient(storage);
+    }
+    return _DefaultScheduleClient.instance;
+  }
+  /**
+   * Reset the singleton instance (useful for testing)
+   */
+  static resetInstance() {
+    if (_DefaultScheduleClient.instance) {
+      _DefaultScheduleClient.instance.cancelAll();
+      _DefaultScheduleClient.instance = null;
+    }
+  }
+  // ===== Handler Registration =====
+  registerHandler(taskType, handler) {
+    this.handlers.set(taskType, handler);
+    console.log(`[Scheduler] Handler registered for task type: ${taskType}`);
+  }
+  unregisterHandler(taskType) {
+    const result = this.handlers.delete(taskType);
+    if (result) {
+      console.log(
+        `[Scheduler] Handler unregistered for task type: ${taskType}`
+      );
+    }
+    return result;
+  }
+  hasHandler(taskType) {
+    return this.handlers.has(taskType);
+  }
+  getHandlerTypes() {
+    return Array.from(this.handlers.keys());
+  }
+  // ===== One-time Task Scheduling =====
+  async scheduleOnce(taskId, taskType, payload, options) {
+    if (!this.handlers.has(taskType)) {
+      console.error(
+        `[Scheduler] No handler registered for task type: ${taskType}`
+      );
+      return false;
+    }
+    let executeAt;
+    if (options.executeAt !== void 0) {
+      executeAt = options.executeAt;
+    } else if (options.delayMs !== void 0) {
+      executeAt = Date.now() + options.delayMs;
+    } else {
+      console.error("[Scheduler] Either executeAt or delayMs must be provided");
+      return false;
+    }
+    if (await this.has(taskId)) {
+      await this.cancel(taskId);
+    }
+    const now = Date.now();
+    const task = {
+      taskId,
+      taskType,
+      payload,
+      assistantId: options.assistantId,
+      threadId: options.threadId,
+      executionType: ScheduleExecutionType2.ONCE,
+      executeAt,
+      delayMs: options.delayMs,
+      status: ScheduledTaskStatus2.PENDING,
+      runCount: 0,
+      retryCount: 0,
+      maxRetries: options.maxRetries ?? 0,
+      createdAt: now,
+      updatedAt: now,
+      metadata: options.metadata
+    };
+    await this.storage.save(task);
+    this.scheduleTimer(task);
+    console.log(
+      `[Scheduler] One-time task scheduled: ${taskId}, executes at ${new Date(
+        executeAt
+      ).toISOString()}`
+    );
+    return true;
+  }
+  // ===== Cron Task Scheduling =====
+  async scheduleCron(taskId, taskType, payload, options) {
+    if (!this.handlers.has(taskType)) {
+      console.error(
+        `[Scheduler] No handler registered for task type: ${taskType}`
+      );
+      return false;
+    }
+    if (!isValidCronExpression(options.cronExpression)) {
+      console.error(
+        `[Scheduler] Invalid cron expression: ${options.cronExpression}`
+      );
+      return false;
+    }
+    if (await this.has(taskId)) {
+      await this.cancel(taskId);
+    }
+    const now = Date.now();
+    const nextRunAt = getNextCronTime(options.cronExpression, new Date(now));
+    const task = {
+      taskId,
+      taskType,
+      payload,
+      assistantId: options.assistantId,
+      threadId: options.threadId,
+      executionType: ScheduleExecutionType2.CRON,
+      cronExpression: options.cronExpression,
+      timezone: options.timezone,
+      nextRunAt: nextRunAt.getTime(),
+      status: ScheduledTaskStatus2.PENDING,
+      runCount: 0,
+      maxRuns: options.maxRuns,
+      retryCount: 0,
+      maxRetries: options.maxRetries ?? 0,
+      createdAt: now,
+      updatedAt: now,
+      expiresAt: options.expiresAt,
+      metadata: options.metadata
+    };
+    await this.storage.save(task);
+    this.scheduleTimer(task);
+    console.log(
+      `[Scheduler] Cron task scheduled: ${taskId}, expression: ${options.cronExpression}, next run: ${nextRunAt.toISOString()}`
+    );
+    return true;
+  }
+  // ===== Task Management =====
+  async cancel(taskId) {
+    const timer = this.timers.get(taskId);
+    if (timer) {
+      clearTimeout(timer.timerId);
+      this.timers.delete(taskId);
+    }
+    const task = await this.storage.get(taskId);
+    if (task) {
+      await this.storage.update(taskId, {
+        status: ScheduledTaskStatus2.CANCELLED
+      });
+      console.log(`[Scheduler] Task cancelled: ${taskId}`);
+      return true;
+    }
+    return false;
+  }
+  async pause(taskId) {
+    const task = await this.storage.get(taskId);
+    if (!task || task.executionType !== ScheduleExecutionType2.CRON) {
+      console.error(`[Scheduler] Can only pause CRON tasks: ${taskId}`);
+      return false;
+    }
+    if (task.status !== ScheduledTaskStatus2.PENDING) {
+      console.error(`[Scheduler] Can only pause PENDING tasks: ${taskId}`);
+      return false;
+    }
+    const timer = this.timers.get(taskId);
+    if (timer) {
+      clearTimeout(timer.timerId);
+      this.timers.delete(taskId);
+    }
+    await this.storage.update(taskId, {
+      status: ScheduledTaskStatus2.PAUSED
+    });
+    console.log(`[Scheduler] Task paused: ${taskId}`);
+    return true;
+  }
+  async resume(taskId) {
+    const task = await this.storage.get(taskId);
+    if (!task || task.executionType !== ScheduleExecutionType2.CRON) {
+      console.error(`[Scheduler] Can only resume CRON tasks: ${taskId}`);
+      return false;
+    }
+    if (task.status !== ScheduledTaskStatus2.PAUSED) {
+      console.error(`[Scheduler] Can only resume PAUSED tasks: ${taskId}`);
+      return false;
+    }
+    const nextRunAt = getNextCronTime(task.cronExpression);
+    await this.storage.update(taskId, {
+      status: ScheduledTaskStatus2.PENDING,
+      nextRunAt: nextRunAt.getTime()
+    });
+    const updatedTask = await this.storage.get(taskId);
+    if (updatedTask) {
+      this.scheduleTimer(updatedTask);
+    }
+    console.log(`[Scheduler] Task resumed: ${taskId}`);
+    return true;
+  }
+  async has(taskId) {
+    const task = await this.storage.get(taskId);
+    return task !== null;
+  }
+  async getTask(taskId) {
+    return this.storage.get(taskId);
+  }
+  async getRemainingTime(taskId) {
+    const task = await this.storage.get(taskId);
+    if (!task) {
+      return -1;
+    }
+    const targetTime = task.executionType === ScheduleExecutionType2.CRON ? task.nextRunAt : task.executeAt;
+    if (targetTime === void 0) {
+      return -1;
+    }
+    return Math.max(0, targetTime - Date.now());
+  }
+  async getActiveTaskCount() {
+    const tasks = await this.storage.getActiveTasks();
+    return tasks.length;
+  }
+  async getActiveTaskIds() {
+    const tasks = await this.storage.getActiveTasks();
+    return tasks.map((t) => t.taskId);
+  }
+  async cancelAll() {
+    for (const timer of this.timers.values()) {
+      clearTimeout(timer.timerId);
+    }
+    this.timers.clear();
+    const activeTasks = await this.storage.getActiveTasks();
+    for (const task of activeTasks) {
+      await this.storage.update(task.taskId, {
+        status: ScheduledTaskStatus2.CANCELLED
+      });
+    }
+    console.log(`[Scheduler] All tasks cancelled`);
+  }
+  // ===== Recovery =====
+  async restore() {
+    const activeTasks = await this.storage.getActiveTasks();
+    let restored = 0;
+    for (const task of activeTasks) {
+      if (!this.handlers.has(task.taskType)) {
+        console.warn(
+          `[Scheduler] No handler for task type ${task.taskType}, skipping restore for task ${task.taskId}`
+        );
+        continue;
+      }
+      if (task.status === ScheduledTaskStatus2.PAUSED) {
+        continue;
+      }
+      if (task.executionType === ScheduleExecutionType2.ONCE) {
+        if (task.executeAt && task.executeAt <= Date.now()) {
+          console.log(
+            `[Scheduler] Executing overdue one-time task: ${task.taskId}`
+          );
+          this.executeTask(task);
+        } else {
+          this.scheduleTimer(task);
+        }
+      } else if (task.executionType === ScheduleExecutionType2.CRON) {
+        const nextRunAt = getNextCronTime(task.cronExpression);
+        await this.storage.update(task.taskId, {
+          nextRunAt: nextRunAt.getTime()
+        });
+        const updatedTask = await this.storage.get(task.taskId);
+        if (updatedTask) {
+          this.scheduleTimer(updatedTask);
+        }
+      }
+      restored++;
+    }
+    console.log(`[Scheduler] Restored ${restored} tasks`);
+    return restored;
+  }
+  // ===== Storage =====
+  setStorage(storage) {
+    this.storage = storage;
+  }
+  getStorage() {
+    return this.storage;
+  }
+  // ===== Private Methods =====
+  scheduleTimer(task) {
+    const targetTime = task.executionType === ScheduleExecutionType2.CRON ? task.nextRunAt : task.executeAt;
+    if (targetTime === void 0) {
+      console.error(`[Scheduler] No execution time for task: ${task.taskId}`);
+      return;
+    }
+    const delay = Math.max(0, targetTime - Date.now());
+    const timerId = setTimeout(() => {
+      this.executeTask(task);
+    }, delay);
+    this.timers.set(task.taskId, {
+      timerId,
+      taskId: task.taskId
+    });
+  }
+  async executeTask(task) {
+    const handler = this.handlers.get(task.taskType);
+    if (!handler) {
+      console.error(
+        `[Scheduler] No handler for task type: ${task.taskType}, task: ${task.taskId}`
+      );
+      await this.storage.update(task.taskId, {
+        status: ScheduledTaskStatus2.FAILED,
+        lastError: `No handler registered for task type: ${task.taskType}`
+      });
+      return;
+    }
+    await this.storage.update(task.taskId, {
+      status: ScheduledTaskStatus2.RUNNING
+    });
+    console.log(`[Scheduler] Executing task: ${task.taskId}`);
+    try {
+      const latestTask = await this.storage.get(task.taskId);
+      if (!latestTask) {
+        console.error(`[Scheduler] Task not found: ${task.taskId}`);
+        return;
+      }
+      await handler(latestTask.payload, latestTask);
+      const newRunCount = latestTask.runCount + 1;
+      console.log(`[Scheduler] Task completed: ${task.taskId}`);
+      if (task.executionType === ScheduleExecutionType2.ONCE) {
+        await this.storage.update(task.taskId, {
+          status: ScheduledTaskStatus2.COMPLETED,
+          runCount: newRunCount,
+          lastRunAt: Date.now()
+        });
+        this.timers.delete(task.taskId);
+      } else if (task.executionType === ScheduleExecutionType2.CRON) {
+        if (task.maxRuns !== void 0 && newRunCount >= task.maxRuns) {
+          await this.storage.update(task.taskId, {
+            status: ScheduledTaskStatus2.COMPLETED,
+            runCount: newRunCount,
+            lastRunAt: Date.now()
+          });
+          this.timers.delete(task.taskId);
+          console.log(
+            `[Scheduler] Cron task completed (max runs): ${task.taskId}`
+          );
+          return;
+        }
+        if (task.expiresAt !== void 0 && Date.now() >= task.expiresAt) {
+          await this.storage.update(task.taskId, {
+            status: ScheduledTaskStatus2.COMPLETED,
+            runCount: newRunCount,
+            lastRunAt: Date.now()
+          });
+          this.timers.delete(task.taskId);
+          console.log(
+            `[Scheduler] Cron task completed (expired): ${task.taskId}`
+          );
+          return;
+        }
+        const nextRunAt = getNextCronTime(task.cronExpression);
+        await this.storage.update(task.taskId, {
+          status: ScheduledTaskStatus2.PENDING,
+          runCount: newRunCount,
+          lastRunAt: Date.now(),
+          nextRunAt: nextRunAt.getTime(),
+          retryCount: 0
+          // Reset retry count on success
+        });
+        const updatedTask = await this.storage.get(task.taskId);
+        if (updatedTask) {
+          this.scheduleTimer(updatedTask);
+          console.log(
+            `[Scheduler] Next cron run scheduled: ${task.taskId} at ${nextRunAt.toISOString()}`
+          );
+        }
+      }
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : String(error);
+      console.error(`[Scheduler] Task failed: ${task.taskId}`, error);
+      const latestTask = await this.storage.get(task.taskId);
+      if (!latestTask) return;
+      const newRetryCount = latestTask.retryCount + 1;
+      if (newRetryCount <= latestTask.maxRetries) {
+        console.log(
+          `[Scheduler] Retrying task: ${task.taskId} (attempt ${newRetryCount}/${latestTask.maxRetries})`
+        );
+        await this.storage.update(task.taskId, {
+          status: ScheduledTaskStatus2.PENDING,
+          retryCount: newRetryCount,
+          lastError: errorMessage
+        });
+        const retryDelay = Math.min(
+          1e3 * Math.pow(2, newRetryCount - 1),
+          6e4
+        );
+        const retryTask = await this.storage.get(task.taskId);
+        if (retryTask) {
+          if (task.executionType === ScheduleExecutionType2.ONCE) {
+            retryTask.executeAt = Date.now() + retryDelay;
+          } else {
+            retryTask.nextRunAt = Date.now() + retryDelay;
+          }
+          await this.storage.update(task.taskId, {
+            executeAt: retryTask.executeAt,
+            nextRunAt: retryTask.nextRunAt
+          });
+          this.scheduleTimer(retryTask);
+        }
+      } else {
+        await this.storage.update(task.taskId, {
+          status: ScheduledTaskStatus2.FAILED,
+          retryCount: newRetryCount,
+          lastError: errorMessage
+        });
+        this.timers.delete(task.taskId);
+        console.error(
+          `[Scheduler] Task failed permanently: ${task.taskId} (max retries exceeded)`
+        );
+      }
+    }
+  }
+};
+_DefaultScheduleClient.instance = null;
+var DefaultScheduleClient = _DefaultScheduleClient;
+
+// src/schedule_lattice/ScheduleLatticeManager.ts
+var ScheduleLatticeManager = class _ScheduleLatticeManager extends BaseLatticeManager {
+  /**
+   * Get ScheduleLatticeManager singleton instance
+   */
+  static getInstance() {
+    if (!_ScheduleLatticeManager._instance) {
+      _ScheduleLatticeManager._instance = new _ScheduleLatticeManager();
+    }
+    return _ScheduleLatticeManager._instance;
+  }
+  /**
+   * Get Lattice type prefix
+   */
+  getLatticeType() {
+    return "schedules";
+  }
+  /**
+   * Register schedule Lattice
+   * @param key Lattice key name
+   * @param config Schedule configuration
+   * @param client Optional schedule client. If not provided, will create based on config type.
+   */
+  registerLattice(key, config, client) {
+    let scheduleClient;
+    if (client) {
+      scheduleClient = client;
+      if (config.storage) {
+        scheduleClient.setStorage(config.storage);
+      }
+    } else {
+      let storage;
+      if (config.storage) {
+        storage = config.storage;
+      } else {
+        storage = new MemoryScheduleStorage();
+      }
+      if (config.type === ScheduleType.MEMORY) {
+        scheduleClient = new DefaultScheduleClient(storage);
+      } else if (config.type === ScheduleType.POSTGRES) {
+        if (!config.storage) {
+          throw new Error(
+            `PostgreSQL schedule storage must be provided. Please install @axiom-lattice/pg-stores and pass the storage in config.storage.`
+          );
+        }
+        scheduleClient = new DefaultScheduleClient(storage);
+      } else {
+        scheduleClient = new DefaultScheduleClient(storage);
+      }
+    }
+    const scheduleLattice = {
+      key,
+      config,
+      client: scheduleClient,
+      // Handler registration
+      registerHandler: (taskType, handler) => {
+        scheduleClient.registerHandler(taskType, handler);
       },
-      has: (taskId) => {
+      unregisterHandler: (taskType) => {
+        return scheduleClient.unregisterHandler(taskType);
+      },
+      hasHandler: (taskType) => {
+        return scheduleClient.hasHandler(taskType);
+      },
+      getHandlerTypes: () => {
+        return scheduleClient.getHandlerTypes();
+      },
+      // One-time task scheduling
+      scheduleOnce: async (taskId, taskType, payload, options) => {
+        return scheduleClient.scheduleOnce(taskId, taskType, payload, options);
+      },
+      // Cron task scheduling
+      scheduleCron: async (taskId, taskType, payload, options) => {
+        return scheduleClient.scheduleCron(taskId, taskType, payload, options);
+      },
+      // Task management
+      cancel: async (taskId) => {
+        return scheduleClient.cancel(taskId);
+      },
+      pause: async (taskId) => {
+        return scheduleClient.pause(taskId);
+      },
+      resume: async (taskId) => {
+        return scheduleClient.resume(taskId);
+      },
+      has: async (taskId) => {
         return scheduleClient.has(taskId);
       },
-      getRemainingTime: (taskId) => {
+      getTask: async (taskId) => {
+        return scheduleClient.getTask(taskId);
+      },
+      getRemainingTime: async (taskId) => {
         return scheduleClient.getRemainingTime(taskId);
       },
-      getTaskCount: () => {
-        return scheduleClient.getTaskCount();
+      getActiveTaskCount: async () => {
+        return scheduleClient.getActiveTaskCount();
       },
-      getTaskIds: () => {
-        return scheduleClient.getTaskIds();
+      getActiveTaskIds: async () => {
+        return scheduleClient.getActiveTaskIds();
       },
-      cancelAll: () => {
+      cancelAll: async () => {
         return scheduleClient.cancelAll();
       },
-      getTaskInfo: scheduleClient.getTaskInfo ? (taskId) => {
-        return scheduleClient.getTaskInfo(taskId);
-      } : void 0
+      // Recovery
+      restore: async () => {
+        return scheduleClient.restore();
+      }
     };
     this.register(key, scheduleLattice);
   }
@@ -3974,6 +5237,323 @@ var registerVectorStoreLattice = (key, vectorStore) => vectorStoreLatticeManager
 var getVectorStoreLattice = (key) => vectorStoreLatticeManager.getVectorStoreLattice(key);
 var getVectorStoreClient = (key) => vectorStoreLatticeManager.getVectorStoreClient(key);
 
+// src/logger_lattice/LoggerLatticeManager.ts
+import {
+  LoggerType
+} from "@axiom-lattice/protocols";
+
+// src/logger_lattice/PinoLoggerClient.ts
+import pino from "pino";
+import "pino-pretty";
+import "pino-roll";
+var PinoLoggerClient = class _PinoLoggerClient {
+  constructor(config) {
+    this.config = config;
+    this.context = config.context || {};
+    const loggerConfig = {
+      // Custom timestamp format
+      timestamp: () => `,"@timestamp":"${(/* @__PURE__ */ new Date()).toISOString()}"`,
+      // Base metadata
+      base: {
+        "@version": "1",
+        app_name: "lattice",
+        service_name: config.serviceName || "lattice-service",
+        thread_name: "main",
+        logger_name: config.loggerName || config.name || "lattice-logger"
+      },
+      formatters: {
+        level: (label, number) => {
+          return {
+            level: label.toUpperCase(),
+            level_value: number * 1e3
+          };
+        }
+      }
+    };
+    const useFileLogging = this.shouldUseFileLogging(config);
+    const fileOptions = this.getFileOptions(config);
+    if (useFileLogging && fileOptions) {
+      try {
+        this.pinoLogger = pino(
+          loggerConfig,
+          pino.transport({
+            target: "pino-roll",
+            options: {
+              file: fileOptions.file || "./logs/app",
+              frequency: fileOptions.frequency || "daily",
+              mkdir: fileOptions.mkdir !== false,
+              // Default to true
+              size: fileOptions.size,
+              maxFiles: fileOptions.maxFiles
+            }
+          })
+        );
+      } catch (error) {
+        console.error(
+          "Failed to initialize pino-roll logger, falling back to console",
+          error
+        );
+        this.pinoLogger = pino({
+          ...loggerConfig,
+          transport: {
+            target: "pino-pretty",
+            options: {
+              colorize: true
+            }
+          }
+        });
+      }
+    } else {
+      this.pinoLogger = pino({
+        ...loggerConfig,
+        transport: {
+          target: "pino-pretty",
+          options: {
+            colorize: true
+          }
+        }
+      });
+    }
+  }
+  /**
+   * Determine if file logging should be used
+   */
+  shouldUseFileLogging(config) {
+    const hasFileConfig = config.file !== void 0;
+    const isProduction = process.env.NODE_ENV === "production";
+    return hasFileConfig || isProduction;
+  }
+  /**
+   * Get file options from config
+   */
+  getFileOptions(config) {
+    if (!config.file) {
+      if (process.env.NODE_ENV === "production") {
+        return {
+          file: "./logs/app",
+          frequency: "daily",
+          mkdir: true
+        };
+      }
+      return null;
+    }
+    if (typeof config.file === "string") {
+      return {
+        file: config.file,
+        frequency: "daily",
+        mkdir: true
+      };
+    }
+    return config.file;
+  }
+  /**
+   * Get contextual logger with merged context
+   */
+  getContextualLogger(additionalContext) {
+    const contextObj = {
+      "x-user-id": this.context["x-user-id"] || "",
+      "x-tenant-id": this.context["x-tenant-id"] || "",
+      "x-request-id": this.context["x-request-id"] || "",
+      "x-thread-id": this.context["x-thread-id"] || "",
+      service_name: this.config.serviceName || "lattice-service",
+      logger_name: this.config.loggerName || this.config.name || "lattice-logger",
+      ...additionalContext
+    };
+    return this.pinoLogger.child(contextObj);
+  }
+  info(msg, obj) {
+    this.getContextualLogger(obj).info(msg);
+  }
+  error(msg, obj) {
+    this.getContextualLogger(obj).error(msg);
+  }
+  warn(msg, obj) {
+    this.getContextualLogger(obj).warn(msg);
+  }
+  debug(msg, obj) {
+    this.getContextualLogger(obj).debug(msg);
+  }
+  updateContext(context) {
+    this.context = {
+      ...this.context,
+      ...context
+    };
+  }
+  child(options) {
+    return new _PinoLoggerClient({
+      ...this.config,
+      ...options,
+      context: {
+        ...this.context,
+        ...options.context
+      }
+    });
+  }
+};
+
+// src/logger_lattice/ConsoleLoggerClient.ts
+var ConsoleLoggerClient = class _ConsoleLoggerClient {
+  constructor(config) {
+    this.config = config;
+    this.context = config.context || {};
+  }
+  formatMessage(level, msg, obj) {
+    const timestamp = (/* @__PURE__ */ new Date()).toISOString();
+    const contextStr = Object.keys(this.context).length > 0 ? ` [${JSON.stringify(this.context)}]` : "";
+    const objStr = obj ? ` ${JSON.stringify(obj)}` : "";
+    return `[${timestamp}] [${level}]${contextStr} ${msg}${objStr}`;
+  }
+  info(msg, obj) {
+    console.log(this.formatMessage("INFO", msg, obj));
+  }
+  error(msg, obj) {
+    console.error(this.formatMessage("ERROR", msg, obj));
+  }
+  warn(msg, obj) {
+    console.warn(this.formatMessage("WARN", msg, obj));
+  }
+  debug(msg, obj) {
+    console.debug(this.formatMessage("DEBUG", msg, obj));
+  }
+  updateContext(context) {
+    this.context = {
+      ...this.context,
+      ...context
+    };
+  }
+  child(options) {
+    const childClient = new _ConsoleLoggerClient({
+      ...this.config,
+      ...options,
+      context: {
+        ...this.context,
+        ...options.context
+      }
+    });
+    return childClient;
+  }
+};
+
+// src/logger_lattice/LoggerLatticeManager.ts
+var LoggerLatticeManager = class _LoggerLatticeManager extends BaseLatticeManager {
+  /**
+   * Get LoggerLatticeManager singleton instance
+   */
+  static getInstance() {
+    if (!_LoggerLatticeManager._instance) {
+      _LoggerLatticeManager._instance = new _LoggerLatticeManager();
+    }
+    return _LoggerLatticeManager._instance;
+  }
+  /**
+   * Get Lattice type prefix
+   */
+  getLatticeType() {
+    return "loggers";
+  }
+  /**
+   * Register logger Lattice
+   * @param key Lattice key name
+   * @param config Logger configuration
+   * @param client Optional logger client. If not provided, will create based on config type.
+   */
+  registerLattice(key, config, client) {
+    let loggerClient;
+    if (client) {
+      loggerClient = client;
+    } else {
+      if (config.type === LoggerType.PINO) {
+        loggerClient = new PinoLoggerClient(config);
+      } else if (config.type === LoggerType.CONSOLE) {
+        loggerClient = new ConsoleLoggerClient(config);
+      } else if (config.type === LoggerType.CUSTOM) {
+        throw new Error(
+          `Custom logger client must be provided. Please pass the client to registerLattice.`
+        );
+      } else {
+        loggerClient = new PinoLoggerClient(config);
+      }
+    }
+    const loggerLattice = {
+      key,
+      config,
+      client: loggerClient,
+      // Logger operations
+      info: (msg, obj) => {
+        loggerClient.info(msg, obj);
+      },
+      error: (msg, obj) => {
+        loggerClient.error(msg, obj);
+      },
+      warn: (msg, obj) => {
+        loggerClient.warn(msg, obj);
+      },
+      debug: (msg, obj) => {
+        loggerClient.debug(msg, obj);
+      },
+      updateContext: loggerClient.updateContext ? (context) => {
+        loggerClient.updateContext(context);
+      } : void 0,
+      child: loggerClient.child ? (options) => {
+        return loggerClient.child(options);
+      } : void 0
+    };
+    this.register(key, loggerLattice);
+  }
+  /**
+   * Get LoggerLattice
+   * @param key Lattice key name
+   */
+  getLoggerLattice(key) {
+    const loggerLattice = this.get(key);
+    if (!loggerLattice) {
+      throw new Error(`LoggerLattice ${key} not found`);
+    }
+    return loggerLattice;
+  }
+  /**
+   * Get all Lattices
+   */
+  getAllLattices() {
+    return this.getAll();
+  }
+  /**
+   * Check if Lattice exists
+   * @param key Lattice key name
+   */
+  hasLattice(key) {
+    return this.has(key);
+  }
+  /**
+   * Remove Lattice
+   * @param key Lattice key name
+   */
+  removeLattice(key) {
+    return this.remove(key);
+  }
+  /**
+   * Clear all Lattices
+   */
+  clearLattices() {
+    this.clear();
+  }
+  /**
+   * Get Lattice count
+   */
+  getLatticeCount() {
+    return this.count();
+  }
+  /**
+   * Get Lattice key list
+   */
+  getLatticeKeys() {
+    return this.keys();
+  }
+};
+var loggerLatticeManager = LoggerLatticeManager.getInstance();
+var registerLoggerLattice = (key, config, client) => loggerLatticeManager.registerLattice(key, config, client);
+var getLoggerLattice = (key) => loggerLatticeManager.getLoggerLattice(key);
+
 // src/index.ts
 import * as Protocols from "@axiom-lattice/protocols";
 export {
@@ -3984,24 +5564,31 @@ export {
   AgentType,
   ChunkBuffer,
   ChunkBufferLatticeManager,
+  ConsoleLoggerClient,
+  DefaultScheduleClient,
   EmbeddingsLatticeManager,
   GraphBuildOptions,
   InMemoryAssistantStore,
   InMemoryChunkBuffer,
   InMemoryThreadStore,
+  LoggerLatticeManager,
   MemoryLatticeManager,
   MemoryQueueClient,
-  MemoryScheduleClient,
+  MemoryScheduleStorage,
   MemoryType,
   ModelLatticeManager,
+  PinoLoggerClient,
+  PostgresDatabase,
   Protocols,
   QueueLatticeManager,
   ScheduleLatticeManager,
+  SqlDatabaseManager,
   StoreLatticeManager,
   ThreadStatus,
   ToolLatticeManager,
   VectorStoreLatticeManager,
   agentLatticeManager,
+  describeCronExpression,
   embeddingsLatticeManager,
   eventBus,
   event_bus_default as eventBusDefault,
@@ -4014,7 +5601,9 @@ export {
   getChunkBuffer,
   getEmbeddingsClient,
   getEmbeddingsLattice,
+  getLoggerLattice,
   getModelLattice,
+  getNextCronTime,
   getQueueLattice,
   getScheduleLattice,
   getStoreLattice,
@@ -4024,13 +5613,17 @@ export {
   getVectorStoreClient,
   getVectorStoreLattice,
   hasChunkBuffer,
+  isValidCronExpression,
+  loggerLatticeManager,
   modelLatticeManager,
+  parseCronExpression,
   queueLatticeManager,
   registerAgentLattice,
   registerAgentLattices,
   registerCheckpointSaver,
   registerChunkBuffer,
   registerEmbeddingsLattice,
+  registerLoggerLattice,
   registerModelLattice,
   registerQueueLattice,
   registerScheduleLattice,
@@ -4038,6 +5631,7 @@ export {
   registerToolLattice,
   registerVectorStoreLattice,
   scheduleLatticeManager,
+  sqlDatabaseManager,
   storeLatticeManager,
   toolLatticeManager,
   validateAgentInput,