clawdbot 2026.1.4-1

package/dist/agents/clawdbot-tools.js

@@ -0,0 +1,30 @@
+import { createBrowserTool } from "./tools/browser-tool.js";
+import { createCanvasTool } from "./tools/canvas-tool.js";
+import { createCronTool } from "./tools/cron-tool.js";
+import { createDiscordTool } from "./tools/discord-tool.js";
+import { createGatewayTool } from "./tools/gateway-tool.js";
+import { createImageTool } from "./tools/image-tool.js";
+import { createNodesTool } from "./tools/nodes-tool.js";
+import { createSessionsHistoryTool } from "./tools/sessions-history-tool.js";
+import { createSessionsListTool } from "./tools/sessions-list-tool.js";
+import { createSessionsSendTool } from "./tools/sessions-send-tool.js";
+import { createSlackTool } from "./tools/slack-tool.js";
+export function createClawdbotTools(options) {
+    const imageTool = createImageTool({ config: options?.config });
+    return [
+        createBrowserTool({ defaultControlUrl: options?.browserControlUrl }),
+        createCanvasTool(),
+        createNodesTool(),
+        createCronTool(),
+        createDiscordTool(),
+        createSlackTool(),
+        createGatewayTool(),
+        createSessionsListTool(),
+        createSessionsHistoryTool(),
+        createSessionsSendTool({
+            agentSessionKey: options?.agentSessionKey,
+            agentSurface: options?.agentSurface,
+        }),
+        ...(imageTool ? [imageTool] : []),
+    ];
+}

package/dist/agents/clawdis-tools.js

@@ -0,0 +1,27 @@
+import { createBrowserTool } from "./tools/browser-tool.js";
+import { createCanvasTool } from "./tools/canvas-tool.js";
+import { createCronTool } from "./tools/cron-tool.js";
+import { createDiscordTool } from "./tools/discord-tool.js";
+import { createGatewayTool } from "./tools/gateway-tool.js";
+import { createNodesTool } from "./tools/nodes-tool.js";
+import { createSessionsHistoryTool } from "./tools/sessions-history-tool.js";
+import { createSessionsListTool } from "./tools/sessions-list-tool.js";
+import { createSessionsSendTool } from "./tools/sessions-send-tool.js";
+import { createSlackTool } from "./tools/slack-tool.js";
+export function createClawdisTools(options) {
+    return [
+        createBrowserTool({ defaultControlUrl: options?.browserControlUrl }),
+        createCanvasTool(),
+        createNodesTool(),
+        createCronTool(),
+        createDiscordTool(),
+        createSlackTool(),
+        createGatewayTool(),
+        createSessionsListTool(),
+        createSessionsHistoryTool(),
+        createSessionsSendTool({
+            agentSessionKey: options?.agentSessionKey,
+            agentSurface: options?.agentSurface,
+        }),
+    ];
+}

package/dist/agents/context.js

@@ -0,0 +1,34 @@
+// Lazy-load pi-coding-agent model metadata so we can infer context windows when
+// the agent reports a model id. This includes custom models.json entries.
+import { loadConfig } from "../config/config.js";
+import { resolveClawdbotAgentDir } from "./agent-paths.js";
+import { ensureClawdbotModelsJson } from "./models-config.js";
+const MODEL_CACHE = new Map();
+const loadPromise = (async () => {
+    try {
+        const { discoverAuthStorage, discoverModels } = await import("@mariozechner/pi-coding-agent");
+        const cfg = loadConfig();
+        await ensureClawdbotModelsJson(cfg);
+        const agentDir = resolveClawdbotAgentDir();
+        const authStorage = discoverAuthStorage(agentDir);
+        const modelRegistry = discoverModels(authStorage, agentDir);
+        const models = modelRegistry.getAll();
+        for (const m of models) {
+            if (!m?.id)
+                continue;
+            if (typeof m.contextWindow === "number" && m.contextWindow > 0) {
+                MODEL_CACHE.set(m.id, m.contextWindow);
+            }
+        }
+    }
+    catch {
+        // If pi-ai isn't available, leave cache empty; lookup will fall back.
+    }
+})();
+export function lookupContextTokens(modelId) {
+    if (!modelId)
+        return undefined;
+    // Best-effort: kick off loading, but don't block.
+    void loadPromise;
+    return MODEL_CACHE.get(modelId);
+}

package/dist/agents/defaults.js

@@ -0,0 +1,6 @@
+// Defaults for agent metadata when upstream does not supply them.
+// Model id uses pi-ai's built-in Anthropic catalog.
+export const DEFAULT_PROVIDER = "anthropic";
+export const DEFAULT_MODEL = "claude-opus-4-5";
+// Context window: Opus 4.5 supports ~200k tokens (per pi-ai models.generated.ts).
+export const DEFAULT_CONTEXT_TOKENS = 200_000;

