telegram-agent-memory 0.2.1

package/CHANGELOG.md

@@ -0,0 +1,24 @@
+# Changelog
+
+## 0.2.1 - 2026-04-11
+
+- moved shared stable profile memory into a canonical `users/<userId>/PROFILE.*` layout
+- kept daily memory and local recall indexes group-scoped under `groups/<groupId>/members/<userId>/`
+- added compatibility coverage for migrating older group-scoped profile data into the shared user-scoped profile file
+- updated the docs so the public file layout matches the actual cross-group memory model
+
+## 0.2.0 - 2026-04-10
+
+- added built-in support for Anthropic Claude as an LLM provider
+- kept OpenAI-compatible and OpenRouter-style API support through configurable base URLs and headers
+- switched the default semantic index embeddings to a built-in local embedding provider
+- changed the default memory model so stable profile memory is shared across groups while daily memory stays group-specific
+- tightened the engineering quality gate with ESLint, Prettier, `verify`, `release:check`, and GitHub CI
+- improved release hygiene with a changelog, release guide, packaging checks, and clearer product-boundary docs
+
+## 0.1.0 - 2026-04-10
+
+- initial Telegram-focused public release
+- file-first member memory with `remember()`, `context()`, and `recall()`
+- local semantic index stored in `INDEX.json`
+- fixture-based Telegram memory behavior tests

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 alitayin
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,186 @@
+# Telegram Agent Memory
+
+A file-first long-term memory library for Telegram bots.
+
+You only need one supported LLM provider API key. No external database is required.
+This package is intentionally scoped to Telegram memory. External vector databases, graph databases, and generic memory-platform APIs are not part of the public product contract.
+
+By default, stable member profile memory is shared across groups for the same `userId`, while recent daily memory stays group-specific.
+
+The default product flow is simple:
+
+- When a member sends a message, the LLM extracts what is worth remembering
+- Long-term member state is written to `PROFILE.md`
+- Recent events are written to `memory/YYYY-MM-DD.md`
+- Before replying, `context()` always includes stable profile memory and automatically adds relevant recent memory
+
+## Install
+
+```bash
+npm install telegram-agent-memory
+```
+
+## Minimal Setup
+
+```ts
+import { createTelegramMemory } from 'telegram-agent-memory';
+
+const memory = await createTelegramMemory({
+  apiKey: process.env.OPENAI_API_KEY!,
+  whatToRemember: `
+  Remember:
+  - user preferences
+  - ongoing plans
+  - important status changes
+
+  Ignore:
+  - greetings
+  - filler chat
+  - one-off small talk
+  `,
+});
+```
+
+## Store Memory
+
+```ts
+await memory.remember('I like coffee and usually work in Beijing.', {
+  userId: 'tg_user_123',
+  groupId: 'tg_group_456',
+  username: 'alice',
+});
+```
+
+By default, this creates files like:
+
+```text
+.telegram-agent-memory/
+  users/
+    tg_user_123/
+      PROFILE.md
+      PROFILE.json
+  groups/
+    tg_group_456/
+      members/
+        tg_user_123/
+          INDEX.json
+          memory/
+            2026-04-10.md
+            2026-04-10.json
+```
+
+`users/<userId>/PROFILE.*` is the stable cross-group member profile. `groups/<groupId>/members/<userId>/memory/*` is recent group-specific memory.
+
+`INDEX.json` is an internal local embedding index used for automatic recall. It is managed by the library and does not require any external database.
+
+## Build Prompt Context
+
+This is the main read path.
+
+`context()` automatically:
+
+- includes stable member profile facts
+- searches recent daily memory with the current message
+- adds only relevant recent memory when it helps
+
+```ts
+const context = await memory.context('What should I know before replying?', {
+  userId: 'tg_user_123',
+  groupId: 'tg_group_456',
+});
+
+console.log(context.text);
+```
+
+The host bot does not need to decide when to use profile memory vs recent memory. The library decides that inside `context()`.
+
+## Optional Recall
+
+`recall()` still exists as a lower-level compatibility API if you want the ranked memory items directly.
+
+## Initialize From Environment
+
+```ts
+import { createTelegramMemoryFromEnv } from 'telegram-agent-memory';
+
+const memory = await createTelegramMemoryFromEnv();
+```
+
+Common environment variables:
+
+```bash
+TELEGRAM_MEMORY_LLM_PROVIDER=openai
+OPENAI_API_KEY=sk-...
+OPENAI_MODEL=gpt-4o-mini
+OPENAI_BASE_URL=
+OPENAI_EMBEDDING_MODEL=text-embedding-3-small
+OPENAI_HEADERS_JSON=
+ANTHROPIC_API_KEY=
+ANTHROPIC_MODEL=claude-3-5-haiku-latest
+ANTHROPIC_BASE_URL=
+ANTHROPIC_HEADERS_JSON=
+TELEGRAM_MEMORY_DIR=./data/telegram-memory
+TELEGRAM_MEMORY_POLICY=Remember user preferences and important status changes. Ignore filler chat.
+TELEGRAM_MEMORY_RECENT_DAYS=3
+TELEGRAM_MEMORY_MAX_PROFILE_FACTS=40
+TELEGRAM_MEMORY_MAX_FACTS_PER_MESSAGE=8
+TELEGRAM_MEMORY_SHARE_PROFILE_ACROSS_GROUPS=true
+```
+
+If `TELEGRAM_MEMORY_DIR` is not set, the default path is `.telegram-agent-memory/` under the current working directory.
+
+## Public API
+
+- `createTelegramMemory(...)`
+- `createTelegramMemoryFromEnv(...)`
+- `TelegramMemory`
+- `remember(...)`
+- `context(...)`
+- `recall(...)` for lower-level access
+
+## Provider Compatibility
+
+Built-in support today:
+
+- OpenAI directly
+- OpenAI-compatible APIs through `OPENAI_BASE_URL`
+- OpenRouter-style setups, including optional headers through `OPENAI_HEADERS_JSON`, `OPENROUTER_HTTP_REFERER`, and `OPENROUTER_APP_NAME`
+- Anthropic Claude through `TELEGRAM_MEMORY_LLM_PROVIDER=anthropic` plus `ANTHROPIC_API_KEY`
+
+Embeddings are local by default.
+If you explicitly want OpenAI-compatible remote embeddings, set `OPENAI_EMBEDDING_MODEL`.
+
+## Evaluation
+
+The repo includes fixture-based product tests for Telegram memory behavior:
+
+- extraction into `profile` vs `daily`
+- skip behavior for low-value messages
+- automatic recent-memory recall inside `context()`
+- user/group isolation
+- English, Chinese, and mixed-language message coverage
+
+Run them with:
+
+```bash
+npm run format:check
+npm run test:telegram-memory
+npm run lint
+npm run release:check
+```
+
+## Design Boundaries
+
+- The library is file-first and does not use Qdrant, Neo4j, or another external vector database as part of the product path
+- `INDEX.json` is an internal local semantic index, not a public storage abstraction
+- The only supported public entrypoint is the Telegram-focused package root
+- Historical generic-memory modules now live under `legacy/` and are not part of the npm surface, the default tests, or the supported architecture
+- The package is not designed for high-concurrency centralized shared storage or as a generic cross-channel memory backend
+- Stable profile memory is shared across groups by default; set `TELEGRAM_MEMORY_SHARE_PROFILE_ACROSS_GROUPS=false` only if you explicitly want group-isolated profiles
+
+See [docs/ARCHITECTURE.md](./docs/ARCHITECTURE.md) for the explicit product boundary.
+For local release hygiene, see [docs/RELEASE.md](./docs/RELEASE.md).
+
+## License
+
+MIT

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+export { TelegramMemory, createTelegramMemory, createTelegramMemoryFromEnv, validateTelegramMemoryConfig, assertValidTelegramMemoryConfig, telegramMemoryConfigFromEnv, TelegramMemoryConfigError, } from './telegram/TelegramMemory';
+export type { TelegramActor, TelegramRecallOptions, TelegramPromptContextOptions, TelegramMemoryStorageConfig, TelegramMemoryBehaviorConfig, TelegramMemoryConfig, TelegramMemoryConfigValidationIssue, TelegramMemoryFromEnvOptions, TelegramMemoryHealthReport, TelegramMemoryPreflightCheck, TelegramMemoryPreflightReport, TelegramRememberResult, TelegramRecallResult, TelegramPromptMemory, TelegramMemoryLogger, TelegramMemoryDependencies, } from './telegram/TelegramMemory';

