@axiom-lattice/local-stores 1.0.2 → 1.0.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@axiom-lattice/local-stores",
-  "version": "1.0.2",
+  "version": "1.0.4",
   "description": "Local SQLite-based stores for Axiom Lattice framework",
   "main": "dist/index.js",
   "module": "dist/index.mjs",
@@ -24,8 +24,8 @@
     "@langchain/langgraph-checkpoint-sqlite": "^1.0.3",
     "@types/sql.js": "^1.4.11",
     "sql.js": "^1.14.1",
-    "@axiom-lattice/core": "2.1.80",
-    "@axiom-lattice/protocols": "2.1.42"
+    "@axiom-lattice/core": "2.1.82",
+    "@axiom-lattice/protocols": "2.1.43"
   },
   "devDependencies": {
     "@types/node": "^20.11.24",

package/src/createLocalStoreConfig.ts

@@ -34,6 +34,7 @@ import { LocalA2AApiKeyStore } from "./stores/LocalA2AApiKeyStore";
 import { LocalThreadMessageQueueStore } from "./stores/LocalThreadMessageQueueStore";
 import { LocalSkillStore } from "./stores/LocalSkillStore";
 import { LocalScheduleStorage } from "./stores/LocalScheduleStorage";
+import { LocalTaskStore } from "./stores/LocalTaskStore";
 
 export interface LocalStoreConfigOptions {
   /**
@@ -76,6 +77,7 @@ export async function createLocalStoreConfig(options: LocalStoreConfigOptions =
     threadMessageQueue: new LocalThreadMessageQueueStore(db),
     skill: new LocalSkillStore(db),
     schedule: new LocalScheduleStorage(db),
+    task: new LocalTaskStore(db),
     checkpoint: SqliteSaver.fromConnString(dbPath),
   };
 }

package/src/index.ts

@@ -42,3 +42,4 @@ export { LocalA2AApiKeyStore } from "./stores/LocalA2AApiKeyStore";
 export { LocalThreadMessageQueueStore } from "./stores/LocalThreadMessageQueueStore";
 export { LocalSkillStore } from "./stores/LocalSkillStore";
 export { LocalScheduleStorage } from "./stores/LocalScheduleStorage";
+export { LocalTaskStore } from "./stores/LocalTaskStore";

package/src/stores/LocalAssistantStore.ts

@@ -17,6 +17,7 @@ CREATE TABLE IF NOT EXISTS lt_assistants (
   name TEXT NOT NULL,
   description TEXT,
   graph_definition TEXT NOT NULL,
+  owner_user_id TEXT,
   created_at TEXT NOT NULL,
   updated_at TEXT NOT NULL,
   PRIMARY KEY (tenant_id, id)
@@ -29,6 +30,7 @@ interface AssistantRow {
   name: string;
   description: string | null;
   graph_definition: string;
+  owner_user_id: string | null;
   created_at: string;
   updated_at: string;
 }
@@ -63,14 +65,15 @@ export class LocalAssistantStore implements AssistantStore {
     const now = nowISO();
 
     this.db.prepare(
-      `INSERT INTO lt_assistants (id, tenant_id, name, description, graph_definition, created_at, updated_at)
-       VALUES (?, ?, ?, ?, ?, ?, ?)
+      `INSERT INTO lt_assistants (id, tenant_id, name, description, graph_definition, owner_user_id, created_at, updated_at)
+       VALUES (?, ?, ?, ?, ?, ?, ?, ?)
        ON CONFLICT(tenant_id, id) DO UPDATE SET
          name = excluded.name,
          description = excluded.description,
          graph_definition = excluded.graph_definition,
+         owner_user_id = excluded.owner_user_id,
          updated_at = excluded.updated_at`,
-    ).run(id, tenantId, data.name, data.description || null, JSON.stringify(data.graphDefinition), now, now);
+    ).run(id, tenantId, data.name, data.description || null, JSON.stringify(data.graphDefinition), data.ownerUserId || null, now, now);
 
     return {
       id,
@@ -78,6 +81,7 @@ export class LocalAssistantStore implements AssistantStore {
       name: data.name,
       description: data.description,
       graphDefinition: data.graphDefinition,
+      ownerUserId: data.ownerUserId,
       createdAt: parseISO(now),
       updatedAt: parseISO(now),
     };
@@ -107,6 +111,11 @@ export class LocalAssistantStore implements AssistantStore {
       values.push(JSON.stringify(updates.graphDefinition));
     }
 
+    if (updates.ownerUserId !== undefined) {
+      setClauses.push("owner_user_id = ?");
+      values.push(updates.ownerUserId || null);
+    }
+
     if (setClauses.length === 0) return existing;
 
     const now = nowISO();
@@ -134,6 +143,13 @@ export class LocalAssistantStore implements AssistantStore {
     ).get(tenantId, id);
     return row !== undefined;
   }
+
+  async getByOwner(tenantId: string, userId: string): Promise<Assistant | null> {
+    const row = this.db.prepare(
+      `SELECT * FROM lt_assistants WHERE tenant_id = ? AND owner_user_id = ? LIMIT 1`,
+    ).get(tenantId, userId) as unknown as AssistantRow | undefined;
+    return row ? mapRowToAssistant(row) : null;
+  }
 }
 
 function mapRowToAssistant(row: AssistantRow): Assistant {
@@ -143,6 +159,7 @@ function mapRowToAssistant(row: AssistantRow): Assistant {
     name: row.name,
     description: row.description || undefined,
     graphDefinition: JSON.parse(row.graph_definition),
+    ownerUserId: row.owner_user_id || undefined,
     createdAt: parseISO(row.created_at),
     updatedAt: parseISO(row.updated_at),
   };

package/src/stores/LocalChannelInstallationStore.ts

@@ -73,6 +73,22 @@ export class LocalChannelInstallationStore implements ChannelInstallationStore {
     return rows.map(mapRow);
   }
 
+  async getAllInstallations(
+    channel?: ChannelInstallationType,
+  ): Promise<ChannelInstallation[]> {
+    let rows: Row[];
+    if (channel) {
+      rows = this.db.prepare(
+        `SELECT * FROM lt_channel_installations WHERE channel = ? ORDER BY created_at DESC`,
+      ).all(channel) as Row[];
+    } else {
+      rows = this.db.prepare(
+        `SELECT * FROM lt_channel_installations ORDER BY created_at DESC`,
+      ).all() as Row[];
+    }
+    return rows.map(mapRow);
+  }
+
   async createInstallation(
     tenantId: string,
     installationId: string,

package/src/stores/LocalTaskStore.ts

@@ -0,0 +1,180 @@
+/**
+ * Local SQLite implementation of TaskStore.
+ */
+
+import { DatabaseWrapper } from "../database";
+import type {
+  TaskStore,
+  TaskItem,
+  CreateTaskRequest,
+  UpdateTaskRequest,
+  TaskListFilter,
+} from "@axiom-lattice/protocols";
+import { ensureTable, nowISO, parseISO } from "../database";
+import { randomUUID } from "crypto";
+
+const DDL = `
+CREATE TABLE IF NOT EXISTS lt_tasks (
+  id TEXT NOT NULL,
+  tenant_id TEXT NOT NULL,
+  owner_type TEXT NOT NULL DEFAULT 'user',
+  owner_id TEXT NOT NULL,
+  title TEXT NOT NULL,
+  description TEXT,
+  status TEXT NOT NULL DEFAULT 'pending',
+  priority TEXT NOT NULL DEFAULT 'medium',
+  due_date TEXT,
+  metadata TEXT,
+  parent_id TEXT,
+  source_id TEXT,
+  context TEXT,
+  created_at TEXT NOT NULL,
+  updated_at TEXT NOT NULL,
+  PRIMARY KEY (tenant_id, id)
+);
+`;
+
+interface TaskRow {
+  id: string;
+  tenant_id: string;
+  owner_type: string;
+  owner_id: string;
+  title: string;
+  description: string | null;
+  status: string;
+  priority: string;
+  due_date: string | null;
+  metadata: string | null;
+  parent_id: string | null;
+  source_id: string | null;
+  context: string | null;
+  created_at: string;
+  updated_at: string;
+}
+
+function mapRowToTask(row: TaskRow): TaskItem {
+  return {
+    id: row.id,
+    tenantId: row.tenant_id,
+    ownerType: row.owner_type as 'user' | 'agent',
+    ownerId: row.owner_id,
+    title: row.title,
+    description: row.description ?? undefined,
+    status: row.status as TaskItem['status'],
+    priority: row.priority as TaskItem['priority'],
+    dueDate: row.due_date ?? undefined,
+    metadata: row.metadata ? JSON.parse(row.metadata) : undefined,
+    parentId: row.parent_id ?? undefined,
+    sourceId: row.source_id ?? undefined,
+    context: row.context ? JSON.parse(row.context) : undefined,
+    createdAt: parseISO(row.created_at),
+    updatedAt: parseISO(row.updated_at),
+  };
+}
+
+export class LocalTaskStore implements TaskStore {
+  private db: DatabaseWrapper;
+
+  constructor(db: DatabaseWrapper) {
+    this.db = db;
+    ensureTable(db, DDL);
+  }
+
+  async create(
+    params: CreateTaskRequest & { tenantId: string; ownerType: string; ownerId: string },
+  ): Promise<TaskItem> {
+    const id = randomUUID();
+    const now = nowISO();
+
+    this.db.prepare(
+      `INSERT INTO lt_tasks (id, tenant_id, owner_type, owner_id, title, description, status, priority, due_date, metadata, parent_id, source_id, context, created_at, updated_at)
+       VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
+    ).run(
+      id, params.tenantId, params.ownerType, params.ownerId, params.title,
+      params.description || null, params.status || 'pending', params.priority || 'medium',
+      params.dueDate || null, params.metadata ? JSON.stringify(params.metadata) : null,
+      params.parentId || null, params.sourceId || null,
+      params.context ? JSON.stringify(params.context) : null, now, now,
+    );
+
+    return (await this.getById(params.tenantId, id))!;
+  }
+
+  async getById(tenantId: string, id: string): Promise<TaskItem | null> {
+    const row = this.db.prepare(
+      `SELECT * FROM lt_tasks WHERE tenant_id = ? AND id = ?`,
+    ).get(tenantId, id) as unknown as TaskRow | undefined;
+    return row ? mapRowToTask(row) : null;
+  }
+
+  async list(filter: TaskListFilter): Promise<TaskItem[]> {
+    const conditions: string[] = ['tenant_id = ?'];
+    const params: unknown[] = [filter.tenantId];
+
+    if (filter.ownerType) { conditions.push('owner_type = ?'); params.push(filter.ownerType); }
+    if (filter.ownerId) { conditions.push('owner_id = ?'); params.push(filter.ownerId); }
+    if (filter.status) { conditions.push('status = ?'); params.push(filter.status); }
+    if (filter.priority) { conditions.push('priority = ?'); params.push(filter.priority); }
+    if (filter.parentId) { conditions.push('parent_id = ?'); params.push(filter.parentId); }
+    if (filter.sourceId) { conditions.push('source_id = ?'); params.push(filter.sourceId); }
+    if (filter.metadata) {
+      for (const [key, value] of Object.entries(filter.metadata)) {
+        const safeKey = key.replace(/[^a-zA-Z0-9_]/g, '');
+        if (safeKey) {
+          conditions.push(`json_extract(metadata, '$.${safeKey}') = ?`);
+          params.push(String(value));
+        }
+      }
+    }
+
+    const where = conditions.join(' AND ');
+    const limit = filter.limit || 100;
+    const offset = filter.offset || 0;
+
+    const rows = this.db.prepare(
+      `SELECT * FROM lt_tasks WHERE ${where} ORDER BY created_at DESC LIMIT ? OFFSET ?`,
+    ).all(...params, limit, offset) as unknown as TaskRow[];
+    return rows.map(mapRowToTask);
+  }
+
+  async update(
+    tenantId: string,
+    id: string,
+    updates: UpdateTaskRequest,
+  ): Promise<TaskItem | null> {
+    const existing = await this.getById(tenantId, id);
+    if (!existing) return null;
+
+    const now = nowISO();
+    const setClauses: string[] = ['updated_at = ?'];
+    const values: unknown[] = [now];
+
+    if (updates.title !== undefined) { setClauses.push('title = ?'); values.push(updates.title); }
+    if (updates.description !== undefined) { setClauses.push('description = ?'); values.push(updates.description); }
+    if (updates.status !== undefined) { setClauses.push('status = ?'); values.push(updates.status); }
+    if (updates.priority !== undefined) { setClauses.push('priority = ?'); values.push(updates.priority); }
+    if (updates.dueDate !== undefined) { setClauses.push('due_date = ?'); values.push(updates.dueDate); }
+    if (updates.metadata !== undefined) { setClauses.push('metadata = ?'); values.push(JSON.stringify(updates.metadata)); }
+    if (updates.parentId !== undefined) { setClauses.push('parent_id = ?'); values.push(updates.parentId); }
+    if (updates.sourceId !== undefined) { setClauses.push('source_id = ?'); values.push(updates.sourceId); }
+    if (updates.context !== undefined) { setClauses.push('context = ?'); values.push(JSON.stringify(updates.context)); }
+    if (updates.ownerType !== undefined) { setClauses.push('owner_type = ?'); values.push(updates.ownerType); }
+    if (updates.ownerId !== undefined) { setClauses.push('owner_id = ?'); values.push(updates.ownerId); }
+
+    if (setClauses.length === 1) return existing;
+
+    values.push(tenantId, id);
+    this.db.prepare(
+      `UPDATE lt_tasks SET ${setClauses.join(', ')} WHERE tenant_id = ? AND id = ?`,
+    ).run(...values);
+
+    return this.getById(tenantId, id);
+  }
+
+  async delete(tenantId: string, id: string): Promise<boolean> {
+    const result = this.db.prepare(
+      `DELETE FROM lt_tasks WHERE tenant_id = ? AND id = ?`,
+    ).run(tenantId, id);
+    return result.changes > 0;
+  }
+}

package/src/stores/LocalThreadMessageQueueStore.ts

@@ -18,6 +18,8 @@ CREATE TABLE IF NOT EXISTS lt_thread_message_queue (
   thread_id TEXT NOT NULL,
   tenant_id TEXT NOT NULL,
   assistant_id TEXT NOT NULL,
+  workspace_id TEXT,
+  project_id TEXT,
   message_content TEXT NOT NULL,
   message_type TEXT NOT NULL DEFAULT 'human',
   sequence_order INTEGER NOT NULL DEFAULT 0,
@@ -36,6 +38,8 @@ interface QueueRow {
   thread_id: string;
   tenant_id: string;
   assistant_id: string;
+  workspace_id: string | null;
+  project_id: string | null;
   message_content: string;
   message_type: string;
   sequence_order: number;
@@ -64,10 +68,11 @@ export class LocalThreadMessageQueueStore implements IMessageQueueStore {
     const nextSeq = seqRow.next_seq;
 
     this.db.prepare(
-      `INSERT INTO lt_thread_message_queue (id, thread_id, tenant_id, assistant_id, message_content, message_type, sequence_order, priority, command, custom_run_config, created_at)
-       VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
+      `INSERT INTO lt_thread_message_queue (id, thread_id, tenant_id, assistant_id, workspace_id, project_id, message_content, message_type, sequence_order, priority, command, custom_run_config, created_at)
+       VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
     ).run(
       id, params.threadId, params.tenantId, params.assistantId,
+      params.workspaceId || null, params.projectId || null,
       JSON.stringify(params.content), params.type || "human", nextSeq,
       params.priority || 0,
       params.command ? JSON.stringify(params.command) : null,
@@ -87,10 +92,11 @@ export class LocalThreadMessageQueueStore implements IMessageQueueStore {
     ).get(params.threadId) as { next_seq: number };
 
     this.db.prepare(
-      `INSERT INTO lt_thread_message_queue (id, thread_id, tenant_id, assistant_id, message_content, message_type, sequence_order, priority, command, custom_run_config, created_at)
-       VALUES (?, ?, ?, ?, ?, ?, ?, 100, ?, ?, ?)`,
+      `INSERT INTO lt_thread_message_queue (id, thread_id, tenant_id, assistant_id, workspace_id, project_id, message_content, message_type, sequence_order, priority, command, custom_run_config, created_at)
+       VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, 100, ?, ?, ?)`,
     ).run(
       id, params.threadId, params.tenantId!, params.assistantId!,
+      params.workspaceId || null, params.projectId || null,
       JSON.stringify(params.content), params.type || "human", seqRow.next_seq,
       params.command ? JSON.stringify(params.command) : null,
       params.custom_run_config ? JSON.stringify(params.custom_run_config) : null,
@@ -123,12 +129,14 @@ export class LocalThreadMessageQueueStore implements IMessageQueueStore {
 
   async getThreadsWithPendingMessages(): Promise<ThreadInfo[]> {
     const rows = this.db.prepare(
-      `SELECT DISTINCT tenant_id, assistant_id, thread_id FROM lt_thread_message_queue WHERE status IN ('pending', 'processing') ORDER BY thread_id`,
-    ).all() as { tenant_id: string; assistant_id: string; thread_id: string }[];
+      `SELECT DISTINCT ON (thread_id) tenant_id, assistant_id, thread_id, workspace_id, project_id FROM lt_thread_message_queue WHERE status IN ('pending', 'processing') ORDER BY thread_id`,
+    ).all() as { tenant_id: string; assistant_id: string; thread_id: string; workspace_id: string | null; project_id: string | null }[];
     return rows.map((r) => ({
       tenantId: r.tenant_id,
       assistantId: r.assistant_id,
       threadId: r.thread_id,
+      workspaceId: r.workspace_id || undefined,
+      projectId: r.project_id || undefined,
     }));
   }
 

package/src/stores/LocalWorkflowTrackingStore.ts

@@ -42,6 +42,7 @@ CREATE TABLE IF NOT EXISTS lt_workflow_steps (
   tenant_id TEXT NOT NULL,
   step_type TEXT NOT NULL,
   step_name TEXT NOT NULL,
+  thread_id TEXT,
   edge_from TEXT,
   edge_to TEXT,
   edge_purpose TEXT,
@@ -57,6 +58,8 @@ CREATE TABLE IF NOT EXISTS lt_workflow_steps (
   PRIMARY KEY (run_id, id)
 );
 CREATE INDEX IF NOT EXISTS idx_lt_ws_type ON lt_workflow_steps(run_id, step_type);
+-- Backfill for existing databases that don't have the column
+ALTER TABLE lt_workflow_steps ADD COLUMN IF NOT EXISTS thread_id TEXT;
 `;
 
 interface RunRow {
@@ -82,6 +85,7 @@ interface StepRow {
   tenant_id: string;
   step_type: string;
   step_name: string;
+  thread_id: string | null;
   edge_from: string | null;
   edge_to: string | null;
   edge_purpose: string | null;
@@ -187,15 +191,17 @@ export class LocalWorkflowTrackingStore implements WorkflowTrackingStore {
     const id = `step_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`;
 
     this.db.prepare(
-      `INSERT INTO lt_workflow_steps (id, run_id, tenant_id, step_type, step_name, edge_from, edge_to, edge_purpose, input, status, started_at, created_at, updated_at)
-       VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, 'running', ?, ?, ?)`,
+      `INSERT INTO lt_workflow_steps (id, run_id, tenant_id, step_type, step_name, thread_id, edge_from, edge_to, edge_purpose, input, status, started_at, created_at, updated_at)
+       VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, 'running', ?, ?, ?)`,
     ).run(id, request.runId, request.tenantId, request.stepType, request.stepName,
+      request.threadId || null,
       request.edgeFrom || null, request.edgeTo || null, request.edgePurpose || null,
       request.input ? JSON.stringify(request.input) : null, now, now, now);
 
     return {
       id, runId: request.runId, tenantId: request.tenantId,
       stepType: request.stepType, stepName: request.stepName,
+      threadId: request.threadId,
       edgeFrom: request.edgeFrom, edgeTo: request.edgeTo, edgePurpose: request.edgePurpose,
       input: request.input, status: 'running', startedAt: parseISO(now),
       createdAt: parseISO(now), updatedAt: parseISO(now),
@@ -207,7 +213,16 @@ export class LocalWorkflowTrackingStore implements WorkflowTrackingStore {
     const row = this.db.prepare(
       `SELECT * FROM lt_workflow_steps WHERE run_id = ? AND step_type = ? AND step_name = ?`,
     ).get(request.runId, request.stepType, request.stepName) as unknown as StepRow | undefined;
-    if (row) return mapRowToStep(row);
+    if (row) {
+      const existing = mapRowToStep(row);
+      if (!existing.threadId && request.threadId) {
+        this.db.prepare(
+          `UPDATE lt_workflow_steps SET thread_id = ?, updated_at = ? WHERE run_id = ? AND id = ?`,
+        ).run(request.threadId, nowISO(), request.runId, existing.id);
+        existing.threadId = request.threadId;
+      }
+      return existing;
+    }
     return this.createRunStep(request);
   }
 
@@ -292,6 +307,7 @@ function mapRowToStep(row: StepRow): RunStep {
     tenantId: row.tenant_id,
     stepType: row.step_type as StepType,
     stepName: row.step_name,
+    threadId: row.thread_id,
     edgeFrom: row.edge_from || undefined,
     edgeTo: row.edge_to || undefined,
     edgePurpose: row.edge_purpose || undefined,