clawdbot 2026.1.4-1

package/dist/agents/model-scan.js

@@ -0,0 +1,263 @@
+import { complete, getEnvApiKey, getModel, } from "@mariozechner/pi-ai";
+import { Type } from "@sinclair/typebox";
+const OPENROUTER_MODELS_URL = "https://openrouter.ai/api/v1/models";
+const DEFAULT_TIMEOUT_MS = 12_000;
+const DEFAULT_CONCURRENCY = 3;
+const BASE_IMAGE_PNG = "iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAQAAAC1HAwCAAAAC0lEQVR42mP8/x8AAwMCAO+X3mIAAAAASUVORK5CYII=";
+const TOOL_PING = {
+    name: "ping",
+    description: "Return OK.",
+    parameters: Type.Object({}),
+};
+function normalizeCreatedAtMs(value) {
+    if (typeof value !== "number" || !Number.isFinite(value))
+        return null;
+    if (value <= 0)
+        return null;
+    if (value > 1e12)
+        return Math.round(value);
+    return Math.round(value * 1000);
+}
+function inferParamBFromIdOrName(text) {
+    const raw = text.toLowerCase();
+    const matches = raw.matchAll(/(?:^|[^a-z0-9])[a-z]?(\d+(?:\.\d+)?)b(?:[^a-z0-9]|$)/g);
+    let best = null;
+    for (const match of matches) {
+        const numRaw = match[1];
+        if (!numRaw)
+            continue;
+        const value = Number(numRaw);
+        if (!Number.isFinite(value) || value <= 0)
+            continue;
+        if (best === null || value > best)
+            best = value;
+    }
+    return best;
+}
+function parseModality(modality) {
+    if (!modality)
+        return ["text"];
+    const normalized = modality.toLowerCase();
+    const parts = normalized.split(/[^a-z]+/).filter(Boolean);
+    const hasImage = parts.includes("image");
+    return hasImage ? ["text", "image"] : ["text"];
+}
+async function withTimeout(timeoutMs, fn) {
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), timeoutMs);
+    try {
+        return await fn(controller.signal);
+    }
+    finally {
+        clearTimeout(timer);
+    }
+}
+async function fetchOpenRouterModels(fetchImpl) {
+    const res = await fetchImpl(OPENROUTER_MODELS_URL, {
+        headers: { Accept: "application/json" },
+    });
+    if (!res.ok) {
+        throw new Error(`OpenRouter /models failed: HTTP ${res.status}`);
+    }
+    const payload = (await res.json());
+    const entries = Array.isArray(payload.data) ? payload.data : [];
+    return entries
+        .map((entry) => {
+        if (!entry || typeof entry !== "object")
+            return null;
+        const obj = entry;
+        const id = typeof obj.id === "string" ? obj.id.trim() : "";
+        if (!id)
+            return null;
+        const name = typeof obj.name === "string" && obj.name.trim() ? obj.name.trim() : id;
+        const contextLength = typeof obj.context_length === "number" &&
+            Number.isFinite(obj.context_length)
+            ? obj.context_length
+            : null;
+        const maxCompletionTokens = typeof obj.max_completion_tokens === "number" &&
+            Number.isFinite(obj.max_completion_tokens)
+            ? obj.max_completion_tokens
+            : typeof obj.max_output_tokens === "number" &&
+                Number.isFinite(obj.max_output_tokens)
+                ? obj.max_output_tokens
+                : null;
+        const supportedParametersCount = Array.isArray(obj.supported_parameters)
+            ? obj.supported_parameters.length
+            : 0;
+        const modality = typeof obj.modality === "string" && obj.modality.trim()
+            ? obj.modality.trim()
+            : null;
+        const inferredParamB = inferParamBFromIdOrName(`${id} ${name}`);
+        const createdAtMs = normalizeCreatedAtMs(obj.created_at);
+        return {
+            id,
+            name,
+            contextLength,
+            maxCompletionTokens,
+            supportedParametersCount,
+            modality,
+            inferredParamB,
+            createdAtMs,
+        };
+    })
+        .filter((entry) => Boolean(entry));
+}
+async function probeTool(model, apiKey, timeoutMs) {
+    const context = {
+        messages: [
+            {
+                role: "user",
+                content: "Call the ping tool with {} and nothing else.",
+                timestamp: Date.now(),
+            },
+        ],
+        tools: [TOOL_PING],
+    };
+    const startedAt = Date.now();
+    try {
+        const message = await withTimeout(timeoutMs, (signal) => complete(model, context, {
+            apiKey,
+            maxTokens: 32,
+            temperature: 0,
+            toolChoice: "required",
+            signal,
+        }));
+        const hasToolCall = message.content.some((block) => block.type === "toolCall");
+        if (!hasToolCall) {
+            return {
+                ok: false,
+                latencyMs: Date.now() - startedAt,
+                error: "No tool call returned",
+            };
+        }
+        return { ok: true, latencyMs: Date.now() - startedAt };
+    }
+    catch (err) {
+        return {
+            ok: false,
+            latencyMs: Date.now() - startedAt,
+            error: err instanceof Error ? err.message : String(err),
+        };
+    }
+}
+async function probeImage(model, apiKey, timeoutMs) {
+    const context = {
+        messages: [
+            {
+                role: "user",
+                content: [
+                    { type: "text", text: "Reply with OK." },
+                    { type: "image", data: BASE_IMAGE_PNG, mimeType: "image/png" },
+                ],
+                timestamp: Date.now(),
+            },
+        ],
+    };
+    const startedAt = Date.now();
+    try {
+        await withTimeout(timeoutMs, (signal) => complete(model, context, {
+            apiKey,
+            maxTokens: 16,
+            temperature: 0,
+            signal,
+        }));
+        return { ok: true, latencyMs: Date.now() - startedAt };
+    }
+    catch (err) {
+        return {
+            ok: false,
+            latencyMs: Date.now() - startedAt,
+            error: err instanceof Error ? err.message : String(err),
+        };
+    }
+}
+function ensureImageInput(model) {
+    if (model.input.includes("image"))
+        return model;
+    return {
+        ...model,
+        input: Array.from(new Set([...model.input, "image"])),
+    };
+}
+async function mapWithConcurrency(items, concurrency, fn) {
+    const limit = Math.max(1, Math.floor(concurrency));
+    const results = Array.from({ length: items.length });
+    let nextIndex = 0;
+    const worker = async () => {
+        while (true) {
+            const current = nextIndex;
+            nextIndex += 1;
+            if (current >= items.length)
+                return;
+            results[current] = await fn(items[current], current);
+        }
+    };
+    await Promise.all(Array.from({ length: Math.min(limit, items.length) }, () => worker()));
+    return results;
+}
+export async function scanOpenRouterModels(options = {}) {
+    const fetchImpl = options.fetchImpl ?? fetch;
+    const apiKey = options.apiKey?.trim() || getEnvApiKey("openrouter") || "";
+    if (!apiKey) {
+        throw new Error("Missing OpenRouter API key. Set OPENROUTER_API_KEY to run models scan.");
+    }
+    const timeoutMs = Math.max(1, Math.floor(options.timeoutMs ?? DEFAULT_TIMEOUT_MS));
+    const concurrency = Math.max(1, Math.floor(options.concurrency ?? DEFAULT_CONCURRENCY));
+    const minParamB = Math.max(0, Math.floor(options.minParamB ?? 0));
+    const maxAgeDays = Math.max(0, Math.floor(options.maxAgeDays ?? 0));
+    const providerFilter = options.providerFilter?.trim().toLowerCase() ?? "";
+    const catalog = await fetchOpenRouterModels(fetchImpl);
+    const now = Date.now();
+    const filtered = catalog.filter((entry) => {
+        if (!entry.id.endsWith(":free"))
+            return false;
+        if (providerFilter) {
+            const prefix = entry.id.split("/")[0]?.toLowerCase() ?? "";
+            if (prefix !== providerFilter)
+                return false;
+        }
+        if (minParamB > 0) {
+            const params = entry.inferredParamB ?? 0;
+            if (params < minParamB)
+                return false;
+        }
+        if (maxAgeDays > 0 && entry.createdAtMs) {
+            const ageMs = now - entry.createdAtMs;
+            const ageDays = ageMs / (24 * 60 * 60 * 1000);
+            if (ageDays > maxAgeDays)
+                return false;
+        }
+        return true;
+    });
+    const baseModel = getModel("openrouter", "openrouter/auto");
+    return mapWithConcurrency(filtered, concurrency, async (entry) => {
+        const model = {
+            ...baseModel,
+            id: entry.id,
+            name: entry.name || entry.id,
+            contextWindow: entry.contextLength ?? baseModel.contextWindow,
+            maxTokens: entry.maxCompletionTokens ?? baseModel.maxTokens,
+            input: parseModality(entry.modality),
+            reasoning: baseModel.reasoning,
+        };
+        const toolResult = await probeTool(model, apiKey, timeoutMs);
+        const imageResult = model.input.includes("image")
+            ? await probeImage(ensureImageInput(model), apiKey, timeoutMs)
+            : { ok: false, latencyMs: null, skipped: true };
+        return {
+            id: entry.id,
+            name: entry.name,
+            provider: "openrouter",
+            modelRef: `openrouter/${entry.id}`,
+            contextLength: entry.contextLength,
+            maxCompletionTokens: entry.maxCompletionTokens,
+            supportedParametersCount: entry.supportedParametersCount,
+            modality: entry.modality,
+            inferredParamB: entry.inferredParamB,
+            createdAtMs: entry.createdAtMs,
+            tool: toolResult,
+            image: imageResult,
+        };
+    });
+}
+export { OPENROUTER_MODELS_URL };