package/dist/index.js

@@ -0,0 +1,12 @@
+"use strict";
+// Product-facing exports for the Telegram intelligent memory package.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TelegramMemoryConfigError = exports.telegramMemoryConfigFromEnv = exports.assertValidTelegramMemoryConfig = exports.validateTelegramMemoryConfig = exports.createTelegramMemoryFromEnv = exports.createTelegramMemory = exports.TelegramMemory = void 0;
+var TelegramMemory_1 = require("./telegram/TelegramMemory");
+Object.defineProperty(exports, "TelegramMemory", { enumerable: true, get: function () { return TelegramMemory_1.TelegramMemory; } });
+Object.defineProperty(exports, "createTelegramMemory", { enumerable: true, get: function () { return TelegramMemory_1.createTelegramMemory; } });
+Object.defineProperty(exports, "createTelegramMemoryFromEnv", { enumerable: true, get: function () { return TelegramMemory_1.createTelegramMemoryFromEnv; } });
+Object.defineProperty(exports, "validateTelegramMemoryConfig", { enumerable: true, get: function () { return TelegramMemory_1.validateTelegramMemoryConfig; } });
+Object.defineProperty(exports, "assertValidTelegramMemoryConfig", { enumerable: true, get: function () { return TelegramMemory_1.assertValidTelegramMemoryConfig; } });
+Object.defineProperty(exports, "telegramMemoryConfigFromEnv", { enumerable: true, get: function () { return TelegramMemory_1.telegramMemoryConfigFromEnv; } });
+Object.defineProperty(exports, "TelegramMemoryConfigError", { enumerable: true, get: function () { return TelegramMemory_1.TelegramMemoryConfigError; } });

