@hashgraphonline/conversational-agent 0.1.204 → 0.1.206

package/dist/cjs/memory/TokenCounter.d.ts

@@ -0,0 +1,61 @@
+import { TiktokenModel } from 'tiktoken';
+import { BaseMessage } from '@langchain/core/messages';
+
+/**
+ * Token counter utility for OpenAI models using tiktoken encoding
+ * Provides accurate token counting for text content and chat messages
+ */
+export declare class TokenCounter {
+    private encoding;
+    private modelName;
+    private static readonly MESSAGE_OVERHEAD;
+    private static readonly ROLE_OVERHEAD;
+    constructor(modelName?: TiktokenModel);
+    /**
+     * Count tokens in raw text content
+     * @param text - The text to count tokens for
+     * @returns Number of tokens
+     */
+    countTokens(text: string): number;
+    /**
+     * Count tokens for a single chat message including role overhead
+     * @param message - The message to count tokens for
+     * @returns Number of tokens including message formatting overhead
+     */
+    countMessageTokens(message: BaseMessage): number;
+    /**
+     * Count tokens for multiple messages
+     * @param messages - Array of messages to count
+     * @returns Total token count for all messages
+     */
+    countMessagesTokens(messages: BaseMessage[]): number;
+    /**
+     * Estimate tokens for system prompt
+     * System prompts have slightly different overhead in chat completions
+     * @param systemPrompt - The system prompt text
+     * @returns Estimated token count
+     */
+    estimateSystemPromptTokens(systemPrompt: string): number;
+    /**
+     * Get total context size estimate including system prompt and messages
+     * @param systemPrompt - System prompt text
+     * @param messages - Conversation messages
+     * @returns Total estimated token count
+     */
+    estimateContextSize(systemPrompt: string, messages: BaseMessage[]): number;
+    /**
+     * Get the role string for a message
+     * @param message - The message to get the role for
+     * @returns Role string ('user', 'assistant', 'system', etc.)
+     */
+    private getMessageRole;
+    /**
+     * Get the model name being used for token counting
+     * @returns The tiktoken model name
+     */
+    getModelName(): string;
+    /**
+     * Clean up encoding resources
+     */
+    dispose(): void;
+}

package/dist/cjs/memory/index.d.ts

@@ -0,0 +1,7 @@
+export { TokenCounter } from './TokenCounter';
+export { MemoryWindow } from './MemoryWindow';
+export { ContentStorage } from './ContentStorage';
+export { SmartMemoryManager } from './SmartMemoryManager';
+export type { SmartMemoryConfig, SearchOptions, MemoryStats } from './SmartMemoryManager';
+export type { AddMessageResult } from './MemoryWindow';
+export type { StorageStats } from './ContentStorage';

package/dist/cjs/plugins/hbar-transfer/TransferHbarTool.d.ts

@@ -26,6 +26,11 @@ declare const TransferHbarZodSchemaCore: z.ZodObject<{
     }[];
     memo?: string | undefined;
 }>;
+/**
+ * A Hedera transaction tool for transferring HBAR between accounts.
+ * Supports single and multi-party transfers with automatic balance validation.
+ * Extends BaseHederaTransactionTool to handle HBAR transfer transactions on the Hedera network.
+ */
 export declare class TransferHbarTool extends BaseHederaTransactionTool<typeof TransferHbarZodSchemaCore> {
     name: string;
     description: string;
@@ -55,7 +60,20 @@ export declare class TransferHbarTool extends BaseHederaTransactionTool<typeof T
         memo?: string | undefined;
     }>;
     namespace: string;
+    /**
+     * Creates and returns the service builder for account operations.
+     *
+     * @returns BaseServiceBuilder instance configured for account operations
+     */
     protected getServiceBuilder(): BaseServiceBuilder;
+    /**
+     * Executes the HBAR transfer using the provided builder and arguments.
+     * Validates that all transfers sum to zero before execution.
+     *
+     * @param builder - The service builder instance for executing transactions
+     * @param specificArgs - The validated transfer parameters including transfers array and optional memo
+     * @returns Promise that resolves when the transfer is complete
+     */
     protected callBuilderMethod(builder: BaseServiceBuilder, specificArgs: z.infer<typeof TransferHbarZodSchemaCore>): Promise<void>;
 }
 export {};

