@dexto/core 1.1.9 → 1.1.11

package/dist/systemPrompt/schemas.d.ts

@@ -1,6 +1,5 @@
 import { z } from 'zod';
-
-declare const ContributorConfigSchema: z.ZodDiscriminatedUnion<"type", [z.ZodObject<{
+export declare const ContributorConfigSchema: z.ZodDiscriminatedUnion<"type", [z.ZodObject<{
     id: z.ZodString;
     priority: z.ZodNumber;
     enabled: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
@@ -9,15 +8,15 @@ declare const ContributorConfigSchema: z.ZodDiscriminatedUnion<"type", [z.ZodObj
     content: z.ZodString;
 }, "strict", z.ZodTypeAny, {
     type: "static";
-    content: string;
     id: string;
     priority: number;
     enabled: boolean;
+    content: string;
 }, {
     type: "static";
-    content: string;
     id: string;
     priority: number;
+    content: string;
     enabled?: boolean | undefined;
 }>, z.ZodObject<{
     id: z.ZodString;
@@ -31,12 +30,12 @@ declare const ContributorConfigSchema: z.ZodDiscriminatedUnion<"type", [z.ZodObj
     id: string;
     priority: number;
     enabled: boolean;
-    source: "resources" | "dateTime" | "memorySummary";
+    source: "dateTime" | "memorySummary" | "resources";
 }, {
     type: "dynamic";
     id: string;
     priority: number;
-    source: "resources" | "dateTime" | "memorySummary";
+    source: "dateTime" | "memorySummary" | "resources";
     enabled?: boolean | undefined;
 }>, z.ZodObject<{
     id: z.ZodString;
@@ -90,10 +89,54 @@ declare const ContributorConfigSchema: z.ZodDiscriminatedUnion<"type", [z.ZodObj
         includeMetadata?: boolean | undefined;
     } | undefined;
     enabled?: boolean | undefined;
+}>, z.ZodObject<{
+    id: z.ZodString;
+    priority: z.ZodNumber;
+    enabled: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+} & {
+    type: z.ZodLiteral<"memory">;
+    options: z.ZodDefault<z.ZodOptional<z.ZodObject<{
+        includeTimestamps: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+        includeTags: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+        limit: z.ZodOptional<z.ZodNumber>;
+        pinnedOnly: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+    }, "strict", z.ZodTypeAny, {
+        includeTimestamps: boolean;
+        includeTags: boolean;
+        pinnedOnly: boolean;
+        limit?: number | undefined;
+    }, {
+        includeTimestamps?: boolean | undefined;
+        includeTags?: boolean | undefined;
+        limit?: number | undefined;
+        pinnedOnly?: boolean | undefined;
+    }>>>;
+}, "strict", z.ZodTypeAny, {
+    options: {
+        includeTimestamps: boolean;
+        includeTags: boolean;
+        pinnedOnly: boolean;
+        limit?: number | undefined;
+    };
+    type: "memory";
+    id: string;
+    priority: number;
+    enabled: boolean;
+}, {
+    type: "memory";
+    id: string;
+    priority: number;
+    options?: {
+        includeTimestamps?: boolean | undefined;
+        includeTags?: boolean | undefined;
+        limit?: number | undefined;
+        pinnedOnly?: boolean | undefined;
+    } | undefined;
+    enabled?: boolean | undefined;
 }>]>;
-type ContributorConfig = z.input<typeof ContributorConfigSchema>;
-type ValidatedContributorConfig = z.output<typeof ContributorConfigSchema>;
-declare const SystemPromptContributorsSchema: z.ZodObject<{
+export type ContributorConfig = z.input<typeof ContributorConfigSchema>;
+export type ValidatedContributorConfig = z.output<typeof ContributorConfigSchema>;
+export declare const SystemPromptContributorsSchema: z.ZodObject<{
     contributors: z.ZodDefault<z.ZodArray<z.ZodDiscriminatedUnion<"type", [z.ZodObject<{
         id: z.ZodString;
         priority: z.ZodNumber;
@@ -103,15 +146,15 @@ declare const SystemPromptContributorsSchema: z.ZodObject<{
         content: z.ZodString;
     }, "strict", z.ZodTypeAny, {
         type: "static";
-        content: string;
         id: string;
         priority: number;
         enabled: boolean;
+        content: string;
     }, {
         type: "static";
-        content: string;
         id: string;
         priority: number;
+        content: string;
         enabled?: boolean | undefined;
     }>, z.ZodObject<{
         id: z.ZodString;
@@ -125,12 +168,12 @@ declare const SystemPromptContributorsSchema: z.ZodObject<{
         id: string;
         priority: number;
         enabled: boolean;
-        source: "resources" | "dateTime" | "memorySummary";
+        source: "dateTime" | "memorySummary" | "resources";
     }, {
         type: "dynamic";
         id: string;
         priority: number;
-        source: "resources" | "dateTime" | "memorySummary";
+        source: "dateTime" | "memorySummary" | "resources";
         enabled?: boolean | undefined;
     }>, z.ZodObject<{
         id: z.ZodString;
@@ -184,20 +227,64 @@ declare const SystemPromptContributorsSchema: z.ZodObject<{
             includeMetadata?: boolean | undefined;
         } | undefined;
         enabled?: boolean | undefined;
+    }>, z.ZodObject<{
+        id: z.ZodString;
+        priority: z.ZodNumber;
+        enabled: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+    } & {
+        type: z.ZodLiteral<"memory">;
+        options: z.ZodDefault<z.ZodOptional<z.ZodObject<{
+            includeTimestamps: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+            includeTags: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+            limit: z.ZodOptional<z.ZodNumber>;
+            pinnedOnly: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+        }, "strict", z.ZodTypeAny, {
+            includeTimestamps: boolean;
+            includeTags: boolean;
+            pinnedOnly: boolean;
+            limit?: number | undefined;
+        }, {
+            includeTimestamps?: boolean | undefined;
+            includeTags?: boolean | undefined;
+            limit?: number | undefined;
+            pinnedOnly?: boolean | undefined;
+        }>>>;
+    }, "strict", z.ZodTypeAny, {
+        options: {
+            includeTimestamps: boolean;
+            includeTags: boolean;
+            pinnedOnly: boolean;
+            limit?: number | undefined;
+        };
+        type: "memory";
+        id: string;
+        priority: number;
+        enabled: boolean;
+    }, {
+        type: "memory";
+        id: string;
+        priority: number;
+        options?: {
+            includeTimestamps?: boolean | undefined;
+            includeTags?: boolean | undefined;
+            limit?: number | undefined;
+            pinnedOnly?: boolean | undefined;
+        } | undefined;
+        enabled?: boolean | undefined;
     }>]>, "many">>;
 }, "strict", z.ZodTypeAny, {
     contributors: ({
         type: "static";
-        content: string;
         id: string;
         priority: number;
         enabled: boolean;
+        content: string;
     } | {
         type: "dynamic";
         id: string;
         priority: number;
         enabled: boolean;
-        source: "resources" | "dateTime" | "memorySummary";
+        source: "dateTime" | "memorySummary" | "resources";
     } | {
         options: {
             includeFilenames: boolean;
@@ -211,19 +298,30 @@ declare const SystemPromptContributorsSchema: z.ZodObject<{
         priority: number;
         enabled: boolean;
         files: string[];
+    } | {
+        options: {
+            includeTimestamps: boolean;
+            includeTags: boolean;
+            pinnedOnly: boolean;
+            limit?: number | undefined;
+        };
+        type: "memory";
+        id: string;
+        priority: number;
+        enabled: boolean;
     })[];
 }, {
     contributors?: ({
         type: "static";
-        content: string;
         id: string;
         priority: number;
+        content: string;
         enabled?: boolean | undefined;
     } | {
         type: "dynamic";
         id: string;
         priority: number;
-        source: "resources" | "dateTime" | "memorySummary";
+        source: "dateTime" | "memorySummary" | "resources";
         enabled?: boolean | undefined;
     } | {
         type: "file";
@@ -238,9 +336,20 @@ declare const SystemPromptContributorsSchema: z.ZodObject<{
             includeMetadata?: boolean | undefined;
         } | undefined;
         enabled?: boolean | undefined;
+    } | {
+        type: "memory";
+        id: string;
+        priority: number;
+        options?: {
+            includeTimestamps?: boolean | undefined;
+            includeTags?: boolean | undefined;
+            limit?: number | undefined;
+            pinnedOnly?: boolean | undefined;
+        } | undefined;
+        enabled?: boolean | undefined;
     })[] | undefined;
 }>;
-declare const SystemPromptConfigSchema: z.ZodBranded<z.ZodUnion<[z.ZodEffects<z.ZodString, {
+export declare const SystemPromptConfigSchema: z.ZodBranded<z.ZodUnion<[z.ZodEffects<z.ZodString, {
     contributors: {
         id: string;
         type: "static";
@@ -258,15 +367,15 @@ declare const SystemPromptConfigSchema: z.ZodBranded<z.ZodUnion<[z.ZodEffects<z.
         content: z.ZodString;
     }, "strict", z.ZodTypeAny, {
         type: "static";
-        content: string;
         id: string;
         priority: number;
         enabled: boolean;
+        content: string;
     }, {
         type: "static";
-        content: string;
         id: string;
         priority: number;
+        content: string;
         enabled?: boolean | undefined;
     }>, z.ZodObject<{
         id: z.ZodString;
@@ -280,12 +389,12 @@ declare const SystemPromptConfigSchema: z.ZodBranded<z.ZodUnion<[z.ZodEffects<z.
         id: string;
         priority: number;
         enabled: boolean;
-        source: "resources" | "dateTime" | "memorySummary";
+        source: "dateTime" | "memorySummary" | "resources";
     }, {
         type: "dynamic";
         id: string;
         priority: number;
-        source: "resources" | "dateTime" | "memorySummary";
+        source: "dateTime" | "memorySummary" | "resources";
         enabled?: boolean | undefined;
     }>, z.ZodObject<{
         id: z.ZodString;
@@ -339,20 +448,64 @@ declare const SystemPromptConfigSchema: z.ZodBranded<z.ZodUnion<[z.ZodEffects<z.
             includeMetadata?: boolean | undefined;
         } | undefined;
         enabled?: boolean | undefined;
+    }>, z.ZodObject<{
+        id: z.ZodString;
+        priority: z.ZodNumber;
+        enabled: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+    } & {
+        type: z.ZodLiteral<"memory">;
+        options: z.ZodDefault<z.ZodOptional<z.ZodObject<{
+            includeTimestamps: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+            includeTags: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+            limit: z.ZodOptional<z.ZodNumber>;
+            pinnedOnly: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+        }, "strict", z.ZodTypeAny, {
+            includeTimestamps: boolean;
+            includeTags: boolean;
+            pinnedOnly: boolean;
+            limit?: number | undefined;
+        }, {
+            includeTimestamps?: boolean | undefined;
+            includeTags?: boolean | undefined;
+            limit?: number | undefined;
+            pinnedOnly?: boolean | undefined;
+        }>>>;
+    }, "strict", z.ZodTypeAny, {
+        options: {
+            includeTimestamps: boolean;
+            includeTags: boolean;
+            pinnedOnly: boolean;
+            limit?: number | undefined;
+        };
+        type: "memory";
+        id: string;
+        priority: number;
+        enabled: boolean;
+    }, {
+        type: "memory";
+        id: string;
+        priority: number;
+        options?: {
+            includeTimestamps?: boolean | undefined;
+            includeTags?: boolean | undefined;
+            limit?: number | undefined;
+            pinnedOnly?: boolean | undefined;
+        } | undefined;
+        enabled?: boolean | undefined;
     }>]>, "many">>;
 }, "strict", z.ZodTypeAny, {
     contributors: ({
         type: "static";
-        content: string;
         id: string;
         priority: number;
         enabled: boolean;
+        content: string;
     } | {
         type: "dynamic";
         id: string;
         priority: number;
         enabled: boolean;
-        source: "resources" | "dateTime" | "memorySummary";
+        source: "dateTime" | "memorySummary" | "resources";
     } | {
         options: {
             includeFilenames: boolean;
@@ -366,19 +519,30 @@ declare const SystemPromptConfigSchema: z.ZodBranded<z.ZodUnion<[z.ZodEffects<z.
         priority: number;
         enabled: boolean;
         files: string[];
+    } | {
+        options: {
+            includeTimestamps: boolean;
+            includeTags: boolean;
+            pinnedOnly: boolean;
+            limit?: number | undefined;
+        };
+        type: "memory";
+        id: string;
+        priority: number;
+        enabled: boolean;
     })[];
 }, {
     contributors?: ({
         type: "static";
-        content: string;
         id: string;
         priority: number;
+        content: string;
         enabled?: boolean | undefined;
     } | {
         type: "dynamic";
         id: string;
         priority: number;
-        source: "resources" | "dateTime" | "memorySummary";
+        source: "dateTime" | "memorySummary" | "resources";
         enabled?: boolean | undefined;
     } | {
         type: "file";
@@ -393,9 +557,19 @@ declare const SystemPromptConfigSchema: z.ZodBranded<z.ZodUnion<[z.ZodEffects<z.
             includeMetadata?: boolean | undefined;
         } | undefined;
         enabled?: boolean | undefined;
+    } | {
+        type: "memory";
+        id: string;
+        priority: number;
+        options?: {
+            includeTimestamps?: boolean | undefined;
+            includeTags?: boolean | undefined;
+            limit?: number | undefined;
+            pinnedOnly?: boolean | undefined;
+        } | undefined;
+        enabled?: boolean | undefined;
     })[] | undefined;
 }>]>, "ValidatedSystemPromptConfig">;
-type SystemPromptConfig = z.input<typeof SystemPromptConfigSchema>;
-type ValidatedSystemPromptConfig = z.output<typeof SystemPromptConfigSchema>;
-
-export { type ContributorConfig, ContributorConfigSchema, type SystemPromptConfig, SystemPromptConfigSchema, SystemPromptContributorsSchema, type ValidatedContributorConfig, type ValidatedSystemPromptConfig };
+export type SystemPromptConfig = z.input<typeof SystemPromptConfigSchema>;
+export type ValidatedSystemPromptConfig = z.output<typeof SystemPromptConfigSchema>;
+//# sourceMappingURL=schemas.d.ts.map

package/dist/systemPrompt/schemas.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"schemas.d.ts","sourceRoot":"","sources":["../../src/systemPrompt/schemas.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AA+GxB,eAAO,MAAM,uBAAuB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAuB/B,CAAC;AAGN,MAAM,MAAM,iBAAiB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,uBAAuB,CAAC,CAAC;AAExE,MAAM,MAAM,0BAA0B,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,uBAAuB,CAAC,CAAC;AAElF,eAAO,MAAM,8BAA8B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAuB9B,CAAC;AAGd,eAAO,MAAM,wBAAwB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;oCAUM,CAAC;AAG5C,MAAM,MAAM,kBAAkB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,wBAAwB,CAAC,CAAC;AAC1E,MAAM,MAAM,2BAA2B,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,wBAAwB,CAAC,CAAC"}

package/dist/systemPrompt/schemas.js

@@ -30,23 +30,37 @@ const FileContributorSchema = BaseContributorSchema.extend({
     )
   }).strict().optional().default({})
 }).strict();
+const MemoryContributorSchema = BaseContributorSchema.extend({
+  type: z.literal("memory"),
+  options: z.object({
+    includeTimestamps: z.boolean().optional().default(false).describe("Whether to include timestamps in memory display"),
+    includeTags: z.boolean().optional().default(true).describe("Whether to include tags in memory display"),
+    limit: z.number().int().positive().optional().describe("Maximum number of memories to include"),
+    pinnedOnly: z.boolean().optional().default(false).describe("Only include pinned memories (for hybrid approach)")
+  }).strict().optional().default({})
+}).strict();
 const ContributorConfigSchema = z.discriminatedUnion(
   "type",
   // The field to discriminate on
-  [StaticContributorSchema, DynamicContributorSchema, FileContributorSchema],
+  [
+    StaticContributorSchema,
+    DynamicContributorSchema,
+    FileContributorSchema,
+    MemoryContributorSchema
+  ],
   {
     // Optional: Custom error message for invalid discriminator
     errorMap: (issue, ctx) => {
       if (issue.code === z.ZodIssueCode.invalid_union_discriminator) {
         return {
-          message: `Invalid contributor type. Expected 'static', 'dynamic', or 'file'.`
+          message: `Invalid contributor type. Expected 'static', 'dynamic', 'file', or 'memory'.`
         };
       }
       return { message: ctx.defaultError };
     }
   }
 ).describe(
-  "Configuration for a system prompt contributor. Type 'static' requires 'content', type 'dynamic' requires 'source', type 'file' requires 'files'."
+  "Configuration for a system prompt contributor. Type 'static' requires 'content', type 'dynamic' requires 'source', type 'file' requires 'files', type 'memory' loads user memories."
 );
 const SystemPromptContributorsSchema = z.object({
   contributors: z.array(ContributorConfigSchema).min(1).default([

package/dist/systemPrompt/types.d.ts

@@ -1,19 +1,10 @@
 import { MCPManager } from '../mcp/manager.js';
-import '../mcp/schemas.js';
-import 'zod';
-import '../mcp/types.js';
-import '@modelcontextprotocol/sdk/client/index.js';
-import '../tools/types.js';
-import 'json-schema';
-import '@modelcontextprotocol/sdk/types.js';
-
-interface DynamicContributorContext {
+export interface DynamicContributorContext {
     mcpManager: MCPManager;
 }
-interface SystemPromptContributor {
+export interface SystemPromptContributor {
     id: string;
     priority: number;
     getContent(context: DynamicContributorContext): Promise<string>;
 }
-
-export type { DynamicContributorContext, SystemPromptContributor };
+//# sourceMappingURL=types.d.ts.map

package/dist/systemPrompt/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/systemPrompt/types.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,mBAAmB,CAAC;AAG/C,MAAM,WAAW,yBAAyB;IACtC,UAAU,EAAE,UAAU,CAAC;CAC1B;AAGD,MAAM,WAAW,uBAAuB;IACpC,EAAE,EAAE,MAAM,CAAC;IACX,QAAQ,EAAE,MAAM,CAAC;IACjB,UAAU,CAAC,OAAO,EAAE,yBAAyB,GAAG,OAAO,CAAC,MAAM,CAAC,CAAC;CACnE"}

package/dist/tools/confirmation/allowed-tools-provider/factory.cjs

@@ -29,7 +29,7 @@ function createAllowedToolsProvider(config) {
     case "memory":
       return new import_in_memory.InMemoryAllowedToolsProvider();
     case "storage":
-      return new import_storage.StorageAllowedToolsProvider(config.storage);
+      return new import_storage.StorageAllowedToolsProvider(config.storageManager);
     default: {
       const _exhaustive = config;
       throw import_errors.ToolError.configInvalid(

package/dist/tools/confirmation/allowed-tools-provider/factory.d.ts

@@ -1,19 +1,13 @@
-import { IAllowedToolsProvider } from './types.js';
-import { StorageBackends } from '../../../storage/backend/types.js';
-import '../../../storage/backend/cache-backend.js';
-import '../../../storage/backend/database-backend.js';
-import '../../../storage/schemas.js';
-import 'zod';
-
-type AllowedToolsConfig = {
+import type { IAllowedToolsProvider } from './types.js';
+import type { StorageManager } from '../../../storage/index.js';
+export type AllowedToolsConfig = {
     type: 'memory';
 } | {
     type: 'storage';
-    storage: StorageBackends;
+    storageManager: StorageManager;
 };
 /**
  * Create an AllowedToolsProvider based on configuration.
  */
-declare function createAllowedToolsProvider(config: AllowedToolsConfig): IAllowedToolsProvider;
-
-export { type AllowedToolsConfig, createAllowedToolsProvider };
+export declare function createAllowedToolsProvider(config: AllowedToolsConfig): IAllowedToolsProvider;
+//# sourceMappingURL=factory.d.ts.map

package/dist/tools/confirmation/allowed-tools-provider/factory.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"factory.d.ts","sourceRoot":"","sources":["../../../../src/tools/confirmation/allowed-tools-provider/factory.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,YAAY,CAAC;AACxD,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,wBAAwB,CAAC;AAW7D,MAAM,MAAM,kBAAkB,GACxB;IACI,IAAI,EAAE,QAAQ,CAAC;CAClB,GACD;IACI,IAAI,EAAE,SAAS,CAAC;IAChB,cAAc,EAAE,cAAc,CAAC;CAClC,CAAC;AAER;;GAEG;AACH,wBAAgB,0BAA0B,CAAC,MAAM,EAAE,kBAAkB,GAAG,qBAAqB,CAc5F"}

package/dist/tools/confirmation/allowed-tools-provider/factory.js

@@ -6,7 +6,7 @@ function createAllowedToolsProvider(config) {
     case "memory":
       return new InMemoryAllowedToolsProvider();
     case "storage":
-      return new StorageAllowedToolsProvider(config.storage);
+      return new StorageAllowedToolsProvider(config.storageManager);
     default: {
       const _exhaustive = config;
       throw ToolError.configInvalid(

package/dist/tools/confirmation/allowed-tools-provider/in-memory.d.ts

@@ -1,6 +1,5 @@
-import { IAllowedToolsProvider } from './types.js';
-
-declare class InMemoryAllowedToolsProvider implements IAllowedToolsProvider {
+import type { IAllowedToolsProvider } from './types.js';
+export declare class InMemoryAllowedToolsProvider implements IAllowedToolsProvider {
     /**
      * Map key is sessionId (undefined => global approvals). Value is a set of
      * approved tool names.
@@ -13,5 +12,4 @@ declare class InMemoryAllowedToolsProvider implements IAllowedToolsProvider {
     isToolAllowed(toolName: string, sessionId?: string): Promise<boolean>;
     getAllowedTools(sessionId?: string): Promise<Set<string>>;
 }
-
-export { InMemoryAllowedToolsProvider };
+//# sourceMappingURL=in-memory.d.ts.map

package/dist/tools/confirmation/allowed-tools-provider/in-memory.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"in-memory.d.ts","sourceRoot":"","sources":["../../../../src/tools/confirmation/allowed-tools-provider/in-memory.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,YAAY,CAAC;AAExD,qBAAa,4BAA6B,YAAW,qBAAqB;IACtE;;;OAGG;IACH,OAAO,CAAC,KAAK,CAAmD;gBAEpD,aAAa,CAAC,EAAE,GAAG,CAAC,MAAM,CAAC;IAMvC,OAAO,CAAC,MAAM;IAUR,SAAS,CAAC,QAAQ,EAAE,MAAM,EAAE,SAAS,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAI9D,YAAY,CAAC,QAAQ,EAAE,MAAM,EAAE,SAAS,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAIjE,aAAa,CAAC,QAAQ,EAAE,MAAM,EAAE,SAAS,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC;IAMrE,eAAe,CAAC,SAAS,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,GAAG,CAAC,MAAM,CAAC,CAAC;CAGlE"}

package/dist/tools/confirmation/allowed-tools-provider/storage.cjs

@@ -23,8 +23,8 @@ __export(storage_exports, {
 module.exports = __toCommonJS(storage_exports);
 var import_logger = require("../../../logger/index.cjs");
 class StorageAllowedToolsProvider {
-  constructor(storage) {
-    this.storage = storage;
+  constructor(storageManager) {
+    this.storageManager = storageManager;
   }
   buildKey(sessionId) {
     return sessionId ? `allowedTools:${sessionId}` : "allowedTools:global";
@@ -32,25 +32,25 @@ class StorageAllowedToolsProvider {
   async allowTool(toolName, sessionId) {
     const key = this.buildKey(sessionId);
     import_logger.logger.debug(`Adding allowed tool '${toolName}' for key '${key}'`);
-    const existingRaw = await this.storage.database.get(key);
+    const existingRaw = await this.storageManager.getDatabase().get(key);
     const newSet = new Set(Array.isArray(existingRaw) ? existingRaw : []);
     newSet.add(toolName);
-    await this.storage.database.set(key, Array.from(newSet));
+    await this.storageManager.getDatabase().set(key, Array.from(newSet));
     import_logger.logger.debug(`Added allowed tool '${toolName}' for key '${key}'`);
   }
   async disallowTool(toolName, sessionId) {
     const key = this.buildKey(sessionId);
     import_logger.logger.debug(`Removing allowed tool '${toolName}' for key '${key}'`);
-    const existingRaw = await this.storage.database.get(key);
+    const existingRaw = await this.storageManager.getDatabase().get(key);
     if (!Array.isArray(existingRaw)) return;
     const newSet = new Set(existingRaw);
     newSet.delete(toolName);
-    await this.storage.database.set(key, Array.from(newSet));
+    await this.storageManager.getDatabase().set(key, Array.from(newSet));
   }
   async isToolAllowed(toolName, sessionId) {
-    const sessionArr = await this.storage.database.get(this.buildKey(sessionId));
+    const sessionArr = await this.storageManager.getDatabase().get(this.buildKey(sessionId));
     if (Array.isArray(sessionArr) && sessionArr.includes(toolName)) return true;
-    const globalArr = await this.storage.database.get(this.buildKey(void 0));
+    const globalArr = await this.storageManager.getDatabase().get(this.buildKey(void 0));
     const allowed = Array.isArray(globalArr) ? globalArr.includes(toolName) : false;
     import_logger.logger.debug(
       `Checked allowed tool '${toolName}' in session '${sessionId ?? "global"}' \u2013 allowed=${allowed}`
@@ -58,7 +58,7 @@ class StorageAllowedToolsProvider {
     return allowed;
   }
   async getAllowedTools(sessionId) {
-    const arr = await this.storage.database.get(this.buildKey(sessionId));
+    const arr = await this.storageManager.getDatabase().get(this.buildKey(sessionId));
     return new Set(Array.isArray(arr) ? arr : []);
   }
 }

package/dist/tools/confirmation/allowed-tools-provider/storage.d.ts

@@ -1,26 +1,20 @@
-import { StorageBackends } from '../../../storage/backend/types.js';
-import { IAllowedToolsProvider } from './types.js';
-import '../../../storage/backend/cache-backend.js';
-import '../../../storage/backend/database-backend.js';
-import '../../../storage/schemas.js';
-import 'zod';
-
+import type { StorageManager } from '../../../storage/index.js';
+import type { IAllowedToolsProvider } from './types.js';
 /**
  * Storage-backed implementation that persists allowed tools in the Dexto
- * storage backends. The key scheme is:
+ * storage manager. The key scheme is:
  *   allowedTools:<sessionId>          – approvals scoped to a session
  *   allowedTools:global               – global approvals (sessionId undefined)
  *
  * Using the database backend for persistence.
  */
-declare class StorageAllowedToolsProvider implements IAllowedToolsProvider {
-    private storage;
-    constructor(storage: StorageBackends);
+export declare class StorageAllowedToolsProvider implements IAllowedToolsProvider {
+    private storageManager;
+    constructor(storageManager: StorageManager);
     private buildKey;
     allowTool(toolName: string, sessionId?: string): Promise<void>;
     disallowTool(toolName: string, sessionId?: string): Promise<void>;
     isToolAllowed(toolName: string, sessionId?: string): Promise<boolean>;
     getAllowedTools(sessionId?: string): Promise<Set<string>>;
 }
-
-export { StorageAllowedToolsProvider };
+//# sourceMappingURL=storage.d.ts.map

package/dist/tools/confirmation/allowed-tools-provider/storage.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"storage.d.ts","sourceRoot":"","sources":["../../../../src/tools/confirmation/allowed-tools-provider/storage.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,wBAAwB,CAAC;AAC7D,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,YAAY,CAAC;AAGxD;;;;;;;GAOG;AACH,qBAAa,2BAA4B,YAAW,qBAAqB;IACzD,OAAO,CAAC,cAAc;gBAAd,cAAc,EAAE,cAAc;IAElD,OAAO,CAAC,QAAQ;IAIV,SAAS,CAAC,QAAQ,EAAE,MAAM,EAAE,SAAS,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAc9D,YAAY,CAAC,QAAQ,EAAE,MAAM,EAAE,SAAS,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAYjE,aAAa,CAAC,QAAQ,EAAE,MAAM,EAAE,SAAS,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC;IAiBrE,eAAe,CAAC,SAAS,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,GAAG,CAAC,MAAM,CAAC,CAAC;CAIlE"}