@intent-systems/nexus 2026.1.5-3

package/dist/agents/chutes-oauth.js

@@ -0,0 +1,47 @@
+export const CHUTES_TOKEN_ENDPOINT = "https://api.chutes.ai/idp/token";
+function parseExpiresIn(expiresIn) {
+    if (typeof expiresIn === "number")
+        return expiresIn;
+    if (typeof expiresIn === "string") {
+        const parsed = Number.parseInt(expiresIn, 10);
+        return Number.isFinite(parsed) ? parsed : undefined;
+    }
+    return undefined;
+}
+export async function refreshChutesTokens(params) {
+    const { credential } = params;
+    if (!credential.refresh) {
+        throw new Error("Chutes refresh token missing");
+    }
+    const clientId = credential.clientId?.trim() || process.env.CHUTES_CLIENT_ID?.trim() || "";
+    if (!clientId) {
+        throw new Error("CHUTES_CLIENT_ID is required to refresh tokens");
+    }
+    const body = new URLSearchParams({
+        grant_type: "refresh_token",
+        refresh_token: credential.refresh,
+        client_id: clientId,
+    });
+    const res = await fetch(CHUTES_TOKEN_ENDPOINT, {
+        method: "POST",
+        headers: { "content-type": "application/x-www-form-urlencoded" },
+        body,
+    });
+    if (!res.ok) {
+        const text = await res.text().catch(() => "");
+        throw new Error(`Chutes token refresh failed (${res.status}): ${text || "no response"}`);
+    }
+    const data = (await res.json());
+    if (!data.access_token) {
+        throw new Error("Chutes token refresh missing access_token");
+    }
+    const expiresIn = parseExpiresIn(data.expires_in);
+    const expires = typeof expiresIn === "number" ? Date.now() + expiresIn * 1000 : undefined;
+    return {
+        access: data.access_token,
+        refresh: data.refresh_token ?? credential.refresh,
+        expires,
+        email: credential.email,
+        clientId,
+    };
+}

package/dist/agents/clawdbot-tools.js

@@ -0,0 +1,62 @@
+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 { createMemoryGetTool, createMemorySearchTool } from "./tools/memory-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 { createSessionsSpawnTool } from "./tools/sessions-spawn-tool.js";
+import { createSlackTool } from "./tools/slack-tool.js";
+import { createTelegramTool } from "./tools/telegram-tool.js";
+import { createWhatsAppLoginTool } from "./tools/whatsapp-login-tool.js";
+export function createNexusTools(options) {
+    const imageTool = createImageTool({
+        config: options?.config,
+        agentDir: options?.agentDir,
+    });
+    const memorySearchTool = createMemorySearchTool({
+        config: options?.config,
+        agentSessionKey: options?.agentSessionKey,
+    });
+    const memoryGetTool = createMemoryGetTool({
+        config: options?.config,
+        agentSessionKey: options?.agentSessionKey,
+    });
+    return [
+        createBrowserTool({ defaultControlUrl: options?.browserControlUrl }),
+        createCanvasTool(),
+        createNodesTool(),
+        createCronTool(),
+        createDiscordTool(),
+        createSlackTool(),
+        createTelegramTool(),
+        createWhatsAppLoginTool(),
+        createGatewayTool(),
+        createSessionsListTool({
+            agentSessionKey: options?.agentSessionKey,
+            sandboxed: options?.sandboxed,
+        }),
+        createSessionsHistoryTool({
+            agentSessionKey: options?.agentSessionKey,
+            sandboxed: options?.sandboxed,
+        }),
+        createSessionsSendTool({
+            agentSessionKey: options?.agentSessionKey,
+            agentChannel: options?.agentChannel,
+            sandboxed: options?.sandboxed,
+        }),
+        createSessionsSpawnTool({
+            agentSessionKey: options?.agentSessionKey,
+            agentChannel: options?.agentChannel,
+            sandboxed: options?.sandboxed,
+        }),
+        ...(memorySearchTool && memoryGetTool ? [memorySearchTool, memoryGetTool] : []),
+        ...(imageTool ? [imageTool] : []),
+    ];
+}
+/** @deprecated Use createNexusTools() */
+export const createClawdbotTools = createNexusTools;

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 { resolveNexusAgentDir } from "./agent-paths.js";
+import { ensureNexusModelsJson } 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 ensureNexusModelsJson(cfg);
+        const agentDir = resolveNexusAgentDir();
+        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/memory-search.js