package/dist/cjs/services/ContentStoreManager.d.ts

@@ -0,0 +1,54 @@
+import { ContentStorage } from '../memory/ContentStorage';
+import { ContentReferenceConfig } from '../types/content-reference';
+import { Logger } from '@hashgraphonline/standards-sdk';
+
+/**
+ * Manages content store lifecycle and cross-package registration
+ */
+export declare class ContentStoreManager {
+    private contentStorage;
+    private adapter;
+    private resolver;
+    private logger;
+    private isRegistered;
+    constructor(maxMessageStorage?: number, referenceConfig?: Partial<ContentReferenceConfig>, logger?: Logger);
+    /**
+     * Initialize and register content storage for cross-package access
+     */
+    initialize(): Promise<void>;
+    /**
+     * Get the underlying ContentStorage instance
+     */
+    getContentStorage(): ContentStorage;
+    /**
+     * Get storage statistics
+     */
+    getStats(): Promise<import('../types').ContentReferenceStats>;
+    /**
+     * Update configuration
+     */
+    updateConfig(config: Partial<ContentReferenceConfig>): Promise<void>;
+    /**
+     * Perform manual cleanup
+     */
+    performCleanup(): Promise<{
+        cleanedUp: number;
+        errors: string[];
+    }>;
+    /**
+     * Check if content should be stored as reference
+     */
+    shouldUseReference(content: Buffer | string): boolean;
+    /**
+     * Store content if it's large enough
+     */
+    storeContentIfLarge(content: Buffer | string, metadata: any): Promise<import('../types').ContentReference | null>;
+    /**
+     * Cleanup and unregister
+     */
+    dispose(): Promise<void>;
+    /**
+     * Check if the manager is initialized
+     */
+    isInitialized(): boolean;
+}

package/dist/cjs/types/content-reference.d.ts