package/dist/agents/model-auth.js

@@ -0,0 +1,112 @@
+import fsSync from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { getEnvApiKey, getOAuthApiKey, } from "@mariozechner/pi-ai";
+import { CONFIG_DIR, resolveUserPath } from "../utils.js";
+const OAUTH_FILENAME = "oauth.json";
+const DEFAULT_OAUTH_DIR = path.join(CONFIG_DIR, "credentials");
+let oauthStorageConfigured = false;
+function resolveClawdbotOAuthPath() {
+    const overrideDir = process.env.CLAWDBOT_OAUTH_DIR?.trim() || DEFAULT_OAUTH_DIR;
+    return path.join(resolveUserPath(overrideDir), OAUTH_FILENAME);
+}
+function loadOAuthStorageAt(pathname) {
+    if (!fsSync.existsSync(pathname))
+        return null;
+    try {
+        const content = fsSync.readFileSync(pathname, "utf8");
+        const json = JSON.parse(content);
+        if (!json || typeof json !== "object")
+            return null;
+        return json;
+    }
+    catch {
+        return null;
+    }
+}
+function hasAnthropicOAuth(storage) {
+    const entry = storage.anthropic;
+    if (!entry)
+        return false;
+    const refresh = entry.refresh ?? entry.refresh_token ?? entry.refreshToken ?? "";
+    const access = entry.access ?? entry.access_token ?? entry.accessToken ?? "";
+    return Boolean(refresh.trim() && access.trim());
+}
+function saveOAuthStorageAt(pathname, storage) {
+    const dir = path.dirname(pathname);
+    fsSync.mkdirSync(dir, { recursive: true, mode: 0o700 });
+    fsSync.writeFileSync(pathname, `${JSON.stringify(storage, null, 2)}\n`, "utf8");
+    fsSync.chmodSync(pathname, 0o600);
+}
+function legacyOAuthPaths() {
+    const paths = [];
+    const piOverride = process.env.PI_CODING_AGENT_DIR?.trim();
+    if (piOverride) {
+        paths.push(path.join(resolveUserPath(piOverride), OAUTH_FILENAME));
+    }
+    paths.push(path.join(os.homedir(), ".pi", "agent", OAUTH_FILENAME));
+    paths.push(path.join(os.homedir(), ".claude", OAUTH_FILENAME));
+    paths.push(path.join(os.homedir(), ".config", "claude", OAUTH_FILENAME));
+    paths.push(path.join(os.homedir(), ".config", "anthropic", OAUTH_FILENAME));
+    return Array.from(new Set(paths));
+}
+function importLegacyOAuthIfNeeded(destPath) {
+    if (fsSync.existsSync(destPath))
+        return;
+    for (const legacyPath of legacyOAuthPaths()) {
+        const storage = loadOAuthStorageAt(legacyPath);
+        if (!storage || !hasAnthropicOAuth(storage))
+            continue;
+        saveOAuthStorageAt(destPath, storage);
+        return;
+    }
+}
+export function ensureOAuthStorage() {
+    if (oauthStorageConfigured)
+        return;
+    oauthStorageConfigured = true;
+    const oauthPath = resolveClawdbotOAuthPath();
+    importLegacyOAuthIfNeeded(oauthPath);
+}
+function isOAuthProvider(provider) {
+    return (provider === "anthropic" ||
+        provider === "anthropic-oauth" ||
+        provider === "google" ||
+        provider === "openai" ||
+        provider === "openai-compatible" ||
+        provider === "github-copilot" ||
+        provider === "google-gemini-cli" ||
+        provider === "google-antigravity");
+}
+export async function getApiKeyForModel(model, authStorage) {
+    const storedKey = await authStorage.getApiKey(model.provider);
+    if (storedKey)
+        return storedKey;
+    ensureOAuthStorage();
+    if (model.provider === "anthropic") {
+        const oauthEnv = process.env.ANTHROPIC_OAUTH_TOKEN;
+        if (oauthEnv?.trim())
+            return oauthEnv.trim();
+    }
+    const envKey = getEnvApiKey(model.provider);
+    if (envKey)
+        return envKey;
+    if (isOAuthProvider(model.provider)) {
+        const oauthPath = resolveClawdbotOAuthPath();
+        const storage = loadOAuthStorageAt(oauthPath);
+        if (storage) {
+            try {
+                const result = await getOAuthApiKey(model.provider, storage);
+                if (result?.apiKey) {
+                    storage[model.provider] = result.newCredentials;
+                    saveOAuthStorageAt(oauthPath, storage);
+                    return result.apiKey;
+                }
+            }
+            catch {
+                // fall through to error below
+            }
+        }
+    }
+    throw new Error(`No API key found for provider "${model.provider}"`);
+}

