verybot 0.1.8

package/dist/brain/task-subscriber.js

@@ -0,0 +1,317 @@
+import { DEFAULT_TASK_STATUSES } from "../tasks/types.js";
+import { Session } from "./session.js";
+import { buildSystemPrompt } from "./context.js";
+import { runLoop } from "./loop.js";
+import { adaptTools } from "./mcp-adapter.js";
+import { getModel } from "./providers.js";
+import { parseModel } from "./agent-registry.js";
+import { createMemorySearchTool } from "../tools/memory.js";
+import { createTaskTools } from "../tools/tasks.js";
+import { resolveInlineAttachmentContent } from "../tasks/inline-attachment-content.js";
+import { BrowserManager } from "../computer/browser/manager.js";
+import { createBrowserTools, BROWSER_TOOL_NAMES } from "../computer/browser/tools.js";
+import { emit } from "../events.js";
+import { logger } from "../logger.js";
+import { buildUserMessageContent } from "./user-content.js";
+/** Poll interval for checking subscribed tasks. */
+const POLL_INTERVAL_MS = 5_000;
+/** Default max steps for subscription workers. */
+const DEFAULT_WORKER_MAX_STEPS = 20;
+/** Claims older than this are considered stale and released (30 minutes). */
+const STALE_CLAIM_TIMEOUT_MS = 30 * 60 * 1_000;
+/** Max candidates to consider per poll tick. */
+const CLAIMABLE_CANDIDATE_LIMIT = 20;
+/** Safety cap: max claims per single poll tick to prevent runaway. */
+const MAX_CLAIMS_PER_TICK = 50;
+/**
+ * Pull-based task execution: workers subscribe to task statuses
+ * and self-select tasks from the board. Runs a single poll timer
+ * and an efficient cross-table query per tick.
+ */
+export class TaskSubscriberManager {
+    deps;
+    timer = null;
+    /** agentId → Set<taskId> of currently running tasks */
+    activeRuns = new Map();
+    polling = false;
+    constructor(deps) {
+        this.deps = deps;
+    }
+    start() {
+        if (this.timer)
+            return;
+        this.poll();
+        this.timer = setInterval(() => this.poll(), POLL_INTERVAL_MS);
+    }
+    stop() {
+        if (this.timer) {
+            clearInterval(this.timer);
+            this.timer = null;
+        }
+    }
+    poll() {
+        if (this.polling)
+            return;
+        this.polling = true;
+        try {
+            // Release stale claims from crashed workers
+            this.cleanupStaleClaims();
+            // Claim as many tasks as possible in one tick (capped to prevent runaway)
+            for (let i = 0; i < MAX_CLAIMS_PER_TICK; i++) {
+                const result = this.findAndClaim();
+                if (!result)
+                    break;
+                // Fire-and-forget — runWorker is async, poll returns immediately
+                this.runWorker(result).catch((err) => {
+                    logger.error(`[task-subscriber] runWorker unhandled error: ${err instanceof Error ? err.message : err}`);
+                });
+            }
+        }
+        finally {
+            this.polling = false;
+        }
+    }
+    /** Release claims that have been held longer than STALE_CLAIM_TIMEOUT_MS. */
+    cleanupStaleClaims() {
+        const cutoff = Date.now() - STALE_CLAIM_TIMEOUT_MS;
+        const released = this.deps.taskStore.cleanupStaleClaims(cutoff);
+        if (released > 0) {
+            logger.warn(`[task-subscriber] Released ${released} stale claim(s)`);
+        }
+    }
+    /** Emit `taskChange.updated` with the latest task snapshot if it still exists. */
+    emitTaskUpdated(taskId) {
+        const latest = this.deps.taskStore.getById(taskId);
+        if (!latest)
+            return;
+        emit("taskChange", { action: "updated", task: latest });
+    }
+    /**
+     * Find a claimable task and atomically claim it via the store.
+     * Uses TeamStore.findClaimableTasks() for cross-table query,
+     * then TaskStore.claimTask() for atomic claim.
+     */
+    findAndClaim() {
+        // Compute busy agents in-memory (not DB-level)
+        const fullAgentIds = new Set();
+        for (const [agentId, tasks] of this.activeRuns) {
+            const agent = this.deps.teamStore.getAgentById(agentId);
+            const limit = agent?.concurrency ?? 1;
+            if (tasks.size >= limit)
+                fullAgentIds.add(agentId);
+        }
+        // Query candidates via store method (small result set)
+        const candidates = this.deps.teamStore.findClaimableTasks(CLAIMABLE_CANDIDATE_LIMIT);
+        // Find first candidate whose agent isn't at capacity
+        const match = candidates.find((c) => !fullAgentIds.has(c.agentId));
+        if (!match)
+            return null;
+        // Claim atomically via store
+        const task = this.deps.taskStore.claimTaskById(match.taskId, match.agentId);
+        if (!task)
+            return null;
+        return {
+            agentId: match.agentId,
+            teamId: match.teamId,
+            agentName: match.agentName,
+            model: match.model,
+            task,
+        };
+    }
+    /**
+     * Run full LLM loop for a claimed task.
+     * Follows same pattern as delegate.ts runWorker().
+     */
+    async runWorker(claim) {
+        const { agentId, teamId, agentName, model: agentModel, task } = claim;
+        let teamName = this.deps.teamStore.getTeamById(task.teamId)?.name;
+        const sessionKey = `${teamId}:task:${task.id}:${agentName}:${Date.now()}`;
+        const session = new Session(sessionKey);
+        let activeRunsForAgent = this.activeRuns.get(agentId);
+        if (!activeRunsForAgent) {
+            activeRunsForAgent = new Set();
+            this.activeRuns.set(agentId, activeRunsForAgent);
+        }
+        activeRunsForAgent.add(task.id);
+        try {
+            const userMessage = task.description
+                ? `${task.title}\n\n${task.description}`
+                : task.title;
+            const { normalizedText, imageDataUrls } = await resolveInlineAttachmentContent(userMessage);
+            session.append({ role: "user", content: buildUserMessageContent(normalizedText, imageDataUrls) });
+            // 1. Resolve agent config
+            const agentRow = this.deps.teamStore.getRuntimeAgentById(agentId);
+            if (!agentRow)
+                throw new Error(`Agent not found: ${agentId}`);
+            // 2. Resolve model
+            const { provider, modelId, codexReasoningEffort } = parseModel(agentModel);
+            const model = getModel(provider, modelId, { codexReasoningEffort });
+            // 3. Build worker tools (filtered base tools + memory_search + task tools)
+            const baseTools = this.filterTools(agentRow.tools);
+            const workerTools = { ...baseTools };
+            // Browser: give worker its own instance
+            const hasBrowserTools = BROWSER_TOOL_NAMES.some((n) => n in workerTools);
+            let workerBrowser = null;
+            if (hasBrowserTools && this.deps.browserConfig) {
+                for (const n of BROWSER_TOOL_NAMES)
+                    delete workerTools[n];
+                workerBrowser = new BrowserManager({ ...this.deps.browserConfig, profileDir: "temp" });
+                Object.assign(workerTools, createBrowserTools(workerBrowser));
+            }
+            // Memory search (read-only)
+            if (this.deps.memoryStore) {
+                workerTools.memory_search = createMemorySearchTool(this.deps.memoryStore, this.deps.embeddingProvider, this.deps.memoryMaxResults);
+            }
+            // Task tools scoped to the task's team, with team's custom statuses
+            const team = this.deps.teamStore.getTeamById(task.teamId);
+            if (team?.name)
+                teamName = team.name;
+            const configuredStatuses = team?.statuses && team.statuses.length > 0 ? team.statuses : DEFAULT_TASK_STATUSES;
+            const taskTools = createTaskTools(this.deps.taskStore, task.teamId, configuredStatuses, {
+                clearClaimOnStatusChange: false,
+                requireClaimedByForStatusChange: agentId,
+                updatedBy: agentId,
+            });
+            Object.assign(workerTools, this.filterToolSetByAllowlist(taskTools, agentRow.tools));
+            // 4. System prompt (task-specific mode for subscribed workers)
+            const system = buildSystemPrompt({
+                identity: agentRow.identity,
+                modelId,
+                teamWorkspace: team?.workspace,
+                hasMemory: this.deps.memoryStore !== null,
+                subscribedTask: {
+                    id: task.id,
+                    teamId: task.teamId,
+                    title: task.title,
+                    currentStatus: task.status,
+                    availableStatusKeys: configuredStatuses.map((status) => status.key),
+                },
+            });
+            logger.info(`[task-subscriber] ${agentRow.name} claimed task ${task.id}: ${task.title.slice(0, 100)}`);
+            try {
+                await this.deps.sessionStore.save(session);
+                this.deps.sessionStore.updateMetadata(sessionKey, {
+                    teamId: task.teamId,
+                    ...(teamName ? { teamName } : {}),
+                    channelType: "worker",
+                    agentId,
+                    agentName: agentRow.name,
+                });
+            }
+            catch (err) {
+                logger.warn(`[task-subscriber] ${agentRow.name} failed to create session ${sessionKey}: ${err instanceof Error ? err.message : err}`);
+            }
+            this.emitTaskUpdated(task.id);
+            emit("agent", {
+                sessionKey,
+                tools: [],
+                subscription: { agentId, agentName, taskId: task.id, status: "started" },
+            });
+            // 6. Adapt tools and run loop
+            const maxSteps = agentRow.maxSteps > 0 ? agentRow.maxSteps : DEFAULT_WORKER_MAX_STEPS;
+            const workerLabel = `worker:${team?.name ?? task.teamId}:${agentRow.name}:task:${task.id}`;
+            let cleanup;
+            try {
+                const adapted = await adaptTools(provider, modelId, model, workerTools, {
+                    sandboxEnabled: this.deps.sandboxEnabled,
+                    cwd: team?.workspace?.trim() || undefined,
+                });
+                cleanup = adapted.cleanup;
+                const { text, responseMessages } = await runLoop({
+                    model: adapted.model,
+                    system,
+                    messages: session.getMessages(),
+                    tools: adapted.tools,
+                    sessionKey,
+                    sessionLabel: workerLabel,
+                    agentId,
+                    maxSteps,
+                    silent: false,
+                });
+                // Append response messages and save session
+                for (const msg of responseMessages)
+                    session.append(msg);
+                await this.deps.sessionStore.save(session);
+                this.deps.sessionStore.updateMetadata(sessionKey, {
+                    teamId: task.teamId,
+                    ...(teamName ? { teamName } : {}),
+                    channelType: "worker",
+                    agentId,
+                    agentName: agentRow.name,
+                });
+                // NOTE: Workers set final status only when task_update is available to that worker.
+                // We no longer hardcode status: "done" here because teams may use custom statuses.
+                emit("agent", {
+                    sessionKey,
+                    tools: [],
+                    subscription: { agentId, agentName, taskId: task.id, status: "completed", resultLength: text.length },
+                });
+                logger.info(`[task-subscriber] ${agentRow.name} completed task ${task.id} (${text.length} chars)`);
+            }
+            finally {
+                if (cleanup) {
+                    try {
+                        await cleanup();
+                    }
+                    catch (err) {
+                        logger.warn(`[task-subscriber] ${agentRow.name} MCP cleanup failed: ${err instanceof Error ? err.message : err}`);
+                    }
+                }
+                if (workerBrowser?.isLaunched()) {
+                    workerBrowser.close().catch((err) => {
+                        logger.warn(`[task-subscriber] ${agentRow.name} browser cleanup failed: ${err instanceof Error ? err.message : err}`);
+                    });
+                }
+            }
+        }
+        catch (err) {
+            logger.error(`[task-subscriber] ${agentName} failed on task ${task.id}: ${err instanceof Error ? err.message : err}`);
+            const error = err instanceof Error ? err.message : String(err);
+            session.append({ role: "assistant", content: `Task execution failed: ${error}` });
+            try {
+                await this.deps.sessionStore.save(session);
+                this.deps.sessionStore.updateMetadata(sessionKey, {
+                    teamId: task.teamId,
+                    ...(teamName ? { teamName } : {}),
+                    channelType: "worker",
+                    agentId,
+                    agentName,
+                });
+            }
+            catch (saveErr) {
+                logger.warn(`[task-subscriber] ${agentName} failed to persist error session ${sessionKey}: ${saveErr instanceof Error ? saveErr.message : saveErr}`);
+            }
+            emit("agent", {
+                sessionKey,
+                tools: [],
+                subscription: { agentId, agentName, taskId: task.id, status: "failed", error },
+            });
+        }
+        finally {
+            // Finalize only if this worker still owns the claim:
+            // mark processed for current task version and release claim atomically.
+            const finalized = this.deps.taskStore.finalizeClaimedTaskRun(task.id, agentId);
+            if (finalized)
+                this.emitTaskUpdated(task.id);
+            activeRunsForAgent?.delete(task.id);
+            if (activeRunsForAgent?.size === 0)
+                this.activeRuns.delete(agentId);
+            // Check for more work after a worker finishes (non-blocking)
+            queueMicrotask(() => this.poll());
+        }
+    }
+    /** Filter base tools by agent allowlist (empty = inherit all). */
+    filterTools(allowlist) {
+        return this.filterToolSetByAllowlist(this.deps.baseTools, allowlist);
+    }
+    filterToolSetByAllowlist(toolSet, allowlist) {
+        if (allowlist.length === 0)
+            return { ...toolSet };
+        const filtered = {};
+        for (const name of allowlist) {
+            if (name in toolSet)
+                filtered[name] = toolSet[name];
+        }
+        return filtered;
+    }
+}