package/dist/agents/model-selection.js

@@ -0,0 +1,116 @@
+function normalizeAliasKey(value) {
+    return value.trim().toLowerCase();
+}
+export function modelKey(provider, model) {
+    return `${provider}/${model}`;
+}
+export function parseModelRef(raw, defaultProvider) {
+    const trimmed = raw.trim();
+    if (!trimmed)
+        return null;
+    const slash = trimmed.indexOf("/");
+    if (slash === -1) {
+        return { provider: defaultProvider, model: trimmed };
+    }
+    const provider = trimmed.slice(0, slash).trim();
+    const model = trimmed.slice(slash + 1).trim();
+    if (!provider || !model)
+        return null;
+    return { provider, model };
+}
+export function buildModelAliasIndex(params) {
+    const rawAliases = params.cfg.agent?.modelAliases ?? {};
+    const byAlias = new Map();
+    const byKey = new Map();
+    for (const [aliasRaw, targetRaw] of Object.entries(rawAliases)) {
+        const alias = aliasRaw.trim();
+        if (!alias)
+            continue;
+        const parsed = parseModelRef(String(targetRaw ?? ""), params.defaultProvider);
+        if (!parsed)
+            continue;
+        const aliasKey = normalizeAliasKey(alias);
+        byAlias.set(aliasKey, { alias, ref: parsed });
+        const key = modelKey(parsed.provider, parsed.model);
+        const existing = byKey.get(key) ?? [];
+        existing.push(alias);
+        byKey.set(key, existing);
+    }
+    return { byAlias, byKey };
+}
+export function resolveModelRefFromString(params) {
+    const trimmed = params.raw.trim();
+    if (!trimmed)
+        return null;
+    if (!trimmed.includes("/")) {
+        const aliasKey = normalizeAliasKey(trimmed);
+        const aliasMatch = params.aliasIndex?.byAlias.get(aliasKey);
+        if (aliasMatch) {
+            return { ref: aliasMatch.ref, alias: aliasMatch.alias };
+        }
+    }
+    const parsed = parseModelRef(trimmed, params.defaultProvider);
+    if (!parsed)
+        return null;
+    return { ref: parsed };
+}
+export function resolveConfiguredModelRef(params) {
+    const rawModel = params.cfg.agent?.model?.trim() || "";
+    if (rawModel) {
+        const trimmed = rawModel.trim();
+        const aliasIndex = buildModelAliasIndex({
+            cfg: params.cfg,
+            defaultProvider: params.defaultProvider,
+        });
+        const resolved = resolveModelRefFromString({
+            raw: trimmed,
+            defaultProvider: params.defaultProvider,
+            aliasIndex,
+        });
+        if (resolved)
+            return resolved.ref;
+        // TODO(steipete): drop this fallback once provider-less agent.model is fully deprecated.
+        return { provider: "anthropic", model: trimmed };
+    }
+    return { provider: params.defaultProvider, model: params.defaultModel };
+}
+export function buildAllowedModelSet(params) {
+    const rawAllowlist = params.cfg.agent?.allowedModels ?? [];
+    const allowAny = rawAllowlist.length === 0;
+    const catalogKeys = new Set(params.catalog.map((entry) => modelKey(entry.provider, entry.id)));
+    if (allowAny) {
+        return {
+            allowAny: true,
+            allowedCatalog: params.catalog,
+            allowedKeys: catalogKeys,
+        };
+    }
+    const allowedKeys = new Set();
+    for (const raw of rawAllowlist) {
+        const parsed = parseModelRef(String(raw), params.defaultProvider);
+        if (!parsed)
+            continue;
+        const key = modelKey(parsed.provider, parsed.model);
+        if (catalogKeys.has(key)) {
+            allowedKeys.add(key);
+        }
+    }
+    const allowedCatalog = params.catalog.filter((entry) => allowedKeys.has(modelKey(entry.provider, entry.id)));
+    if (allowedCatalog.length === 0) {
+        return {
+            allowAny: true,
+            allowedCatalog: params.catalog,
+            allowedKeys: catalogKeys,
+        };
+    }
+    return { allowAny: false, allowedCatalog, allowedKeys };
+}
+export function resolveThinkingDefault(params) {
+    const configured = params.cfg.agent?.thinkingDefault;
+    if (configured)
+        return configured;
+    const candidate = params.catalog?.find((entry) => entry.provider === params.provider && entry.id === params.model);
+    if (candidate?.reasoning)
+        return "low";
+    return "off";
+}

