@intent-systems/nexus 2026.1.5-3

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,152 @@
+function normalizeAliasKey(value) {
+    return value.trim().toLowerCase();
+}
+export function modelKey(provider, model) {
+    return `${provider}/${model}`;
+}
+export function normalizeProviderId(provider) {
+    const normalized = provider.trim().toLowerCase();
+    if (normalized === "z.ai" || normalized === "z-ai")
+        return "zai";
+    return normalized;
+}
+function normalizeModelId(provider, model) {
+    const trimmedModel = model.trim();
+    if (!trimmedModel)
+        return trimmedModel;
+    const normalizedProvider = normalizeProviderId(provider);
+    if (normalizedProvider === "google") {
+        const lower = trimmedModel.toLowerCase();
+        if (lower.startsWith("gemini-3-") && !lower.endsWith("-preview")) {
+            return `${trimmedModel}-preview`;
+        }
+    }
+    return trimmedModel;
+}
+export function parseModelRef(raw, defaultProvider) {
+    const trimmed = raw.trim();
+    if (!trimmed)
+        return null;
+    const slash = trimmed.indexOf("/");
+    if (slash === -1) {
+        return {
+            provider: defaultProvider,
+            model: normalizeModelId(defaultProvider, trimmed),
+        };
+    }
+    const provider = trimmed.slice(0, slash).trim();
+    const model = trimmed.slice(slash + 1).trim();
+    if (!provider || !model)
+        return null;
+    return { provider, model: normalizeModelId(provider, model) };
+}
+export function buildModelAliasIndex(params) {
+    const byAlias = new Map();
+    const byKey = new Map();
+    const rawModels = params.cfg.agent?.models ?? {};
+    for (const [keyRaw, entryRaw] of Object.entries(rawModels)) {
+        const parsed = parseModelRef(String(keyRaw ?? ""), params.defaultProvider);
+        if (!parsed)
+            continue;
+        const alias = String(entryRaw?.alias ?? "").trim();
+        if (!alias)
+            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 = (() => {
+        const raw = params.cfg.agent?.model;
+        if (typeof raw === "string")
+            return raw.trim();
+        return raw?.primary?.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 = (() => {
+        const modelMap = params.cfg.agent?.models ?? {};
+        return Object.keys(modelMap);
+    })();
+    const allowAny = rawAllowlist.length === 0;
+    const catalogKeys = new Set(params.catalog.map((entry) => modelKey(entry.provider, entry.id)));
+    const configuredProviders = (params.cfg.models?.providers ?? {});
+    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);
+        const providerKey = normalizeProviderId(parsed.provider);
+        if (catalogKeys.has(key)) {
+            allowedKeys.add(key);
+        }
+        else if (configuredProviders[providerKey] != null) {
+            // Allow explicitly configured providers even when missing from the catalog.
+            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,171 @@
+import fs from "node:fs/promises";
+import path from "node:path";
+import { loadConfig } from "../config/config.js";
+import { DEFAULT_COPILOT_API_BASE_URL, resolveCopilotApiToken, } from "../providers/github-copilot-token.js";
+import { resolveNexusAgentDir } from "./agent-paths.js";
+import { ensureAuthProfileStore, listProfilesForProvider, resolveApiKeyForProfile, } from "./auth-profiles.js";
+import { resolveEnvApiKey } from "./model-auth.js";
+const DEFAULT_MODE = "merge";
+const MINIMAX_API_BASE_URL = process.env.MINIMAX_BASE_URL?.trim() || "https://api.minimax.io/v1";
+const MINIMAX_DEFAULT_MODEL_ID = process.env.MINIMAX_MODEL?.trim() || "minimax-m2.1";
+const MINIMAX_DEFAULT_VISION_MODEL_ID = process.env.MINIMAX_VISION_MODEL?.trim() || "minimax-vl-01";
+const MINIMAX_DEFAULT_CONTEXT_WINDOW = Number.parseInt(process.env.MINIMAX_CONTEXT_WINDOW?.trim() || "8192", 10);
+const MINIMAX_DEFAULT_MAX_TOKENS = Number.parseInt(process.env.MINIMAX_MAX_TOKENS?.trim() || "2048", 10);
+const MINIMAX_API_COST = {
+    input: 0,
+    output: 0,
+    cacheRead: 0,
+    cacheWrite: 0,
+};
+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;
+    }
+}
+function buildMinimaxApiProvider(apiKey) {
+    return {
+        baseUrl: MINIMAX_API_BASE_URL,
+        ...(apiKey ? { apiKey } : {}),
+        api: "openai-completions",
+        models: [
+            {
+                id: MINIMAX_DEFAULT_MODEL_ID,
+                name: "MiniMax M2.1",
+                reasoning: false,
+                input: ["text"],
+                cost: MINIMAX_API_COST,
+                contextWindow: MINIMAX_DEFAULT_CONTEXT_WINDOW,
+                maxTokens: MINIMAX_DEFAULT_MAX_TOKENS,
+            },
+            {
+                id: MINIMAX_DEFAULT_VISION_MODEL_ID,
+                name: "MiniMax VL 01",
+                reasoning: false,
+                input: ["text", "image"],
+                cost: MINIMAX_API_COST,
+                contextWindow: MINIMAX_DEFAULT_CONTEXT_WINDOW,
+                maxTokens: MINIMAX_DEFAULT_MAX_TOKENS,
+            },
+        ],
+    };
+}
+function resolveMinimaxApiKeyFromStore(store) {
+    const profileIds = listProfilesForProvider(store, "minimax");
+    for (const profileId of profileIds) {
+        const cred = store.profiles[profileId];
+        if (!cred)
+            continue;
+        if (cred.type === "api_key") {
+            const key = cred.key?.trim();
+            if (key)
+                return key;
+            continue;
+        }
+        if (cred.type === "token") {
+            const token = cred.token?.trim();
+            if (!token)
+                continue;
+            if (typeof cred.expires === "number" &&
+                Number.isFinite(cred.expires) &&
+                cred.expires > 0 &&
+                Date.now() >= cred.expires) {
+                continue;
+            }
+            return token;
+        }
+    }
+    return undefined;
+}
+function resolveImplicitProviders(params) {
+    const providers = {};
+    const minimaxEnv = resolveEnvApiKey("minimax");
+    const authStore = ensureAuthProfileStore(params.agentDir);
+    const minimaxKey = minimaxEnv?.apiKey ?? resolveMinimaxApiKeyFromStore(authStore);
+    if (minimaxKey) {
+        providers.minimax = buildMinimaxApiProvider(minimaxKey);
+    }
+    return providers;
+}
+async function maybeBuildCopilotProvider(params) {
+    const env = params.env ?? process.env;
+    const authStore = ensureAuthProfileStore(params.agentDir);
+    const profileIds = listProfilesForProvider(authStore, "github-copilot");
+    const hasProfile = profileIds.length > 0;
+    const envToken = env.COPILOT_GITHUB_TOKEN ?? env.GH_TOKEN ?? env.GITHUB_TOKEN;
+    const githubToken = (envToken ?? "").trim();
+    if (!hasProfile && !githubToken)
+        return null;
+    let selectedGithubToken = githubToken;
+    if (!selectedGithubToken && hasProfile) {
+        const profileId = profileIds[0];
+        if (profileId) {
+            const resolved = await resolveApiKeyForProfile({ store: authStore, profileId });
+            if (resolved?.apiKey)
+                selectedGithubToken = resolved.apiKey;
+        }
+    }
+    let baseUrl = DEFAULT_COPILOT_API_BASE_URL;
+    if (selectedGithubToken) {
+        try {
+            const token = await resolveCopilotApiToken({
+                githubToken: selectedGithubToken,
+                env,
+            });
+            baseUrl = token.baseUrl;
+        }
+        catch {
+            baseUrl = DEFAULT_COPILOT_API_BASE_URL;
+        }
+    }
+    // We intentionally do NOT define custom models for Copilot in models.json.
+    // pi-coding-agent treats providers with models as replacements requiring apiKey.
+    // We only override baseUrl; the model list comes from pi-ai built-ins.
+    return {
+        baseUrl,
+        models: [],
+    };
+}
+export async function ensureNexusModelsJson(config, agentDirOverride) {
+    const cfg = config ?? loadConfig();
+    const providers = cfg.models?.providers;
+    if (!providers || Object.keys(providers).length === 0) {
+        const agentDir = agentDirOverride?.trim()
+            ? agentDirOverride.trim()
+            : resolveNexusAgentDir();
+        return { agentDir, wrote: false };
+    }
+    const mode = cfg.models?.mode ?? DEFAULT_MODE;
+    const agentDir = agentDirOverride?.trim()
+        ? agentDirOverride.trim()
+        : resolveNexusAgentDir();
+    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/nexus-tools.js

@@ -0,0 +1,46 @@
+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 { createSessionsSpawnTool } from "./tools/sessions-spawn-tool.js";
+import { createSlackTool } from "./tools/slack-tool.js";
+export function createNexusTools(options) {
+    const imageTool = createImageTool({
+        config: options?.config,
+        agentDir: options?.agentDir,
+    });
+    return [
+        createBrowserTool({ defaultControlUrl: options?.browserControlUrl }),
+        createCanvasTool(),
+        createNodesTool(),
+        createCronTool(),
+        createDiscordTool(),
+        createSlackTool(),
+        createGatewayTool(),
+        createSessionsListTool({
+            agentSessionKey: options?.agentSessionKey,
+            sandboxed: options?.sandboxed,
+        }),
+        createSessionsHistoryTool({
+            agentSessionKey: options?.agentSessionKey,
+            sandboxed: options?.sandboxed,
+        }),
+        createSessionsSendTool({
+            agentSessionKey: options?.agentSessionKey,
+            agentProvider: options?.agentProvider,
+            sandboxed: options?.sandboxed,
+        }),
+        createSessionsSpawnTool({
+            agentSessionKey: options?.agentSessionKey,
+            agentProvider: options?.agentProvider,
+            sandboxed: options?.sandboxed,
+        }),
+        ...(imageTool ? [imageTool] : []),
+    ];
+}