verybot 0.1.3

package/dist/brain/agent-registry.d.ts

@@ -0,0 +1,75 @@
+import type { LanguageModel, ToolSet } from "ai";
+import type { AgentConfig, TeamConfig } from "../config/agent-config.js";
+import type { Config } from "../config.js";
+import type { MemoryStore } from "../memory/store.js";
+import type { EmbeddingProvider } from "../memory/embedding.js";
+import type { ModelDef } from "../config/model-catalog.js";
+export interface WorkerDeps {
+    memoryStore: MemoryStore | null;
+    embeddingProvider: EmbeddingProvider | null;
+    baseTools: ToolSet;
+    config: Config;
+}
+export interface ResolvedAgent {
+    agentConfig: AgentConfig;
+    model: LanguageModel;
+    modelDef: ModelDef;
+    tools: ToolSet;
+}
+/**
+ * Holds agent configs for a single team.
+ * The first config is the orchestrator, rest are workers.
+ * `canDelegate` is auto-derived from team membership.
+ */
+export declare class AgentRegistry {
+    private deps;
+    private orchestratorConfig;
+    /** Workers keyed by name (human-readable, unique within team). */
+    private workersByName;
+    private workerNames;
+    constructor(orchestrator: AgentConfig, workers: AgentConfig[], deps: WorkerDeps);
+    getOrchestrator(): AgentConfig;
+    /** Resolve the orchestrator into a model + def, ready for per-session override. */
+    resolveOrchestrator(): ResolvedAgent;
+    getWorker(name: string): AgentConfig | undefined;
+    /** Return the list of worker names that the orchestrator can delegate to. */
+    delegatableWorkers(): string[];
+    /** Build an id→name map for all agents (orchestrator + workers). */
+    buildIdToNameMap(): Map<string, string>;
+    /** Resolve a worker by name into a model + filtered tool set, ready for runLoop(). */
+    resolveWorker(name: string): ResolvedAgent | null;
+}
+/** Info returned by TeamRegistry.listTeams() for UI display. */
+export interface TeamInfo {
+    id: string;
+    name: string;
+    color: string;
+    orchestratorId: string;
+    orchestratorIdentity: string;
+    orchestratorModel: string;
+    workerCount: number;
+}
+/**
+ * Wraps per-team AgentRegistry instances.
+ * Provides team resolution and isolation boundaries.
+ */
+export declare class TeamRegistry {
+    private teams;
+    constructor(teams: TeamConfig[], deps: WorkerDeps);
+    /** Find which team owns an orchestrator ID. */
+    resolveTeam(orchestratorId: string): {
+        teamId: string;
+        registry: AgentRegistry;
+    } | null;
+    /** Get registry for a specific team by teamId. */
+    getTeamRegistry(teamId: string): AgentRegistry | null;
+    /** All teams for UI picker. */
+    listTeams(): TeamInfo[];
+    /** True if any team has workers. */
+    hasWorkers(): boolean;
+}
+/** Parse "provider:modelId" string. */
+export declare function parseModel(raw: string): {
+    provider: string;
+    modelId: string;
+};

package/dist/brain/agent-registry.js