@@ -0,0 +1,80 @@
+import os from "node:os";
+import path from "node:path";
+import { resolveStateDir } from "../config/paths.js";
+import { resolveUserPath } from "../utils.js";
+import { resolveAgentConfig } from "./agent-scope.js";
+const DEFAULT_MODEL = "text-embedding-3-small";
+const DEFAULT_CHUNK_TOKENS = 400;
+const DEFAULT_CHUNK_OVERLAP = 80;
+const DEFAULT_WATCH_DEBOUNCE_MS = 1500;
+const DEFAULT_MAX_RESULTS = 6;
+const DEFAULT_MIN_SCORE = 0.35;
+function resolveStorePath(agentId, raw) {
+    const stateDir = resolveStateDir(process.env, os.homedir);
+    const fallback = path.join(stateDir, "memory", `${agentId}.sqlite`);
+    if (!raw)
+        return fallback;
+    const withToken = raw.includes("{agentId}") ? raw.replaceAll("{agentId}", agentId) : raw;
+    return resolveUserPath(withToken);
+}
+function mergeConfig(defaults, overrides, agentId) {
+    const enabled = overrides?.enabled ?? defaults?.enabled ?? true;
+    const provider = overrides?.provider ?? defaults?.provider ?? "openai";
+    const hasRemote = Boolean(defaults?.remote || overrides?.remote);
+    const remote = hasRemote
+        ? {
+            baseUrl: overrides?.remote?.baseUrl ?? defaults?.remote?.baseUrl,
+            apiKey: overrides?.remote?.apiKey ?? defaults?.remote?.apiKey,
+            headers: overrides?.remote?.headers ?? defaults?.remote?.headers,
+        }
+        : undefined;
+    const fallback = overrides?.fallback ?? defaults?.fallback ?? "openai";
+    const model = overrides?.model ?? defaults?.model ?? DEFAULT_MODEL;
+    const local = {
+        modelPath: overrides?.local?.modelPath ?? defaults?.local?.modelPath,
+        modelCacheDir: overrides?.local?.modelCacheDir ?? defaults?.local?.modelCacheDir,
+    };
+    const store = {
+        driver: overrides?.store?.driver ?? defaults?.store?.driver ?? "sqlite",
+        path: resolveStorePath(agentId, overrides?.store?.path ?? defaults?.store?.path),
+    };
+    const chunking = {
+        tokens: overrides?.chunking?.tokens ?? defaults?.chunking?.tokens ?? DEFAULT_CHUNK_TOKENS,
+        overlap: overrides?.chunking?.overlap ?? defaults?.chunking?.overlap ?? DEFAULT_CHUNK_OVERLAP,
+    };
+    const sync = {
+        onSessionStart: overrides?.sync?.onSessionStart ?? defaults?.sync?.onSessionStart ?? true,
+        onSearch: overrides?.sync?.onSearch ?? defaults?.sync?.onSearch ?? true,
+        watch: overrides?.sync?.watch ?? defaults?.sync?.watch ?? true,
+        watchDebounceMs: overrides?.sync?.watchDebounceMs ??
+            defaults?.sync?.watchDebounceMs ??
+            DEFAULT_WATCH_DEBOUNCE_MS,
+        intervalMinutes: overrides?.sync?.intervalMinutes ?? defaults?.sync?.intervalMinutes ?? 0,
+    };
+    const query = {
+        maxResults: overrides?.query?.maxResults ?? defaults?.query?.maxResults ?? DEFAULT_MAX_RESULTS,
+        minScore: overrides?.query?.minScore ?? defaults?.query?.minScore ?? DEFAULT_MIN_SCORE,
+    };
+    const overlap = Math.max(0, Math.min(chunking.overlap, chunking.tokens - 1));
+    const minScore = Math.max(0, Math.min(1, query.minScore));
+    return {
+        enabled,
+        provider,
+        remote,
+        fallback,
+        model,
+        local,
+        store,
+        chunking: { tokens: Math.max(1, chunking.tokens), overlap },
+        sync,
+        query: { ...query, minScore },
+    };
+}
+export function resolveMemorySearchConfig(cfg, agentId) {
+    const defaults = cfg.agent?.memorySearch;
+    const overrides = resolveAgentConfig(cfg, agentId)?.memorySearch;
+    const resolved = mergeConfig(defaults, overrides, agentId);
+    if (!resolved.enabled)
+        return null;
+    return resolved;
+}

package/dist/agents/model-auth.js