package/dist/intelligence/AnthropicProvider.d.ts

@@ -0,0 +1,20 @@
+import type { MemoryLogger } from './logger';
+import type { LLMOptions, LLMProvider } from './types';
+export interface AnthropicProviderConfig {
+    apiKey?: string;
+    model?: string;
+    baseURL?: string;
+    headers?: Record<string, string>;
+    anthropicVersion?: string;
+    logger?: MemoryLogger;
+}
+export declare class AnthropicProvider implements LLMProvider {
+    private readonly apiKey?;
+    private readonly baseURL;
+    private readonly defaultModel;
+    private readonly headers?;
+    private readonly anthropicVersion;
+    private readonly logger?;
+    constructor(config?: AnthropicProviderConfig);
+    generate(prompt: string, options?: LLMOptions): Promise<string>;
+}

package/dist/intelligence/AnthropicProvider.js

@@ -0,0 +1,64 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AnthropicProvider = void 0;
+const logger_1 = require("./logger");
+const DEFAULT_ANTHROPIC_BASE_URL = 'https://api.anthropic.com';
+const DEFAULT_ANTHROPIC_MODEL = 'claude-3-5-haiku-latest';
+const DEFAULT_ANTHROPIC_VERSION = '2023-06-01';
+class AnthropicProvider {
+    constructor(config = {}) {
+        this.apiKey = config.apiKey || process.env.ANTHROPIC_API_KEY;
+        this.baseURL = (config.baseURL || DEFAULT_ANTHROPIC_BASE_URL).replace(/\/+$/, '');
+        this.defaultModel = config.model || DEFAULT_ANTHROPIC_MODEL;
+        this.headers = config.headers;
+        this.anthropicVersion = config.anthropicVersion || DEFAULT_ANTHROPIC_VERSION;
+        this.logger = config.logger;
+    }
+    async generate(prompt, options = {}) {
+        const model = options.model || this.defaultModel;
+        const temperature = options.temperature ?? 0.3;
+        const maxTokens = options.maxTokens || 1000;
+        try {
+            const response = await fetch(`${this.baseURL}/v1/messages`, {
+                method: 'POST',
+                headers: {
+                    'content-type': 'application/json',
+                    'x-api-key': this.apiKey ?? '',
+                    'anthropic-version': this.anthropicVersion,
+                    ...this.headers,
+                },
+                body: JSON.stringify({
+                    model,
+                    max_tokens: maxTokens,
+                    temperature,
+                    system: options.responseFormat === 'json_object'
+                        ? 'You are a fact extraction system. Return strict valid JSON only.'
+                        : 'You are a fact extraction system.',
+                    messages: [
+                        {
+                            role: 'user',
+                            content: prompt,
+                        },
+                    ],
+                }),
+            });
+            const payload = (await response.json());
+            if (!response.ok) {
+                throw new Error(payload.error?.message || `Anthropic request failed with status ${response.status}`);
+            }
+            return (payload.content
+                ?.filter((block) => block.type === 'text' && typeof block.text === 'string')
+                .map((block) => block.text)
+                .join('\n')
+                .trim() || '{}');
+        }
+        catch (error) {
+            this.logger?.error?.('Anthropic API request failed.', {
+                error: (0, logger_1.formatLoggerError)(error),
+                model,
+            });
+            throw new Error(`Anthropic generation failed: ${error instanceof Error ? error.message : 'Unknown error'}`);
+        }
+    }
+}
+exports.AnthropicProvider = AnthropicProvider;

