Add the harness, envs, per-bot models and chat attachments

- Harness: providers, model catalog synced hourly, automatic free picks, cooldowns, tool loop with context trimming, MCP computer tools - Bots queue runs replies and tasks through the harness; jobs wait (attempt refunded) while every model is resting - Envs: Settings > Environment, scoped general/workspace/computer, written to computers and redacted from tool output - Models: Settings > Models, per-harness provider select defaulting to OpenRouter, and a models modal on each bot's chat (the coordinator's edits the defaults) - Chat: thinking row while a reply runs, file attachments (upload, paste, drop) that replies read as images, audio and document text - Fix media uploads failing after a user's first file, and private files being served from the public media path Co-Authored-By: Claude Opus 5.5 <[email protected]>
2026-10-19 03:38:38 +01:00
parent d49f524fe8
commit 6a2665dae9
223 changed files with 12342 additions and 162 deletions
@@ -0,0 +1,77 @@
+import { z } from "zod";
+import type { BUN_SQLITE_COBBLE_BOTS } from "@/db/types/db";
+import pushBotNotice from "@/src/bots-queue/push-bot-notice";
+import enqueueBotJob from "@/src/functions/backend/db/bots-queue/enqueue-bot-job";
+import insertBotMessage from "@/src/functions/backend/db/bots/insert-bot-message";
+import grabBotComputers from "@/src/functions/backend/db/computers/grab-bot-computers";
+import type { HarnessTool } from "../../types";
+
+type Params = {
+    user_id: number | string;
+    /**
+     * The coordinator's name, shown in the worker's conversation.
+     */
+    coordinator_name: string;
+    /**
+     * The user's worker bots.
+     */
+    workers: BUN_SQLITE_COBBLE_BOTS[];
+};
+
+type Args = {
+    bot_id: number;
+    title: string;
+    instructions: string;
+};
+
+/**
+ * Lets the coordinator hand a task to a worker bot. The worker runs it on
+ * its own main computer (if it has one) and posts the result in its own
+ * conversation, where a note says who asked.
+ */
+export default function delegateTaskTool({
+    user_id,
+    coordinator_name,
+    workers,
+}: Params): HarnessTool<Args> {
+    const crew = workers
+        .map((bot) => `${bot.id}: ${bot.name}${bot.role ? ` (${bot.role})` : ""}`)
+        .join("; ");
+
+    return {
+        name: "delegate_task",
+        description: `Hand a task to a crew member. They run it in the background and post the result in their own conversation. Write the instructions as a full brief: what to do, where, and how they'll know it's done. Crew: ${crew}.`,
+        schema: z.object({
+            bot_id: z.number().int(),
+            title: z.string().min(1).max(80),
+            instructions: z.string().min(1).max(8000),
+        }),
+        run: async ({ args }) => {
+            const worker = workers.find((bot) => bot.id == args.bot_id);
+
+            if (!worker?.id) {
+                throw new Error(`No crew member has id ${args.bot_id}. Crew: ${crew}.`);
+            }
+
+            const computers = await grabBotComputers({ bot_id: worker.id, user_id });
+
+            const job_id = await enqueueBotJob({
+                user_id,
+                bot_id: worker.id,
+                title: args.title,
+                instructions: args.instructions,
+                computer_id: computers[0]?.id || undefined,
+            });
+
+            await pushBotNotice({
+                bot_id: worker.id,
+                message: await insertBotMessage({
+                    bot_id: worker.id,
+                    text: `${coordinator_name} asked me to: **${args.title}**`,
+                }),
+            });
+
+            return `Task #${job_id} is with ${worker.name}. Their result will be in their conversation.`;
+        },
+    };
+}
@@ -0,0 +1,60 @@
+import BunSQLite from "@moduletrace/bun-sqlite";
+import type { BUN_SQLITE_COBBLE_BOTS } from "@/db/types/db";
+import grabBotComputers from "@/src/functions/backend/db/computers/grab-bot-computers";
+import type { HarnessTool } from "../../types";
+import delegateTaskTool from "./delegate-task-tool";
+import grabBotTools from "./grab-bot-tools";
+import startTaskTool from "./start-task-tool";
+
+type Params = {
+    bot: BUN_SQLITE_COBBLE_BOTS;
+    user_id: number | string;
+    /**
+     * The user message being answered.
+     */
+    message_id?: number | string;
+};
+
+/**
+ * The tools a bot replies in chat with: its own (memory, instructions),
+ * start_task for longer work, and for the coordinator delegate_task to
+ * the crew. Computers are reached through tasks, never mid-reply.
+ */
+export default async function grabBotChatTools({
+    bot,
+    user_id,
+    message_id,
+}: Params): Promise<HarnessTool[]> {
+    const bot_id = bot.id || 0;
+    const tools = [
+        ...grabBotTools({ user_id, bot_id }),
+        startTaskTool({
+            user_id,
+            bot_id,
+            computers: await grabBotComputers({ bot_id, user_id }),
+            message_id,
+        }),
+    ];
+
+    if (bot.kind != "coordinator") return tools;
+
+    const workers =
+        (
+            await BunSQLite.sql<BUN_SQLITE_COBBLE_BOTS>({
+                sql: `SELECT * FROM bots WHERE user_id = ? AND kind = 'worker' ORDER BY id ASC`,
+                values: [user_id],
+            })
+        ).payload || [];
+
+    if (workers.length) {
+        tools.push(
+            delegateTaskTool({
+                user_id,
+                coordinator_name: bot.name || "The coordinator",
+                workers,
+            }),
+        );
+    }
+
+    return tools;
+}
@@ -0,0 +1,19 @@
+import type { HarnessTool } from "../../types";
+import updateInstructionsTool from "./update-instructions-tool";
+import updateMemoryTool from "./update-memory-tool";
+
+type Params = {
+    user_id: number | string;
+    bot_id: number | string;
+};
+
+/**
+ * The tools a bot works with, bound to that bot. Computer, delegation and
+ * media tools join this list as they are built.
+ */
+export default function grabBotTools({ user_id, bot_id }: Params): HarnessTool[] {
+    return [
+        updateMemoryTool({ user_id, bot_id }),
+        updateInstructionsTool({ user_id, bot_id }),
+    ];
+}
@@ -0,0 +1,66 @@
+import { z } from "zod";
+import type { BUN_SQLITE_COBBLE_COMPUTERS } from "@/db/types/db";
+import enqueueBotJob from "@/src/functions/backend/db/bots-queue/enqueue-bot-job";
+import type { HarnessTool } from "../../types";
+
+type Params = {
+    user_id: number | string;
+    bot_id: number | string;
+    /**
+     * The bot's computers, its main one first (`grabBotComputers`).
+     */
+    computers: BUN_SQLITE_COBBLE_COMPUTERS[];
+    /**
+     * The user message that asked for the work.
+     */
+    message_id?: number | string;
+};
+
+type Args = {
+    title: string;
+    instructions: string;
+    computer_id?: number;
+};
+
+/**
+ * Lets a bot queue long-running work for itself. The task runs in the
+ * background with the computer's tools and posts its result to the chat.
+ */
+export default function startTaskTool({
+    user_id,
+    bot_id,
+    computers,
+    message_id,
+}: Params): HarnessTool<Args> {
+    const listed = computers
+        .map((computer) => `${computer.id} (${computer.name || computer.kind})`)
+        .join(", ");
+
+    return {
+        name: "start_task",
+        description: `Queue work that takes a while or needs a computer. It runs in the background and its result is posted in this chat. Write the instructions as a full brief for yourself: what to do, where, and how you'll know it's done. ${
+            computers.length
+                ? `Computers you can use: ${listed}. Defaults to ${computers[0]!.id}.`
+                : `You have no computer, so the task can't run commands or browse.`
+        }`,
+        schema: z.object({
+            title: z.string().min(1).max(80).describe("A short label, e.g. \"Check the backup logs\""),
+            instructions: z.string().min(1).max(8000),
+            computer_id: z.number().int().optional(),
+        }),
+        run: async ({ args }) => {
+            const computer_id = args.computer_id ?? computers[0]?.id ?? undefined;
+
+            const job_id = await enqueueBotJob({
+                user_id,
+                bot_id,
+                title: args.title,
+                instructions: args.instructions,
+                message_id,
+                computer_id: computer_id || undefined,
+            });
+
+            return `Task #${job_id} queued. Tell the user you're on it; the result will be posted here when it's done.`;
+        },
+    };
+}
@@ -0,0 +1,33 @@
+import { z } from "zod";
+import { AppData } from "@/src/data/app-data";
+import updateBotSystemPrompt from "@/src/functions/backend/db/bots/update-bot-system-prompt";
+import type { HarnessTool } from "../../types";
+
+type Params = {
+    user_id: number | string;
+    bot_id: number | string;
+};
+
+/**
+ * Lets a bot rewrite its own core instructions as it adapts to the user.
+ */
+export default function updateInstructionsTool({
+    user_id,
+    bot_id,
+}: Params): HarnessTool<{ instructions: string }> {
+    return {
+        name: "update_instructions",
+        description: `Replace your core instructions with this full text (markdown): the start of your prompt, before any workspace or memory. Change them only to work better for this user, such as a new standing rule they gave you. Keep everything that still applies.`,
+        schema: z.object({
+            instructions: z.string().trim().min(1).max(AppData.PromptMaxLength),
+        }),
+        run: async ({ args }) => {
+            await updateBotSystemPrompt({
+                user_id,
+                bot_id,
+                system_prompt: args.instructions,
+            });
+            return `Instructions saved. They apply from your next run.`;
+        },
+    };
+}
@@ -0,0 +1,29 @@
+import { z } from "zod";
+import { AppData } from "@/src/data/app-data";
+import updateBotMemory from "@/src/functions/backend/db/bots/update-bot-memory";
+import type { HarnessTool } from "../../types";
+
+type Params = {
+    user_id: number | string;
+    bot_id: number | string;
+};
+
+/**
+ * Lets a bot rewrite its own memory (shown to it under `# Memory`).
+ */
+export default function updateMemoryTool({
+    user_id,
+    bot_id,
+}: Params): HarnessTool<{ memory: string }> {
+    return {
+        name: "update_memory",
+        description: `Replace your memory with this full text (markdown). It's in your prompt under "# Memory" on every run. Keep what you must always remember: the user's preferences, facts about their work, decisions made. Anything you leave out is forgotten, so include the parts that still matter.`,
+        schema: z.object({
+            memory: z.string().max(AppData.PromptMaxLength),
+        }),
+        run: async ({ args }) => {
+            await updateBotMemory({ user_id, bot_id, memory: args.memory });
+            return `Memory saved.`;
+        },
+    };
+}