@@ -0,0 +1,115 @@
+import { getEnvApiKey } from "@mariozechner/pi-ai";
+import { getShellEnvAppliedKeys } from "../infra/shell-env.js";
+import { ensureAuthProfileStore, listProfilesForProvider, resolveApiKeyForProfile, resolveAuthProfileOrder, } from "./auth-profiles.js";
+export { ensureAuthProfileStore, resolveAuthProfileOrder, } from "./auth-profiles.js";
+export function getCustomProviderApiKey(cfg, provider) {
+    const providers = cfg?.models?.providers ?? {};
+    const entry = providers[provider];
+    const key = entry?.apiKey?.trim();
+    return key || undefined;
+}
+export async function resolveApiKeyForProvider(params) {
+    const { provider, cfg, profileId, preferredProfile } = params;
+    const store = params.store ?? ensureAuthProfileStore(params.agentDir);
+    if (profileId) {
+        const resolved = await resolveApiKeyForProfile({
+            cfg,
+            store,
+            profileId,
+        });
+        if (!resolved) {
+            throw new Error(`No credentials found for profile "${profileId}".`);
+        }
+        return {
+            apiKey: resolved.apiKey,
+            profileId,
+            source: `profile:${profileId}`,
+        };
+    }
+    const order = resolveAuthProfileOrder({
+        cfg,
+        store,
+        provider,
+        preferredProfile,
+    });
+    for (const candidate of order) {
+        try {
+            const resolved = await resolveApiKeyForProfile({
+                cfg,
+                store,
+                profileId: candidate,
+            });
+            if (resolved) {
+                return {
+                    apiKey: resolved.apiKey,
+                    profileId: candidate,
+                    source: `profile:${candidate}`,
+                };
+            }
+        }
+        catch { }
+    }
+    const envResolved = resolveEnvApiKey(provider);
+    if (envResolved) {
+        return { apiKey: envResolved.apiKey, source: envResolved.source };
+    }
+    const customKey = getCustomProviderApiKey(cfg, provider);
+    if (customKey) {
+        return { apiKey: customKey, source: "models.json" };
+    }
+    if (provider === "openai") {
+        const hasCodex = listProfilesForProvider(store, "openai-codex").length > 0;
+        if (hasCodex) {
+            throw new Error('No API key found for provider "openai". You are authenticated with OpenAI Codex OAuth. Use openai-codex/gpt-5.2 (ChatGPT OAuth) or set OPENAI_API_KEY for openai/gpt-5.2.');
+        }
+    }
+    throw new Error(`No API key found for provider "${provider}".`);
+}
+export function resolveEnvApiKey(provider) {
+    const applied = new Set(getShellEnvAppliedKeys());
+    const pick = (envVar) => {
+        const value = process.env[envVar]?.trim();
+        if (!value)
+            return null;
+        const source = applied.has(envVar)
+            ? `shell env: ${envVar}`
+            : `env: ${envVar}`;
+        return { apiKey: value, source };
+    };
+    if (provider === "github-copilot") {
+        return (pick("COPILOT_GITHUB_TOKEN") ?? pick("GH_TOKEN") ?? pick("GITHUB_TOKEN"));
+    }
+    if (provider === "anthropic") {
+        return pick("ANTHROPIC_OAUTH_TOKEN") ?? pick("ANTHROPIC_API_KEY");
+    }
+    if (provider === "google-vertex") {
+        const envKey = getEnvApiKey(provider);
+        if (!envKey)
+            return null;
+        return { apiKey: envKey, source: "gcloud adc" };
+    }
+    const envMap = {
+        openai: "OPENAI_API_KEY",
+        google: "GEMINI_API_KEY",
+        groq: "GROQ_API_KEY",
+        cerebras: "CEREBRAS_API_KEY",
+        xai: "XAI_API_KEY",
+        openrouter: "OPENROUTER_API_KEY",
+        zai: "ZAI_API_KEY",
+        mistral: "MISTRAL_API_KEY",
+    };
+    const envVar = envMap[provider];
+    if (!envVar)
+        return null;
+    return pick(envVar);
+}
+export async function getApiKeyForModel(params) {
+    return resolveApiKeyForProvider({
+        provider: params.model.provider,
+        cfg: params.cfg,
+        profileId: params.profileId,
+        preferredProfile: params.preferredProfile,
+        store: params.store,
+        agentDir: params.agentDir,
+    });
+}

package/dist/agents/model-catalog.js

@@ -0,0 +1,55 @@
+import { loadConfig } from "../config/config.js";
+import { resolveNexusAgentDir } from "./agent-paths.js";
+import { ensureNexusModelsJson } 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 ensureNexusModelsJson(cfg);
+            const agentDir = resolveNexusAgentDir();
+            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,210 @@
+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 = (() => {
+        const modelMap = cfg?.agent?.models ?? {};
+        return Object.keys(modelMap);
+    })();
+    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 {
+        const imageModel = params.cfg?.agent?.imageModel;
+        const primary = typeof imageModel === "string" ? imageModel.trim() : imageModel?.primary;
+        if (primary?.trim())
+            addRaw(primary, false);
+    }
+    const imageFallbacks = (() => {
+        const imageModel = params.cfg?.agent?.imageModel;
+        if (imageModel && typeof imageModel === "object") {
+            return imageModel.fallbacks ?? [];
+        }
+        return [];
+    })();
+    for (const raw of imageFallbacks) {
+        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);
+    const modelFallbacks = (() => {
+        const model = params.cfg?.agent?.model;
+        if (model && typeof model === "object")
+            return model.fallbacks ?? [];
+        return [];
+    })();
+    for (const raw of 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.primary or agent.imageModel.fallbacks.");
+    }
+    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 });
+}