@dexto/core 1.1.10 → 1.2.0

package/dist/resources/schemas.d.ts

@@ -0,0 +1,212 @@
+import { z } from 'zod';
+/**
+ * Schema for filesystem resource configuration
+ */
+declare const FileSystemResourceSchema: z.ZodObject<{
+    type: z.ZodLiteral<"filesystem">;
+    paths: z.ZodArray<z.ZodString, "many">;
+    maxDepth: z.ZodDefault<z.ZodNumber>;
+    maxFiles: z.ZodDefault<z.ZodNumber>;
+    includeHidden: z.ZodDefault<z.ZodBoolean>;
+    includeExtensions: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+}, "strict", z.ZodTypeAny, {
+    maxFiles: number;
+    type: "filesystem";
+    paths: string[];
+    maxDepth: number;
+    includeHidden: boolean;
+    includeExtensions: string[];
+}, {
+    type: "filesystem";
+    paths: string[];
+    maxFiles?: number | undefined;
+    maxDepth?: number | undefined;
+    includeHidden?: boolean | undefined;
+    includeExtensions?: string[] | undefined;
+}>;
+/**
+ * Validated filesystem resource configuration type
+ */
+export type ValidatedFileSystemResourceConfig = z.output<typeof FileSystemResourceSchema>;
+/**
+ * Schema for blob storage resource configuration
+ *
+ * NOTE: This only enables the blob resource provider.
+ * Actual blob storage settings (size limits, backend, cleanup) are configured
+ * in the 'storage.blob' section of the agent config.
+ */
+declare const BlobResourceSchema: z.ZodObject<{
+    type: z.ZodLiteral<"blob">;
+}, "strict", z.ZodTypeAny, {
+    type: "blob";
+}, {
+    type: "blob";
+}>;
+/**
+ * Validated blob resource configuration type
+ */
+export type ValidatedBlobResourceConfig = z.output<typeof BlobResourceSchema>;
+/**
+ * Union schema for all internal resource types (composed from individual schemas)
+ */
+export declare const InternalResourceConfigSchema: z.ZodDiscriminatedUnion<"type", [z.ZodObject<{
+    type: z.ZodLiteral<"filesystem">;
+    paths: z.ZodArray<z.ZodString, "many">;
+    maxDepth: z.ZodDefault<z.ZodNumber>;
+    maxFiles: z.ZodDefault<z.ZodNumber>;
+    includeHidden: z.ZodDefault<z.ZodBoolean>;
+    includeExtensions: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+}, "strict", z.ZodTypeAny, {
+    maxFiles: number;
+    type: "filesystem";
+    paths: string[];
+    maxDepth: number;
+    includeHidden: boolean;
+    includeExtensions: string[];
+}, {
+    type: "filesystem";
+    paths: string[];
+    maxFiles?: number | undefined;
+    maxDepth?: number | undefined;
+    includeHidden?: boolean | undefined;
+    includeExtensions?: string[] | undefined;
+}>, z.ZodObject<{
+    type: z.ZodLiteral<"blob">;
+}, "strict", z.ZodTypeAny, {
+    type: "blob";
+}, {
+    type: "blob";
+}>]>;
+/**
+ * Validated union type for all internal resource configurations
+ */
+export type ValidatedInternalResourceConfig = z.output<typeof InternalResourceConfigSchema>;
+/**
+ * Schema for internal resources configuration with smart auto-enable logic
+ *
+ * Design principles:
+ * - Clean input format: just specify resources array or object
+ * - Auto-enable when resources are specified
+ * - Backward compatibility with explicit enabled field
+ * - Empty/omitted = disabled
+ */
+export declare const InternalResourcesSchema: z.ZodEffects<z.ZodDefault<z.ZodUnion<[z.ZodArray<z.ZodDiscriminatedUnion<"type", [z.ZodObject<{
+    type: z.ZodLiteral<"filesystem">;
+    paths: z.ZodArray<z.ZodString, "many">;
+    maxDepth: z.ZodDefault<z.ZodNumber>;
+    maxFiles: z.ZodDefault<z.ZodNumber>;
+    includeHidden: z.ZodDefault<z.ZodBoolean>;
+    includeExtensions: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+}, "strict", z.ZodTypeAny, {
+    maxFiles: number;
+    type: "filesystem";
+    paths: string[];
+    maxDepth: number;
+    includeHidden: boolean;
+    includeExtensions: string[];
+}, {
+    type: "filesystem";
+    paths: string[];
+    maxFiles?: number | undefined;
+    maxDepth?: number | undefined;
+    includeHidden?: boolean | undefined;
+    includeExtensions?: string[] | undefined;
+}>, z.ZodObject<{
+    type: z.ZodLiteral<"blob">;
+}, "strict", z.ZodTypeAny, {
+    type: "blob";
+}, {
+    type: "blob";
+}>]>, "many">, z.ZodObject<{
+    enabled: z.ZodOptional<z.ZodBoolean>;
+    resources: z.ZodDefault<z.ZodArray<z.ZodDiscriminatedUnion<"type", [z.ZodObject<{
+        type: z.ZodLiteral<"filesystem">;
+        paths: z.ZodArray<z.ZodString, "many">;
+        maxDepth: z.ZodDefault<z.ZodNumber>;
+        maxFiles: z.ZodDefault<z.ZodNumber>;
+        includeHidden: z.ZodDefault<z.ZodBoolean>;
+        includeExtensions: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    }, "strict", z.ZodTypeAny, {
+        maxFiles: number;
+        type: "filesystem";
+        paths: string[];
+        maxDepth: number;
+        includeHidden: boolean;
+        includeExtensions: string[];
+    }, {
+        type: "filesystem";
+        paths: string[];
+        maxFiles?: number | undefined;
+        maxDepth?: number | undefined;
+        includeHidden?: boolean | undefined;
+        includeExtensions?: string[] | undefined;
+    }>, z.ZodObject<{
+        type: z.ZodLiteral<"blob">;
+    }, "strict", z.ZodTypeAny, {
+        type: "blob";
+    }, {
+        type: "blob";
+    }>]>, "many">>;
+}, "strict", z.ZodTypeAny, {
+    resources: ({
+        maxFiles: number;
+        type: "filesystem";
+        paths: string[];
+        maxDepth: number;
+        includeHidden: boolean;
+        includeExtensions: string[];
+    } | {
+        type: "blob";
+    })[];
+    enabled?: boolean | undefined;
+}, {
+    enabled?: boolean | undefined;
+    resources?: ({
+        type: "filesystem";
+        paths: string[];
+        maxFiles?: number | undefined;
+        maxDepth?: number | undefined;
+        includeHidden?: boolean | undefined;
+        includeExtensions?: string[] | undefined;
+    } | {
+        type: "blob";
+    })[] | undefined;
+}>]>>, {
+    enabled: boolean;
+    resources: ({
+        maxFiles: number;
+        type: "filesystem";
+        paths: string[];
+        maxDepth: number;
+        includeHidden: boolean;
+        includeExtensions: string[];
+    } | {
+        type: "blob";
+    })[];
+}, ({
+    type: "filesystem";
+    paths: string[];
+    maxFiles?: number | undefined;
+    maxDepth?: number | undefined;
+    includeHidden?: boolean | undefined;
+    includeExtensions?: string[] | undefined;
+} | {
+    type: "blob";
+})[] | {
+    enabled?: boolean | undefined;
+    resources?: ({
+        type: "filesystem";
+        paths: string[];
+        maxFiles?: number | undefined;
+        maxDepth?: number | undefined;
+        includeHidden?: boolean | undefined;
+        includeExtensions?: string[] | undefined;
+    } | {
+        type: "blob";
+    })[] | undefined;
+} | undefined>;
+export type InternalResourcesConfig = z.input<typeof InternalResourcesSchema>;
+export type ValidatedInternalResourcesConfig = z.output<typeof InternalResourcesSchema>;
+export declare function isInternalResourcesEnabled(config: ValidatedInternalResourcesConfig): boolean;
+export {};
+//# sourceMappingURL=schemas.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"schemas.d.ts","sourceRoot":"","sources":["../../src/resources/schemas.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAaxB;;GAEG;AACH,QAAA,MAAM,wBAAwB;;;;;;;;;;;;;;;;;;;;;EAsDjB,CAAC;AAEd;;GAEG;AACH,MAAM,MAAM,iCAAiC,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,wBAAwB,CAAC,CAAC;AAE1F;;;;;;GAMG;AACH,QAAA,MAAM,kBAAkB;;;;;;EAOnB,CAAC;AAEN;;GAEG;AACH,MAAM,MAAM,2BAA2B,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,kBAAkB,CAAC,CAAC;AAE9E;;GAEG;AACH,eAAO,MAAM,4BAA4B;;;;;;;;;;;;;;;;;;;;;;;;;;;IAGvC,CAAC;AAEH;;GAEG;AACH,MAAM,MAAM,+BAA+B,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,4BAA4B,CAAC,CAAC;AAE5F;;;;;;;;GAQG;AACH,eAAO,MAAM,uBAAuB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cA0B9B,CAAC;AAEP,MAAM,MAAM,uBAAuB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,uBAAuB,CAAC,CAAC;AAC9E,MAAM,MAAM,gCAAgC,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,uBAAuB,CAAC,CAAC;AAExF,wBAAgB,0BAA0B,CAAC,MAAM,EAAE,gCAAgC,GAAG,OAAO,CAE5F"}

