@dexto/core 1.7.2 → 1.8.0

package/dist/storage/stores/in-memory.cjs

@@ -0,0 +1,510 @@
+"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 in_memory_exports = {};
+__export(in_memory_exports, {
+  InMemoryDextoStores: () => InMemoryDextoStores
+});
+module.exports = __toCommonJS(in_memory_exports);
+var import_crypto = require("crypto");
+var import_content_clone = require("../../context/content-clone.js");
+var import_queue_clone = require("../../session/queue-clone.js");
+var import_types = require("../tool-executions/types.js");
+var import_errors = require("../errors.js");
+const GLOBAL_SCOPE = "global";
+const DEFAULT_APPROVAL_STATE = {
+  toolPatterns: {},
+  approvedDirectories: []
+};
+const DEFAULT_TOOL_PREFERENCES = {
+  userAutoApproveTools: [],
+  disabledTools: []
+};
+class InMemoryConversationStore {
+  messages = /* @__PURE__ */ new Map();
+  async listMessages(input) {
+    return (0, import_content_clone.cloneInternalMessages)(this.messages.get(input.sessionId) ?? []);
+  }
+  async saveMessage(input) {
+    const messages = this.messages.get(input.sessionId) ?? [];
+    if (input.message.id && messages.some((message) => message.id === input.message.id)) {
+      return;
+    }
+    messages.push((0, import_content_clone.cloneInternalMessage)(input.message));
+    this.messages.set(input.sessionId, messages);
+  }
+  async updateMessage(input) {
+    if (!input.message.id) {
+      return;
+    }
+    const messages = this.messages.get(input.sessionId) ?? [];
+    const index = messages.findIndex((message) => message.id === input.message.id);
+    if (index === -1) {
+      return;
+    }
+    messages[index] = (0, import_content_clone.cloneInternalMessage)(input.message);
+    this.messages.set(input.sessionId, messages);
+  }
+  async clearMessages(input) {
+    this.messages.delete(input.sessionId);
+  }
+  async flush(_input) {
+  }
+}
+class InMemoryApprovalStore {
+  requests = /* @__PURE__ */ new Map();
+  responses = /* @__PURE__ */ new Map();
+  sessionStates = /* @__PURE__ */ new Map();
+  async createRequest(input) {
+    const existing = this.requests.get(input.request.approvalId);
+    if (existing) {
+      return structuredClone(existing);
+    }
+    this.requests.set(input.request.approvalId, structuredClone(input.request));
+    return structuredClone(input.request);
+  }
+  async getRequest(input) {
+    const request = this.requests.get(input.approvalId);
+    return request ? structuredClone(request) : void 0;
+  }
+  async listPending(input) {
+    const pending = [];
+    for (const request of this.requests.values()) {
+      if (this.responses.has(request.approvalId)) {
+        continue;
+      }
+      if (input.sessionId !== void 0 && request.sessionId !== input.sessionId) {
+        continue;
+      }
+      pending.push(structuredClone(request));
+    }
+    return pending;
+  }
+  async saveResponse(input) {
+    const existing = this.responses.get(input.response.approvalId);
+    if (existing) {
+      return { response: structuredClone(existing), status: "replayed" };
+    }
+    this.responses.set(input.response.approvalId, structuredClone(input.response));
+    return { response: structuredClone(input.response), status: "created" };
+  }
+  async getResponse(input) {
+    const response = this.responses.get(input.approvalId);
+    return response ? structuredClone(response) : void 0;
+  }
+  async loadSessionState(input) {
+    return structuredClone(
+      this.sessionStates.get(input.sessionId ?? GLOBAL_SCOPE) ?? DEFAULT_APPROVAL_STATE
+    );
+  }
+  async saveSessionState(input) {
+    this.sessionStates.set(input.sessionId ?? GLOBAL_SCOPE, structuredClone(input.state));
+  }
+  async deleteSessionState(input) {
+    this.sessionStates.delete(input.sessionId ?? GLOBAL_SCOPE);
+  }
+}
+class InMemorySessionStore {
+  sessions = /* @__PURE__ */ new Map();
+  async listSessionIds() {
+    return Array.from(this.sessions.keys());
+  }
+  async getSession(input) {
+    const session = this.sessions.get(input.sessionId);
+    return session ? structuredClone(session) : void 0;
+  }
+  async saveSession(input) {
+    void input.ttlSeconds;
+    this.sessions.set(input.sessionId, structuredClone(input.session));
+  }
+  async deleteSession(input) {
+    this.sessions.delete(input.sessionId);
+  }
+  async evictSession(_input) {
+  }
+}
+class InMemoryMemoryStore {
+  memories = /* @__PURE__ */ new Map();
+  async create(input) {
+    this.memories.set(input.memory.id, structuredClone(input.memory));
+  }
+  async get(input) {
+    const memory = this.memories.get(input.id);
+    return memory ? structuredClone(memory) : void 0;
+  }
+  async update(input) {
+    this.memories.set(input.memory.id, structuredClone(input.memory));
+  }
+  async delete(input) {
+    this.memories.delete(input.id);
+  }
+  async list() {
+    return structuredClone(Array.from(this.memories.values()));
+  }
+}
+class InMemoryWorkspaceStore {
+  workspaces = /* @__PURE__ */ new Map();
+  currentWorkspaceId;
+  async saveWorkspace(input) {
+    this.workspaces.set(input.workspace.id, structuredClone(input.workspace));
+  }
+  async getWorkspace(input) {
+    const workspace = this.workspaces.get(input.id);
+    return workspace ? structuredClone(workspace) : void 0;
+  }
+  async findWorkspaceByPath(input) {
+    for (const workspace of this.workspaces.values()) {
+      if (workspace.path === input.path) {
+        return structuredClone(workspace);
+      }
+    }
+    return void 0;
+  }
+  async listWorkspaces() {
+    return structuredClone(Array.from(this.workspaces.values()));
+  }
+  async setCurrentWorkspace(input) {
+    this.currentWorkspaceId = input.id;
+  }
+  async getCurrentWorkspaceId() {
+    return this.currentWorkspaceId;
+  }
+  async clearCurrentWorkspace() {
+    this.currentWorkspaceId = void 0;
+  }
+}
+class InMemoryToolPreferenceStore {
+  allowedTools = /* @__PURE__ */ new Map();
+  sessionPreferences = /* @__PURE__ */ new Map();
+  async allowTool(input) {
+    this.getAllowedToolSet(input.sessionId).add(input.toolName);
+  }
+  async disallowTool(input) {
+    this.getAllowedToolSet(input.sessionId).delete(input.toolName);
+  }
+  async isToolAllowed(input) {
+    return this.getAllowedToolSet(input.sessionId).has(input.toolName) || this.getAllowedToolSet(void 0).has(input.toolName);
+  }
+  async listAllowedTools(input) {
+    return Array.from(this.getAllowedToolSet(input.sessionId));
+  }
+  async loadSessionPreferences(input) {
+    return structuredClone(
+      this.sessionPreferences.get(input.sessionId) ?? DEFAULT_TOOL_PREFERENCES
+    );
+  }
+  async saveSessionPreferences(input) {
+    this.sessionPreferences.set(input.sessionId, structuredClone(input.preferences));
+  }
+  async deleteSessionPreferences(input) {
+    this.sessionPreferences.delete(input.sessionId);
+  }
+  getAllowedToolSet(sessionId) {
+    const key = sessionId ?? GLOBAL_SCOPE;
+    const existing = this.allowedTools.get(key);
+    if (existing) {
+      return existing;
+    }
+    const tools = /* @__PURE__ */ new Set();
+    this.allowedTools.set(key, tools);
+    return tools;
+  }
+}
+class InMemorySessionMessageQueueStore {
+  queues = /* @__PURE__ */ new Map();
+  async listSessionIds() {
+    return Array.from(this.queues.keys());
+  }
+  async load(input) {
+    return (0, import_queue_clone.cloneQueuedMessages)(this.queues.get(input.sessionId) ?? []);
+  }
+  async save(input) {
+    if (input.queue.length === 0) {
+      this.queues.delete(input.sessionId);
+      return;
+    }
+    this.queues.set(input.sessionId, (0, import_queue_clone.cloneQueuedMessages)(input.queue));
+  }
+  async delete(input) {
+    this.queues.delete(input.sessionId);
+  }
+}
+class InMemoryCustomPromptStore {
+  prompts = /* @__PURE__ */ new Map();
+  async save(input) {
+    this.prompts.set(input.prompt.name, structuredClone(input.prompt));
+  }
+  async get(input) {
+    const prompt = this.prompts.get(input.name);
+    return prompt ? structuredClone(prompt) : void 0;
+  }
+  async delete(input) {
+    this.prompts.delete(input.name);
+  }
+  async list() {
+    return structuredClone(Array.from(this.prompts.values()));
+  }
+}
+class InMemoryArtifactStore {
+  artifacts = /* @__PURE__ */ new Map();
+  async store(input) {
+    const data = this.toBuffer(input.data);
+    const id = (0, import_crypto.randomUUID)();
+    const hash = (0, import_crypto.createHash)("sha256").update(data).digest("hex");
+    const metadata = this.createMetadata(id, data, hash, input.metadata);
+    this.artifacts.set(id, { data, metadata });
+    return { id, uri: `blob:${id}`, metadata: structuredClone(metadata) };
+  }
+  async retrieve(input) {
+    const id = this.toId(input.reference);
+    const artifact = this.artifacts.get(id);
+    if (!artifact) {
+      throw import_errors.StorageError.blobNotFound(input.reference);
+    }
+    if (input.format === "buffer") {
+      return {
+        format: "buffer",
+        data: Buffer.from(artifact.data),
+        metadata: structuredClone(artifact.metadata)
+      };
+    }
+    return {
+      format: "base64",
+      data: artifact.data.toString("base64"),
+      metadata: structuredClone(artifact.metadata)
+    };
+  }
+  async exists(input) {
+    return this.artifacts.has(this.toId(input.reference));
+  }
+  async delete(input) {
+    this.artifacts.delete(this.toId(input.reference));
+  }
+  async cleanup(input = {}) {
+    let deleted = 0;
+    for (const [id, artifact] of this.artifacts.entries()) {
+      if (input.olderThan && artifact.metadata.createdAt >= input.olderThan) {
+        continue;
+      }
+      this.artifacts.delete(id);
+      deleted++;
+    }
+    return deleted;
+  }
+  async getStats() {
+    let totalSize = 0;
+    for (const artifact of this.artifacts.values()) {
+      totalSize += artifact.metadata.size;
+    }
+    return {
+      count: this.artifacts.size,
+      totalSize,
+      backendType: "in-memory"
+    };
+  }
+  async listArtifacts() {
+    return Array.from(this.artifacts.values()).map((artifact) => ({
+      id: artifact.metadata.id,
+      uri: `blob:${artifact.metadata.id}`,
+      metadata: structuredClone(artifact.metadata)
+    }));
+  }
+  getStoragePath() {
+    return void 0;
+  }
+  toBuffer(input) {
+    if (typeof input === "string") {
+      return Buffer.from(input, "base64");
+    }
+    if (input instanceof Uint8Array) {
+      return Buffer.from(input);
+    }
+    return Buffer.from(input);
+  }
+  createMetadata(id, data, hash, metadata) {
+    return {
+      id,
+      mimeType: metadata?.mimeType ?? "application/octet-stream",
+      ...metadata?.originalName !== void 0 && { originalName: metadata.originalName },
+      createdAt: metadata?.createdAt ?? /* @__PURE__ */ new Date(),
+      size: metadata?.size ?? data.byteLength,
+      hash,
+      ...metadata?.source !== void 0 && { source: metadata.source }
+    };
+  }
+  toId(reference) {
+    if (reference.startsWith("artifact:")) {
+      return reference.slice("artifact:".length);
+    }
+    if (reference.startsWith("blob:")) {
+      return reference.slice("blob:".length);
+    }
+    return reference;
+  }
+}
+class InMemoryRuntimeEventStore {
+  events = [];
+  async append(input) {
+    this.events.push(structuredClone(input.event));
+  }
+  async list(input) {
+    const events = this.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 ? events : events.slice(-input.limit));
+  }
+}
+class InMemoryToolStateStore {
+  values = /* @__PURE__ */ new Map();
+  async get(input) {
+    return structuredClone(this.values.get(this.toKey(input)));
+  }
+  async set(input) {
+    this.values.set(this.toKey(input), structuredClone(input.value));
+  }
+  async delete(input) {
+    this.values.delete(this.toKey(input));
+  }
+  async listKeys(input) {
+    const prefix = this.toKey({ toolName: input.toolName, key: input.prefix ?? "" });
+    return Array.from(this.values.keys()).filter((key) => key.startsWith(prefix)).map((key) => key.slice(this.toKey({ toolName: input.toolName, key: "" }).length));
+  }
+  toKey(input) {
+    return `${input.toolName}:${input.key}`;
+  }
+}
+class InMemoryToolExecutionStore {
+  records = /* @__PURE__ */ new Map();
+  async get(input) {
+    const record = this.records.get(input.executionId);
+    return record ? structuredClone(record) : void 0;
+  }
+  async start(input) {
+    const existing = this.records.get(input.record.executionId);
+    if (existing) {
+      return { status: "existing", record: structuredClone(existing) };
+    }
+    this.records.set(input.record.executionId, structuredClone(input.record));
+    return { status: "started", record: structuredClone(input.record) };
+  }
+  async complete(input) {
+    const existing = this.requireRecord(input.executionId);
+    if (existing.status === "completed") {
+      return structuredClone(existing);
+    }
+    if (existing.status !== "running") {
+      throw new Error(`Tool execution is already ${existing.status}: ${input.executionId}`);
+    }
+    const resultParts = (0, import_types.splitToolExecutionResult)(input.result);
+    const record = {
+      ...existing,
+      status: "completed",
+      completedAt: input.completedAt,
+      updatedAt: input.completedAt,
+      ...resultParts
+    };
+    this.records.set(input.executionId, structuredClone(record));
+    return structuredClone(record);
+  }
+  async fail(input) {
+    const existing = this.requireRecord(input.executionId);
+    if (existing.status === "failed") {
+      return structuredClone(existing);
+    }
+    if (existing.status !== "running") {
+      throw new Error(`Tool execution is already ${existing.status}: ${input.executionId}`);
+    }
+    const record = {
+      ...existing,
+      status: "failed",
+      completedAt: input.completedAt,
+      updatedAt: input.completedAt,
+      error: input.error
+    };
+    this.records.set(input.executionId, structuredClone(record));
+    return structuredClone(record);
+  }
+  async cancel(input) {
+    const existing = this.requireRecord(input.executionId);
+    if (existing.status === "cancelled") {
+      return structuredClone(existing);
+    }
+    if (existing.status !== "running") {
+      throw new Error(`Tool execution is already ${existing.status}: ${input.executionId}`);
+    }
+    const record = {
+      ...existing,
+      status: "cancelled",
+      completedAt: input.completedAt,
+      updatedAt: input.completedAt,
+      ...input.reason !== void 0 ? { reason: input.reason } : {}
+    };
+    this.records.set(input.executionId, structuredClone(record));
+    return structuredClone(record);
+  }
+  requireRecord(executionId) {
+    const existing = this.records.get(executionId);
+    if (!existing) {
+      throw new Error(`Tool execution record not found: ${executionId}`);
+    }
+    return existing;
+  }
+}
+class InMemoryDextoStores {
+  connected = false;
+  stores = {
+    conversation: new InMemoryConversationStore(),
+    sessions: new InMemorySessionStore(),
+    memories: new InMemoryMemoryStore(),
+    workspaces: new InMemoryWorkspaceStore(),
+    approvals: new InMemoryApprovalStore(),
+    toolPreferences: new InMemoryToolPreferenceStore(),
+    toolState: new InMemoryToolStateStore(),
+    steerQueue: new InMemorySessionMessageQueueStore(),
+    followUpQueue: new InMemorySessionMessageQueueStore(),
+    customPrompts: new InMemoryCustomPromptStore(),
+    artifacts: new InMemoryArtifactStore(),
+    runtimeEvents: new InMemoryRuntimeEventStore(),
+    toolExecutions: new InMemoryToolExecutionStore()
+  };
+  getStore(name) {
+    return this.stores[name];
+  }
+  async connect() {
+    this.connected = true;
+  }
+  async disconnect() {
+    this.connected = false;
+  }
+  isConnected() {
+    return this.connected;
+  }
+  getStoreType() {
+    return "in-memory";
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  InMemoryDextoStores
+});

