@dexto/core 1.6.25 → 1.6.27

package/dist/test-utils/session-state-stores.cjs

@@ -0,0 +1,68 @@
+"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 session_state_stores_exports = {};
+__export(session_state_stores_exports, {
+  createInMemoryMessageQueueStore: () => createInMemoryMessageQueueStore,
+  createInMemorySessionApprovalStore: () => createInMemorySessionApprovalStore,
+  createInMemorySessionStateStorage: () => createInMemorySessionStateStorage,
+  createInMemorySessionToolPreferencesStore: () => createInMemorySessionToolPreferencesStore
+});
+module.exports = __toCommonJS(session_state_stores_exports);
+var import_session_approval_store = require("../approval/session-approval-store.js");
+var import_session_tool_preferences_store = require("../tools/session-tool-preferences-store.js");
+var import_in_memory_storage = require("./in-memory-storage.js");
+function createInMemorySessionStateStorage() {
+  const cache = (0, import_in_memory_storage.createInMemoryCache)();
+  const database = (0, import_in_memory_storage.createInMemoryDatabase)();
+  return {
+    getCache: () => cache,
+    getDatabase: () => database
+  };
+}
+function createInMemorySessionApprovalStore(logger, storageManager = createInMemorySessionStateStorage()) {
+  return new import_session_approval_store.SessionApprovalStore(storageManager, logger);
+}
+function createInMemorySessionToolPreferencesStore(logger, storageManager = createInMemorySessionStateStorage()) {
+  return new import_session_tool_preferences_store.SessionToolPreferencesStore(storageManager, logger);
+}
+function createInMemoryMessageQueueStore() {
+  const queues = /* @__PURE__ */ new Map();
+  return {
+    async load(sessionId) {
+      return structuredClone(queues.get(sessionId) ?? []);
+    },
+    async save(sessionId, queue) {
+      if (queue.length === 0) {
+        queues.delete(sessionId);
+        return;
+      }
+      queues.set(sessionId, structuredClone(queue));
+    },
+    async delete(sessionId) {
+      queues.delete(sessionId);
+    }
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createInMemoryMessageQueueStore,
+  createInMemorySessionApprovalStore,
+  createInMemorySessionStateStorage,
+  createInMemorySessionToolPreferencesStore
+});

package/dist/test-utils/session-state-stores.js

@@ -0,0 +1,42 @@
+import "../chunk-PTJYTZNU.js";
+import { SessionApprovalStore } from "../approval/session-approval-store.js";
+import { SessionToolPreferencesStore } from "../tools/session-tool-preferences-store.js";
+import { createInMemoryCache, createInMemoryDatabase } from "./in-memory-storage.js";
+function createInMemorySessionStateStorage() {
+  const cache = createInMemoryCache();
+  const database = createInMemoryDatabase();
+  return {
+    getCache: () => cache,
+    getDatabase: () => database
+  };
+}
+function createInMemorySessionApprovalStore(logger, storageManager = createInMemorySessionStateStorage()) {
+  return new SessionApprovalStore(storageManager, logger);
+}
+function createInMemorySessionToolPreferencesStore(logger, storageManager = createInMemorySessionStateStorage()) {
+  return new SessionToolPreferencesStore(storageManager, logger);
+}
+function createInMemoryMessageQueueStore() {
+  const queues = /* @__PURE__ */ new Map();
+  return {
+    async load(sessionId) {
+      return structuredClone(queues.get(sessionId) ?? []);
+    },
+    async save(sessionId, queue) {
+      if (queue.length === 0) {
+        queues.delete(sessionId);
+        return;
+      }
+      queues.set(sessionId, structuredClone(queue));
+    },
+    async delete(sessionId) {
+      queues.delete(sessionId);
+    }
+  };
+}
+export {
+  createInMemoryMessageQueueStore,
+  createInMemorySessionApprovalStore,
+  createInMemorySessionStateStorage,
+  createInMemorySessionToolPreferencesStore
+};

package/dist/tools/session-tool-preferences-store.cjs

@@ -0,0 +1,86 @@
+"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 session_tool_preferences_store_exports = {};
+__export(session_tool_preferences_store_exports, {
+  SessionToolPreferencesStore: () => SessionToolPreferencesStore
+});
+module.exports = __toCommonJS(session_tool_preferences_store_exports);
+var import_zod = require("zod");
+const SessionToolPreferencesSchema = import_zod.z.object({
+  userAutoApproveTools: import_zod.z.array(import_zod.z.string()).default([]),
+  disabledTools: import_zod.z.array(import_zod.z.string()).default([])
+}).strict();
+const DEFAULT_SESSION_TOOL_PREFERENCES = {
+  userAutoApproveTools: [],
+  disabledTools: []
+};
+class SessionToolPreferencesStore {
+  constructor(storageManager, logger, options = {}) {
+    this.storageManager = storageManager;
+    this.logger = logger;
+    const cacheTtlMs = options.cacheTtlMs ?? 36e5;
+    this.cacheTtlSeconds = Math.max(1, Math.floor(cacheTtlMs / 1e3));
+  }
+  cacheTtlSeconds;
+  buildKey(sessionId) {
+    return `session-tool-preferences:${sessionId}`;
+  }
+  async load(sessionId) {
+    const key = this.buildKey(sessionId);
+    const cached = await this.storageManager.getCache().get(key);
+    if (cached !== void 0) {
+      return this.parsePreferences(cached, key);
+    }
+    const stored = await this.storageManager.getDatabase().get(key);
+    if (stored === void 0) {
+      return structuredClone(DEFAULT_SESSION_TOOL_PREFERENCES);
+    }
+    const parsed = this.parsePreferences(stored, key);
+    await this.storageManager.getCache().set(key, parsed, this.cacheTtlSeconds);
+    return parsed;
+  }
+  async save(sessionId, preferences) {
+    const key = this.buildKey(sessionId);
+    const normalized = SessionToolPreferencesSchema.parse(preferences);
+    await this.storageManager.getDatabase().set(key, normalized);
+    await this.storageManager.getCache().set(key, normalized, this.cacheTtlSeconds);
+  }
+  async delete(sessionId) {
+    const key = this.buildKey(sessionId);
+    await Promise.all([
+      this.storageManager.getDatabase().delete(key),
+      this.storageManager.getCache().delete(key)
+    ]);
+  }
+  parsePreferences(value, key) {
+    const result = 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_SESSION_TOOL_PREFERENCES);
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  SessionToolPreferencesStore
+});