package/dist/brain/user-content.d.ts

@@ -0,0 +1,16 @@
+export type UserImageContentPart = {
+    type: "image";
+    image: string;
+    mediaType?: string;
+};
+export type UserTextContentPart = {
+    type: "text";
+    text: string;
+};
+export type UserMessageContent = string | Array<UserImageContentPart | UserTextContentPart>;
+export declare function mergeImageDataUrls(first?: string[], second?: string[]): string[] | undefined;
+/**
+ * Build AI SDK user message content with image parts when data URLs are available.
+ * Keeps text-only content as a plain string for the common path.
+ */
+export declare function buildUserMessageContent(text: string, imageDataUrls?: string[]): UserMessageContent;

package/dist/brain/user-content.js

@@ -0,0 +1,32 @@
+export function mergeImageDataUrls(first, second) {
+    if (!first?.length && !second?.length)
+        return undefined;
+    const merged = [];
+    const seen = new Set();
+    for (const url of [...(first ?? []), ...(second ?? [])]) {
+        if (seen.has(url))
+            continue;
+        seen.add(url);
+        merged.push(url);
+    }
+    return merged.length > 0 ? merged : undefined;
+}
+/**
+ * Build AI SDK user message content with image parts when data URLs are available.
+ * Keeps text-only content as a plain string for the common path.
+ */
+export function buildUserMessageContent(text, imageDataUrls) {
+    if (!imageDataUrls?.length)
+        return text;
+    return [
+        ...imageDataUrls.map((dataUrl) => {
+            // Parse data URL (data:image/png;base64,AAAA...) into raw base64 + mediaType
+            const match = dataUrl.match(/^data:(image\/[^;]+);base64,(.+)$/s);
+            if (match) {
+                return { type: "image", image: match[2], mediaType: match[1] };
+            }
+            return { type: "image", image: dataUrl };
+        }),
+        { type: "text", text },
+    ];
+}

