teleton 0.8.4 → 0.8.6

package/dist/index.d.ts

@@ -0,0 +1,923 @@
+import { z } from 'zod';
+import { Api } from 'telegram';
+import { Tool as Tool$1, ToolCall } from '@mariozechner/pi-ai';
+import { TSchema } from '@sinclair/typebox';
+import Database from 'better-sqlite3';
+import { HookName, HookHandlerMap } from '@teleton-agent/sdk';
+import { EventEmitter } from 'node:events';
+
+interface CompactionConfig {
+    enabled: boolean;
+    maxMessages?: number;
+    maxTokens?: number;
+    keepRecentMessages?: number;
+    memoryFlushEnabled?: boolean;
+    softThresholdTokens?: number;
+}
+
+declare const ConfigSchema: z.ZodObject<{
+    meta: z.ZodDefault<z.ZodObject<{
+        version: z.ZodDefault<z.ZodString>;
+        created_at: z.ZodOptional<z.ZodString>;
+        last_modified_at: z.ZodOptional<z.ZodString>;
+        onboard_command: z.ZodDefault<z.ZodString>;
+    }, z.core.$strip>>;
+    agent: z.ZodObject<{
+        provider: z.ZodDefault<z.ZodEnum<{
+            anthropic: "anthropic";
+            "claude-code": "claude-code";
+            openai: "openai";
+            google: "google";
+            xai: "xai";
+            groq: "groq";
+            openrouter: "openrouter";
+            moonshot: "moonshot";
+            mistral: "mistral";
+            cerebras: "cerebras";
+            zai: "zai";
+            minimax: "minimax";
+            huggingface: "huggingface";
+            cocoon: "cocoon";
+            local: "local";
+        }>>;
+        api_key: z.ZodDefault<z.ZodString>;
+        base_url: z.ZodOptional<z.ZodString>;
+        model: z.ZodDefault<z.ZodString>;
+        utility_model: z.ZodOptional<z.ZodString>;
+        max_tokens: z.ZodDefault<z.ZodNumber>;
+        temperature: z.ZodDefault<z.ZodNumber>;
+        system_prompt: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+        max_agentic_iterations: z.ZodDefault<z.ZodNumber>;
+        toolset: z.ZodDefault<z.ZodString>;
+        session_reset_policy: z.ZodDefault<z.ZodObject<{
+            daily_reset_enabled: z.ZodDefault<z.ZodBoolean>;
+            daily_reset_hour: z.ZodDefault<z.ZodNumber>;
+            idle_expiry_enabled: z.ZodDefault<z.ZodBoolean>;
+            idle_expiry_minutes: z.ZodDefault<z.ZodNumber>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>;
+    telegram: z.ZodObject<{
+        mode: z.ZodDefault<z.ZodEnum<{
+            user: "user";
+            bot: "bot";
+        }>>;
+        api_id: z.ZodOptional<z.ZodNumber>;
+        api_hash: z.ZodOptional<z.ZodString>;
+        phone: z.ZodOptional<z.ZodString>;
+        session_name: z.ZodDefault<z.ZodString>;
+        session_path: z.ZodDefault<z.ZodString>;
+        dm_policy: z.ZodDefault<z.ZodEnum<{
+            allowlist: "allowlist";
+            open: "open";
+            "admin-only": "admin-only";
+            disabled: "disabled";
+        }>>;
+        allow_from: z.ZodDefault<z.ZodArray<z.ZodNumber>>;
+        group_policy: z.ZodDefault<z.ZodEnum<{
+            allowlist: "allowlist";
+            open: "open";
+            "admin-only": "admin-only";
+            disabled: "disabled";
+        }>>;
+        group_allow_from: z.ZodDefault<z.ZodArray<z.ZodNumber>>;
+        require_mention: z.ZodDefault<z.ZodBoolean>;
+        max_message_length: z.ZodDefault<z.ZodNumber>;
+        typing_simulation: z.ZodDefault<z.ZodBoolean>;
+        rate_limit_messages_per_second: z.ZodDefault<z.ZodNumber>;
+        rate_limit_groups_per_minute: z.ZodDefault<z.ZodNumber>;
+        admin_ids: z.ZodDefault<z.ZodArray<z.ZodNumber>>;
+        agent_channel: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+        owner_name: z.ZodOptional<z.ZodString>;
+        owner_username: z.ZodOptional<z.ZodString>;
+        owner_id: z.ZodOptional<z.ZodNumber>;
+        debounce_ms: z.ZodDefault<z.ZodNumber>;
+        bot_token: z.ZodOptional<z.ZodString>;
+        bot_username: z.ZodOptional<z.ZodString>;
+        stream_mode: z.ZodDefault<z.ZodEnum<{
+            all: "all";
+            replace: "replace";
+            off: "off";
+        }>>;
+    }, z.core.$strip>;
+    storage: z.ZodDefault<z.ZodObject<{
+        sessions_file: z.ZodDefault<z.ZodString>;
+        memory_file: z.ZodDefault<z.ZodString>;
+        history_limit: z.ZodDefault<z.ZodNumber>;
+    }, z.core.$strip>>;
+    embedding: z.ZodDefault<z.ZodObject<{
+        provider: z.ZodDefault<z.ZodEnum<{
+            anthropic: "anthropic";
+            local: "local";
+            none: "none";
+        }>>;
+        model: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+    deals: z.ZodDefault<z.ZodObject<{
+        enabled: z.ZodDefault<z.ZodBoolean>;
+        expiry_seconds: z.ZodDefault<z.ZodNumber>;
+        buy_max_floor_percent: z.ZodDefault<z.ZodNumber>;
+        sell_min_floor_percent: z.ZodDefault<z.ZodNumber>;
+        poll_interval_ms: z.ZodDefault<z.ZodNumber>;
+        max_verification_retries: z.ZodDefault<z.ZodNumber>;
+        expiry_check_interval_ms: z.ZodDefault<z.ZodNumber>;
+    }, z.core.$strip>>;
+    webui: z.ZodDefault<z.ZodObject<{
+        enabled: z.ZodDefault<z.ZodBoolean>;
+        port: z.ZodDefault<z.ZodNumber>;
+        host: z.ZodDefault<z.ZodString>;
+        auth_token: z.ZodOptional<z.ZodString>;
+        cors_origins: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        log_requests: z.ZodDefault<z.ZodBoolean>;
+    }, z.core.$strip>>;
+    logging: z.ZodDefault<z.ZodObject<{
+        level: z.ZodDefault<z.ZodEnum<{
+            fatal: "fatal";
+            error: "error";
+            warn: "warn";
+            info: "info";
+            debug: "debug";
+            trace: "trace";
+        }>>;
+        pretty: z.ZodDefault<z.ZodBoolean>;
+    }, z.core.$strip>>;
+    dev: z.ZodDefault<z.ZodObject<{
+        hot_reload: z.ZodDefault<z.ZodBoolean>;
+    }, z.core.$strip>>;
+    tool_rag: z.ZodDefault<z.ZodObject<{
+        enabled: z.ZodDefault<z.ZodBoolean>;
+        top_k: z.ZodDefault<z.ZodNumber>;
+        always_include: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        skip_unlimited_providers: z.ZodDefault<z.ZodBoolean>;
+    }, z.core.$strip>>;
+    capabilities: z.ZodDefault<z.ZodObject<{
+        exec: z.ZodDefault<z.ZodObject<{
+            mode: z.ZodDefault<z.ZodEnum<{
+                off: "off";
+                yolo: "yolo";
+            }>>;
+            scope: z.ZodDefault<z.ZodEnum<{
+                allowlist: "allowlist";
+                "admin-only": "admin-only";
+                all: "all";
+            }>>;
+            allowlist: z.ZodDefault<z.ZodArray<z.ZodNumber>>;
+            limits: z.ZodDefault<z.ZodObject<{
+                timeout: z.ZodDefault<z.ZodNumber>;
+                max_output: z.ZodDefault<z.ZodNumber>;
+            }, z.core.$strip>>;
+            audit: z.ZodDefault<z.ZodObject<{
+                log_commands: z.ZodDefault<z.ZodBoolean>;
+            }, z.core.$strip>>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
+    api: z.ZodOptional<z.ZodDefault<z.ZodObject<{
+        enabled: z.ZodDefault<z.ZodBoolean>;
+        port: z.ZodDefault<z.ZodNumber>;
+        key_hash: z.ZodDefault<z.ZodString>;
+        allowed_ips: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    }, z.core.$strip>>>;
+    ton_proxy: z.ZodDefault<z.ZodObject<{
+        enabled: z.ZodDefault<z.ZodBoolean>;
+        port: z.ZodDefault<z.ZodNumber>;
+        binary_path: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+    heartbeat: z.ZodDefault<z.ZodObject<{
+        enabled: z.ZodDefault<z.ZodBoolean>;
+        interval_ms: z.ZodDefault<z.ZodNumber>;
+        prompt: z.ZodDefault<z.ZodString>;
+        self_configurable: z.ZodDefault<z.ZodBoolean>;
+    }, z.core.$strip>>;
+    mcp: z.ZodDefault<z.ZodObject<{
+        servers: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodObject<{
+            command: z.ZodOptional<z.ZodString>;
+            args: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            env: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+            url: z.ZodOptional<z.ZodString>;
+            scope: z.ZodDefault<z.ZodEnum<{
+                allowlist: "allowlist";
+                open: "open";
+                "admin-only": "admin-only";
+                disabled: "disabled";
+                always: "always";
+                "dm-only": "dm-only";
+                "group-only": "group-only";
+            }>>;
+            enabled: z.ZodDefault<z.ZodBoolean>;
+        }, z.core.$strip>>>;
+    }, z.core.$strip>>;
+    plugins: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    cocoon: z.ZodOptional<z.ZodObject<{
+        port: z.ZodDefault<z.ZodNumber>;
+    }, z.core.$strip>>;
+    tonapi_key: z.ZodOptional<z.ZodString>;
+    toncenter_api_key: z.ZodOptional<z.ZodString>;
+    tavily_api_key: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+type Config = z.infer<typeof ConfigSchema>;
+
+interface TelegramMessage$1 {
+    id: number;
+    chatId: string;
+    senderId: number;
+    senderUsername?: string;
+    senderFirstName?: string;
+    senderRank?: string;
+    text: string;
+    isGroup: boolean;
+    isChannel: boolean;
+    isBot: boolean;
+    mentionsMe: boolean;
+    timestamp: Date;
+    _rawPeer?: Api.TypePeer;
+    hasMedia: boolean;
+    mediaType?: "photo" | "document" | "video" | "audio" | "voice" | "sticker";
+    replyToId?: number;
+    _rawMessage?: Api.Message;
+}
+interface InlineButton {
+    text: string;
+    callback_data: string;
+}
+interface SendMessageOptions {
+    chatId: string;
+    text: string;
+    replyToId?: number;
+    inlineKeyboard?: InlineButton[][];
+}
+interface SentMessage {
+    id: number;
+    date: number;
+    chatId: string;
+}
+interface EditMessageOptions {
+    chatId: string;
+    messageId: number;
+    text: string;
+    inlineKeyboard?: InlineButton[][];
+}
+interface ReplyContext {
+    text?: string;
+    senderName?: string;
+    isAgent?: boolean;
+}
+interface BotInfo {
+    id: number;
+    username?: string;
+    firstName: string;
+    isBot: boolean;
+}
+interface ChatInfo {
+    id: string;
+    title?: string;
+    type: "private" | "group" | "supergroup" | "channel";
+    memberCount?: number;
+    description?: string;
+    username?: string;
+}
+interface ITelegramBridge {
+    connect(): Promise<void>;
+    disconnect(): Promise<void>;
+    isAvailable(): boolean;
+    getMode(): "user" | "bot";
+    getOwnUserId(): bigint | undefined;
+    getUsername(): string | undefined;
+    getMe(): Promise<BotInfo | undefined>;
+    getMessages(chatId: string, limit: number): Promise<TelegramMessage$1[]>;
+    sendMessage(options: SendMessageOptions): Promise<SentMessage>;
+    editMessage(options: EditMessageOptions): Promise<SentMessage>;
+    deleteMessage(chatId: string, messageId: number): Promise<boolean>;
+    forwardMessage(fromChatId: string, toChatId: string, messageId: number): Promise<SentMessage>;
+    sendPhoto(chatId: string, photo: string | Buffer, caption?: string, replyToId?: number): Promise<SentMessage>;
+    setTyping(chatId: string): Promise<void>;
+    sendReaction(chatId: string, messageId: number, emoji: string): Promise<void>;
+    pinMessage(chatId: string, messageId: number): Promise<boolean>;
+    sendDice(chatId: string, emoji?: string): Promise<SentMessage>;
+    getChatInfo(chatId: string): Promise<ChatInfo>;
+    /** Stream a response token by token via message drafts (bot mode). Returns final sent message. */
+    streamResponse?(chatId: string, textStream: AsyncIterable<string>): Promise<SentMessage>;
+    onNewMessage(handler: (msg: TelegramMessage$1) => void | Promise<void>, filters?: {
+        incoming?: boolean;
+        outgoing?: boolean;
+        chats?: string[];
+    }): void;
+    fetchReplyContext(rawMsg: unknown): Promise<ReplyContext | null>;
+    getPeer(chatId: string): unknown | undefined;
+    getRawClient(): unknown;
+}
+
+interface EmbeddingProvider {
+    id: string;
+    model: string;
+    dimensions: number;
+    embedQuery(text: string): Promise<number[]>;
+    embedBatch(texts: string[]): Promise<number[][]>;
+    /** Optional startup warmup — pre-load model, validate credentials, etc. */
+    warmup?(): Promise<boolean>;
+}
+interface EmbeddingProviderConfig {
+    provider: "anthropic" | "local" | "none";
+    model?: string;
+    apiKey?: string;
+    dimensions?: number;
+}
+
+/**
+ * Context provided to tool executors
+ */
+interface ToolContext {
+    /** Telegram bridge for sending messages, reactions, etc. */
+    bridge: ITelegramBridge;
+    /** Database instance for storage */
+    db: Database.Database;
+    /** Current chat ID where the tool is being executed */
+    chatId: string;
+    /** Current user/sender ID */
+    senderId: number;
+    /** Whether this is a group chat */
+    isGroup: boolean;
+    /** Full config for accessing API key, model, etc. (optional) */
+    config?: Config;
+}
+/**
+ * Result returned by a tool execution
+ */
+interface ToolResult {
+    /** Whether the execution was successful */
+    success: boolean;
+    /** Result data (will be serialized to JSON for the LLM) */
+    data?: unknown;
+    /** Error message if failed */
+    error?: string;
+}
+/**
+ * Tool category for masking behavior
+ */
+type ToolCategory = "data-bearing" | "action";
+/**
+ * Tool scope for context-based filtering.
+ * - "open": included in both DMs and groups (default, canonical form)
+ * - "always": legacy alias for "open" (backward compat)
+ * - "dm-only": excluded from group chats (financial, private tools)
+ * - "group-only": excluded from DMs (moderation tools)
+ * - "admin-only": restricted to admin users only
+ * - "allowlist": restricted to allow_from user IDs (admins bypass)
+ * - "disabled": tool completely hidden from all contexts
+ */
+type ToolScope = "open" | "always" | "dm-only" | "group-only" | "admin-only" | "allowlist" | "disabled";
+/**
+ * Tool definition compatible with pi-ai
+ */
+interface Tool<TParameters extends TSchema = TSchema> {
+    /** Unique tool name (e.g., "telegram_send_message") */
+    name: string;
+    /** Human-readable description for the LLM */
+    description: string;
+    /** TypeBox schema for parameter validation */
+    parameters: TParameters;
+    /** Tool category (affects masking behavior) */
+    category?: ToolCategory;
+}
+/**
+ * Tool executor function
+ */
+type ToolExecutor<TParams = unknown> = (params: TParams, context: ToolContext) => Promise<ToolResult>;
+
+type ModuleLevel = "open" | "admin" | "disabled";
+/**
+ * Per-group module permission manager.
+ * Only non-default overrides (level !== "open") are stored in DB.
+ */
+declare class ModulePermissions {
+    private db;
+    private cache;
+    constructor(db: Database.Database);
+    private ensureTable;
+    private loadAll;
+    getLevel(chatId: string, module: string): ModuleLevel;
+    setLevel(chatId: string, module: string, level: ModuleLevel, userId?: number): void;
+    resetModule(chatId: string, module: string): void;
+    resetAll(chatId: string): void;
+    getOverrides(chatId: string): Map<string, ModuleLevel>;
+    isProtected(module: string): boolean;
+}
+
+interface ToolIndexConfig {
+    topK: number;
+    alwaysInclude: string[];
+    skipUnlimitedProviders: boolean;
+}
+interface ToolSearchResult {
+    name: string;
+    description: string;
+    score: number;
+    vectorScore?: number;
+    keywordScore?: number;
+}
+/**
+ * Semantic index for tool definitions.
+ * Uses the same hybrid search pattern (vector + FTS5) as the knowledge RAG.
+ */
+declare class ToolIndex {
+    private db;
+    private embedder;
+    private vectorEnabled;
+    private config;
+    private _isIndexed;
+    constructor(db: Database.Database, embedder: EmbeddingProvider, vectorEnabled: boolean, config: ToolIndexConfig);
+    get isIndexed(): boolean;
+    /**
+     * Create the vector table (dimensions are dynamic, so can't be in schema migration).
+     */
+    ensureSchema(): void;
+    /**
+     * Index all registered tools. Replaces any previous index.
+     */
+    indexAll(tools: Tool$1[]): Promise<number>;
+    /**
+     * Delta update for hot-reload plugins.
+     */
+    reindexTools(removed: string[], added: Tool$1[]): Promise<void>;
+    /**
+     * Hybrid search: vector + FTS5, same pattern as HybridSearch.
+     */
+    search(query: string, queryEmbedding: number[], limit?: number): Promise<ToolSearchResult[]>;
+    /**
+     * Check if a tool name matches any always-include pattern.
+     */
+    isAlwaysIncluded(toolName: string): boolean;
+    private vectorSearch;
+    private keywordSearch;
+    private mergeResults;
+}
+
+declare class ToolRegistry {
+    private tools;
+    private scopes;
+    private toolModules;
+    private permissions;
+    private toolArrayCache;
+    private toolConfigs;
+    private db;
+    private pluginToolNames;
+    private toolIndex;
+    private onToolsChangedCallbacks;
+    private mode;
+    private requiredModes;
+    private toolTags;
+    private activeToolset;
+    private allowFrom;
+    private static readonly TOOLSET_PROFILES;
+    constructor(mode?: "user" | "bot");
+    register<TParams = unknown>(tool: Tool, executor: ToolExecutor<TParams>, scope?: ToolScope, requiredMode?: "user" | "bot", tags?: string[]): void;
+    setPermissions(mp: ModulePermissions): void;
+    setMode(mode: "user" | "bot"): void;
+    setActiveToolset(name: string | null): void;
+    setAllowFrom(ids: number[]): void;
+    getActiveToolset(): string | null;
+    getAvailableToolsets(): string[];
+    getAvailableModules(): string[];
+    getModuleToolCount(module: string): number;
+    getModuleTools(module: string): Array<{
+        name: string;
+        scope: ToolScope;
+    }>;
+    getAll(): Tool$1[];
+    execute(toolCall: ToolCall, context: ToolContext): Promise<ToolResult>;
+    getForProvider(toolLimit: number | null): Tool$1[];
+    getForContext(isGroup: boolean, toolLimit: number | null, chatId?: string, isAdmin?: boolean, senderId?: number): Tool$1[];
+    isPluginModule(moduleName: string): boolean;
+    has(name: string): boolean;
+    get count(): number;
+    getToolCategory(name: string): "data-bearing" | "action" | undefined;
+    /**
+     * Load tool configurations from database and seed missing ones
+     */
+    loadConfigFromDB(db: Database.Database): void;
+    /**
+     * Get effective scope for a tool (config override or default)
+     */
+    private getEffectiveScope;
+    /**
+     * Check if a tool is enabled
+     */
+    isToolEnabled(toolName: string): boolean;
+    /**
+     * Update tool enabled status
+     */
+    setToolEnabled(toolName: string, enabled: boolean, updatedBy?: number): boolean;
+    /**
+     * Update tool scope
+     */
+    updateToolScope(toolName: string, scope: ToolScope, updatedBy?: number): boolean;
+    /**
+     * Get tool configuration
+     */
+    getToolConfig(toolName: string): {
+        enabled: boolean;
+        scope: ToolScope;
+    } | null;
+    /**
+     * Register all tools belonging to a plugin (tracks ownership for hot-reload).
+     */
+    registerPluginTools(pluginName: string, tools: Array<{
+        tool: Tool;
+        executor: ToolExecutor;
+        scope?: ToolScope;
+    }>): number;
+    /**
+     * Replace all tools belonging to a plugin with new ones (hot-reload).
+     * Atomically removes old tools then registers new ones.
+     */
+    replacePluginTools(pluginName: string, newTools: Array<{
+        tool: Tool;
+        executor: ToolExecutor;
+        scope?: ToolScope;
+    }>): void;
+    /**
+     * Remove all tools belonging to a plugin.
+     */
+    removePluginTools(pluginName: string): void;
+    setToolIndex(index: ToolIndex): void;
+    getToolIndex(): ToolIndex | null;
+    onToolsChanged(callback: (removed: string[], added: Tool$1[]) => void): void;
+    private notifyToolsChanged;
+    /**
+     * Select tools using semantic RAG search on the user message.
+     * Falls back to getForContext() if search returns nothing.
+     */
+    getForContextWithRAG(query: string, queryEmbedding: number[], isGroup: boolean, toolLimit: number | null, chatId?: string, isAdmin?: boolean, senderId?: number): Promise<Tool$1[]>;
+    private applyLimit;
+}
+
+/**
+ * Hook registration entry.
+ *
+ * Priority ranges (convention):
+ *   -100 to -1  : Security gates, auth checks, spam filters
+ *       0       : Default — standard plugin logic
+ *    1 to 49    : Post-processing, enrichment
+ *   50 to 99    : Audit, logging, observability
+ *   100+        : Reserved — always-last guarantees
+ */
+interface HookRegistration<K extends HookName = HookName> {
+    pluginId: string;
+    hookName: K;
+    handler: HookHandlerMap[K];
+    priority: number;
+    /** Plugin-level priority offset (from plugin_config DB table). Default 0. */
+    globalPriority: number;
+}
+interface HookRunnerOptions {
+    logger: {
+        warn: (...args: unknown[]) => void;
+        error: (...args: unknown[]) => void;
+        debug: (...args: unknown[]) => void;
+    };
+    timeoutMs?: number;
+    catchErrors?: boolean;
+}
+
+declare class HookRegistry {
+    private hooks;
+    private hookMap;
+    private rebuildMap;
+    register<K extends HookName>(reg: Omit<HookRegistration<K>, "globalPriority"> & {
+        globalPriority?: number;
+    }): boolean;
+    getHooks<K extends HookName>(name: K): HookRegistration<K>[];
+    hasHooks(name: HookName): boolean;
+    hasAnyHooks(): boolean;
+    unregister(pluginId: string): number;
+    clear(): void;
+}
+
+declare function createHookRunner(registry: HookRegistry, opts: HookRunnerOptions): {
+    runModifyingHook: <K extends HookName>(name: K, event: Parameters<HookHandlerMap[K]>[0]) => Promise<void>;
+    runObservingHook: <K extends HookName>(name: K, event: Parameters<HookHandlerMap[K]>[0]) => Promise<void>;
+    readonly depth: number;
+};
+
+/**
+ * UserHookEvaluator — keyword blocklist + context injection triggers.
+ * Hot-reloadable: call reload() after DB changes, no restart needed.
+ */
+
+interface UserHookResult {
+    blocked: boolean;
+    blockMessage?: string;
+    additionalContext: string;
+}
+declare class UserHookEvaluator {
+    private db;
+    private blocklistEnabled;
+    private singleKeywords;
+    private multiKeywords;
+    private blockMessage;
+    private triggers;
+    constructor(db: Database.Database);
+    /** Reload config from DB — called on startup and after WebUI changes */
+    reload(): void;
+    /** Evaluate a message — returns { blocked, blockMessage, additionalContext } */
+    evaluate(text: string): UserHookResult;
+}
+
+interface ProcessMessageOptions {
+    chatId: string;
+    userMessage: string;
+    userName?: string;
+    timestamp?: number;
+    isGroup?: boolean;
+    pendingContext?: string | null;
+    toolContext?: Omit<ToolContext, "chatId" | "isGroup">;
+    senderUsername?: string;
+    senderRank?: string;
+    hasMedia?: boolean;
+    mediaType?: string;
+    messageId?: number;
+    replyContext?: {
+        senderName?: string;
+        text: string;
+        isAgent?: boolean;
+    };
+    isHeartbeat?: boolean;
+    streamToChat?: {
+        chatId: string;
+        bridge: ITelegramBridge;
+        mode: "all" | "replace" | "off";
+    };
+}
+interface AgentResponse {
+    content: string;
+    toolCalls?: Array<{
+        name: string;
+        input: Record<string, unknown>;
+    }>;
+    streamed?: boolean;
+}
+declare class AgentRuntime {
+    private config;
+    private soul;
+    private compactionManager;
+    private contextBuilder;
+    private toolRegistry;
+    private embedder;
+    private hookRunner?;
+    private userHookEvaluator?;
+    constructor(config: Config, soul?: string, toolRegistry?: ToolRegistry);
+    setHookRunner(runner: ReturnType<typeof createHookRunner>): void;
+    setUserHookEvaluator(evaluator: UserHookEvaluator): void;
+    initializeContextBuilder(embedder: EmbeddingProvider, vectorEnabled: boolean): void;
+    getToolRegistry(): ToolRegistry | null;
+    processMessage(opts: ProcessMessageOptions): Promise<AgentResponse>;
+    clearHistory(chatId: string): void;
+    getConfig(): Config;
+    getActiveChatIds(): string[];
+    setSoul(soul: string): void;
+    configureCompaction(config: {
+        enabled?: boolean;
+        maxMessages?: number;
+        maxTokens?: number;
+    }): void;
+    getCompactionConfig(): CompactionConfig;
+    private _memoryStatsCache;
+    getMemoryStats(): {
+        totalMessages: number;
+        totalChats: number;
+        knowledgeChunks: number;
+    };
+}
+
+declare function createEmbeddingProvider(config: EmbeddingProviderConfig): EmbeddingProvider;
+
+declare class KnowledgeIndexer {
+    private db;
+    private workspaceDir;
+    private embedder;
+    private vectorEnabled;
+    constructor(db: Database.Database, workspaceDir: string, embedder: EmbeddingProvider, vectorEnabled: boolean);
+    getEmbedder(): EmbeddingProvider;
+    indexAll(options?: {
+        force?: boolean;
+    }): Promise<{
+        indexed: number;
+        skipped: number;
+    }>;
+    indexFile(absPath: string, force?: boolean): Promise<boolean>;
+    pruneOrphans(): Promise<{
+        markedInactive: number;
+        deleted: number;
+    }>;
+    private listMemoryFiles;
+    private getMemoryType;
+    /**
+     * Chunk markdown content with structure awareness.
+     * Respects heading boundaries, code blocks, and list groups.
+     * Target: KNOWLEDGE_CHUNK_SIZE chars, hard max: 2x target.
+     */
+    private chunkMarkdown;
+}
+
+interface TelegramMessage {
+    id: string;
+    chatId: string;
+    senderId: string | null;
+    text: string | null;
+    replyToId?: string;
+    isFromAgent: boolean;
+    hasMedia: boolean;
+    mediaType?: string;
+    timestamp: number;
+}
+declare class MessageStore {
+    private db;
+    private embedder;
+    private vectorEnabled;
+    constructor(db: Database.Database, embedder: EmbeddingProvider, vectorEnabled: boolean);
+    private ensureChat;
+    private ensureUser;
+    storeMessage(message: TelegramMessage): Promise<void>;
+    pruneOldMessages(maxAgeDays?: number): number;
+    getRecentMessages(chatId: string, limit?: number): TelegramMessage[];
+}
+
+interface ContextOptions {
+    query: string;
+    chatId: string;
+    includeAgentMemory?: boolean;
+    includeFeedHistory?: boolean;
+    searchAllChats?: boolean;
+    maxRecentMessages?: number;
+    maxRelevantChunks?: number;
+    maxTokens?: number;
+    queryEmbedding?: number[];
+}
+interface Context {
+    recentMessages: Array<{
+        role: string;
+        content: string;
+    }>;
+    relevantKnowledge: string[];
+    relevantFeed: string[];
+    estimatedTokens: number;
+}
+declare class ContextBuilder {
+    private db;
+    private embedder;
+    private hybridSearch;
+    private messageStore;
+    constructor(db: Database.Database, embedder: EmbeddingProvider, vectorEnabled: boolean);
+    buildContext(options: ContextOptions): Promise<Context>;
+}
+
+interface MemorySystem {
+    db: Database.Database;
+    embedder: ReturnType<typeof createEmbeddingProvider>;
+    knowledge: KnowledgeIndexer;
+    messages: MessageStore;
+    context: ContextBuilder;
+}
+
+type AgentState = "stopped" | "starting" | "running" | "stopping";
+declare class AgentLifecycle extends EventEmitter {
+    private state;
+    private error;
+    private startPromise;
+    private stopPromise;
+    private runningSince;
+    private registeredStartFn;
+    private registeredStopFn;
+    getState(): AgentState;
+    getError(): string | undefined;
+    getUptime(): number | null;
+    /**
+     * Register the start/stop callbacks so start()/stop() can be called without args.
+     */
+    registerCallbacks(startFn: () => Promise<void>, stopFn: () => Promise<void>): void;
+    /**
+     * Start the agent. Uses the provided callback or falls back to registered one.
+     * - No-op if already running
+     * - Returns existing promise if already starting
+     * - Throws if currently stopping
+     */
+    start(startFn?: () => Promise<void>): Promise<void>;
+    /**
+     * Stop the agent. Uses the provided callback or falls back to registered one.
+     * - No-op if already stopped
+     * - Returns existing promise if already stopping
+     * - If starting, waits for start to complete then stops
+     */
+    stop(stopFn?: () => Promise<void>): Promise<void>;
+    private transition;
+}
+
+declare class TeletonApp {
+    private config;
+    private agent;
+    private bridge;
+    private messageHandler;
+    private adminHandler;
+    private debouncer;
+    private toolCount;
+    private toolRegistry;
+    private modules;
+    private builtinModuleCount;
+    private memory;
+    private sdkDeps;
+    private webuiServer;
+    private apiServer;
+    private pluginWatcher;
+    private mcpConnections;
+    private callbackHandlerRegistered;
+    private messageHandlersRegistered;
+    private lifecycle;
+    private hookRunner?;
+    private userHookEvaluator;
+    private startTime;
+    private messagesProcessed;
+    private heartbeatRunner;
+    private scheduledTaskHandler;
+    private configPath;
+    private getMcpServerInfo;
+    private buildServerDeps;
+    constructor(configPath?: string);
+    /**
+     * Get the lifecycle state machine for WebUI integration
+     */
+    getLifecycle(): AgentLifecycle;
+    getAgent(): AgentRuntime;
+    getBridge(): ITelegramBridge;
+    getMemory(): MemorySystem;
+    getToolRegistry(): ToolRegistry;
+    getPlugins(): {
+        name: string;
+        version: string;
+    }[];
+    getWebuiConfig(): {
+        enabled: boolean;
+        port: number;
+        host: string;
+        cors_origins: string[];
+        log_requests: boolean;
+        auth_token?: string | undefined;
+    };
+    getConfigPath(): string;
+    /** Start agent subsystems without WebUI/API servers. For bootstrap mode. */
+    startAgentSubsystems(): Promise<void>;
+    /** Stop agent subsystems and close database. For bootstrap mode. */
+    stopAgentSubsystems(): Promise<void>;
+    /**
+     * Start the agent
+     */
+    start(): Promise<void>;
+    /**
+     * Start agent subsystems (Telegram, plugins, MCP, modules, debouncer, handler).
+     * Called by lifecycle.start() — do NOT call directly.
+     */
+    private startAgent;
+    /**
+     * Wire bot-mode SDK deps, callback handler, and Grammy polling.
+     */
+    private wireBotMode;
+    /**
+     * Wire user-mode SDK deps from DealBot and register service message handler.
+     */
+    private wireUserMode;
+    /**
+     * Register provider-specific models (Cocoon Network / local LLM).
+     */
+    private initializeProviders;
+    /**
+     * Start module background jobs with timeout. Skips deals module in bot mode.
+     */
+    private startModules;
+    /**
+     * Resolve owner name and username from Telegram API if not already configured.
+     * Persists resolved values to the config file so this only happens once.
+     */
+    private resolveOwnerInfo;
+    /**
+     * Handle a single message (extracted for debouncer callback)
+     */
+    private handleSingleMessage;
+    /**
+     * Collect plugin onMessage/onCallbackQuery hooks and register them.
+     * Uses dynamic dispatch over this.modules so newly installed/uninstalled
+     * plugins are picked up without re-registering handlers.
+     */
+    private wirePluginEventHooks;
+    /**
+     * Stop the agent
+     */
+    stop(): Promise<void>;
+    /**
+     * Stop agent subsystems (watcher, MCP, debouncer, handler, modules, bridge).
+     * Called by lifecycle.stop() — do NOT call directly.
+     */
+    private stopAgent;
+}
+/**
+ * Start the application
+ */
+declare function main(configPath?: string): Promise<void>;
+
+export { TeletonApp, main };