verybot 0.1.8

package/dist/brain/agent.d.ts

@@ -0,0 +1,167 @@
+import type { ToolSet } from "ai";
+import type { IncomingMessage, Channel } from "../channels/types.js";
+import type { Config } from "../config.js";
+import type { ConfigStore } from "../config/store.js";
+import type { MemoryStore } from "../memory/store.js";
+import type { EmbeddingProvider } from "../memory/embedding.js";
+import { Session } from "./session.js";
+import { SessionStore } from "./session-store.js";
+import type { DockerSandbox } from "../security/docker-sandbox.js";
+import type { SkillManager } from "../skills/loader.js";
+import { IntegrationRegistry } from "../integrations/registry.js";
+import type { ScheduleStore } from "../scheduler/store.js";
+import type { ConnectedChannelRegistry } from "../scheduler/connected-channels.js";
+import type { TaskStore } from "../tasks/store.js";
+import type { TeamStore } from "../teams/store.js";
+import type { PromptTemplateStore } from "../prompt-templates/store.js";
+import type { DesktopAdapter } from "../computer/desktop/adapter.js";
+import { BrowserManager } from "../computer/browser/manager.js";
+import { ChannelStore } from "./channel-store.js";
+import { DelegationStore } from "./delegation-store.js";
+import { type TeamInfo } from "./agent-registry.js";
+import { ChannelManager } from "../channels/manager.js";
+import { type SaveExplicitMemoryResult } from "../memory/explicit.js";
+import { type LearnSessionMemoriesResult } from "../memory/session-learning.js";
+export interface AgentDeps {
+    config: Config;
+    configStore: ConfigStore;
+    tools: ToolSet;
+    dataDir: string;
+    memoryStore?: MemoryStore | null;
+    embeddingProvider?: EmbeddingProvider | null;
+    sandbox?: DockerSandbox | null;
+    skillManager?: SkillManager;
+    integrationRegistry?: IntegrationRegistry;
+    scheduleStore?: ScheduleStore | null;
+    taskStore?: TaskStore | null;
+    desktopAdapter?: DesktopAdapter | null;
+    browserManager?: BrowserManager | null;
+    delegationStore?: DelegationStore | null;
+    channelStore?: ChannelStore | null;
+    teamStore?: TeamStore | null;
+    promptTemplateStore?: PromptTemplateStore | null;
+    channelManager?: ChannelManager | null;
+    connectedChannels?: ConnectedChannelRegistry | null;
+}
+export declare class Agent {
+    private sessions;
+    private sessionStore;
+    private queue;
+    private model;
+    private modelId;
+    private identity;
+    private language;
+    private tools;
+    private modelDef;
+    private memoryStore;
+    private embeddingProvider;
+    private memoryMaxResults;
+    private config;
+    private configStore;
+    private sandbox;
+    private skillManager;
+    private integrationRegistry;
+    private scheduleStore;
+    private taskStore;
+    private desktopAdapter;
+    private browserManager;
+    private sessionBrowserManagers;
+    private teamRegistry;
+    private delegationStore;
+    private channelStore;
+    private teamStore;
+    private promptTemplateStore;
+    private channelManager;
+    private connectedChannels;
+    private lastConfigMtime;
+    private teamRegistryDirty;
+    private newSessionPending;
+    private unsubTeamChange;
+    private memoryExtractor;
+    private workerCoordinator;
+    private taskSubscriber;
+    /** Cleanup functions for HTTP MCP servers (keyed by session key). */
+    private mcpCleanups;
+    constructor(deps: AgentDeps);
+    /** Force an immediate config reload + channel reconciliation. */
+    forceConfigReload(): Promise<void>;
+    getSession(key: string): Session | undefined;
+    getStore(): SessionStore;
+    /** Called from channels (Telegram, Discord, etc.) */
+    handleMessage(msg: IncomingMessage, channel: Channel, agentId?: string): Promise<void>;
+    /** Deliver reply as text or voice based on TTS reply mode. */
+    private deliverReply;
+    /** Called from gateway RPC (WebSocket UI) */
+    handleGatewayMessage(sessionKey: string, text: string, agentId?: string, images?: string[]): Promise<string>;
+    /** Validate and bind an agentId to an existing session state. */
+    private applyAgentBinding;
+    /** Return teams for the UI picker. Reads from TeamStore for immediate visibility. */
+    getTeams(): TeamInfo[];
+    /** Abort current run for a session. */
+    abortSession(sessionKey: string): boolean;
+    /** Clear conversation history (memories are preserved across clears). */
+    clearSession(sessionKey: string): Promise<void>;
+    /** Clear old sessions while keeping the newest N sessions (optionally within a team). */
+    clearOldSessions(keepLatest: number, teamId?: string): Promise<number>;
+    /** Save one explicit fact into long-term memory for a session. */
+    rememberMemory(sessionKey: string, fact: string): Promise<SaveExplicitMemoryResult>;
+    /** Save one explicit fact from a channel command (team-aware). */
+    rememberChannelMemory(channelType: string, channelId: string, fact: string, teamId?: string): Promise<SaveExplicitMemoryResult>;
+    /** Auto-learn facts from the current session, optionally filtered by topic. */
+    learnMemory(sessionKey: string, topic?: string): Promise<LearnSessionMemoriesResult>;
+    /** Auto-learn facts from channel session context. */
+    learnChannelMemory(channelType: string, channelId: string, topic?: string, teamId?: string): Promise<LearnSessionMemoriesResult>;
+    /**
+     * Run a scheduled task in a persistent scheduler session. Returns the raw LLM reply.
+     * Serialized through the message queue to avoid races with human messages.
+     * The caller (Scheduler) handles [SKIP] detection and channel delivery.
+     */
+    runScheduledTask(opts: {
+        prompt: string;
+        teamId: string;
+        integrations: string[];
+    }): Promise<string>;
+    /**
+     * Handle a human message sent to the scheduler session.
+     * Serialized via the message queue to avoid overlap with scheduled task executions.
+     */
+    handleSchedulerMessage(teamId: string, text: string, senderInfo?: string): Promise<string>;
+    /** Get the scheduler session for a team (for history display). */
+    getSchedulerSession(teamId: string): Session | undefined;
+    /** Start initial channels based on current config. Called once at boot. */
+    initChannels(): Promise<void>;
+    /** Clean up sandbox containers. */
+    cleanupSandbox(): void;
+    /** Extract remaining facts from all active sessions (call before shutdown). */
+    flushMemories(): Promise<void>;
+    private getOrCreateSession;
+    /** Build tools, adapt for MCP providers, and run the inference loop. */
+    private buildAdaptAndRun;
+    /** Build the RunToolsDeps from current agent state (agentRegistry filled per-call). */
+    private buildRunToolsDeps;
+    /** Return all tool names available in the current config (for UI discovery). */
+    getToolNames(): string[];
+    /** Run the loop with compaction retries on context overflow. */
+    private runLoopWithRetry;
+    /** (Re)build team registry from TeamStore (or skip if no store). */
+    private rebuildTeamRegistry;
+    /** Reload config from disk so API key / model changes take effect immediately. */
+    private reloadConfig;
+    /**
+     * Build channel specs from config and reconcile with ChannelManager.
+     * Handlers use dynamic orchestrator lookup (reads this.config at call time)
+     * so orchestrator-only changes don't require a channel restart.
+     */
+    private reconcileChannels;
+    /** Resolve a human-readable team label for logs/console (name preferred, falls back to ID). */
+    private teamLabel;
+    /** Build a human-readable session label for logs: replaces team UUID with team name. */
+    private sessionLabel;
+    private resolveLearningModel;
+    private buildPerSessionBrowserConfig;
+    private getRunBrowserManager;
+    private closeAllSessionBrowsers;
+    /** Enrich session index entry with team/agent name metadata for UI display. */
+    private enrichSessionMetadata;
+    private main;
+}