package/dist/agents/models-config.js

@@ -0,0 +1,49 @@
+import fs from "node:fs/promises";
+import path from "node:path";
+import { loadConfig } from "../config/config.js";
+import { ensureClawdbotAgentEnv, resolveClawdbotAgentDir, } from "./agent-paths.js";
+const DEFAULT_MODE = "merge";
+function isRecord(value) {
+    return Boolean(value && typeof value === "object" && !Array.isArray(value));
+}
+async function readJson(pathname) {
+    try {
+        const raw = await fs.readFile(pathname, "utf8");
+        return JSON.parse(raw);
+    }
+    catch {
+        return null;
+    }
+}
+export async function ensureClawdbotModelsJson(config) {
+    const cfg = config ?? loadConfig();
+    const providers = cfg.models?.providers;
+    if (!providers || Object.keys(providers).length === 0) {
+        return { agentDir: resolveClawdbotAgentDir(), wrote: false };
+    }
+    const mode = cfg.models?.mode ?? DEFAULT_MODE;
+    const agentDir = ensureClawdbotAgentEnv();
+    const targetPath = path.join(agentDir, "models.json");
+    let mergedProviders = providers;
+    let existingRaw = "";
+    if (mode === "merge") {
+        const existing = await readJson(targetPath);
+        if (isRecord(existing) && isRecord(existing.providers)) {
+            const existingProviders = existing.providers;
+            mergedProviders = { ...existingProviders, ...providers };
+        }
+    }
+    const next = `${JSON.stringify({ providers: mergedProviders }, null, 2)}\n`;
+    try {
+        existingRaw = await fs.readFile(targetPath, "utf8");
+    }
+    catch {
+        existingRaw = "";
+    }
+    if (existingRaw === next) {
+        return { agentDir, wrote: false };
+    }
+    await fs.mkdir(agentDir, { recursive: true, mode: 0o700 });
+    await fs.writeFile(targetPath, next, { mode: 0o600 });
+    return { agentDir, wrote: true };
+}

