openmausbot 0.1.85 → 0.1.87

package/dist-server/server/model-prices.js

@@ -0,0 +1,121 @@
+import { billableFor } from "./prices.js";
+const AS_OF = "2026-09-23";
+const OPENAI = "https://developers.openai.com/api/docs/pricing";
+const ANTHROPIC = "https://platform.claude.com/docs/en/about-claude/pricing";
+const XAI = "https://docs.x.ai/developers/models";
+const GOOGLE = "https://ai.google.dev/gemini-api/docs/pricing";
+const MINIMAX = "https://platform.minimax.io/docs/guides/pricing-paygo";
+// OpenRouter's FAQ (https://openrouter.ai/docs/faq) says it passes provider
+// prices through without markup, but its live list does discount some
+// models, so these are read from that list rather than copied from the
+// vendors. Its 5.5% fee on buying credits is not a per-token price.
+const OPENROUTER = "https://openrouter.ai/api/v1/models";
+const price = (source, input, cached, output, extra = {}) => ({
+    inputPerMillion: input,
+    cachedInputPerMillion: cached,
+    outputPerMillion: output,
+    asOf: AS_OF,
+    source,
+    ...extra,
+});
+/** Keyed by the model id as a bot's selection names it, lower-cased. */
+export const LIST_PRICES = {
+    // OpenAI, Standard tier, short context (<272K input tokens).
+    "gpt-6-astra": price(OPENAI, 10, 1, 50),
+    // Labelled promotional pricing on the source page, with no end date given.
+    "gpt-5.6-sol": price(OPENAI, 4, 0.4, 20),
+    "gpt-5.6-terra": price(OPENAI, 2, 0.2, 12),
+    "gpt-5.6-luna": price(OPENAI, 0.2, 0.02, 1.2),
+    "gpt-5.5": price(OPENAI, 5, 0.5, 30),
+    "gpt-5.4": price(OPENAI, 2.5, 0.25, 15),
+    "gpt-5.4-mini": price(OPENAI, 0.75, 0.075, 4.5),
+    "gpt-5.3-codex": price(OPENAI, 1.75, 0.175, 14),
+    // gpt-5.3-codex-spark has no published API price: unpriced.
+    // Anthropic: base input, cache hit, output. No long-context tier.
+    "claude-fable-5-1": price(ANTHROPIC, 10, 0.25, 50),
+    "claude-fable-5": price(ANTHROPIC, 10, 1, 50),
+    "claude-opus-5": price(ANTHROPIC, 5, 0.5, 25),
+    "claude-sonnet-5": price(ANTHROPIC, 2, 0.2, 10),
+    "claude-haiku-4-5": price(ANTHROPIC, 1, 0.1, 5),
+    "claude-haiku-4-5-20251001": price(ANTHROPIC, 1, 0.1, 5),
+    // xAI, under 200k prompt tokens. grok-4, grok-4-fast and grok-3-mini are
+    // retired or unlisted: unpriced.
+    "grok-4.7": price(XAI, 2, 0.5, 6),
+    "grok-4.6": price(XAI, 2, 0.5, 6),
+    "grok-4.5": price(XAI, 2, 0.3, 6),
+    // Google Gemini API, paid tier, prompts up to 200k tokens.
+    "gemini-2.5-pro": price(GOOGLE, 1.25, 0.125, 10),
+    "gemini-2.5-flash": price(GOOGLE, 0.3, 0.03, 2.5),
+    "gemini-3.1-pro-preview": price(GOOGLE, 2, 0.2, 12),
+    "gemini-3.8-flash": price(GOOGLE, 0.75, 0.075, 3.75, {
+        changes: [{ from: "2027-01-01", inputPerMillion: 1.5, cachedInputPerMillion: 0.15, outputPerMillion: 7.5 }],
+    }),
+    // MiniMax, international pay-as-you-go, Standard. M3 up to 512k input
+    // tokens, at the price charged (the page shows it as 50% off, permanently).
+    "minimax-m3": price(MINIMAX, 0.3, 0.06, 1.2),
+    "minimax-m2.7": price(MINIMAX, 0.3, 0.06, 1.2),
+    "minimax-m2.7-highspeed": price(MINIMAX, 0.6, 0.06, 2.4),
+    // OpenRouter ids, as its live model list prices them.
+    "openai/gpt-6-astra": price(OPENROUTER, 10, 1, 50),
+    "openai/gpt-5.6-sol": price(OPENROUTER, 2, 0.2, 10),
+    "openai/gpt-5.6-terra": price(OPENROUTER, 2, 0.2, 12),
+    "openai/gpt-5.6-luna": price(OPENROUTER, 0.2, 0.02, 1.2),
+    "openai/gpt-5.5": price(OPENROUTER, 5, 0.5, 30),
+    "openai/gpt-5.4": price(OPENROUTER, 2.5, 0.25, 15),
+    "openai/gpt-5.4-mini": price(OPENROUTER, 0.75, 0.075, 4.5),
+    "openai/gpt-5.3-codex": price(OPENROUTER, 1.75, 0.175, 14),
+    "anthropic/claude-fable-5.1": price(OPENROUTER, 10, 0.25, 50),
+    "anthropic/claude-fable-5": price(OPENROUTER, 10, 1, 50),
+    "anthropic/claude-opus-5": price(OPENROUTER, 5, 0.5, 25),
+    "anthropic/claude-sonnet-5": price(OPENROUTER, 2, 0.2, 10),
+    "anthropic/claude-haiku-4.5": price(OPENROUTER, 1, 0.1, 5),
+    "x-ai/grok-4.7": price(OPENROUTER, 1.6, 0.4, 4.8),
+    "x-ai/grok-4.6": price(OPENROUTER, 2, 0.5, 6),
+    "x-ai/grok-4.5": price(OPENROUTER, 2, 0.3, 6),
+    "google/gemini-2.5-pro": price(OPENROUTER, 1.25, 0.125, 10),
+    "google/gemini-2.5-flash": price(OPENROUTER, 0.3, 0.03, 2.5),
+    "google/gemini-3.1-pro-preview": price(OPENROUTER, 2, 0.2, 12),
+    "google/gemini-3.8-flash": price(OPENROUTER, 0.75, 0.075, 3.75),
+    "minimax/minimax-m3": price(OPENROUTER, 0.3, 0.06, 1.2),
+    "minimax/minimax-m2.7": price(OPENROUTER, 0.3, 0.06, 1.2),
+};
+/** Catalog ids that name a listed model with a setting attached: the
+ * Antigravity picker offers Gemini 3.8 Flash at three thinking levels. */
+const ALIASES = {
+    "gemini-3.8-flash-high": "gemini-3.8-flash",
+    "gemini-3.8-flash-medium": "gemini-3.8-flash",
+    "gemini-3.8-flash-low": "gemini-3.8-flash",
+};
+/** The list price for a model at a moment, or null when it is not listed. */
+export function listPriceFor(model, at = new Date()) {
+    const key = model.trim().toLowerCase();
+    const entry = LIST_PRICES[ALIASES[key] ?? key];
+    if (!entry)
+        return null;
+    const day = at.toISOString().slice(0, 10);
+    const change = entry.changes?.filter((candidate) => candidate.from <= day).at(-1);
+    const current = change ?? entry;
+    return {
+        inputPerMillion: current.inputPerMillion,
+        outputPerMillion: current.outputPerMillion,
+        ...(current.cachedInputPerMillion !== undefined ? { cachedInputPerMillion: current.cachedInputPerMillion } : {}),
+    };
+}
+/** The price an estimate uses: the operator's own price for this exact
+ * model (Settings → Usage → prices, `driver/model` or model id), then the
+ * built-in list, then the operator's `default` row. */
+export function estimatePriceFor(turn, operatorPrices, at = new Date()) {
+    return operatorPrices?.[`${turn.driverKind}/${turn.model}`] ?? operatorPrices?.[turn.model] ??
+        listPriceFor(turn.model, at) ?? operatorPrices?.default ?? null;
+}
+/** What the ledger books for a settled turn: the engine's own cost when it
+ * reported one, else an estimate, else null (unpriced). */
+export function ledgerCost(turn, operatorPrices, at = new Date()) {
+    if (typeof turn.costUsd === "number" && Number.isFinite(turn.costUsd) && turn.costUsd >= 0) {
+        return { costUsd: turn.costUsd, costSource: "reported" };
+    }
+    const unit = estimatePriceFor(turn, operatorPrices, at);
+    if (!unit)
+        return { costUsd: null };
+    return { costUsd: billableFor(turn, { [turn.model]: unit }), costSource: "estimated" };
+}