@@ -0,0 +1,124 @@
+import { getModel } from "./providers.js";
+import { resolveModelDef } from "../config/model-catalog.js";
+/**
+ * Holds agent configs for a single team.
+ * The first config is the orchestrator, rest are workers.
+ * `canDelegate` is auto-derived from team membership.
+ */
+export class AgentRegistry {
+    deps;
+    orchestratorConfig;
+    /** Workers keyed by name (human-readable, unique within team). */
+    workersByName;
+    workerNames;
+    constructor(orchestrator, workers, deps) {
+        this.deps = deps;
+        this.orchestratorConfig = orchestrator;
+        this.workersByName = new Map(workers.map((w) => [w.name, w]));
+        this.workerNames = workers.map((w) => w.name);
+    }
+    getOrchestrator() {
+        return this.orchestratorConfig;
+    }
+    /** Resolve the orchestrator into a model + def, ready for per-session override. */
+    resolveOrchestrator() {
+        const cfg = this.orchestratorConfig;
+        const { provider, modelId } = parseModel(cfg.model);
+        const model = getModel(provider, modelId);
+        const modelDef = resolveModelDef(modelId, cfg.contextWindow);
+        const tools = filterTools(this.deps.baseTools, cfg.tools);
+        return { agentConfig: cfg, model, modelDef, tools };
+    }
+    getWorker(name) {
+        return this.workersByName.get(name);
+    }
+    /** Return the list of worker names that the orchestrator can delegate to. */
+    delegatableWorkers() {
+        return this.workerNames;
+    }
+    /** Build an id→name map for all agents (orchestrator + workers). */
+    buildIdToNameMap() {
+        const map = new Map();
+        map.set(this.orchestratorConfig.id, this.orchestratorConfig.name);
+        for (const w of this.workersByName.values()) {
+            map.set(w.id, w.name);
+        }
+        return map;
+    }
+    /** Resolve a worker by name into a model + filtered tool set, ready for runLoop(). */
+    resolveWorker(name) {
+        const cfg = this.workersByName.get(name);
+        if (!cfg)
+            return null;
+        const { provider, modelId } = parseModel(cfg.model);
+        const model = getModel(provider, modelId);
+        const modelDef = resolveModelDef(modelId, cfg.contextWindow);
+        const tools = filterTools(this.deps.baseTools, cfg.tools);
+        return { agentConfig: cfg, model, modelDef, tools };
+    }
+}
+/**
+ * Wraps per-team AgentRegistry instances.
+ * Provides team resolution and isolation boundaries.
+ */
+export class TeamRegistry {
+    teams;
+    constructor(teams, deps) {
+        this.teams = new Map(teams.map((t) => [
+            t.id,
+            {
+                config: t,
+                registry: new AgentRegistry(t.orchestrator, t.workers, deps),
+            },
+        ]));
+    }
+    /** Find which team owns an orchestrator ID. */
+    resolveTeam(orchestratorId) {
+        for (const [teamId, { config, registry }] of this.teams) {
+            if (config.orchestrator.id === orchestratorId) {
+                return { teamId, registry };
+            }
+        }
+        return null;
+    }
+    /** Get registry for a specific team by teamId. */
+    getTeamRegistry(teamId) {
+        return this.teams.get(teamId)?.registry ?? null;
+    }
+    /** All teams for UI picker. */
+    listTeams() {
+        return [...this.teams.values()].map(({ config }) => ({
+            id: config.id,
+            name: config.name ?? config.id,
+            color: config.color ?? "",
+            orchestratorId: config.orchestrator.id,
+            orchestratorIdentity: config.orchestrator.identity,
+            orchestratorModel: parseModel(config.orchestrator.model).modelId,
+            workerCount: config.workers.length,
+        }));
+    }
+    /** True if any team has workers. */
+    hasWorkers() {
+        for (const { config } of this.teams.values()) {
+            if (config.workers.length > 0)
+                return true;
+        }
+        return false;
+    }
+}
+/** Parse "provider:modelId" string. */
+export function parseModel(raw) {
+    const [provider, ...rest] = raw.split(":");
+    return { provider, modelId: rest.join(":") };
+}
+/** Return only the tools whose names are in the allowlist, or all if allowlist is empty. */
+function filterTools(base, allowlist) {
+    if (allowlist.length === 0)
+        return { ...base };
+    const filtered = {};
+    for (const name of allowlist) {
+        if (name in base)
+            filtered[name] = base[name];
+    }
+    return filtered;
+}

package/dist/brain/agent.d.ts

@@ -0,0 +1,146 @@
+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 { DesktopAdapter } from "../computer/desktop/adapter.js";
+import type { 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";
+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;
+    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 teamRegistry;
+    private delegationStore;
+    private channelStore;
+    private teamStore;
+    private channelManager;
+    private connectedChannels;
+    private lastConfigMtime;
+    private teamRegistryDirty;
+    private newSessionPending;
+    private unsubTeamChange;
+    private memoryExtractor;
+    private workerCoordinator;
+    /** 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): 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>;
+    /**
+     * 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;
+    /** Enrich session index entry with team/agent name metadata for UI display. */
+    private enrichSessionMetadata;
+    private main;
+}