package/dist/intelligence/OpenAIProvider.d.ts

@@ -0,0 +1,16 @@
+import type { LLMOptions, LLMProvider } from './types';
+import type { MemoryLogger } from './logger';
+export interface OpenAIProviderConfig {
+    apiKey?: string;
+    model?: string;
+    baseURL?: string;
+    headers?: Record<string, string>;
+    logger?: MemoryLogger;
+}
+export declare class OpenAIProvider implements LLMProvider {
+    private readonly client;
+    private readonly defaultModel;
+    private readonly logger?;
+    constructor(config?: OpenAIProviderConfig);
+    generate(prompt: string, options?: LLMOptions): Promise<string>;
+}

package/dist/intelligence/OpenAIProvider.js

@@ -0,0 +1,51 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OpenAIProvider = void 0;
+const openai_1 = __importDefault(require("openai"));
+const logger_1 = require("./logger");
+class OpenAIProvider {
+    constructor(config = {}) {
+        this.client = new openai_1.default({
+            apiKey: config.apiKey || process.env.OPENAI_API_KEY,
+            baseURL: config.baseURL,
+            defaultHeaders: config.headers,
+        });
+        this.defaultModel = config.model || 'gpt-4o-mini';
+        this.logger = config.logger;
+    }
+    async generate(prompt, options = {}) {
+        const model = options.model || this.defaultModel;
+        const temperature = options.temperature ?? 0.3;
+        const maxTokens = options.maxTokens || 1000;
+        try {
+            const completion = await this.client.chat.completions.create({
+                model,
+                messages: [
+                    {
+                        role: 'system',
+                        content: 'You are a fact extraction system. Extract structured facts from user messages and return valid JSON.',
+                    },
+                    {
+                        role: 'user',
+                        content: prompt,
+                    },
+                ],
+                temperature,
+                max_tokens: maxTokens,
+                response_format: options.responseFormat === 'json_object' ? { type: 'json_object' } : { type: 'text' },
+            });
+            return completion.choices[0]?.message?.content || '{}';
+        }
+        catch (error) {
+            this.logger?.error?.('OpenAI API request failed.', {
+                error: (0, logger_1.formatLoggerError)(error),
+                model,
+            });
+            throw new Error(`OpenAI generation failed: ${error instanceof Error ? error.message : 'Unknown error'}`);
+        }
+    }
+}
+exports.OpenAIProvider = OpenAIProvider;

package/dist/intelligence/logger.d.ts