package/dist/resources/schemas.js

@@ -0,0 +1,73 @@
+import "../chunk-C6A6W6XS.js";
+import { z } from "zod";
+const FileExtensionSchema = z.string().regex(
+  /^\.[A-Za-z0-9][A-Za-z0-9._-]*$/,
+  "Extensions must start with a dot and may include alphanumerics, dot, underscore, or hyphen (e.g., .d.ts, .tar.gz)"
+).describe("File extension pattern starting with a dot; supports multi-part extensions");
+const FileSystemResourceSchema = z.object({
+  type: z.literal("filesystem"),
+  paths: z.array(z.string()).min(1).describe("File paths or directories to expose as resources (at least one required)"),
+  maxDepth: z.number().min(1).max(10).default(3).describe("Maximum directory depth to traverse (default: 3)"),
+  maxFiles: z.number().min(1).max(1e4).default(1e3).describe("Maximum number of files to include (default: 1000)"),
+  includeHidden: z.boolean().default(false).describe("Include hidden files and directories (default: false)"),
+  includeExtensions: z.array(FileExtensionSchema).default([
+    ".txt",
+    ".md",
+    ".js",
+    ".ts",
+    ".json",
+    ".html",
+    ".css",
+    ".py",
+    ".yaml",
+    ".yml",
+    ".xml",
+    ".jsx",
+    ".tsx",
+    ".vue",
+    ".php",
+    ".rb",
+    ".go",
+    ".rs",
+    ".java",
+    ".kt",
+    ".swift",
+    ".sql",
+    ".sh",
+    ".bash",
+    ".zsh"
+  ]).describe("File extensions to include (default: common text files)")
+}).strict();
+const BlobResourceSchema = z.object({
+  type: z.literal("blob").describe("Enable blob storage resource provider")
+}).strict().describe(
+  "Blob resource provider configuration - actual storage settings are in storage.blob section"
+);
+const InternalResourceConfigSchema = z.discriminatedUnion("type", [
+  FileSystemResourceSchema,
+  BlobResourceSchema
+]);
+const InternalResourcesSchema = z.union([
+  z.array(InternalResourceConfigSchema),
+  // array-only form
+  z.object({
+    enabled: z.boolean().optional().describe("Explicit toggle; auto-enabled when resources are non-empty"),
+    resources: z.array(InternalResourceConfigSchema).default([]).describe("List of internal resource configurations")
+  }).strict()
+]).default([]).describe(
+  "Internal resource configuration. Can be an array of resources (auto-enabled) or object with enabled field"
+).transform((input) => {
+  if (Array.isArray(input)) {
+    return { enabled: input.length > 0, resources: input };
+  }
+  const enabled = input.enabled !== void 0 ? input.enabled : input.resources.length > 0;
+  return { enabled, resources: input.resources };
+});
+function isInternalResourcesEnabled(config) {
+  return config.enabled && config.resources.length > 0;
+}
+export {
+  InternalResourceConfigSchema,
+  InternalResourcesSchema,
+  isInternalResourcesEnabled
+};