package/dist/tools/session-tool-preferences-store.d.ts

@@ -0,0 +1,29 @@
+import { z } from 'zod';
+import type { StorageManager } from '../storage/index.js';
+import type { Logger } from '../logger/v2/types.js';
+declare const SessionToolPreferencesSchema: z.ZodObject<{
+    userAutoApproveTools: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    disabledTools: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+}, "strict", z.ZodTypeAny, {
+    userAutoApproveTools: string[];
+    disabledTools: string[];
+}, {
+    userAutoApproveTools?: string[] | undefined;
+    disabledTools?: string[] | undefined;
+}>;
+export type SessionToolPreferences = z.output<typeof SessionToolPreferencesSchema>;
+export declare class SessionToolPreferencesStore {
+    private readonly storageManager;
+    private readonly logger;
+    private readonly cacheTtlSeconds;
+    constructor(storageManager: StorageManager, logger: Logger, options?: {
+        cacheTtlMs?: number;
+    });
+    private buildKey;
+    load(sessionId: string): Promise<SessionToolPreferences>;
+    save(sessionId: string, preferences: SessionToolPreferences): Promise<void>;
+    delete(sessionId: string): Promise<void>;
+    private parsePreferences;
+}
+export {};
+//# sourceMappingURL=session-tool-preferences-store.d.ts.map

package/dist/tools/session-tool-preferences-store.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"session-tool-preferences-store.d.ts","sourceRoot":"","sources":["../../src/tools/session-tool-preferences-store.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,qBAAqB,CAAC;AAC1D,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,uBAAuB,CAAC;AAEpD,QAAA,MAAM,4BAA4B;;;;;;;;;EAKrB,CAAC;AAEd,MAAM,MAAM,sBAAsB,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,4BAA4B,CAAC,CAAC;AAOnF,qBAAa,2BAA2B;IAIhC,OAAO,CAAC,QAAQ,CAAC,cAAc;IAC/B,OAAO,CAAC,QAAQ,CAAC,MAAM;IAJ3B,OAAO,CAAC,QAAQ,CAAC,eAAe,CAAS;gBAGpB,cAAc,EAAE,cAAc,EAC9B,MAAM,EAAE,MAAM,EAC/B,OAAO,GAAE;QAAE,UAAU,CAAC,EAAE,MAAM,CAAA;KAAO;IAMzC,OAAO,CAAC,QAAQ;IAIV,IAAI,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,sBAAsB,CAAC;IAiBxD,IAAI,CAAC,SAAS,EAAE,MAAM,EAAE,WAAW,EAAE,sBAAsB,GAAG,OAAO,CAAC,IAAI,CAAC;IAO3E,MAAM,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAQ9C,OAAO,CAAC,gBAAgB;CAY3B"}

package/dist/tools/session-tool-preferences-store.js

@@ -0,0 +1,63 @@
+import "../chunk-PTJYTZNU.js";
+import { z } from "zod";
+const SessionToolPreferencesSchema = z.object({
+  userAutoApproveTools: z.array(z.string()).default([]),
+  disabledTools: z.array(z.string()).default([])
+}).strict();
+const DEFAULT_SESSION_TOOL_PREFERENCES = {
+  userAutoApproveTools: [],
+  disabledTools: []
+};
+class SessionToolPreferencesStore {
+  constructor(storageManager, logger, options = {}) {
+    this.storageManager = storageManager;
+    this.logger = logger;
+    const cacheTtlMs = options.cacheTtlMs ?? 36e5;
+    this.cacheTtlSeconds = Math.max(1, Math.floor(cacheTtlMs / 1e3));
+  }
+  cacheTtlSeconds;
+  buildKey(sessionId) {
+    return `session-tool-preferences:${sessionId}`;
+  }
+  async load(sessionId) {
+    const key = this.buildKey(sessionId);
+    const cached = await this.storageManager.getCache().get(key);
+    if (cached !== void 0) {
+      return this.parsePreferences(cached, key);
+    }
+    const stored = await this.storageManager.getDatabase().get(key);
+    if (stored === void 0) {
+      return structuredClone(DEFAULT_SESSION_TOOL_PREFERENCES);
+    }
+    const parsed = this.parsePreferences(stored, key);
+    await this.storageManager.getCache().set(key, parsed, this.cacheTtlSeconds);
+    return parsed;
+  }
+  async save(sessionId, preferences) {
+    const key = this.buildKey(sessionId);
+    const normalized = SessionToolPreferencesSchema.parse(preferences);
+    await this.storageManager.getDatabase().set(key, normalized);
+    await this.storageManager.getCache().set(key, normalized, this.cacheTtlSeconds);
+  }
+  async delete(sessionId) {
+    const key = this.buildKey(sessionId);
+    await Promise.all([
+      this.storageManager.getDatabase().delete(key),
+      this.storageManager.getCache().delete(key)
+    ]);
+  }
+  parsePreferences(value, key) {
+    const result = 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_SESSION_TOOL_PREFERENCES);
+  }
+}
+export {
+  SessionToolPreferencesStore
+};