openmausbot 0.1.55

package/dist-server/server/drivers/minimax.js

@@ -0,0 +1,108 @@
+// MiniMax API driver. The wire protocol is OpenAI chat completions; this file
+// keeps only MiniMax's credentials, catalog, and request differences.
+import { readFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+import { z } from "zod";
+import { createOpenAIChatRuntime } from "./openai-chat.js";
+const DRIVER_KIND = "minimax";
+const API_KEY_ENV = "MINIMAX_API_KEY";
+const DEFAULT_URL = "https://api.minimax.io/v1";
+const CN_URL = "https://api.minimaxi.com/v1";
+const MODELS = {
+    default: "MiniMax-M3",
+    options: [
+        { id: "MiniMax-M3", label: "MiniMax M3", contextWindow: 1_000_000 },
+        { id: "MiniMax-M2.7", label: "MiniMax M2.7", contextWindow: 204_800 },
+        { id: "MiniMax-M2.7-highspeed", label: "MiniMax M2.7 Highspeed", contextWindow: 204_800 },
+    ],
+};
+const localConfigSchema = z.object({
+    api_key: z.string().optional(),
+    region: z.enum(["global", "cn"]).optional(),
+    base_url: z.string().optional(),
+    default_text_model: z.string().optional(),
+});
+const driverConfigSchema = z.object({ url: z.string().optional() });
+function normalizedApiUrl(value) {
+    const root = value.trim().replace(/\/+$/, "");
+    return root.endsWith("/v1") ? root : `${root}/v1`;
+}
+export function loadLocalMiniMaxConfig(home = homedir()) {
+    try {
+        const raw = localConfigSchema.parse(JSON.parse(readFileSync(join(home, ".mmx", "config.json"), "utf8")));
+        const configuredUrl = raw.base_url?.trim()
+            ? raw.base_url
+            : raw.region === "cn" ? CN_URL : DEFAULT_URL;
+        return {
+            apiKey: raw.api_key?.trim() ?? "",
+            url: normalizedApiUrl(configuredUrl),
+            defaultModel: raw.default_text_model?.trim() ?? "",
+        };
+    }
+    catch {
+        return { apiKey: "", url: DEFAULT_URL, defaultModel: "" };
+    }
+}
+export function decodeMinimaxConfig(raw) {
+    const parsed = driverConfigSchema.safeParse(raw ?? {});
+    const config = parsed.success ? parsed.data : {};
+    return {
+        url: normalizedApiUrl(config.url?.trim() || process.env.MINIMAX_BASE_URL?.trim() || DEFAULT_URL),
+    };
+}
+export const MinimaxDriver = {
+    driverKind: DRIVER_KIND,
+    metadata: { displayName: "MiniMax (API)", supportsMultipleInstances: true, access: "custom" },
+    models: MODELS,
+    install: {
+        docsUrl: "https://platform.minimax.io/docs/token-plan/minimax-cli",
+        command: {
+            darwin: "npm install -g mmx-cli",
+            linux: "npm install -g mmx-cli",
+            win32: "npm install -g mmx-cli",
+        },
+        signInCommand: "mmx auth login --api-key YOUR_MINIMAX_API_KEY",
+        needsNode: true,
+    },
+    decodeConfig: decodeMinimaxConfig,
+    defaultConfig: () => decodeMinimaxConfig({}),
+    async create(input) {
+        const local = loadLocalMiniMaxConfig();
+        const apiKey = input.environment[API_KEY_ENV]?.trim() ||
+            process.env[API_KEY_ENV]?.trim() ||
+            local.apiKey;
+        const apiUrl = input.config.url === DEFAULT_URL && local.url !== DEFAULT_URL
+            ? local.url
+            : input.config.url;
+        const models = local.defaultModel && MODELS.options.some((model) => model.id === local.defaultModel)
+            ? { ...MODELS, default: local.defaultModel }
+            : MODELS;
+        return createOpenAIChatRuntime({
+            input,
+            driverKind: DRIVER_KIND,
+            apiKey,
+            apiUrl,
+            models: () => models,
+            requestBody: (model, messages, stream) => ({
+                model,
+                messages,
+                stream,
+                reasoning_split: true,
+                stream_options: stream ? { include_usage: true } : undefined,
+            }),
+            httpErrorLabel: "MiniMax",
+            missingKeyError: `no MiniMax key — set ${API_KEY_ENV} or run mmx auth login --api-key …`,
+            unavailableReason: `no MiniMax API key — run mmx auth login --api-key … or set ${API_KEY_ENV}`,
+            timeoutMs: 180_000,
+            billing: "metered",
+            includeUsageInCompleted: true,
+            noBodyError: "MiniMax returned no response body",
+            nativeLog: {
+                source: "minimax.chat.completions",
+                outgoing: (_turn, messages, model) => ({ model, messageCount: messages.length }),
+                incoming: ({ text, usage }) => ({ textLength: text.length, usage }),
+            },
+        });
+    },
+};

package/dist-server/server/drivers/native.js

@@ -0,0 +1,21 @@
+// Native (un-normalized) protocol tee — the debugging trick from upstream's
+// EventNdjsonLogger and agentcal's onRaw: every provider-native message is
+// written verbatim next to the canonical stream, so protocol drift can be
+// diagnosed by diffing the two.
+import { appendFileSync } from "node:fs";
+import { join } from "node:path";
+import { NATIVE_DIR } from "../config.js";
+import { redactSecrets } from "../redact.js";
+export function appendNative(threadId, entry) {
+    try {
+        // The session-setup messages carry the credentials the agent is handed —
+        // the box and comms tokens ride inside session/new's mcpServers env, and
+        // an MCP header can carry a Composio key. These files are ordinary
+        // 0644 files people paste into bug reports, so values are masked while
+        // the shape stays intact.
+        appendFileSync(join(NATIVE_DIR, `${threadId}.ndjson`), JSON.stringify({ at: new Date().toISOString(), ...entry, msg: redactSecrets(entry.msg) }) + "\n", { mode: 0o600 });
+    }
+    catch {
+        /* never let logging break a run */
+    }
+}

package/dist-server/server/drivers/openai-chat.js

@@ -0,0 +1,240 @@
+import { newEventId, newId } from "../contracts.js";
+import { appendNative } from "./native.js";
+import { classifyError, computeBackoff, interruptibleDelay, RETRY_MAX_ATTEMPTS } from "./retry.js";
+const usageFrom = (usage) => usage
+    ? { input: usage.prompt_tokens ?? 0, output: usage.completion_tokens ?? 0 }
+    : null;
+const asError = (value) => value instanceof Error ? value : new Error(String(value));
+/** Shared runtime for the three providers that speak OpenAI chat completions. */
+export function createOpenAIChatRuntime(options) {
+    const { input } = options;
+    const listeners = new Set();
+    const active = new Map();
+    const emit = (event) => {
+        for (const listener of Array.from(listeners))
+            listener(event);
+    };
+    const base = (threadId, turnId) => ({
+        eventId: newEventId(),
+        provider: options.driverKind,
+        threadId,
+        turnId,
+        createdAt: new Date().toISOString(),
+    });
+    const complete = async (messages, model, stream, signal, onDelta) => {
+        const timeout = AbortSignal.timeout(options.timeoutMs);
+        const response = await fetch(`${options.apiUrl}/chat/completions`, {
+            method: "POST",
+            headers: { authorization: `Bearer ${options.apiKey}`, "content-type": "application/json" },
+            body: JSON.stringify(options.requestBody(model, messages, stream)),
+            signal: signal ? AbortSignal.any([signal, timeout]) : timeout,
+        });
+        if (!response.ok) {
+            const body = await response.text().catch(() => "");
+            throw new Error(`${options.httpErrorLabel} HTTP ${response.status}${body ? `: ${body.slice(0, 200)}` : ""}`);
+        }
+        if (!stream) {
+            const json = await response.json();
+            const message = json.choices?.[0]?.message;
+            return {
+                text: typeof message?.content === "string" ? message.content : "",
+                reasoning: options.reasoning && typeof message?.reasoning_content === "string"
+                    ? message.reasoning_content
+                    : "",
+                usage: usageFrom(json.usage),
+            };
+        }
+        if (!response.body) {
+            throw new Error(options.noBodyError ?? `${options.httpErrorLabel} returned no response body`);
+        }
+        let text = "";
+        let reasoning = "";
+        let usage = null;
+        const reader = response.body.getReader();
+        const decoder = new TextDecoder();
+        let buffer = "";
+        try {
+            readLoop: for (;;) {
+                const { done, value } = await reader.read();
+                if (done)
+                    break;
+                buffer += decoder.decode(value, { stream: true });
+                let newline;
+                while ((newline = buffer.indexOf("\n")) !== -1) {
+                    const line = buffer.slice(0, newline).trim();
+                    buffer = buffer.slice(newline + 1);
+                    if (!line.startsWith("data:"))
+                        continue;
+                    const data = line.slice(5).trim();
+                    if (data === "[DONE]")
+                        break readLoop;
+                    let chunk;
+                    try {
+                        chunk = JSON.parse(data);
+                    }
+                    catch {
+                        continue;
+                    }
+                    const delta = chunk.choices?.[0]?.delta;
+                    const reasoningDelta = options.reasoning && typeof delta?.reasoning_content === "string"
+                        ? delta.reasoning_content
+                        : "";
+                    const contentDelta = typeof delta?.content === "string" ? delta.content : "";
+                    if (reasoningDelta) {
+                        reasoning += reasoningDelta;
+                        onDelta?.(reasoningDelta, "reasoning_text");
+                    }
+                    if (contentDelta) {
+                        text += contentDelta;
+                        onDelta?.(contentDelta, "assistant_text");
+                    }
+                    if (chunk.usage)
+                        usage = usageFrom(chunk.usage);
+                }
+            }
+        }
+        finally {
+            await reader.cancel().catch(() => { });
+        }
+        return { text, reasoning, usage };
+    };
+    const messagesFor = (turn) => [
+        ...(turn.system ? [{ role: "system", content: turn.system }] : []),
+        ...(turn.transcript ?? []).map((message) => ({
+            role: message.role,
+            content: message.text,
+        })),
+        { role: "user", content: turn.text },
+    ];
+    const sendTurn = async (turn) => {
+        if (!options.apiKey)
+            throw new Error(options.missingKeyError);
+        if (active.has(turn.threadId))
+            throw new Error("a turn is already running on this thread");
+        const turnId = newId();
+        const abort = new AbortController();
+        const messages = messagesFor(turn);
+        const model = turn.model || options.models().default;
+        active.set(turn.threadId, abort);
+        appendNative(turn.threadId, {
+            dir: "out",
+            source: options.nativeLog.source,
+            msg: options.nativeLog.outgoing(turn, messages, model),
+        });
+        emit({ ...base(turn.threadId, turnId), type: "turn.started" });
+        emit({ ...base(turn.threadId, turnId), type: "session.started", sessionId: null, model });
+        void (async () => {
+            let attempt = 0;
+            let streamedText = false;
+            for (;;) {
+                try {
+                    const completion = await complete(messages, model, true, abort.signal, (delta, streamKind) => {
+                        if (streamKind === "assistant_text")
+                            streamedText = true;
+                        emit({ ...base(turn.threadId, turnId), type: "content.delta", streamKind, delta });
+                    });
+                    appendNative(turn.threadId, {
+                        dir: "in",
+                        source: options.nativeLog.source,
+                        msg: options.nativeLog.incoming(completion),
+                    });
+                    const reply = completion.text.trim() ? completion.text : completion.reasoning;
+                    if (reply.trim()) {
+                        emit({ ...base(turn.threadId, turnId), type: "item.completed", itemType: "assistant_text", text: reply });
+                    }
+                    if (completion.usage) {
+                        emit({ ...base(turn.threadId, turnId), type: "thread.token-usage.updated", ...completion.usage });
+                    }
+                    active.delete(turn.threadId);
+                    const completed = {
+                        ...base(turn.threadId, turnId),
+                        type: "turn.completed",
+                        ok: true,
+                        stopReason: null,
+                        cost: null,
+                    };
+                    emit(options.includeUsageInCompleted && completion.usage
+                        ? { ...completed, usage: completion.usage }
+                        : completed);
+                    return;
+                }
+                catch (value) {
+                    const error = asError(value);
+                    const aborted = error.name === "AbortError";
+                    const verdict = classifyError(error);
+                    if (options.retryScale !== undefined &&
+                        !aborted &&
+                        !streamedText &&
+                        verdict.transient &&
+                        attempt < RETRY_MAX_ATTEMPTS - 1) {
+                        const delayMs = computeBackoff(attempt++);
+                        emit({
+                            ...base(turn.threadId, turnId),
+                            type: "turn.retrying",
+                            attempt,
+                            delayMs,
+                            reason: verdict.reason,
+                        });
+                        const outcome = await interruptibleDelay(delayMs * options.retryScale, abort.signal).promise;
+                        if (outcome === "elapsed" && !abort.signal.aborted)
+                            continue;
+                        active.delete(turn.threadId);
+                        emit({ ...base(turn.threadId, turnId), type: "turn.completed", ok: false, stopReason: "interrupted", cost: null });
+                        return;
+                    }
+                    active.delete(turn.threadId);
+                    if (!aborted)
+                        emit({ ...base(turn.threadId, turnId), type: "runtime.error", message: error.message });
+                    emit({
+                        ...base(turn.threadId, turnId),
+                        type: "turn.completed",
+                        ok: false,
+                        stopReason: aborted ? "interrupted" : "error",
+                        cost: null,
+                    });
+                    return;
+                }
+            }
+        })();
+        return { turnId };
+    };
+    return {
+        instanceId: input.instanceId,
+        driverKind: options.driverKind,
+        displayName: input.displayName,
+        enabled: input.enabled,
+        get models() {
+            return options.models();
+        },
+        ...(options.refreshModels ? { refreshModels: options.refreshModels } : {}),
+        snapshot: async () => options.apiKey
+            ? { state: "available", authenticated: true, version: null, ...(options.billing ? { billing: options.billing } : {}) }
+            : { state: "unavailable", reason: options.unavailableReason },
+        adapter: {
+            provider: options.driverKind,
+            capabilities: { sessionModelSwitch: "in-session" },
+            sendTurn,
+            interruptTurn: async (threadId) => active.get(threadId)?.abort(),
+            respondToRequest: async () => "unavailable",
+            hasSession: (threadId) => active.has(threadId),
+            stopAll: async () => {
+                for (const abort of active.values())
+                    abort.abort();
+            },
+            onEvent: (listener) => {
+                listeners.add(listener);
+                return () => listeners.delete(listener);
+            },
+        },
+        generateText: async (prompt) => {
+            const model = options.generateModel?.() ?? options.models().default;
+            const { text, reasoning } = await complete([{ role: "user", content: prompt }], model, false);
+            return text.trim() ? text : reasoning;
+        },
+        dispose: async () => {
+            for (const abort of active.values())
+                abort.abort();
+            listeners.clear();
+        },
+    };
+}

package/dist-server/server/drivers/openai-compat.js

@@ -0,0 +1,143 @@
+import { createOpenAIChatRuntime } from "./openai-chat.js";
+const DRIVER_KIND = "openai-compat";
+const DEFAULT_MODELS = {
+    default: "meta-llama/llama-3.3-70b-instruct",
+    options: [
+        { id: "meta-llama/llama-3.3-70b-instruct", label: "Llama 3.3 70B (OpenRouter)", custom: true },
+        { id: "llama-3.3-70b-versatile", label: "Llama 3.3 70B (Groq)", custom: true },
+    ],
+};
+function isOpenRouterUrl(url) {
+    try {
+        const host = new URL(url).hostname.toLowerCase();
+        return host === "openrouter.ai" || host.endsWith(".openrouter.ai");
+    }
+    catch {
+        return false;
+    }
+}
+function decodeConfig(raw) {
+    const config = (raw ?? {});
+    const envUrl = process.env.OPENAI_COMPAT_URL;
+    return {
+        url: (typeof config.url === "string" && config.url ? config.url : envUrl || "https://openrouter.ai/api/v1")
+            .replace(/\/+$/, ""),
+        apiKeyEnv: typeof config.apiKeyEnv === "string" && config.apiKeyEnv
+            ? config.apiKeyEnv
+            : "OPENAI_COMPAT_API_KEY",
+        key: typeof config.key === "string" && config.key ? config.key : undefined,
+        model: typeof config.model === "string" && config.model
+            ? config.model
+            : process.env.OPENAI_COMPAT_MODEL || undefined,
+        provider: typeof config.provider === "string" && config.provider
+            ? config.provider
+            : process.env.OPENAI_COMPAT_PROVIDER || undefined,
+    };
+}
+export const OpenAICompatDriver = {
+    driverKind: DRIVER_KIND,
+    metadata: {
+        displayName: "OpenAI-compatible (OpenRouter / Groq)",
+        supportsMultipleInstances: true,
+        access: "custom",
+    },
+    models: DEFAULT_MODELS,
+    install: {
+        docsUrl: "https://openrouter.ai/keys",
+        signInCommand: "add {\"openaiCompat\":{\"key\":\"sk-or-v1-…\"}} to ~/.openmausbot/config.json (or set OPENAI_COMPAT_API_KEY)",
+        command: {
+            darwin: "Get a free key at https://openrouter.ai/keys (or https://console.groq.com) then add it to ~/.openmausbot/config.json under openaiCompat.key",
+            linux: "Get a free key at https://openrouter.ai/keys (or https://console.groq.com) then add it to ~/.openmausbot/config.json under openaiCompat.key",
+            win32: "Get a free key at https://openrouter.ai/keys (or https://console.groq.com) then add it to %USERPROFILE%\\.openmausbot\\config.json under openaiCompat.key",
+        },
+    },
+    decodeConfig,
+    defaultConfig: () => decodeConfig({}),
+    async create(input) {
+        const { config } = input;
+        const apiKey = config.key ??
+            input.environment[config.apiKeyEnv] ??
+            input.environment.OPENAI_COMPAT_API_KEY ??
+            process.env[config.apiKeyEnv] ??
+            process.env.OPENAI_COMPAT_API_KEY ??
+            "";
+        let catalog = config.model
+            ? {
+                default: config.model,
+                options: DEFAULT_MODELS.options.some((model) => model.id === config.model)
+                    ? DEFAULT_MODELS.options
+                    : [{ id: config.model, label: config.model, custom: true }, ...DEFAULT_MODELS.options],
+            }
+            : DEFAULT_MODELS;
+        const fetchModels = async () => {
+            if (!apiKey)
+                return;
+            try {
+                const response = await fetch(`${config.url}/models`, {
+                    headers: { authorization: `Bearer ${apiKey}` },
+                    signal: AbortSignal.timeout(8_000),
+                });
+                if (!response.ok)
+                    return;
+                const json = await response.json();
+                const rows = Array.isArray(json) ? json : Array.isArray(json.data) ? json.data : [];
+                const seen = new Set();
+                const options = [];
+                for (const row of rows) {
+                    const id = typeof row.id === "string" ? row.id : "";
+                    if (!id || seen.has(id))
+                        continue;
+                    seen.add(id);
+                    options.push({
+                        id,
+                        label: typeof row.name === "string" && row.name.trim() ? row.name : id,
+                        custom: true,
+                    });
+                }
+                if (!options.length)
+                    return;
+                if (config.model && !options.some((model) => model.id === config.model)) {
+                    options.unshift({ id: config.model, label: config.model, custom: true });
+                }
+                catalog = { default: config.model ?? options[0].id, options };
+            }
+            catch {
+                // Catalog refresh is opportunistic; keep the seeded options.
+            }
+        };
+        if (apiKey)
+            void fetchModels();
+        return createOpenAIChatRuntime({
+            input,
+            driverKind: DRIVER_KIND,
+            apiKey,
+            apiUrl: config.url,
+            models: () => catalog,
+            refreshModels: fetchModels,
+            requestBody: (model, messages, stream) => ({
+                model,
+                messages,
+                stream,
+                ...(config.provider && isOpenRouterUrl(config.url)
+                    ? { provider: { order: [config.provider], allow_fallbacks: false } }
+                    : {}),
+            }),
+            httpErrorLabel: "upstream",
+            missingKeyError: `no API key — set ${config.apiKeyEnv} or add it to the instance config`,
+            unavailableReason: `no API key — set ${config.apiKeyEnv} or add it to the instance config`,
+            timeoutMs: 120_000,
+            reasoning: true,
+            billing: "metered",
+            includeUsageInCompleted: true,
+            nativeLog: {
+                source: "openai-compat.chat.completions",
+                outgoing: (_turn, messages, model) => ({ model, messageCount: messages.length }),
+                incoming: ({ text, reasoning, usage }) => ({
+                    textLength: text.length,
+                    reasoningLength: reasoning.length,
+                    usage,
+                }),
+            },
+        });
+    },
+};