@@ -0,0 +1,213 @@
+/**
+ * Content Reference System Types
+ *
+ * Shared interfaces for the Reference-Based Content System that handles
+ * large content storage with unique reference IDs to optimize context window usage.
+ */
+/**
+ * Unique identifier for stored content references
+ * Format: Cryptographically secure 32-byte identifier with base64url encoding
+ */
+export type ReferenceId = string;
+/**
+ * Lifecycle state of a content reference
+ */
+export type ReferenceLifecycleState = 'active' | 'expired' | 'cleanup_pending' | 'invalid';
+/**
+ * Content types supported by the reference system
+ */
+export type ContentType = 'text' | 'json' | 'html' | 'markdown' | 'binary' | 'unknown';
+/**
+ * Sources that created the content reference
+ */
+export type ContentSource = 'mcp_tool' | 'user_upload' | 'agent_generated' | 'system';
+/**
+ * Metadata associated with stored content
+ */
+export interface ContentMetadata {
+    /** Content type classification */
+    contentType: ContentType;
+    /** MIME type of the original content */
+    mimeType?: string;
+    /** Size in bytes of the stored content */
+    sizeBytes: number;
+    /** When the content was originally stored */
+    createdAt: Date;
+    /** Last time the content was accessed via reference resolution */
+    lastAccessedAt: Date;
+    /** Source that created this content reference */
+    source: ContentSource;
+    /** Name of the MCP tool that generated the content (if applicable) */
+    mcpToolName?: string;
+    /** Original filename or suggested name for the content */
+    fileName?: string;
+    /** Number of times this reference has been resolved */
+    accessCount: number;
+    /** Tags for categorization and cleanup policies */
+    tags?: string[];
+    /** Custom metadata from the source */
+    customMetadata?: Record<string, unknown>;
+}
+/**
+ * Core content reference object passed through agent context
+ * Designed to be lightweight (<100 tokens) while providing enough
+ * information for agent decision-making
+ */
+export interface ContentReference {
+    /** Unique identifier for resolving the content */
+    referenceId: ReferenceId;
+    /** Current lifecycle state */
+    state: ReferenceLifecycleState;
+    /** Brief description or preview of the content (max 200 chars) */
+    preview: string;
+    /** Essential metadata for agent decision-making */
+    metadata: Pick<ContentMetadata, 'contentType' | 'sizeBytes' | 'source' | 'fileName' | 'mimeType'>;
+    /** When this reference was created */
+    createdAt: Date;
+    /** Special format indicator for reference IDs in content */
+    readonly format: 'ref://{id}';
+}
+/**
+ * Result of attempting to resolve a content reference
+ */
+export interface ReferenceResolutionResult {
+    /** Whether the resolution was successful */
+    success: boolean;
+    /** The resolved content if successful */
+    content?: Buffer;
+    /** Complete metadata if successful */
+    metadata?: ContentMetadata;
+    /** Error message if resolution failed */
+    error?: string;
+    /** Specific error type for targeted error handling */
+    errorType?: 'not_found' | 'expired' | 'corrupted' | 'access_denied' | 'system_error';
+    /** Suggested actions for recovery */
+    suggestedActions?: string[];
+}
+/**
+ * Configuration for content reference storage and lifecycle
+ */
+export interface ContentReferenceConfig {
+    /** Size threshold above which content should be stored as references (default: 10KB) */
+    sizeThresholdBytes: number;
+    /** Maximum age for unused references before cleanup (default: 1 hour) */
+    maxAgeMs: number;
+    /** Maximum number of references to store simultaneously */
+    maxReferences: number;
+    /** Maximum total storage size for all references */
+    maxTotalStorageBytes: number;
+    /** Whether to enable automatic cleanup */
+    enableAutoCleanup: boolean;
+    /** Interval for cleanup checks in milliseconds */
+    cleanupIntervalMs: number;
+    /** Whether to persist references across restarts */
+    enablePersistence: boolean;
+    /** Storage backend configuration */
+    storageBackend: 'memory' | 'filesystem' | 'hybrid';
+    /** Cleanup policies for different content types */
+    cleanupPolicies: {
+        /** Policy for content marked as "recent" from MCP tools */
+        recent: {
+            maxAgeMs: number;
+            priority: number;
+        };
+        /** Policy for user-uploaded content */
+        userContent: {
+            maxAgeMs: number;
+            priority: number;
+        };
+        /** Policy for agent-generated content */
+        agentGenerated: {
+            maxAgeMs: number;
+            priority: number;
+        };
+        /** Default policy for other content */
+        default: {
+            maxAgeMs: number;
+            priority: number;
+        };
+    };
+}
+/**
+ * Default configuration values
+ */
+export declare const DEFAULT_CONTENT_REFERENCE_CONFIG: ContentReferenceConfig;
+/**
+ * Statistics about content reference usage and storage
+ */
+export interface ContentReferenceStats {
+    /** Total number of active references */
+    activeReferences: number;
+    /** Total storage used by all references in bytes */
+    totalStorageBytes: number;
+    /** Number of references cleaned up in last cleanup cycle */
+    recentlyCleanedUp: number;
+    /** Number of successful reference resolutions since startup */
+    totalResolutions: number;
+    /** Number of failed resolution attempts */
+    failedResolutions: number;
+    /** Average content size in bytes */
+    averageContentSize: number;
+    /** Most frequently accessed reference ID */
+    mostAccessedReferenceId?: ReferenceId;
+    /** Storage utilization percentage */
+    storageUtilization: number;
+    /** Performance metrics */
+    performanceMetrics: {
+        /** Average time to create a reference in milliseconds */
+        averageCreationTimeMs: number;
+        /** Average time to resolve a reference in milliseconds */
+        averageResolutionTimeMs: number;
+        /** Average cleanup time in milliseconds */
+        averageCleanupTimeMs: number;
+    };
+}
+/**
+ * Error types for content reference operations
+ */
+export declare class ContentReferenceError extends Error {
+    readonly type: ReferenceResolutionResult['errorType'];
+    readonly referenceId?: ReferenceId | undefined;
+    readonly suggestedActions?: string[] | undefined;
+    constructor(message: string, type: ReferenceResolutionResult['errorType'], referenceId?: ReferenceId | undefined, suggestedActions?: string[] | undefined);
+}
+/**
+ * Interface for content reference storage implementations
+ */
+export interface ContentReferenceStore {
+    /**
+     * Store content and return a reference
+     */
+    storeContent(content: Buffer, metadata: Omit<ContentMetadata, 'createdAt' | 'lastAccessedAt' | 'accessCount'>): Promise<ContentReference>;
+    /**
+     * Resolve a reference to its content
+     */
+    resolveReference(referenceId: ReferenceId): Promise<ReferenceResolutionResult>;
+    /**
+     * Check if a reference exists and is valid
+     */
+    hasReference(referenceId: ReferenceId): Promise<boolean>;
+    /**
+     * Mark a reference for cleanup
+     */
+    cleanupReference(referenceId: ReferenceId): Promise<boolean>;
+    /**
+     * Get current storage statistics
+     */
+    getStats(): Promise<ContentReferenceStats>;
+    /**
+     * Update configuration
+     */
+    updateConfig(config: Partial<ContentReferenceConfig>): Promise<void>;
+    /**
+     * Perform cleanup based on current policies
+     */
+    performCleanup(): Promise<{
+        cleanedUp: number;
+        errors: string[];
+    }>;
+    /**
+     * Dispose of resources
+     */
+    dispose(): Promise<void>;
+}