package/dist/agents/model-catalog.js

@@ -0,0 +1,55 @@
+import { loadConfig } from "../config/config.js";
+import { resolveClawdbotAgentDir } from "./agent-paths.js";
+import { ensureClawdbotModelsJson } from "./models-config.js";
+let modelCatalogPromise = null;
+export function resetModelCatalogCacheForTest() {
+    modelCatalogPromise = null;
+}
+export async function loadModelCatalog(params) {
+    if (params?.useCache === false) {
+        modelCatalogPromise = null;
+    }
+    if (modelCatalogPromise)
+        return modelCatalogPromise;
+    modelCatalogPromise = (async () => {
+        const piSdk = await import("@mariozechner/pi-coding-agent");
+        const models = [];
+        try {
+            const cfg = params?.config ?? loadConfig();
+            await ensureClawdbotModelsJson(cfg);
+            const agentDir = resolveClawdbotAgentDir();
+            const authStorage = piSdk.discoverAuthStorage(agentDir);
+            const registry = piSdk.discoverModels(authStorage, agentDir);
+            const entries = Array.isArray(registry) ? registry : registry.getAll();
+            for (const entry of entries) {
+                const id = String(entry?.id ?? "").trim();
+                if (!id)
+                    continue;
+                const provider = String(entry?.provider ?? "").trim();
+                if (!provider)
+                    continue;
+                const name = String(entry?.name ?? id).trim() || id;
+                const contextWindow = typeof entry?.contextWindow === "number" && entry.contextWindow > 0
+                    ? entry.contextWindow
+                    : undefined;
+                const reasoning = typeof entry?.reasoning === "boolean" ? entry.reasoning : undefined;
+                models.push({ id, name, provider, contextWindow, reasoning });
+            }
+            if (models.length === 0) {
+                // If we found nothing, don't cache this result so we can try again.
+                modelCatalogPromise = null;
+            }
+        }
+        catch {
+            // Leave models empty on discovery errors and don't cache.
+            modelCatalogPromise = null;
+        }
+        return models.sort((a, b) => {
+            const p = a.provider.localeCompare(b.provider);
+            if (p !== 0)
+                return p;
+            return a.name.localeCompare(b.name);
+        });
+    })();
+    return modelCatalogPromise;
+}

package/dist/agents/model-fallback.js