package/dist/agents/pi-embedded-helpers.js

@@ -0,0 +1,74 @@
+import fs from "node:fs/promises";
+import path from "node:path";
+import { sanitizeContentBlocksImages } from "./tool-images.js";
+export async function ensureSessionHeader(params) {
+    const file = params.sessionFile;
+    try {
+        await fs.stat(file);
+        return;
+    }
+    catch {
+        // create
+    }
+    await fs.mkdir(path.dirname(file), { recursive: true });
+    const sessionVersion = 2;
+    const entry = {
+        type: "session",
+        version: sessionVersion,
+        id: params.sessionId,
+        timestamp: new Date().toISOString(),
+        cwd: params.cwd,
+    };
+    await fs.writeFile(file, `${JSON.stringify(entry)}\n`, "utf-8");
+}
+export async function sanitizeSessionMessagesImages(messages, label) {
+    // We sanitize historical session messages because Anthropic can reject a request
+    // if the transcript contains oversized base64 images (see MAX_IMAGE_DIMENSION_PX).
+    const out = [];
+    for (const msg of messages) {
+        if (!msg || typeof msg !== "object") {
+            out.push(msg);
+            continue;
+        }
+        const role = msg.role;
+        if (role === "toolResult") {
+            const toolMsg = msg;
+            const content = Array.isArray(toolMsg.content) ? toolMsg.content : [];
+            const nextContent = (await sanitizeContentBlocksImages(content, label));
+            out.push({ ...toolMsg, content: nextContent });
+            continue;
+        }
+        if (role === "user") {
+            const userMsg = msg;
+            const content = userMsg.content;
+            if (Array.isArray(content)) {
+                const nextContent = (await sanitizeContentBlocksImages(content, label));
+                out.push({ ...userMsg, content: nextContent });
+                continue;
+            }
+        }
+        out.push(msg);
+    }
+    return out;
+}
+export function buildBootstrapContextFiles(files) {
+    return files.map((file) => ({
+        path: file.name,
+        content: file.missing
+            ? `[MISSING] Expected at: ${file.path}`
+            : (file.content ?? ""),
+    }));
+}
+export function formatAssistantErrorText(msg) {
+    if (msg.stopReason !== "error")
+        return undefined;
+    const raw = (msg.errorMessage ?? "").trim();
+    if (!raw)
+        return "LLM request failed with an unknown error.";
+    const invalidRequest = raw.match(/"type":"invalid_request_error".*?"message":"([^"]+)"/);
+    if (invalidRequest?.[1]) {
+        return `LLM request rejected: ${invalidRequest[1]}`;
+    }
+    // Keep it short for WhatsApp.
+    return raw.length > 600 ? `${raw.slice(0, 600)}…` : raw;
+}