package/dist/cjs/types/index.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Shared types for the conversational agent system
+ */
+export * from './content-reference';

package/dist/esm/index12.js

@@ -1,10 +1,10 @@
 import { z } from "zod";
-import { AccountBuilder } from "./index16.js";
+import { AccountBuilder } from "./index18.js";
 import { BaseHederaTransactionTool } from "hedera-agent-kit";
 const HbarTransferInputSchema = z.object({
   accountId: z.string().describe('Account ID for the transfer (e.g., "0.0.xxxx").'),
   amount: z.union([z.number(), z.string()]).describe(
-    "HBAR amount. Positive for credit, negative for debit. Builder handles Hbar unit & sum validation."
+    "HBAR amount in decimal format (e.g., 1 for 1 HBAR, 0.5 for 0.5 HBAR). Positive for credit, negative for debit. DO NOT multiply by 10^8 for tinybars - just use the HBAR amount directly."
   )
 });
 const TransferHbarZodSchemaCore = z.object({
@@ -21,9 +21,22 @@ class TransferHbarTool extends BaseHederaTransactionTool {
     this.specificInputSchema = TransferHbarZodSchemaCore;
     this.namespace = "account";
   }
+  /**
+   * Creates and returns the service builder for account operations.
+   * 
+   * @returns BaseServiceBuilder instance configured for account operations
+   */
   getServiceBuilder() {
     return new AccountBuilder(this.hederaKit);
   }
+  /**
+   * Executes the HBAR transfer using the provided builder and arguments.
+   * Validates that all transfers sum to zero before execution.
+   * 
+   * @param builder - The service builder instance for executing transactions
+   * @param specificArgs - The validated transfer parameters including transfers array and optional memo
+   * @returns Promise that resolves when the transfer is complete
+   */
   async callBuilderMethod(builder, specificArgs) {
     await builder.transferHbar(
       specificArgs

package/dist/esm/index12.js.map

@@ -1 +1 @@
-{"version":3,"file":"index12.js","sources":["../../src/plugins/hbar-transfer/TransferHbarTool.ts"],"sourcesContent":["import { z } from 'zod';\nimport { HbarTransferParams } from './types';\nimport { AccountBuilder } from './AccountBuilder';\nimport { BaseHederaTransactionTool, BaseServiceBuilder } from 'hedera-agent-kit';\n\nconst HbarTransferInputSchema = z.object({\n  accountId: z\n    .string()\n    .describe('Account ID for the transfer (e.g., \"0.0.xxxx\").'),\n  amount: z\n    .union([z.number(), z.string()])\n    .describe(\n      'HBAR amount. Positive for credit, negative for debit. Builder handles Hbar unit & sum validation.'\n    ),\n});\n\nconst TransferHbarZodSchemaCore = z.object({\n  transfers: z\n    .array(HbarTransferInputSchema)\n    .min(1)\n    .describe(\n      'Array of ALL transfers for this transaction. For multi-party transfers (e.g., \"A sends 5 to C and B sends 3 to C\"), include all transfers here: [{accountId: \"A\", amount: -5}, {accountId: \"B\", amount: -3}, {accountId: \"C\", amount: 8}]. Amounts must sum to zero.'\n    ),\n  memo: z.string().optional().describe('Optional. Memo for the transaction.'),\n});\n\nexport class TransferHbarTool extends BaseHederaTransactionTool<\n  typeof TransferHbarZodSchemaCore\n> {\n  name = 'hedera-account-transfer-hbar-v2';\n  description =\n    'PRIMARY TOOL FOR HBAR TRANSFERS: Transfers HBAR between accounts. Supports multiple transfers in a single transaction - when multiple accounts need to send/receive HBAR (e.g., \"A sends 5 HBAR to C and B sends 3 HBAR to C\"), include ALL transfers in one transfers array. The sum of all transfers must equal zero. Use this for scheduled transactions and multi-signature scenarios.';\n  specificInputSchema = TransferHbarZodSchemaCore;\n  namespace = 'account';\n\n\n  protected getServiceBuilder(): BaseServiceBuilder {\n    return new AccountBuilder(this.hederaKit) as BaseServiceBuilder;\n  }\n\n  protected async callBuilderMethod(\n    builder: BaseServiceBuilder,\n    specificArgs: z.infer<typeof TransferHbarZodSchemaCore>\n  ): Promise<void> {\n    await (builder as AccountBuilder).transferHbar(\n      specificArgs as unknown as HbarTransferParams\n    );\n  }\n}"],"names":[],"mappings":";;;AAKA,MAAM,0BAA0B,EAAE,OAAO;AAAA,EACvC,WAAW,EACR,SACA,SAAS,iDAAiD;AAAA,EAC7D,QAAQ,EACL,MAAM,CAAC,EAAE,OAAA,GAAU,EAAE,QAAQ,CAAC,EAC9B;AAAA,IACC;AAAA,EAAA;AAEN,CAAC;AAED,MAAM,4BAA4B,EAAE,OAAO;AAAA,EACzC,WAAW,EACR,MAAM,uBAAuB,EAC7B,IAAI,CAAC,EACL;AAAA,IACC;AAAA,EAAA;AAAA,EAEJ,MAAM,EAAE,OAAA,EAAS,SAAA,EAAW,SAAS,qCAAqC;AAC5E,CAAC;AAEM,MAAM,yBAAyB,0BAEpC;AAAA,EAFK,cAAA;AAAA,UAAA,GAAA,SAAA;AAGL,SAAA,OAAO;AACP,SAAA,cACE;AACF,SAAA,sBAAsB;AACtB,SAAA,YAAY;AAAA,EAAA;AAAA,EAGF,oBAAwC;AAChD,WAAO,IAAI,eAAe,KAAK,SAAS;AAAA,EAC1C;AAAA,EAEA,MAAgB,kBACd,SACA,cACe;AACf,UAAO,QAA2B;AAAA,MAChC;AAAA,IAAA;AAAA,EAEJ;AACF;"}
+{"version":3,"file":"index12.js","sources":["../../src/plugins/hbar-transfer/TransferHbarTool.ts"],"sourcesContent":["import { z } from 'zod';\nimport { HbarTransferParams } from './types';\nimport { AccountBuilder } from './AccountBuilder';\nimport { BaseHederaTransactionTool, BaseServiceBuilder } from 'hedera-agent-kit';\n\nconst HbarTransferInputSchema = z.object({\n  accountId: z\n    .string()\n    .describe('Account ID for the transfer (e.g., \"0.0.xxxx\").'),\n  amount: z\n    .union([z.number(), z.string()])\n    .describe(\n      'HBAR amount in decimal format (e.g., 1 for 1 HBAR, 0.5 for 0.5 HBAR). Positive for credit, negative for debit. DO NOT multiply by 10^8 for tinybars - just use the HBAR amount directly.'\n    ),\n});\n\nconst TransferHbarZodSchemaCore = z.object({\n  transfers: z\n    .array(HbarTransferInputSchema)\n    .min(1)\n    .describe(\n      'Array of ALL transfers for this transaction. For multi-party transfers (e.g., \"A sends 5 to C and B sends 3 to C\"), include all transfers here: [{accountId: \"A\", amount: -5}, {accountId: \"B\", amount: -3}, {accountId: \"C\", amount: 8}]. Amounts must sum to zero.'\n    ),\n  memo: z.string().optional().describe('Optional. Memo for the transaction.'),\n});\n\n/**\n * A Hedera transaction tool for transferring HBAR between accounts.\n * Supports single and multi-party transfers with automatic balance validation.\n * Extends BaseHederaTransactionTool to handle HBAR transfer transactions on the Hedera network.\n */\nexport class TransferHbarTool extends BaseHederaTransactionTool<\n  typeof TransferHbarZodSchemaCore\n> {\n  name = 'hedera-account-transfer-hbar-v2';\n  description =\n    'PRIMARY TOOL FOR HBAR TRANSFERS: Transfers HBAR between accounts. Supports multiple transfers in a single transaction - when multiple accounts need to send/receive HBAR (e.g., \"A sends 5 HBAR to C and B sends 3 HBAR to C\"), include ALL transfers in one transfers array. The sum of all transfers must equal zero. Use this for scheduled transactions and multi-signature scenarios.';\n  specificInputSchema = TransferHbarZodSchemaCore;\n  namespace = 'account';\n\n\n  /**\n   * Creates and returns the service builder for account operations.\n   * \n   * @returns BaseServiceBuilder instance configured for account operations\n   */\n  protected getServiceBuilder(): BaseServiceBuilder {\n    return new AccountBuilder(this.hederaKit) as BaseServiceBuilder;\n  }\n\n  /**\n   * Executes the HBAR transfer using the provided builder and arguments.\n   * Validates that all transfers sum to zero before execution.\n   * \n   * @param builder - The service builder instance for executing transactions\n   * @param specificArgs - The validated transfer parameters including transfers array and optional memo\n   * @returns Promise that resolves when the transfer is complete\n   */\n  protected async callBuilderMethod(\n    builder: BaseServiceBuilder,\n    specificArgs: z.infer<typeof TransferHbarZodSchemaCore>\n  ): Promise<void> {\n    await (builder as AccountBuilder).transferHbar(\n      specificArgs as unknown as HbarTransferParams\n    );\n  }\n}"],"names":[],"mappings":";;;AAKA,MAAM,0BAA0B,EAAE,OAAO;AAAA,EACvC,WAAW,EACR,SACA,SAAS,iDAAiD;AAAA,EAC7D,QAAQ,EACL,MAAM,CAAC,EAAE,OAAA,GAAU,EAAE,QAAQ,CAAC,EAC9B;AAAA,IACC;AAAA,EAAA;AAEN,CAAC;AAED,MAAM,4BAA4B,EAAE,OAAO;AAAA,EACzC,WAAW,EACR,MAAM,uBAAuB,EAC7B,IAAI,CAAC,EACL;AAAA,IACC;AAAA,EAAA;AAAA,EAEJ,MAAM,EAAE,OAAA,EAAS,SAAA,EAAW,SAAS,qCAAqC;AAC5E,CAAC;AAOM,MAAM,yBAAyB,0BAEpC;AAAA,EAFK,cAAA;AAAA,UAAA,GAAA,SAAA;AAGL,SAAA,OAAO;AACP,SAAA,cACE;AACF,SAAA,sBAAsB;AACtB,SAAA,YAAY;AAAA,EAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAQF,oBAAwC;AAChD,WAAO,IAAI,eAAe,KAAK,SAAS;AAAA,EAC1C;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAUA,MAAgB,kBACd,SACA,cACe;AACf,UAAO,QAA2B;AAAA,MAChC;AAAA,IAAA;AAAA,EAEJ;AACF;"}

package/dist/esm/index14.js

@@ -1,127 +1,151 @@
-import { Client } from "@modelcontextprotocol/sdk/client/index.js";
-import { StdioClientTransport } from "@modelcontextprotocol/sdk/client/stdio.js";
-class MCPClientManager {
-  constructor(logger) {
-    this.clients = /* @__PURE__ */ new Map();
-    this.tools = /* @__PURE__ */ new Map();
-    this.logger = logger;
+import { ContentStorage } from "./index19.js";
+import { ContentStoreService, ContentResolverRegistry, shouldUseReference, extractReferenceId } from "@hashgraphonline/standards-sdk";
+class ContentStorageAdapter {
+  constructor(storage) {
+    this.storage = storage;
   }
-  /**
-   * Connect to an MCP server and discover its tools
-   */
-  async connectServer(config) {
-    try {
-      if (this.isServerConnected(config.name)) {
-        return {
-          serverName: config.name,
-          connected: false,
-          error: `Server ${config.name} is already connected`,
-          tools: []
+  async storeContent(content, metadata) {
+    const contentRef = await this.storage.storeContent(content, metadata);
+    return contentRef.referenceId;
+  }
+  async resolveReference(referenceId) {
+    const result = await this.storage.resolveReference(referenceId);
+    if (result.success && result.content) {
+      const response = {
+        content: result.content
+      };
+      if (result.metadata) {
+        response.metadata = {
+          ...result.metadata.mimeType !== void 0 && { mimeType: result.metadata.mimeType },
+          ...result.metadata.fileName !== void 0 && { fileName: result.metadata.fileName },
+          originalSize: result.metadata.sizeBytes
         };
       }
-      if (config.transport && config.transport !== "stdio") {
-        throw new Error(`Transport ${config.transport} not yet supported`);
-      }
-      const transport = new StdioClientTransport({
-        command: config.command,
-        args: config.args,
-        ...config.env && { env: config.env }
-      });
-      const client = new Client({
-        name: `conversational-agent-${config.name}`,
-        version: "1.0.0"
-      }, {
-        capabilities: {}
-      });
-      await client.connect(transport);
-      this.clients.set(config.name, client);
-      const toolsResponse = await client.listTools();
-      const toolsWithServer = toolsResponse.tools.map((tool) => ({
-        ...tool,
-        serverName: config.name
-      }));
-      this.tools.set(config.name, toolsWithServer);
-      this.logger.info(`Connected to MCP server ${config.name} with ${toolsWithServer.length} tools`);
-      return {
-        serverName: config.name,
-        connected: true,
-        tools: toolsWithServer
-      };
-    } catch (error) {
-      this.logger.error(`Failed to connect to MCP server ${config.name}:`, error);
-      return {
-        serverName: config.name,
-        connected: false,
-        error: error instanceof Error ? error.message : "Unknown error",
-        tools: []
-      };
+      return response;
+    } else {
+      throw new Error(result.error || "Reference not found");
     }
   }
+  async hasReference(referenceId) {
+    return await this.storage.hasReference(referenceId);
+  }
+  async cleanupReference(referenceId) {
+    await this.storage.cleanupReference(referenceId);
+  }
+  async getStats() {
+    return await this.storage.getStats();
+  }
+  async updateConfig(config) {
+    return await this.storage.updateConfig(config);
+  }
+  async performCleanup() {
+    await this.storage.performCleanup();
+  }
+  async dispose() {
+    return Promise.resolve(this.storage.dispose());
+  }
+}
+class ContentResolver {
+  constructor(adapter) {
+    this.adapter = adapter;
+  }
+  async resolveReference(referenceId) {
+    return await this.adapter.resolveReference(referenceId);
+  }
+  shouldUseReference(content) {
+    return shouldUseReference(content);
+  }
+  extractReferenceId(input) {
+    return extractReferenceId(input);
+  }
+}
+class ContentStoreManager {
+  constructor(maxMessageStorage = 1e3, referenceConfig, logger) {
+    this.isRegistered = false;
+    this.logger = logger || {
+      info: console.log,
+      debug: console.log,
+      warn: console.warn,
+      error: console.error
+    };
+    this.contentStorage = new ContentStorage(maxMessageStorage, referenceConfig);
+    this.adapter = new ContentStorageAdapter(this.contentStorage);
+    this.resolver = new ContentResolver(this.adapter);
+  }
   /**
-   * Execute a tool on a specific MCP server
+   * Initialize and register content storage for cross-package access
    */
-  async executeTool(serverName, toolName, args) {
-    const client = this.clients.get(serverName);
-    if (!client) {
-      throw new Error(`MCP server ${serverName} not connected`);
+  async initialize() {
+    if (this.isRegistered) {
+      this.logger.warn("ContentStoreManager is already initialized");
+      return;
     }
-    this.logger.debug(`Executing MCP tool ${toolName} on server ${serverName}`, args);
     try {
-      const result = await client.callTool({
-        name: toolName,
-        arguments: args
-      });
-      return result;
+      await ContentStoreService.setInstance(this.adapter);
+      ContentResolverRegistry.register(this.resolver);
+      this.isRegistered = true;
+      this.logger.info("ContentStoreManager initialized and registered for cross-package access");
     } catch (error) {
-      this.logger.error(`Error executing MCP tool ${toolName}:`, error);
+      this.logger.error("Failed to initialize ContentStoreManager:", error);
       throw error;
     }
   }
   /**
-   * Disconnect all MCP servers
+   * Get the underlying ContentStorage instance
    */
-  async disconnectAll() {
-    for (const [name, client] of this.clients) {
-      try {
-        await client.close();
-        this.logger.info(`Disconnected from MCP server ${name}`);
-      } catch (error) {
-        this.logger.error(`Error disconnecting MCP server ${name}:`, error);
-      }
-    }
-    this.clients.clear();
-    this.tools.clear();
+  getContentStorage() {
+    return this.contentStorage;
   }
   /**
-   * Get all discovered tools from all connected servers
+   * Get storage statistics
    */
-  getAllTools() {
-    const allTools = [];
-    for (const tools of this.tools.values()) {
-      allTools.push(...tools);
-    }
-    return allTools;
+  async getStats() {
+    return await this.contentStorage.getStats();
   }
   /**
-   * Get tools from a specific server
+   * Update configuration
    */
-  getServerTools(serverName) {
-    return this.tools.get(serverName) || [];
+  async updateConfig(config) {
+    return await this.contentStorage.updateConfig(config);
   }
   /**
-   * Check if a server is connected
+   * Perform manual cleanup
    */
-  isServerConnected(serverName) {
-    return this.clients.has(serverName);
+  async performCleanup() {
+    return await this.contentStorage.performCleanup();
+  }
+  /**
+   * Check if content should be stored as reference
+   */
+  shouldUseReference(content) {
+    return this.contentStorage.shouldUseReference(content);
+  }
+  /**
+   * Store content if it's large enough
+   */
+  async storeContentIfLarge(content, metadata) {
+    return await this.contentStorage.storeContentIfLarge(content, metadata);
+  }
+  /**
+   * Cleanup and unregister
+   */
+  async dispose() {
+    if (this.isRegistered) {
+      this.contentStorage.dispose();
+      ContentStoreService.dispose();
+      ContentResolverRegistry.unregister();
+      this.isRegistered = false;
+      this.logger.info("ContentStoreManager disposed and unregistered");
+    }
   }
   /**
-   * Get list of connected server names
+   * Check if the manager is initialized
    */
-  getConnectedServers() {
-    return Array.from(this.clients.keys());
+  isInitialized() {
+    return this.isRegistered;
   }
 }
 export {
-  MCPClientManager
+  ContentStoreManager
 };
 //# sourceMappingURL=index14.js.map