package/dist/storage/stores/in-memory.d.ts

@@ -0,0 +1,11 @@
+import type { DextoStoreMap, DextoStoreName, DextoStores } from './types.js';
+export declare class InMemoryDextoStores implements DextoStores {
+    private connected;
+    private readonly stores;
+    getStore<K extends DextoStoreName>(name: K): DextoStoreMap[K];
+    connect(): Promise<void>;
+    disconnect(): Promise<void>;
+    isConnected(): boolean;
+    getStoreType(): string;
+}
+//# sourceMappingURL=in-memory.d.ts.map

package/dist/storage/stores/in-memory.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"in-memory.d.ts","sourceRoot":"","sources":["../../../src/storage/stores/in-memory.ts"],"names":[],"mappings":"AA0CA,OAAO,KAAK,EAAE,aAAa,EAAE,cAAc,EAAE,WAAW,EAAE,MAAM,YAAY,CAAC;AAykB7E,qBAAa,mBAAoB,YAAW,WAAW;IACnD,OAAO,CAAC,SAAS,CAAS;IAC1B,OAAO,CAAC,QAAQ,CAAC,MAAM,CAcrB;IAEF,QAAQ,CAAC,CAAC,SAAS,cAAc,EAAE,IAAI,EAAE,CAAC,GAAG,aAAa,CAAC,CAAC,CAAC;IAIvD,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC;IAIxB,UAAU,IAAI,OAAO,CAAC,IAAI,CAAC;IAIjC,WAAW,IAAI,OAAO;IAItB,YAAY,IAAI,MAAM;CAGzB"}