@@ -0,0 +1,7 @@
+export interface MemoryLogger {
+    debug?(message: string, metadata?: Record<string, unknown>): void;
+    info?(message: string, metadata?: Record<string, unknown>): void;
+    warn?(message: string, metadata?: Record<string, unknown>): void;
+    error?(message: string, metadata?: Record<string, unknown>): void;
+}
+export declare function formatLoggerError(error: unknown): string;

package/dist/intelligence/logger.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.formatLoggerError = formatLoggerError;
+function formatLoggerError(error) {
+    return error instanceof Error ? error.message : String(error);
+}

package/dist/intelligence/types.d.ts

@@ -0,0 +1,18 @@
+import type { MemoryLogger } from './logger';
+export interface LLMProvider {
+    generate(prompt: string, options?: LLMOptions): Promise<string>;
+}
+export interface LLMOptions {
+    temperature?: number;
+    maxTokens?: number;
+    responseFormat?: 'text' | 'json_object';
+    model?: string;
+}
+export interface FactExtractorConfig {
+    llm?: LLMProvider;
+    mockMode?: boolean;
+    language?: string;
+    minImportance?: number;
+    enableBatch?: boolean;
+    logger?: MemoryLogger;
+}

package/dist/intelligence/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/telegram/TelegramMemory.d.ts