package/dist/brain/utils.d.ts

@@ -0,0 +1,4 @@
+/** Check if two sets have the same elements. */
+export declare function setsEqual(a: Set<string>, b: Set<string>): boolean;
+/** Extract a user-facing message from API/runtime errors. */
+export declare function friendlyError(err: unknown): string;

package/dist/brain/utils.js

@@ -0,0 +1,26 @@
+/** Check if two sets have the same elements. */
+export function setsEqual(a, b) {
+    if (a.size !== b.size)
+        return false;
+    for (const item of a) {
+        if (!b.has(item))
+            return false;
+    }
+    return true;
+}
+/** Extract a user-facing message from API/runtime errors. */
+export function friendlyError(err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    const lower = msg.toLowerCase();
+    if (lower.includes("credit") || lower.includes("billing") || lower.includes("402") || lower.includes("payment"))
+        return "API credit balance is too low. Please top up your account and try again.";
+    if (lower.includes("rate limit") || lower.includes("429"))
+        return "Rate limited by the API. Please wait a moment and try again.";
+    if (lower.includes("authentication") || lower.includes("api key") || lower.includes("401"))
+        return "API authentication failed. Please check your API key.";
+    if (lower.includes("overloaded") || lower.includes("529"))
+        return "The AI service is currently overloaded. Please try again shortly.";
+    if (lower.includes("context") && lower.includes("overflow"))
+        return "The conversation is too long. Please start a new session.";
+    return `Something went wrong: ${msg.slice(0, 200)}`;
+}