package/dist/resources/types.cjs

@@ -0,0 +1,16 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+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 types_exports = {};
+module.exports = __toCommonJS(types_exports);

package/dist/resources/types.d.ts

@@ -0,0 +1,57 @@
+/**
+ * Core resource types and interfaces for the ResourceManager
+ */
+import type { ReadResourceResult } from '@modelcontextprotocol/sdk/types.js';
+/**
+ * Supported resource sources
+ */
+export type ResourceSource = 'mcp' | 'internal';
+/**
+ * Resource metadata information
+ */
+export interface ResourceMetadata {
+    /** Unique URI/identifier for the resource */
+    uri: string;
+    /** Human-readable name for the resource */
+    name?: string;
+    /** Description of what this resource contains */
+    description?: string;
+    /** MIME type of the resource content */
+    mimeType?: string;
+    /** Source system that provides this resource */
+    source: ResourceSource;
+    /** Original server/provider name (for MCP resources) */
+    serverName?: string;
+    /** Size of the resource in bytes (if known) */
+    size?: number;
+    /** Last modified timestamp (ISO string or Date) */
+    lastModified?: string | Date;
+    /** Additional metadata specific to the resource type */
+    metadata?: Record<string, unknown>;
+}
+/**
+ * Resource provider interface - implemented by sources that can provide resources
+ */
+export interface ResourceProvider {
+    /**
+     * List all available resources from this provider
+     */
+    listResources(): Promise<ResourceMetadata[]>;
+    /**
+     * Read the content of a specific resource
+     */
+    readResource(uri: string): Promise<ReadResourceResult>;
+    /**
+     * Check if a resource exists
+     */
+    hasResource(uri: string): Promise<boolean>;
+    /**
+     * Get the source type of this provider
+     */
+    getSource(): ResourceSource;
+}
+/**
+ * Resource set mapping URIs to resource metadata
+ */
+export type ResourceSet = Record<string, ResourceMetadata>;
+//# sourceMappingURL=types.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/resources/types.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,oCAAoC,CAAC;AAE7E;;GAEG;AACH,MAAM,MAAM,cAAc,GAAG,KAAK,GAAG,UAAU,CAAC;AAEhD;;GAEG;AACH,MAAM,WAAW,gBAAgB;IAC7B,6CAA6C;IAC7C,GAAG,EAAE,MAAM,CAAC;IACZ,2CAA2C;IAC3C,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,iDAAiD;IACjD,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,wCAAwC;IACxC,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,gDAAgD;IAChD,MAAM,EAAE,cAAc,CAAC;IACvB,wDAAwD;IACxD,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,+CAA+C;IAC/C,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,mDAAmD;IACnD,YAAY,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IAC7B,wDAAwD;IACxD,QAAQ,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CACtC;AAED;;GAEG;AACH,MAAM,WAAW,gBAAgB;IAC7B;;OAEG;IACH,aAAa,IAAI,OAAO,CAAC,gBAAgB,EAAE,CAAC,CAAC;IAE7C;;OAEG;IACH,YAAY,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,kBAAkB,CAAC,CAAC;IAEvD;;OAEG;IACH,WAAW,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC,CAAC;IAE3C;;OAEG;IACH,SAAS,IAAI,cAAc,CAAC;CAC/B;AAED;;GAEG;AACH,MAAM,MAAM,WAAW,GAAG,MAAM,CAAC,MAAM,EAAE,gBAAgB,CAAC,CAAC"}