@@ -0,0 +1,174 @@
+import type { LLMProvider } from '../intelligence/types';
+import type { MemoryLogger } from '../intelligence/logger';
+import { StoredMemoryFact, TelegramFileMemoryStore } from './file-memory';
+import { TelegramEmbeddingProvider } from './local-index';
+export interface TelegramActor {
+    userId: string;
+    groupId: string;
+    username?: string;
+    metadata?: Record<string, unknown>;
+}
+export interface TelegramRecallOptions {
+    userId: string;
+    groupId: string;
+    limit?: number;
+    minImportance?: number;
+    includeProfile?: boolean;
+    recentDays?: number;
+}
+export type TelegramPromptContextOptions = TelegramRecallOptions;
+export interface TelegramMemoryOpenAIConfig {
+    apiKey: string;
+    model?: string;
+    baseURL?: string;
+    embeddingModel?: string;
+    headers?: Record<string, string>;
+}
+export interface TelegramMemoryAnthropicConfig {
+    apiKey: string;
+    model?: string;
+    baseURL?: string;
+    headers?: Record<string, string>;
+}
+export interface TelegramMemoryStorageConfig {
+    rootDir?: string;
+}
+export interface TelegramMemoryBehaviorConfig {
+    recentDays?: number;
+    maxProfileFacts?: number;
+    maxFactsPerMessage?: number;
+    shareProfileAcrossGroups?: boolean;
+}
+export interface TelegramMemoryConfig {
+    provider?: 'openai' | 'anthropic';
+    apiKey?: string;
+    model?: string;
+    baseURL?: string;
+    embeddingModel?: string;
+    headers?: Record<string, string>;
+    dir?: string;
+    whatToRemember?: string;
+    openai?: TelegramMemoryOpenAIConfig;
+    anthropic?: TelegramMemoryAnthropicConfig;
+    storage?: TelegramMemoryStorageConfig;
+    behavior?: TelegramMemoryBehaviorConfig;
+}
+export interface TelegramMemoryConfigValidationIssue {
+    field: string;
+    message: string;
+}
+export interface TelegramMemoryFromEnvOptions {
+    env?: NodeJS.ProcessEnv;
+}
+export interface TelegramMemoryDependencies {
+    llm?: LLMProvider;
+    logger?: TelegramMemoryLogger;
+    store?: TelegramFileMemoryStore;
+    embedder?: TelegramEmbeddingProvider;
+    now?: () => Date;
+}
+export type TelegramMemoryLogger = MemoryLogger;
+export interface TelegramMemoryHealthReport {
+    ok: boolean;
+    checks: Array<{
+        name: 'storage' | 'llm';
+        ok: boolean;
+        message?: string;
+    }>;
+}
+export interface TelegramMemoryPreflightCheck {
+    name: 'config' | 'storage' | 'llm';
+    ok: boolean;
+    fatal: boolean;
+    message?: string;
+    details?: Record<string, unknown>;
+}
+export interface TelegramMemoryPreflightReport {
+    ok: boolean;
+    checks: TelegramMemoryPreflightCheck[];
+}
+export interface TelegramRememberResult {
+    profileFacts: StoredMemoryFact[];
+    dailyFacts: StoredMemoryFact[];
+    skipped: boolean;
+    summary: {
+        added: number;
+        profile: number;
+        daily: number;
+    };
+}
+export interface TelegramRecallResult {
+    id: string;
+    kind: 'profile' | 'daily';
+    content: string;
+    summary: string;
+    category: string;
+    importance: number;
+    score: number;
+    path: string;
+    updatedAt: string;
+}
+export type TelegramPromptMemory = TelegramRecallResult;
+export interface BuildContextResult {
+    text: string;
+    memories: TelegramPromptMemory[];
+}
+export declare class TelegramMemoryConfigError extends Error {
+    readonly issues: TelegramMemoryConfigValidationIssue[];
+    constructor(message: string, issues: TelegramMemoryConfigValidationIssue[]);
+}
+export declare class TelegramMemory {
+    private readonly store;
+    private readonly llm;
+    private readonly embedder;
+    private readonly logger?;
+    private readonly now;
+    private readonly rootDir;
+    private readonly recentDays;
+    private readonly maxProfileFacts;
+    private readonly maxFactsPerMessage;
+    private readonly shareProfileAcrossGroups;
+    private readonly provider;
+    private readonly rawConfig;
+    private readonly whatToRemember?;
+    constructor(config: TelegramMemoryConfig, deps?: TelegramMemoryDependencies);
+    rememberTelegramMessage(message: string, actor: TelegramActor): Promise<TelegramRememberResult>;
+    remember(message: string, actor: TelegramActor): Promise<TelegramRememberResult>;
+    recall(query: string, options: TelegramRecallOptions): Promise<TelegramRecallResult[]>;
+    buildPromptContext(query: string, options: TelegramPromptContextOptions): Promise<BuildContextResult>;
+    context(query: string, options: TelegramPromptContextOptions): Promise<BuildContextResult>;
+    getUserMemoryStats(userId: string, groupId: string): Promise<{
+        profileFacts: number;
+        dailyFacts: number;
+        totalFacts: number;
+        lastUpdatedAt?: string;
+    }>;
+    getMemory(memoryId: string): Promise<StoredMemoryFact | null>;
+    updateMemory(memoryId: string, updates: Partial<Pick<StoredMemoryFact, 'content' | 'summary' | 'importance' | 'tags'>>): Promise<StoredMemoryFact | null>;
+    deleteMemory(memoryId: string): Promise<boolean>;
+    getMemoryHistory(memoryId: string): Promise<StoredMemoryFact[]>;
+    checkHealth(): Promise<TelegramMemoryHealthReport>;
+    preflight(): Promise<TelegramMemoryPreflightReport>;
+    private extractFacts;
+    private mergeProfileFacts;
+    private toStoredFact;
+    private searchIndexedFacts;
+    private collectFactsForUser;
+    private ensureLocalIndex;
+    private rebuildLocalIndex;
+    private embedQuery;
+    private embedTexts;
+    private refreshLocalIndexSafely;
+    private collectProfileFacts;
+    private readWritableProfile;
+    private writeWritableProfile;
+    private readProfileForFact;
+    private writeProfileForFact;
+    private isSharedProfilePath;
+    private profileMarkdownPathForActor;
+}
+export declare function createTelegramMemory(config: TelegramMemoryConfig, dependencies?: TelegramMemoryDependencies): Promise<TelegramMemory>;
+export declare function validateTelegramMemoryConfig(config: TelegramMemoryConfig): TelegramMemoryConfigValidationIssue[];
+export declare function assertValidTelegramMemoryConfig(config: TelegramMemoryConfig): void;
+export declare function telegramMemoryConfigFromEnv(options?: TelegramMemoryFromEnvOptions): TelegramMemoryConfig;
+export declare function createTelegramMemoryFromEnv(options?: TelegramMemoryFromEnvOptions, dependencies?: TelegramMemoryDependencies): Promise<TelegramMemory>;