package/dist/brain/worker-coordinator.d.ts

@@ -0,0 +1,25 @@
+import type { MessageQueue } from "./queue.js";
+import type { SessionStateMap } from "./session-state.js";
+/**
+ * Coordinates worker completion and orchestrator re-triggering.
+ * Debounces multiple concurrent worker completions into a single LLM call.
+ */
+export declare class WorkerCoordinator {
+    private sessions;
+    private queue;
+    constructor(sessions: SessionStateMap, queue: MessageQueue);
+    /**
+     * Called when a worker finishes. Debounces multiple completions into a single
+     * orchestrator re-trigger so concurrent workers batch into one LLM call.
+     */
+    onWorkerComplete(sessionKey: string, channelId: string): void;
+    /**
+     * Track delegation depth: synthetic worker triggers increment, real messages reset.
+     * Returns true if the message is a worker result synthetic message.
+     */
+    trackDelegationDepth(sessionKey: string, text: string): void;
+    /** Cancel all pending debounce timers (e.g. on shutdown). */
+    clearAllTimers(): void;
+    /** Enqueue a synthetic message to re-trigger the orchestrator after workers finish. */
+    private triggerOrchestratorForWorkerResults;
+}

package/dist/brain/worker-coordinator.js

@@ -0,0 +1,83 @@
+import { logger } from "../logger.js";
+/** Debounce delay before re-triggering orchestrator after worker completion. */
+const WORKER_TRIGGER_DEBOUNCE_MS = 2_000;
+/** Max times the orchestrator can be auto-triggered by worker results per user message. */
+const MAX_DELEGATION_DEPTH = 5;
+/** Prefix for synthetic messages injected when workers complete. */
+const WORKER_RESULTS_PREFIX = "[worker_results]";
+/**
+ * Coordinates worker completion and orchestrator re-triggering.
+ * Debounces multiple concurrent worker completions into a single LLM call.
+ */
+export class WorkerCoordinator {
+    sessions;
+    queue;
+    constructor(sessions, queue) {
+        this.sessions = sessions;
+        this.queue = queue;
+    }
+    /**
+     * Called when a worker finishes. Debounces multiple completions into a single
+     * orchestrator re-trigger so concurrent workers batch into one LLM call.
+     */
+    onWorkerComplete(sessionKey, channelId) {
+        const state = this.sessions.get(sessionKey);
+        if (!state)
+            return;
+        // Accumulate completed channel IDs during debounce window
+        if (!state.workerPendingChannels) {
+            state.workerPendingChannels = new Set();
+        }
+        state.workerPendingChannels.add(channelId);
+        // Debounce: reset timer on each completion
+        if (state.workerTriggerTimer)
+            clearTimeout(state.workerTriggerTimer);
+        state.workerTriggerTimer = setTimeout(() => {
+            state.workerTriggerTimer = undefined;
+            this.triggerOrchestratorForWorkerResults(sessionKey);
+        }, WORKER_TRIGGER_DEBOUNCE_MS);
+    }
+    /**
+     * Track delegation depth: synthetic worker triggers increment, real messages reset.
+     * Returns true if the message is a worker result synthetic message.
+     */
+    trackDelegationDepth(sessionKey, text) {
+        const state = this.sessions.get(sessionKey);
+        if (!state)
+            return;
+        if (text.startsWith(WORKER_RESULTS_PREFIX)) {
+            state.delegationDepth++;
+        }
+        else {
+            state.delegationDepth = 0;
+        }
+    }
+    /** Cancel all pending debounce timers (e.g. on shutdown). */
+    clearAllTimers() {
+        this.sessions.clearAllTimers();
+    }
+    /** Enqueue a synthetic message to re-trigger the orchestrator after workers finish. */
+    triggerOrchestratorForWorkerResults(sessionKey) {
+        const state = this.sessions.get(sessionKey);
+        if (!state)
+            return;
+        if (state.delegationDepth >= MAX_DELEGATION_DEPTH) {
+            logger.warn(`[${sessionKey}] Delegation depth limit reached (${MAX_DELEGATION_DEPTH}), skipping re-trigger`);
+            return;
+        }
+        const channelIds = state.workerPendingChannels ? [...state.workerPendingChannels] : [];
+        state.workerPendingChannels = undefined;
+        const channelList = channelIds.map((id) => `- ${id}`).join("\n");
+        const synthetic = `${WORKER_RESULTS_PREFIX}\nWorker agents have completed. Call read_channel for each:\n${channelList}`;
+        const deliver = state.replyCallback;
+        this.queue.enqueue(sessionKey, synthetic).then((reply) => {
+            if (reply && deliver) {
+                deliver(reply).catch((err) => {
+                    logger.error(`[${sessionKey}] Failed to deliver worker trigger reply: ${err instanceof Error ? err.message : err}`);
+                });
+            }
+        }, (err) => {
+            logger.error(`[${sessionKey}] Failed to enqueue worker trigger: ${err instanceof Error ? err.message : err}`);
+        });
+    }
+}