package/dist-server/server/new-bot-defaults.js

@@ -0,0 +1,115 @@
+import { z } from "zod";
+import { profilePatchSchema, fitsOnOneLine } from "./bot-profile.js";
+import { EFFORT_LEVELS } from "../shared/wire.js";
+import { isModelVariant } from "./contracts.js";
+import { normalizeCronSchedule } from "../shared/routine-schedule.js";
+const strings = (max, length) => z.array(z.string().max(length)).max(max);
+const clock = z.string().regex(/^(?:[01]\d|2[0-3]):[0-5]\d$/);
+const weekdays = z.array(z.number().int().min(0).max(6)).min(1).max(7);
+const timestamp = z.number().int().nonnegative().max(8_640_000_000_000_000);
+export const botDefaultModelSchema = z.object({
+    instanceId: z.string().trim().min(1).max(200),
+    model: z.string().trim().min(1).max(500),
+    effort: z.enum(EFFORT_LEVELS).optional(),
+    variant: z.string().refine(isModelVariant, "invalid model variant").optional(),
+}).strict().refine(value => value.effort === undefined || value.variant === undefined, "choose either a model variant or an effort level");
+// Preferences only. Consent flags, live grants, bot IDs and execution state
+// cannot be stored here and therefore cannot be replayed as permission grants.
+export const botDefaultsProfileSchema = profilePatchSchema.extend({
+    name: z.string().max(100).refine(fitsOnOneLine, "name must fit on one line").optional(),
+    section: z.string().trim().max(60).optional(),
+    color: z.enum(["green", "blue", "red", "orange", "purple", "cyan", "pink", "yellow", "teal", "coral"]).optional(),
+    mascotExpression: z.string().max(60).nullable().optional(),
+    modelSelection: botDefaultModelSchema.optional(),
+    computer: z.enum(["cloud", "vm", "local", "browser", "off"]).nullable().optional(),
+    cloudBackend: z.enum(["box", "vps"]).optional(),
+    autoStartVps: z.boolean().optional(),
+    cwd: z.string().max(4096).nullable().optional(),
+    approvalMode: z.enum(["ask", "auto", "full", "custom"]).optional(),
+    alwaysAllow: strings(200, 500).optional(),
+    chiefOfStaff: z.boolean().optional(),
+    managedSections: strings(100, 60).optional(),
+    approvePeerComms: z.boolean().optional(),
+    peers: strings(1000, 100).nullable().optional(),
+    composio: z.boolean().optional(),
+    browser: z.boolean().optional(),
+    browserProfile: z.string().max(100).nullable().optional(),
+    mcpServers: strings(100, 100).nullable().optional(),
+    parkDirectMessages: z.boolean().optional(),
+}).strict();
+const scheduleSchema = z.discriminatedUnion("type", [
+    z.object({ type: z.literal("once"), at: timestamp }).strict(),
+    z.object({ type: z.literal("daily"), time: clock, weekdays }).strict(),
+    z.object({
+        type: z.literal("interval"), everyMinutes: z.number().int().min(5).max(1440), anchorAt: timestamp,
+        weekdays: weekdays.nullable().optional(),
+        window: z.object({ start: clock, end: clock }).strict().nullable().optional(),
+        endsAt: timestamp.nullable().optional(),
+    }).strict(),
+    z.object({ type: z.literal("cron"), expression: z.string().max(256), timeZone: z.string().max(128) }).strict(),
+]).superRefine((value, ctx) => {
+    if (value.type === "cron") {
+        try {
+            normalizeCronSchedule(value);
+        }
+        catch (error) {
+            ctx.addIssue({ code: "custom", message: String(error) });
+        }
+    }
+    if (value.type === "interval" && value.window) {
+        const minutes = (time) => Number(time.slice(0, 2)) * 60 + Number(time.slice(3));
+        if (minutes(value.window.end) - minutes(value.window.start) < value.everyMinutes) {
+            ctx.addIssue({ code: "custom", message: "The interval must fit inside its time window" });
+        }
+    }
+});
+export const botRoutineTemplateSchema = z.object({
+    name: z.string().trim().min(1).max(80), prompt: z.string().trim().min(1).max(20_000),
+    schedule: scheduleSchema, enabled: z.boolean().optional(),
+    runOn: z.enum(["maus", "cloud"]).optional(),
+    durationMinutes: z.number().int().min(5).max(240).optional(),
+    timeoutMinutes: z.number().min(1).max(1440).nullable().optional(),
+    overlap: z.enum(["skip", "queue"]).optional(),
+    attachments: z.array(z.object({
+        id: z.string().min(1).max(200), kind: z.enum(["file", "image"]),
+        name: z.string().min(1).max(255), path: z.string().min(1).max(4096), size: z.number().nonnegative(),
+    }).strict()).max(50).optional(),
+}).strict();
+export const botSkillTemplateSchema = z.object({
+    name: z.string().regex(/^[a-z0-9]+(?:-[a-z0-9]+)*$/).max(64),
+    description: z.string().max(1024),
+    warnings: strings(100, 2000).default([]),
+    source: z.string().min(1).max(2000),
+    text: z.string().refine(value => Buffer.byteLength(value, "utf8") <= 262_144, "Skill exceeds 256 KiB"),
+    enabled: z.boolean(),
+}).strict();
+export const newBotDefaultsSchema = z.object({
+    profile: botDefaultsProfileSchema.default({}),
+    memory: z.record(z.string().regex(/^(?:MEMORY\.md|memory\/[a-zA-Z0-9_-]+\.md)$/), z.string().refine(value => Buffer.byteLength(value, "utf8") <= 262_144, "Memory file exceeds 256 KiB"))
+        .refine(value => Object.keys(value).length <= 100, "At most 100 memory files").default({}),
+    skills: z.array(botSkillTemplateSchema).max(100).default([]),
+    routines: z.array(botRoutineTemplateSchema).max(100).default([]),
+}).strict().refine(value => Buffer.byteLength(JSON.stringify(value), "utf8") <= 900_000, "Bot defaults must fit within 900 KB");
+/** Explicit values (including empty values) win. A resolved renderer draft
+ * opts out so deleted fields and template extras are not restored on POST. */
+export function resolveBotCreationDefaults(saved, body) {
+    if (body.useDefaults !== undefined && typeof body.useDefaults !== "boolean") {
+        throw Object.assign(new Error("useDefaults must be true or false"), { status: 400 });
+    }
+    const template = newBotDefaultsSchema.parse(body.useDefaults === false ? {} : saved ?? {});
+    const checked = botDefaultsProfileSchema.safeParse(body.settings === undefined ? {} : body.settings);
+    if (!checked.success)
+        throw Object.assign(new Error(checked.error.message), { status: 400 });
+    const explicit = checked.data;
+    const profile = { ...template.profile, ...explicit };
+    for (const key of ["name", "title", "description", "modelSelection", "section"]) {
+        if (Object.hasOwn(body, key))
+            Object.assign(profile, { [key]: key === "section" && body[key] === null ? "" : body[key] });
+    }
+    const resolved = botDefaultsProfileSchema.safeParse(profile);
+    if (!resolved.success)
+        throw Object.assign(new Error(resolved.error.message), { status: 400 });
+    if (!resolved.data.name?.trim())
+        delete resolved.data.name;
+    return { ...template, profile: resolved.data };
+}