@@ -0,0 +1,191 @@
+import { DEFAULT_MODEL, DEFAULT_PROVIDER } from "./defaults.js";
+import { buildModelAliasIndex, modelKey, parseModelRef, resolveModelRefFromString, } from "./model-selection.js";
+function isAbortError(err) {
+    if (!err || typeof err !== "object")
+        return false;
+    const name = "name" in err ? String(err.name) : "";
+    if (name === "AbortError")
+        return true;
+    const message = "message" in err && typeof err.message === "string"
+        ? err.message.toLowerCase()
+        : "";
+    return message.includes("aborted");
+}
+function buildAllowedModelKeys(cfg, defaultProvider) {
+    const rawAllowlist = cfg?.agent?.allowedModels ?? [];
+    if (rawAllowlist.length === 0)
+        return null;
+    const keys = new Set();
+    for (const raw of rawAllowlist) {
+        const parsed = parseModelRef(String(raw ?? ""), defaultProvider);
+        if (!parsed)
+            continue;
+        keys.add(modelKey(parsed.provider, parsed.model));
+    }
+    return keys.size > 0 ? keys : null;
+}
+function resolveImageFallbackCandidates(params) {
+    const aliasIndex = buildModelAliasIndex({
+        cfg: params.cfg ?? {},
+        defaultProvider: params.defaultProvider,
+    });
+    const allowlist = buildAllowedModelKeys(params.cfg, params.defaultProvider);
+    const seen = new Set();
+    const candidates = [];
+    const addCandidate = (candidate, enforceAllowlist) => {
+        if (!candidate.provider || !candidate.model)
+            return;
+        const key = modelKey(candidate.provider, candidate.model);
+        if (seen.has(key))
+            return;
+        if (enforceAllowlist && allowlist && !allowlist.has(key))
+            return;
+        seen.add(key);
+        candidates.push(candidate);
+    };
+    const addRaw = (raw, enforceAllowlist) => {
+        const resolved = resolveModelRefFromString({
+            raw: String(raw ?? ""),
+            defaultProvider: params.defaultProvider,
+            aliasIndex,
+        });
+        if (!resolved)
+            return;
+        addCandidate(resolved.ref, enforceAllowlist);
+    };
+    if (params.modelOverride?.trim()) {
+        addRaw(params.modelOverride, false);
+    }
+    else if (params.cfg?.agent?.imageModel?.trim()) {
+        addRaw(params.cfg.agent.imageModel, false);
+    }
+    for (const raw of params.cfg?.agent?.imageModelFallbacks ?? []) {
+        addRaw(raw, true);
+    }
+    return candidates;
+}
+function resolveFallbackCandidates(params) {
+    const provider = params.provider.trim() || DEFAULT_PROVIDER;
+    const model = params.model.trim() || DEFAULT_MODEL;
+    const aliasIndex = buildModelAliasIndex({
+        cfg: params.cfg ?? {},
+        defaultProvider: DEFAULT_PROVIDER,
+    });
+    const allowlist = buildAllowedModelKeys(params.cfg, DEFAULT_PROVIDER);
+    const seen = new Set();
+    const candidates = [];
+    const addCandidate = (candidate, enforceAllowlist) => {
+        if (!candidate.provider || !candidate.model)
+            return;
+        const key = modelKey(candidate.provider, candidate.model);
+        if (seen.has(key))
+            return;
+        if (enforceAllowlist && allowlist && !allowlist.has(key))
+            return;
+        seen.add(key);
+        candidates.push(candidate);
+    };
+    addCandidate({ provider, model }, false);
+    for (const raw of params.cfg?.agent?.modelFallbacks ?? []) {
+        const resolved = resolveModelRefFromString({
+            raw: String(raw ?? ""),
+            defaultProvider: DEFAULT_PROVIDER,
+            aliasIndex,
+        });
+        if (!resolved)
+            continue;
+        addCandidate(resolved.ref, true);
+    }
+    return candidates;
+}
+export async function runWithModelFallback(params) {
+    const candidates = resolveFallbackCandidates(params);
+    const attempts = [];
+    let lastError;
+    for (let i = 0; i < candidates.length; i += 1) {
+        const candidate = candidates[i];
+        try {
+            const result = await params.run(candidate.provider, candidate.model);
+            return {
+                result,
+                provider: candidate.provider,
+                model: candidate.model,
+                attempts,
+            };
+        }
+        catch (err) {
+            if (isAbortError(err))
+                throw err;
+            lastError = err;
+            attempts.push({
+                provider: candidate.provider,
+                model: candidate.model,
+                error: err instanceof Error ? err.message : String(err),
+            });
+            await params.onError?.({
+                provider: candidate.provider,
+                model: candidate.model,
+                error: err,
+                attempt: i + 1,
+                total: candidates.length,
+            });
+        }
+    }
+    if (attempts.length <= 1 && lastError)
+        throw lastError;
+    const summary = attempts.length > 0
+        ? attempts
+            .map((attempt) => `${attempt.provider}/${attempt.model}: ${attempt.error}`)
+            .join(" | ")
+        : "unknown";
+    throw new Error(`All models failed (${attempts.length || candidates.length}): ${summary}`, { cause: lastError instanceof Error ? lastError : undefined });
+}
+export async function runWithImageModelFallback(params) {
+    const candidates = resolveImageFallbackCandidates({
+        cfg: params.cfg,
+        defaultProvider: DEFAULT_PROVIDER,
+        modelOverride: params.modelOverride,
+    });
+    if (candidates.length === 0) {
+        throw new Error("No image model configured. Set agent.imageModel or agent.imageModelFallbacks.");
+    }
+    const attempts = [];
+    let lastError;
+    for (let i = 0; i < candidates.length; i += 1) {
+        const candidate = candidates[i];
+        try {
+            const result = await params.run(candidate.provider, candidate.model);
+            return {
+                result,
+                provider: candidate.provider,
+                model: candidate.model,
+                attempts,
+            };
+        }
+        catch (err) {
+            if (isAbortError(err))
+                throw err;
+            lastError = err;
+            attempts.push({
+                provider: candidate.provider,
+                model: candidate.model,
+                error: err instanceof Error ? err.message : String(err),
+            });
+            await params.onError?.({
+                provider: candidate.provider,
+                model: candidate.model,
+                error: err,
+                attempt: i + 1,
+                total: candidates.length,
+            });
+        }
+    }
+    if (attempts.length <= 1 && lastError)
+        throw lastError;
+    const summary = attempts.length > 0
+        ? attempts
+            .map((attempt) => `${attempt.provider}/${attempt.model}: ${attempt.error}`)
+            .join(" | ")
+        : "unknown";
+    throw new Error(`All image models failed (${attempts.length || candidates.length}): ${summary}`, { cause: lastError instanceof Error ? lastError : undefined });
+}