package/dist/channels/commands.d.ts

@@ -0,0 +1,50 @@
+/** A segment of a command response that needs channel-specific formatting. */
+export type CommandPart = string | {
+    bold: string;
+} | {
+    code: string;
+};
+export interface CommandResult {
+    parts: CommandPart[];
+}
+export interface CommandRouterOpts {
+    onClear?: (channelType: string, channelId: string, teamId?: string) => Promise<void>;
+    onLearn?: (channelType: string, channelId: string, topic?: string, teamId?: string) => Promise<{
+        topic?: string;
+        extracted: number;
+        saved: number;
+        skipped: number;
+        savedFacts: string[];
+    }>;
+    onRemember?: (channelType: string, channelId: string, fact: string, teamId?: string) => Promise<{
+        saved: boolean;
+        fact: string;
+    }>;
+    /** List available teams for the /team command. */
+    listTeams?: () => {
+        id: string;
+        name: string;
+    }[];
+    /** Fallback team when no active team is set for a channel. */
+    defaultTeamId?: string;
+}
+export declare class CommandRouter {
+    private readonly opts;
+    private readonly activeTeams;
+    constructor(opts: CommandRouterOpts);
+    /** Resolve the active team for a channel, falling back to configured defaultTeamId. */
+    resolveTeamId(channelId: string): string | undefined;
+    /**
+     * Parse raw text for slash-style commands (e.g. "/clear", "/team foo").
+     * Returns `null` if the text is not a recognised command.
+     */
+    handle(channelType: string, channelId: string, text: string): Promise<CommandResult | null>;
+    /** Handle /clear (or /reset). */
+    handleClear(channelType: string, channelId: string): Promise<CommandResult>;
+    /** Handle /team [name]. */
+    handleTeam(channelType: string, channelId: string, arg: string): Promise<CommandResult>;
+    /** Handle /learn [topic]. */
+    handleLearn(channelType: string, channelId: string, topic?: string): Promise<CommandResult>;
+    /** Handle /remember [fact]. */
+    handleRemember(channelType: string, channelId: string, fact: string): Promise<CommandResult>;
+}