package/dist-server/server/notify.js

@@ -33,6 +33,13 @@ export function blockedTarget(bot, room) {
         return { threadId: bot.threadId };
     return { threadId: room.threadId, group: { id: room.id, name: room.name } };
 }
+/** A workspace spend notice (server/spend.ts decides when). It opens the
+ * thread whose turn crossed the line, so clicking it lands somewhere real,
+ * but it is the workspace's news, not that bot's: the bot's notification
+ * toggle does not silence it. */
+export function buildSpendNotification(bot, threadId, text) {
+    return { kind: "spend", botId: bot.id, botName: bot.name, threadId, title: text.title, body: summarize(text.body, 200) };
+}
 /** Build the frame for one event, or null when it should stay quiet.
  *
  * Kept pure and separate from the event fold so the policy — which is the
@@ -62,7 +69,9 @@ export function buildNotification(kind, bot, threadId, detail, extra) {
                             ? `${who} couldn't start`
                             : kind === "incident"
                                 ? `${who} hit a problem`
-                                : `${who} finished`;
+                                : kind === "delegation-settled"
+                                    ? `${who} resumed with results`
+                                    : `${who} finished`;
     // A "finished" with nothing to say is not worth a notification — the
     // badge in the sidebar already carries that much.
     if (kind === "done" && !body)