@dexto/core 1.7.2 → 1.8.1

package/dist/storage/stores/backend.cjs

@@ -0,0 +1,702 @@
+"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 backend_exports = {};
+__export(backend_exports, {
+  BackendDextoStores: () => BackendDextoStores,
+  DatabaseBackedApprovalStore: () => DatabaseBackedApprovalStore,
+  DatabaseBackedArtifactStore: () => DatabaseBackedArtifactStore,
+  DatabaseBackedCustomPromptStore: () => DatabaseBackedCustomPromptStore,
+  DatabaseBackedMemoryStore: () => DatabaseBackedMemoryStore,
+  DatabaseBackedRuntimeEventStore: () => DatabaseBackedRuntimeEventStore,
+  DatabaseBackedSessionMessageQueueStore: () => DatabaseBackedSessionMessageQueueStore,
+  DatabaseBackedSessionStore: () => DatabaseBackedSessionStore,
+  DatabaseBackedToolExecutionStore: () => DatabaseBackedToolExecutionStore,
+  DatabaseBackedToolPreferenceStore: () => DatabaseBackedToolPreferenceStore,
+  DatabaseBackedToolStateStore: () => DatabaseBackedToolStateStore,
+  DatabaseBackedWorkspaceStore: () => DatabaseBackedWorkspaceStore,
+  SESSION_FOLLOW_UP_QUEUE_KEY_PREFIX: () => SESSION_FOLLOW_UP_QUEUE_KEY_PREFIX,
+  SESSION_STEER_QUEUE_KEY_PREFIX: () => SESSION_STEER_QUEUE_KEY_PREFIX
+});
+module.exports = __toCommonJS(backend_exports);
+var import_schemas = require("../../approval/schemas.js");
+var import_queue_clone = require("../../session/queue-clone.js");
+var import_types = require("../../session/types.js");
+var import_session_tool_preferences_store = require("../../tools/session-tool-preferences-store.js");
+var import_types2 = require("../approvals/types.js");
+var import_types3 = require("../tool-executions/types.js");
+const GLOBAL_SCOPE = "global";
+const MEMORY_KEY_PREFIX = "memory:item:";
+const CUSTOM_PROMPT_KEY_PREFIX = "prompt:custom:";
+const RUNTIME_EVENTS_KEY = "runtime-events";
+const RUNTIME_EVENTS_LIMIT = 1e4;
+const TOOL_EXECUTION_KEY_PREFIX = "tool-execution:";
+const TOOL_STATE_KEY_PREFIX = "tool-state:";
+const WORKSPACE_KEY_PREFIX = "workspace:item:";
+const WORKSPACE_CURRENT_KEY = "workspace:current";
+const SESSION_STEER_QUEUE_KEY_PREFIX = "session-steer-queue";
+const SESSION_FOLLOW_UP_QUEUE_KEY_PREFIX = "session-follow-up-queue";
+const DEFAULT_APPROVAL_STATE = {
+  toolPatterns: {},
+  approvedDirectories: []
+};
+const DEFAULT_TOOL_PREFERENCES = {
+  userAutoApproveTools: [],
+  disabledTools: []
+};
+class DatabaseBackedArtifactStore {
+  constructor(blobStore) {
+    this.blobStore = blobStore;
+  }
+  async store(input) {
+    const reference = await this.blobStore.store(input.data, input.metadata);
+    return this.toArtifactReference(reference);
+  }
+  async retrieve(input) {
+    const data = await this.blobStore.retrieve(input.reference, input.format);
+    return this.toArtifactData(data);
+  }
+  async exists(input) {
+    return await this.blobStore.exists(input.reference);
+  }
+  async delete(input) {
+    await this.blobStore.delete(input.reference);
+  }
+  async cleanup(input) {
+    return await this.blobStore.cleanup(input?.olderThan);
+  }
+  async getStats() {
+    const stats = await this.blobStore.getStats();
+    return {
+      count: stats.count,
+      totalSize: stats.totalSize,
+      backendType: stats.backendType,
+      storePath: stats.storePath
+    };
+  }
+  async listArtifacts() {
+    const references = await this.blobStore.listBlobs();
+    return references.map((reference) => this.toArtifactReference(reference));
+  }
+  getStoragePath() {
+    return this.blobStore.getStoragePath();
+  }
+  toArtifactReference(reference) {
+    return {
+      id: reference.id,
+      uri: reference.uri,
+      metadata: this.toArtifactMetadata(reference.metadata)
+    };
+  }
+  toArtifactData(data) {
+    switch (data.format) {
+      case "base64":
+        return {
+          format: data.format,
+          data: data.data,
+          metadata: this.toArtifactMetadata(data.metadata)
+        };
+      case "buffer":
+        return {
+          format: data.format,
+          data: data.data,
+          metadata: this.toArtifactMetadata(data.metadata)
+        };
+      case "path":
+        return {
+          format: data.format,
+          data: data.data,
+          metadata: this.toArtifactMetadata(data.metadata)
+        };
+      case "stream":
+        return {
+          format: data.format,
+          data: data.data,
+          metadata: this.toArtifactMetadata(data.metadata)
+        };
+      case "url":
+        return {
+          format: data.format,
+          data: data.data,
+          metadata: this.toArtifactMetadata(data.metadata)
+        };
+    }
+  }
+  toArtifactMetadata(metadata) {
+    return {
+      id: metadata.id,
+      mimeType: metadata.mimeType,
+      createdAt: metadata.createdAt,
+      size: metadata.size,
+      hash: metadata.hash,
+      ...metadata.originalName !== void 0 ? { originalName: metadata.originalName } : {},
+      ...metadata.source !== void 0 ? { source: metadata.source } : {}
+    };
+  }
+}
+class DatabaseBackedApprovalStore {
+  constructor(database, cache, logger) {
+    this.database = database;
+    this.cache = cache;
+    this.logger = logger;
+  }
+  async createRequest(input) {
+    const request = import_schemas.ApprovalRequestSchema.parse(input.request);
+    const key = this.requestKey(request.approvalId);
+    const stored = await this.database.setIfAbsent(key, request);
+    return import_schemas.ApprovalRequestSchema.parse(stored.value);
+  }
+  async getRequest(input) {
+    const stored = await this.database.get(this.requestKey(input.approvalId));
+    return this.parseRequest(stored);
+  }
+  async listPending(input) {
+    const keys = await this.database.list("approval-request:");
+    const pending = [];
+    for (const key of keys) {
+      const stored = await this.database.get(key);
+      const request = this.parseRequest(stored);
+      if (!request) {
+        continue;
+      }
+      if (input.sessionId !== void 0 && request.sessionId !== input.sessionId) {
+        continue;
+      }
+      const response = await this.getResponse({ approvalId: request.approvalId });
+      if (!response) {
+        pending.push(request);
+      }
+    }
+    return pending;
+  }
+  async saveResponse(input) {
+    const response = import_schemas.ApprovalResponseSchema.parse(input.response);
+    const key = this.responseKey(response.approvalId);
+    const stored = await this.database.setIfAbsent(key, response);
+    return {
+      response: import_schemas.ApprovalResponseSchema.parse(stored.value),
+      status: stored.inserted ? "created" : "replayed"
+    };
+  }
+  async getResponse(input) {
+    const stored = await this.database.get(this.responseKey(input.approvalId));
+    return this.parseResponse(stored);
+  }
+  async loadSessionState(input) {
+    const key = this.sessionStateKey(input.sessionId);
+    const cached = await this.cache.get(key);
+    if (cached !== void 0) {
+      return this.parseSessionState(cached, key);
+    }
+    const stored = await this.database.get(key);
+    if (stored === void 0) {
+      return structuredClone(DEFAULT_APPROVAL_STATE);
+    }
+    const parsed = this.parseSessionState(stored, key);
+    await this.cache.set(key, parsed, 3600);
+    return parsed;
+  }
+  async saveSessionState(input) {
+    const key = this.sessionStateKey(input.sessionId);
+    const state = import_types2.SessionApprovalStateSchema.parse(input.state);
+    await this.database.set(key, state);
+    await this.cache.set(key, state, 3600);
+  }
+  async deleteSessionState(input) {
+    const key = this.sessionStateKey(input.sessionId);
+    await Promise.all([this.database.delete(key), this.cache.delete(key)]);
+  }
+  parseRequest(value) {
+    const result = import_schemas.ApprovalRequestSchema.safeParse(value);
+    return result.success ? result.data : void 0;
+  }
+  parseResponse(value) {
+    const result = import_schemas.ApprovalResponseSchema.safeParse(value);
+    return result.success ? result.data : void 0;
+  }
+  parseSessionState(value, key) {
+    const result = import_types2.SessionApprovalStateSchema.safeParse(value);
+    if (result.success) {
+      return result.data;
+    }
+    this.logger.warn("Invalid persisted approval state encountered; using defaults", {
+      key,
+      error: result.error.message
+    });
+    return structuredClone(DEFAULT_APPROVAL_STATE);
+  }
+  requestKey(approvalId) {
+    return `approval-request:${approvalId}`;
+  }
+  responseKey(approvalId) {
+    return `approval-response:${approvalId}`;
+  }
+  sessionStateKey(sessionId) {
+    return sessionId ? `session-approvals:${sessionId}` : "session-approvals:global";
+  }
+}
+class DatabaseBackedSessionStore {
+  constructor(database, cache) {
+    this.database = database;
+    this.cache = cache;
+  }
+  async listSessionIds() {
+    const keys = await this.database.list("session:");
+    return keys.map((key) => key.replace("session:", ""));
+  }
+  async getSession(input) {
+    const key = this.key(input.sessionId);
+    const cached = await this.cache.get(key);
+    if (cached !== void 0) {
+      return structuredClone(cached);
+    }
+    const session = await this.database.get(key);
+    return session ? structuredClone(session) : void 0;
+  }
+  async saveSession(input) {
+    const key = this.key(input.sessionId);
+    await this.database.set(key, input.session);
+    await this.cache.set(key, input.session, input.ttlSeconds);
+  }
+  async deleteSession(input) {
+    const key = this.key(input.sessionId);
+    await Promise.all([this.database.delete(key), this.cache.delete(key)]);
+  }
+  async evictSession(input) {
+    await this.cache.delete(this.key(input.sessionId));
+  }
+  key(sessionId) {
+    return `session:${sessionId}`;
+  }
+}
+class DatabaseBackedMemoryStore {
+  constructor(database) {
+    this.database = database;
+  }
+  async create(input) {
+    await this.database.set(this.key(input.memory.id), input.memory);
+  }
+  async get(input) {
+    return await this.database.get(this.key(input.id));
+  }
+  async update(input) {
+    await this.database.set(this.key(input.memory.id), input.memory);
+  }
+  async delete(input) {
+    await this.database.delete(this.key(input.id));
+  }
+  async list() {
+    const keys = await this.database.list(MEMORY_KEY_PREFIX);
+    const memories = [];
+    for (const key of keys) {
+      const memory = await this.database.get(key);
+      if (memory) {
+        memories.push(memory);
+      }
+    }
+    return memories;
+  }
+  key(id) {
+    return `${MEMORY_KEY_PREFIX}${id}`;
+  }
+}
+class DatabaseBackedWorkspaceStore {
+  constructor(database) {
+    this.database = database;
+  }
+  async saveWorkspace(input) {
+    await this.database.set(this.key(input.workspace.id), input.workspace);
+  }
+  async getWorkspace(input) {
+    return await this.database.get(this.key(input.id));
+  }
+  async findWorkspaceByPath(input) {
+    const workspaces = await this.listWorkspaces();
+    return workspaces.find((workspace) => workspace.path === input.path);
+  }
+  async listWorkspaces() {
+    const keys = await this.database.list(WORKSPACE_KEY_PREFIX);
+    const workspaces = [];
+    for (const key of keys) {
+      const workspace = await this.database.get(key);
+      if (workspace) {
+        workspaces.push(workspace);
+      }
+    }
+    return workspaces;
+  }
+  async setCurrentWorkspace(input) {
+    await this.database.set(WORKSPACE_CURRENT_KEY, input.id);
+  }
+  async getCurrentWorkspaceId() {
+    return await this.database.get(WORKSPACE_CURRENT_KEY);
+  }
+  async clearCurrentWorkspace() {
+    await this.database.delete(WORKSPACE_CURRENT_KEY);
+  }
+  key(id) {
+    return `${WORKSPACE_KEY_PREFIX}${id}`;
+  }
+}
+class DatabaseBackedToolPreferenceStore {
+  constructor(database, cache, logger) {
+    this.database = database;
+    this.cache = cache;
+    this.logger = logger;
+  }
+  async allowTool(input) {
+    const tools = await this.listAllowedTools(this.scope(input.sessionId));
+    if (tools.includes(input.toolName)) {
+      return;
+    }
+    await this.database.set(this.allowedToolsKey(input.sessionId), [...tools, input.toolName]);
+  }
+  async disallowTool(input) {
+    const tools = await this.listAllowedTools(this.scope(input.sessionId));
+    await this.database.set(
+      this.allowedToolsKey(input.sessionId),
+      tools.filter((toolName) => toolName !== input.toolName)
+    );
+  }
+  async isToolAllowed(input) {
+    const sessionTools = await this.listAllowedTools(this.scope(input.sessionId));
+    if (sessionTools.includes(input.toolName)) {
+      return true;
+    }
+    const globalTools = await this.listAllowedTools({});
+    return globalTools.includes(input.toolName);
+  }
+  async listAllowedTools(input) {
+    const stored = await this.database.get(this.allowedToolsKey(input.sessionId));
+    return Array.isArray(stored) ? stored.filter((value) => typeof value === "string") : [];
+  }
+  async loadSessionPreferences(input) {
+    const key = this.sessionPreferencesKey(input.sessionId);
+    const cached = await this.cache.get(key);
+    if (cached !== void 0) {
+      return this.parsePreferences(cached, key);
+    }
+    const stored = await this.database.get(key);
+    if (stored === void 0) {
+      return structuredClone(DEFAULT_TOOL_PREFERENCES);
+    }
+    const parsed = this.parsePreferences(stored, key);
+    await this.cache.set(key, parsed, 3600);
+    return parsed;
+  }
+  async saveSessionPreferences(input) {
+    const key = this.sessionPreferencesKey(input.sessionId);
+    const preferences = import_session_tool_preferences_store.SessionToolPreferencesSchema.parse(input.preferences);
+    await this.database.set(key, preferences);
+    await this.cache.set(key, preferences, 3600);
+  }
+  async deleteSessionPreferences(input) {
+    const key = this.sessionPreferencesKey(input.sessionId);
+    await Promise.all([this.database.delete(key), this.cache.delete(key)]);
+  }
+  parsePreferences(value, key) {
+    const result = import_session_tool_preferences_store.SessionToolPreferencesSchema.safeParse(value);
+    if (result.success) {
+      return result.data;
+    }
+    this.logger.warn("Invalid persisted session tool preferences encountered; using defaults", {
+      key,
+      error: result.error.message
+    });
+    return structuredClone(DEFAULT_TOOL_PREFERENCES);
+  }
+  allowedToolsKey(sessionId) {
+    return sessionId ? `allowedTools:${sessionId}` : `allowedTools:${GLOBAL_SCOPE}`;
+  }
+  scope(sessionId) {
+    return sessionId === void 0 ? {} : { sessionId };
+  }
+  sessionPreferencesKey(sessionId) {
+    return `session-tool-preferences:${sessionId}`;
+  }
+}
+class DatabaseBackedSessionMessageQueueStore {
+  constructor(database, cache, logger, keyPrefix) {
+    this.database = database;
+    this.cache = cache;
+    this.logger = logger;
+    this.keyPrefix = keyPrefix;
+  }
+  async listSessionIds() {
+    const prefix = `${this.keyPrefix}:`;
+    const keys = await this.database.list(prefix);
+    return keys.map((key) => key.replace(prefix, ""));
+  }
+  async load(input) {
+    const key = this.key(input.sessionId);
+    const cached = await this.cache.get(key);
+    const cachedQueue = import_types.QueuedMessagesSchema.safeParse(cached);
+    if (cachedQueue.success) {
+      return (0, import_queue_clone.cloneQueuedMessages)(cachedQueue.data);
+    }
+    const stored = await this.database.get(key);
+    const storedQueue = import_types.QueuedMessagesSchema.safeParse(stored);
+    if (!storedQueue.success) {
+      if (stored !== void 0) {
+        this.logger.warn("Invalid persisted message queue encountered; ignoring state", {
+          key
+        });
+      }
+      return [];
+    }
+    const queue = (0, import_queue_clone.cloneQueuedMessages)(storedQueue.data);
+    await this.cache.set(key, queue, 3600);
+    return (0, import_queue_clone.cloneQueuedMessages)(queue);
+  }
+  async save(input) {
+    const key = this.key(input.sessionId);
+    if (input.queue.length === 0) {
+      await this.delete({ sessionId: input.sessionId });
+      return;
+    }
+    const queue = (0, import_queue_clone.cloneQueuedMessages)(input.queue);
+    await this.database.set(key, queue);
+    await this.cache.set(key, queue, 3600);
+  }
+  async delete(input) {
+    const key = this.key(input.sessionId);
+    await Promise.all([this.database.delete(key), this.cache.delete(key)]);
+  }
+  key(sessionId) {
+    return `${this.keyPrefix}:${sessionId}`;
+  }
+}
+class DatabaseBackedCustomPromptStore {
+  constructor(database) {
+    this.database = database;
+  }
+  async save(input) {
+    await this.database.set(this.key(input.prompt.name), input.prompt);
+  }
+  async get(input) {
+    return await this.database.get(this.key(input.name));
+  }
+  async delete(input) {
+    await this.database.delete(this.key(input.name));
+  }
+  async list() {
+    const keys = await this.database.list(CUSTOM_PROMPT_KEY_PREFIX);
+    const prompts = [];
+    for (const key of keys) {
+      const prompt = await this.database.get(key);
+      if (prompt) {
+        prompts.push(prompt);
+      }
+    }
+    return prompts;
+  }
+  key(name) {
+    return `${CUSTOM_PROMPT_KEY_PREFIX}${name}`;
+  }
+}
+class DatabaseBackedRuntimeEventStore {
+  constructor(database) {
+    this.database = database;
+  }
+  async append(input) {
+    await this.database.append(RUNTIME_EVENTS_KEY, structuredClone(input.event));
+  }
+  async list(input) {
+    const events = await this.database.getRange(
+      RUNTIME_EVENTS_KEY,
+      0,
+      RUNTIME_EVENTS_LIMIT
+    );
+    const filtered = events.filter((event) => {
+      if (input.sessionId !== void 0 && event.sessionId !== input.sessionId) {
+        return false;
+      }
+      if (input.runId !== void 0 && event.runId !== input.runId) {
+        return false;
+      }
+      return true;
+    });
+    return structuredClone(input.limit === void 0 ? filtered : filtered.slice(-input.limit));
+  }
+}
+class DatabaseBackedToolStateStore {
+  constructor(database) {
+    this.database = database;
+  }
+  async get(input) {
+    return await this.database.get(this.toKey(input));
+  }
+  async set(input) {
+    await this.database.set(this.toKey(input), input.value);
+  }
+  async delete(input) {
+    await this.database.delete(this.toKey(input));
+  }
+  async listKeys(input) {
+    const prefix = this.toKey({ toolName: input.toolName, key: input.prefix ?? "" });
+    return (await this.database.list(prefix)).map(
+      (key) => key.slice(this.scopePrefix(input.toolName).length)
+    );
+  }
+  toKey(input) {
+    return `${this.scopePrefix(input.toolName)}${input.key}`;
+  }
+  scopePrefix(toolName) {
+    return `${TOOL_STATE_KEY_PREFIX}${toolName}:`;
+  }
+}
+class DatabaseBackedToolExecutionStore {
+  constructor(database) {
+    this.database = database;
+  }
+  async get(input) {
+    const stored = await this.database.get(this.toKey(input.executionId));
+    return stored === void 0 ? void 0 : import_types3.ToolExecutionRecordSchema.parse(stored);
+  }
+  async start(input) {
+    const parsed = import_types3.ToolExecutionRunningRecordSchema.parse(input.record);
+    const stored = await this.database.setIfAbsent(
+      this.toKey(parsed.executionId),
+      parsed
+    );
+    const record = import_types3.ToolExecutionRecordSchema.parse(stored.value);
+    return stored.inserted ? { status: "started", record: parsed } : { status: "existing", record };
+  }
+  async complete(input) {
+    const existing = await this.requireRecord(input.executionId);
+    if (existing.status === "completed") {
+      return existing;
+    }
+    if (existing.status !== "running") {
+      throw new Error(`Tool execution is already ${existing.status}: ${input.executionId}`);
+    }
+    const resultParts = (0, import_types3.splitToolExecutionResult)(input.result);
+    const record = import_types3.ToolExecutionCompletedRecordSchema.parse({
+      ...existing,
+      status: "completed",
+      completedAt: input.completedAt,
+      updatedAt: input.completedAt,
+      ...resultParts
+    });
+    await this.database.set(this.toKey(input.executionId), record);
+    return record;
+  }
+  async fail(input) {
+    const existing = await this.requireRecord(input.executionId);
+    if (existing.status === "failed") {
+      return existing;
+    }
+    if (existing.status !== "running") {
+      throw new Error(`Tool execution is already ${existing.status}: ${input.executionId}`);
+    }
+    const record = import_types3.ToolExecutionFailedRecordSchema.parse({
+      ...existing,
+      status: "failed",
+      completedAt: input.completedAt,
+      updatedAt: input.completedAt,
+      error: input.error
+    });
+    await this.database.set(this.toKey(input.executionId), record);
+    return record;
+  }
+  async cancel(input) {
+    const existing = await this.requireRecord(input.executionId);
+    if (existing.status === "cancelled") {
+      return existing;
+    }
+    if (existing.status !== "running") {
+      throw new Error(`Tool execution is already ${existing.status}: ${input.executionId}`);
+    }
+    const record = import_types3.ToolExecutionCancelledRecordSchema.parse({
+      ...existing,
+      status: "cancelled",
+      completedAt: input.completedAt,
+      updatedAt: input.completedAt,
+      ...input.reason !== void 0 ? { reason: input.reason } : {}
+    });
+    await this.database.set(this.toKey(input.executionId), record);
+    return record;
+  }
+  async requireRecord(executionId) {
+    const existing = await this.get({ executionId });
+    if (existing === void 0) {
+      throw new Error(`Tool execution record not found: ${executionId}`);
+    }
+    return existing;
+  }
+  toKey(executionId) {
+    return `${TOOL_EXECUTION_KEY_PREFIX}${executionId}`;
+  }
+}
+const NOOP_LIFECYCLE = {
+  async connect() {
+  },
+  async disconnect() {
+  },
+  isConnected() {
+    return true;
+  }
+};
+class BackendDextoStores {
+  constructor(stores, lifecycle = NOOP_LIFECYCLE, storeType = "backend") {
+    this.stores = stores;
+    this.lifecycle = lifecycle;
+    this.storeType = storeType;
+  }
+  connected = false;
+  getStore(name) {
+    return this.stores[name];
+  }
+  async connect() {
+    if (this.connected) {
+      return;
+    }
+    await this.lifecycle.connect();
+    this.connected = true;
+  }
+  async disconnect() {
+    if (!this.connected) {
+      return;
+    }
+    await this.lifecycle.disconnect();
+    this.connected = false;
+  }
+  isConnected() {
+    return this.connected && this.lifecycle.isConnected();
+  }
+  getStoreType() {
+    return this.storeType;
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  BackendDextoStores,
+  DatabaseBackedApprovalStore,
+  DatabaseBackedArtifactStore,
+  DatabaseBackedCustomPromptStore,
+  DatabaseBackedMemoryStore,
+  DatabaseBackedRuntimeEventStore,
+  DatabaseBackedSessionMessageQueueStore,
+  DatabaseBackedSessionStore,
+  DatabaseBackedToolExecutionStore,
+  DatabaseBackedToolPreferenceStore,
+  DatabaseBackedToolStateStore,
+  DatabaseBackedWorkspaceStore,
+  SESSION_FOLLOW_UP_QUEUE_KEY_PREFIX,
+  SESSION_STEER_QUEUE_KEY_PREFIX
+});