package/dist/search/index.d.ts

@@ -1,5 +1,3 @@
 export { SearchService } from './search-service.js';
-export { SearchOptions, SearchResponse, SearchResult, SessionSearchResponse, SessionSearchResult } from './types.js';
-import '../storage/backend/database-backend.js';
-import '../context/types.js';
-import '../llm/types.js';
+export type { SearchOptions, SearchResult, SessionSearchResult, SearchResponse, SessionSearchResponse, } from './types.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/search/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/search/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAC;AACpD,YAAY,EACR,aAAa,EACb,YAAY,EACZ,mBAAmB,EACnB,cAAc,EACd,qBAAqB,GACxB,MAAM,YAAY,CAAC"}

package/dist/search/index.js

@@ -1,3 +1,4 @@
+import "../chunk-C6A6W6XS.js";
 import { SearchService } from "./search-service.js";
 export {
   SearchService

package/dist/search/search-service.d.ts

@@ -1,15 +1,12 @@
-import { DatabaseBackend } from '../storage/backend/database-backend.js';
-import { SearchOptions, SearchResponse, SessionSearchResponse } from './types.js';
-import '../context/types.js';
-import '../llm/types.js';
-
+import type { Database } from '../storage/types.js';
+import type { SearchOptions, SearchResponse, SessionSearchResponse } from './types.js';
 /**
  * Service for searching through conversation history
  * TODO: remove duplicate stuff related to session manager instead of directly using DB
  */
-declare class SearchService {
+export declare class SearchService {
     private database;
-    constructor(database: DatabaseBackend);
+    constructor(database: Database);
     /**
      * Search for messages across all sessions or within a specific session
      */
@@ -43,5 +40,4 @@ declare class SearchService {
      */
     private getSessionMetadata;
 }
-
-export { SearchService };
+//# sourceMappingURL=search-service.d.ts.map

package/dist/search/search-service.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"search-service.d.ts","sourceRoot":"","sources":["../../src/search/search-service.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,wBAAwB,CAAC;AAEvD,OAAO,KAAK,EACR,aAAa,EAGb,cAAc,EACd,qBAAqB,EACxB,MAAM,YAAY,CAAC;AAEpB;;;GAGG;AACH,qBAAa,aAAa;IACV,OAAO,CAAC,QAAQ;gBAAR,QAAQ,EAAE,QAAQ;IAEtC;;OAEG;IACG,cAAc,CAAC,KAAK,EAAE,MAAM,EAAE,OAAO,GAAE,aAAkB,GAAG,OAAO,CAAC,cAAc,CAAC;IA2DzF;;OAEG;IACG,cAAc,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,qBAAqB,CAAC;IAiEnE;;OAEG;YACW,eAAe;IAsD7B;;OAEG;IACH,OAAO,CAAC,qBAAqB;IAmB7B;;OAEG;IACH,OAAO,CAAC,UAAU;IAsBlB;;OAEG;IACH,OAAO,CAAC,WAAW;IAyBnB;;OAEG;YACW,aAAa;IAK3B;;OAEG;YACW,kBAAkB;CAiBnC"}

package/dist/search/search-service.js

@@ -1,3 +1,4 @@
+import "../chunk-C6A6W6XS.js";
 import { logger } from "../logger/index.js";
 class SearchService {
   constructor(database) {

package/dist/search/types.d.ts

@@ -1,10 +1,8 @@
-import { InternalMessage } from '../context/types.js';
-import '../llm/types.js';
-
+import type { InternalMessage } from '../context/types.js';
 /**
  * Options for searching messages
  */
-interface SearchOptions {
+export interface SearchOptions {
     /** Limit search to a specific session */
     sessionId?: string;
     /** Filter by message role */
@@ -17,7 +15,7 @@ interface SearchOptions {
 /**
  * Result of a message search
  */
-interface SearchResult {
+export interface SearchResult {
     /** Session ID where the message was found */
     sessionId: string;
     /** The message that matched the search */
@@ -32,7 +30,7 @@ interface SearchResult {
 /**
  * Result of a session search
  */
-interface SessionSearchResult {
+export interface SessionSearchResult {
     /** Session ID */
     sessionId: string;
     /** Number of messages that matched in this session */
@@ -49,7 +47,7 @@ interface SessionSearchResult {
 /**
  * Response format for search API
  */
-interface SearchResponse {
+export interface SearchResponse {
     /** Array of search results */
     results: SearchResult[];
     /** Total number of results available */
@@ -64,7 +62,7 @@ interface SearchResponse {
 /**
  * Response format for session search API
  */
-interface SessionSearchResponse {
+export interface SessionSearchResponse {
     /** Array of session search results */
     results: SessionSearchResult[];
     /** Total number of sessions with matches */
@@ -74,5 +72,4 @@ interface SessionSearchResponse {
     /** Query that was searched */
     query: string;
 }
-
-export type { SearchOptions, SearchResponse, SearchResult, SessionSearchResponse, SessionSearchResult };
+//# sourceMappingURL=types.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/search/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,qBAAqB,CAAC;AAE3D;;GAEG;AACH,MAAM,WAAW,aAAa;IAC1B,yCAAyC;IACzC,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,6BAA6B;IAC7B,IAAI,CAAC,EAAE,MAAM,GAAG,WAAW,GAAG,QAAQ,GAAG,MAAM,CAAC;IAChD,0CAA0C;IAC1C,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,4BAA4B;IAC5B,MAAM,CAAC,EAAE,MAAM,CAAC;CACnB;AAED;;GAEG;AACH,MAAM,WAAW,YAAY;IACzB,6CAA6C;IAC7C,SAAS,EAAE,MAAM,CAAC;IAClB,0CAA0C;IAC1C,OAAO,EAAE,eAAe,CAAC;IACzB,sDAAsD;IACtD,WAAW,EAAE,MAAM,CAAC;IACpB,2CAA2C;IAC3C,OAAO,EAAE,MAAM,CAAC;IAChB,8CAA8C;IAC9C,YAAY,EAAE,MAAM,CAAC;CACxB;AAED;;GAEG;AACH,MAAM,WAAW,mBAAmB;IAChC,iBAAiB;IACjB,SAAS,EAAE,MAAM,CAAC;IAClB,sDAAsD;IACtD,UAAU,EAAE,MAAM,CAAC;IACnB,4CAA4C;IAC5C,UAAU,EAAE,YAAY,CAAC;IACzB,uBAAuB;IACvB,QAAQ,EAAE;QACN,SAAS,EAAE,MAAM,CAAC;QAClB,YAAY,EAAE,MAAM,CAAC;QACrB,YAAY,EAAE,MAAM,CAAC;KACxB,CAAC;CACL;AAED;;GAEG;AACH,MAAM,WAAW,cAAc;IAC3B,8BAA8B;IAC9B,OAAO,EAAE,YAAY,EAAE,CAAC;IACxB,wCAAwC;IACxC,KAAK,EAAE,MAAM,CAAC;IACd,6DAA6D;IAC7D,OAAO,EAAE,OAAO,CAAC;IACjB,8BAA8B;IAC9B,KAAK,EAAE,MAAM,CAAC;IACd,kCAAkC;IAClC,OAAO,EAAE,aAAa,CAAC;CAC1B;AAED;;GAEG;AACH,MAAM,WAAW,qBAAqB;IAClC,sCAAsC;IACtC,OAAO,EAAE,mBAAmB,EAAE,CAAC;IAC/B,4CAA4C;IAC5C,KAAK,EAAE,MAAM,CAAC;IACd,6DAA6D;IAC7D,OAAO,EAAE,OAAO,CAAC;IACjB,8BAA8B;IAC9B,KAAK,EAAE,MAAM,CAAC;CACjB"}

package/dist/session/chat-session.cjs

@@ -25,6 +25,8 @@ var import_factory = require("./history/factory.js");
 var import_factory2 = require("../llm/services/factory.js");
 var import_events = require("../events/index.js");
 var import_logger = require("../logger/index.js");
+var import_errors = require("../errors/index.js");
+var import_error_codes = require("../plugins/error-codes.js");
 class ChatSession {
   /**
    * Creates a new ChatSession instance.
@@ -112,22 +114,55 @@ class ChatSession {
   async initializeServices() {
     const llmConfig = this.services.stateManager.getLLMConfig(this.id);
     this.historyProvider = (0, import_factory.createDatabaseHistoryProvider)(
-      this.services.storage.database,
+      this.services.storageManager.getDatabase(),
       this.id
     );
     this.llmService = (0, import_factory2.createLLMService)(
       llmConfig,
       llmConfig.router,
       this.services.toolManager,
-      this.services.promptManager,
+      this.services.systemPromptManager,
       this.historyProvider,
       // Pass history provider for service to use
       this.eventBus,
       // Use session event bus
-      this.id
+      this.id,
+      this.services.resourceManager
+      // Pass ResourceManager for blob storage
     );
     import_logger.logger.debug(`ChatSession ${this.id}: Services initialized with storage`);
   }
+  /**
+   * Saves a blocked interaction to history when a plugin blocks execution.
+   * This ensures that even when a plugin blocks execution (e.g., due to abusive language),
+   * the user's message and the error response are preserved in the conversation history.
+   *
+   * @param userInput - The user's text input that was blocked
+   * @param errorMessage - The error message explaining why execution was blocked
+   * @param imageData - Optional image data that was part of the blocked message
+   * @param fileData - Optional file data that was part of the blocked message
+   * @private
+   */
+  async saveBlockedInteraction(userInput, errorMessage, _imageData, _fileData) {
+    const userMessage = {
+      role: "user",
+      content: "[Blocked by content policy: input redacted]"
+    };
+    const errorContent = `Error: ${errorMessage}`;
+    const assistantMessage = {
+      role: "assistant",
+      content: errorContent
+    };
+    await this.historyProvider.saveMessage(userMessage);
+    await this.historyProvider.saveMessage(assistantMessage);
+    const llmConfig = this.services.stateManager.getLLMConfig(this.id);
+    this.eventBus.emit("llmservice:response", {
+      content: errorContent,
+      provider: llmConfig.provider,
+      model: llmConfig.model,
+      router: llmConfig.router
+    });
+  }
   /**
    * Processes user input through the session's LLM service and returns the response.
    *
@@ -153,19 +188,60 @@ class ChatSession {
    */
   async run(input, imageDataInput, fileDataInput, stream) {
     import_logger.logger.debug(
-      `Running session ${this.id} with input: ${input}, imageDataInput: ${imageDataInput}, fileDataInput: ${fileDataInput}`
+      `Running session ${this.id} | input.len=${input?.length ?? 0} | image=${imageDataInput ? imageDataInput.mimeType : "none"} | file=${fileDataInput ? `${fileDataInput.mimeType}:${fileDataInput.filename ?? "unknown"}` : "none"}`
     );
     this.currentRunController = new AbortController();
     const signal = this.currentRunController.signal;
     try {
+      const beforeLLMPayload = {
+        text: input,
+        ...imageDataInput !== void 0 && { imageData: imageDataInput },
+        ...fileDataInput !== void 0 && { fileData: fileDataInput },
+        sessionId: this.id
+      };
+      const modifiedBeforePayload = await this.services.pluginManager.executePlugins(
+        "beforeLLMRequest",
+        beforeLLMPayload,
+        {
+          sessionManager: this.services.sessionManager,
+          mcpManager: this.services.mcpManager,
+          toolManager: this.services.toolManager,
+          stateManager: this.services.stateManager,
+          sessionId: this.id,
+          abortSignal: signal
+        }
+      );
+      const finalInput = modifiedBeforePayload.text;
+      const finalImageData = modifiedBeforePayload.imageData;
+      const finalFileData = modifiedBeforePayload.fileData;
       const response = await this.llmService.completeTask(
-        input,
+        finalInput,
         { signal },
-        imageDataInput,
-        fileDataInput,
+        finalImageData,
+        finalFileData,
         stream
       );
-      return response;
+      const llmConfig = this.services.stateManager.getLLMConfig(this.id);
+      const beforeResponsePayload = {
+        content: response,
+        provider: llmConfig.provider,
+        model: llmConfig.model,
+        router: llmConfig.router,
+        sessionId: this.id
+      };
+      const modifiedResponsePayload = await this.services.pluginManager.executePlugins(
+        "beforeResponse",
+        beforeResponsePayload,
+        {
+          sessionManager: this.services.sessionManager,
+          mcpManager: this.services.mcpManager,
+          toolManager: this.services.toolManager,
+          stateManager: this.services.stateManager,
+          sessionId: this.id,
+          abortSignal: signal
+        }
+      );
+      return modifiedResponsePayload.content;
     } catch (error) {
       const aborted = error instanceof Error && error.name === "AbortError" || typeof error === "object" && error !== null && error.aborted === true;
       if (aborted) {
@@ -176,6 +252,22 @@ class ChatSession {
         });
         return "";
       }
+      if (error instanceof import_errors.DextoRuntimeError && error.code === import_error_codes.PluginErrorCode.PLUGIN_BLOCKED_EXECUTION && error.scope === import_errors.ErrorScope.PLUGIN && error.type === import_errors.ErrorType.FORBIDDEN) {
+        try {
+          await this.saveBlockedInteraction(
+            input,
+            error.message,
+            imageDataInput,
+            fileDataInput
+          );
+          import_logger.logger.debug(`ChatSession ${this.id}: Saved blocked interaction to history`);
+        } catch (saveError) {
+          import_logger.logger.warn(
+            `Failed to save blocked interaction to history: ${saveError instanceof Error ? saveError.message : String(saveError)}`
+          );
+        }
+        return error.message;
+      }
       throw error;
     } finally {
       this.currentRunController = null;
@@ -259,10 +351,10 @@ class ChatSession {
    *
    * @example
    * ```typescript
-   * // Switch from Claude to GPT-4 while keeping conversation history
+   * // Switch from Claude to GPT-5 while keeping conversation history
    * session.switchLLM({
    *   provider: 'openai',
-   *   model: 'gpt-4',
+   *   model: 'gpt-5',
    *   apiKey: process.env.OPENAI_API_KEY,
    *   router: 'in-built'
    * });
@@ -275,12 +367,13 @@ class ChatSession {
         newLLMConfig,
         router,
         this.services.toolManager,
-        this.services.promptManager,
+        this.services.systemPromptManager,
         this.historyProvider,
         // Pass the SAME history provider - preserves conversation!
         this.eventBus,
         // Use session event bus
-        this.id
+        this.id,
+        this.services.resourceManager
       );
       this.llmService = newLLMService;
       import_logger.logger.info(