pikiloop 0.4.0

package/dist/dashboard/routes/local-models.js

@@ -0,0 +1,290 @@
+/**
+ * Dashboard API: Local Model backends (Ollama / mlx-lm).
+ *
+ * Surfaces a probe endpoint plus a connect action that links a detected
+ * backend into the Provider/Profile model layer so the agent cards above
+ * pick it up without any further configuration.
+ *
+ *   GET  /api/local-models/probe    → which backends are running, what models
+ *                                     they expose, install/run hints, and
+ *                                     whether a Provider already points at each.
+ *   POST /api/local-models/connect  → idempotently create the Provider for the
+ *                                     named backend.
+ *
+ * Endpoints we expect:
+ *   - Ollama  baseURL → http://127.0.0.1:11434
+ *             version  → GET /api/version
+ *             models   → GET /api/tags
+ *             OpenAI   → /v1/chat/completions, /v1/models
+ *
+ *   - mlx-lm  baseURL → http://127.0.0.1:8080   (mlx_lm.server default)
+ *             probe   → GET /v1/models   (200 OK iff server up; no version)
+ *
+ * Model downloads stay manual (user runs `ollama pull <tag>` or restarts
+ * `mlx_lm.server --model <repo>` in their own terminal). The install spec
+ * is shipped alongside detection so the UI can mirror the CLI tools page.
+ */
+import { Hono } from 'hono';
+import { LOCAL_MODELS } from '../../catalog/local-models.js';
+import { listProviders, addProvider, listProfiles, addProfile, } from '../../model/index.js';
+const router = new Hono();
+const BACKENDS = [
+    {
+        id: 'ollama',
+        label: 'Ollama',
+        baseURL: 'http://127.0.0.1:11434',
+        openAIBaseURL: 'http://127.0.0.1:11434/v1',
+        probePath: '/api/version',
+        homepage: 'https://ollama.com/',
+        install: {
+            docs: 'https://github.com/ollama/ollama#ollama',
+            darwin: [
+                { label: 'Homebrew', cmd: 'brew install ollama' },
+                { label: 'Install script', cmd: 'curl -fsSL https://ollama.com/install.sh | sh' },
+            ],
+            linux: [
+                { label: 'Install script', cmd: 'curl -fsSL https://ollama.com/install.sh | sh' },
+            ],
+            win: [
+                { label: 'winget', cmd: 'winget install Ollama.Ollama' },
+            ],
+        },
+        runHint: { label: 'Start the daemon', cmd: 'ollama serve' },
+        pullCommandTemplate: 'ollama pull ${model}',
+        modelField: 'ollamaTag',
+        platforms: ['darwin', 'linux', 'win'],
+    },
+    {
+        id: 'mlx',
+        label: 'mlx-lm',
+        baseURL: 'http://127.0.0.1:8080',
+        openAIBaseURL: 'http://127.0.0.1:8080/v1',
+        // mlx_lm.server has no /api/version; /v1/models doubles as liveness probe.
+        probePath: '/v1/models',
+        homepage: 'https://github.com/ml-explore/mlx-lm',
+        install: {
+            docs: 'https://github.com/ml-explore/mlx-lm#installation',
+            darwin: [
+                { label: 'pipx (recommended)', cmd: 'pipx install mlx-lm' },
+                { label: 'pip', cmd: 'pip install mlx-lm' },
+            ],
+        },
+        runHint: {
+            label: 'Start the server (replace model)',
+            cmd: 'mlx_lm.server --model mlx-community/Qwen2.5-Coder-7B-Instruct-4bit --port 8080',
+        },
+        // mlx-lm loads a single model per server instance — "pull" here means
+        // re-launching the server with that model id.
+        pullCommandTemplate: 'mlx_lm.server --model ${model} --port 8080',
+        modelField: 'mlxModel',
+        platforms: ['darwin'],
+    },
+];
+const PROBE_TIMEOUT_MS = 1500;
+// ---------------------------------------------------------------------------
+// HTTP helpers
+// ---------------------------------------------------------------------------
+async function fetchJson(url, timeoutMs = PROBE_TIMEOUT_MS) {
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), timeoutMs);
+    try {
+        const res = await fetch(url, { signal: controller.signal });
+        if (!res.ok)
+            return null;
+        return (await res.json());
+    }
+    catch {
+        return null;
+    }
+    finally {
+        clearTimeout(timer);
+    }
+}
+function currentOs() {
+    if (process.platform === 'darwin')
+        return 'darwin';
+    if (process.platform === 'win32')
+        return 'win';
+    return 'linux';
+}
+async function probeOllama(spec) {
+    const ver = await fetchJson(`${spec.baseURL}${spec.probePath}`);
+    if (!ver)
+        return { detected: false, models: [] };
+    const tags = await fetchJson(`${spec.baseURL}/api/tags`, 3000);
+    const models = (tags?.models || []).map(m => ({
+        id: m.name,
+        sizeBytes: typeof m.size === 'number' ? m.size : undefined,
+    }));
+    return { detected: true, version: ver.version, models };
+}
+async function probeMlx(spec) {
+    const res = await fetchJson(`${spec.baseURL}${spec.probePath}`, 3000);
+    if (!res)
+        return { detected: false, models: [] };
+    return {
+        detected: true,
+        models: (res.data || []).map(m => ({ id: m.id })),
+    };
+}
+/**
+ * Normalize a provider baseURL for comparison: drop trailing slashes and
+ * collapse the localhost ↔ 127.0.0.1 distinction.
+ */
+function normalizeBaseURL(raw) {
+    return raw
+        .replace(/\/+$/, '')
+        .replace(/^http:\/\/localhost(?=[:/]|$)/i, 'http://127.0.0.1')
+        .replace(/^https:\/\/localhost(?=[:/]|$)/i, 'https://127.0.0.1');
+}
+function findProviderForBackend(providers, spec) {
+    const target = normalizeBaseURL(spec.openAIBaseURL);
+    return providers.find(p => normalizeBaseURL(p.baseURL) === target) || null;
+}
+async function probeBackend(spec, providers) {
+    const os = currentOs();
+    const supported = spec.platforms.includes(os);
+    const result = !supported
+        ? { detected: false, models: [] }
+        : spec.id === 'ollama' ? await probeOllama(spec) : await probeMlx(spec);
+    const existing = findProviderForBackend(providers, spec);
+    return {
+        id: spec.id,
+        label: spec.label,
+        detected: result.detected,
+        version: result.version,
+        baseURL: spec.baseURL,
+        openAIBaseURL: spec.openAIBaseURL,
+        models: result.models,
+        existingProviderId: existing?.id || null,
+        homepage: spec.homepage,
+        install: spec.install,
+        runHint: spec.runHint,
+        pullCommandTemplate: spec.pullCommandTemplate,
+        supportedOnThisOs: supported,
+    };
+}
+// ---------------------------------------------------------------------------
+// Catalog join — recommended models × backend availability
+// ---------------------------------------------------------------------------
+function isEntryInstalled(entry, spec, installed) {
+    const target = entry[spec.modelField];
+    if (!target)
+        return null;
+    const base = target.split(':')[0].toLowerCase();
+    for (const m of installed) {
+        if (m.id.toLowerCase().startsWith(base))
+            return m.id;
+    }
+    return null;
+}
+function joinCatalog(backends) {
+    return LOCAL_MODELS.map(entry => {
+        for (const b of backends) {
+            if (!b.detected)
+                continue;
+            const spec = BACKENDS.find(s => s.id === b.id);
+            if (!spec)
+                continue;
+            const hit = isEntryInstalled(entry, spec, b.models);
+            if (hit)
+                return { ...entry, installed: { backend: b.id, id: hit } };
+        }
+        return { ...entry, installed: null };
+    });
+}
+/**
+ * For a connected local backend, mirror every detected model as a Profile under
+ * its Provider so the unified picker shows them without an extra user gesture.
+ * Idempotent. Never deletes Profiles — a model that disappears from probe
+ * output might be a transient blip.
+ */
+function syncLocalProfilesForBackend(providerId, detected) {
+    if (!providerId || !detected.length)
+        return { added: 0 };
+    const existing = new Set(listProfiles().filter(p => p.providerId === providerId).map(p => p.modelId));
+    let added = 0;
+    for (const m of detected) {
+        if (!m.id || existing.has(m.id))
+            continue;
+        try {
+            addProfile({ providerId, modelId: m.id });
+            added += 1;
+            existing.add(m.id);
+        }
+        catch {
+            // Provider may have been removed between calls — skip; next probe retries.
+        }
+    }
+    return { added };
+}
+/**
+ * Idempotently create a Provider pointing at this backend. Returns the
+ * provider id. The placeholder API key is a sentinel ("local-no-auth") rather
+ * than something that looks like a real key, so future code can recognize and
+ * special-case local providers.
+ */
+async function ensureProviderForBackend(spec) {
+    const providers = listProviders();
+    const existing = findProviderForBackend(providers, spec);
+    if (existing)
+        return existing.id;
+    try {
+        const provider = await addProvider({
+            kind: 'openai-compatible',
+            name: spec.label,
+            baseURL: spec.openAIBaseURL,
+            apiKey: 'local-no-auth',
+        });
+        return provider.id;
+    }
+    catch {
+        return null;
+    }
+}
+// ---------------------------------------------------------------------------
+// Routes
+// ---------------------------------------------------------------------------
+/**
+ * Single probe-and-attach endpoint. The Local Models page no longer asks the
+ * user to "connect" — every detected backend becomes a Provider automatically
+ * so its models show up in the unified picker without an extra click.
+ *
+ *   - Backend detected, no existing Provider → create one, then sync Profiles.
+ *   - Backend detected, Provider already exists → just sync Profiles.
+ *   - Backend not detected → leave existing Provider in place (a transient
+ *     blip during a restart shouldn't tear down config).
+ *
+ * Response includes `addedProviderIds` so the dashboard can refetch the upper
+ * Model Providers / agent layer exactly when something new appears.
+ */
+router.get('/api/local-models/probe', async (c) => {
+    try {
+        const initialProviders = listProviders();
+        const backends = await Promise.all(BACKENDS.map(spec => probeBackend(spec, initialProviders)));
+        const addedProviderIds = [];
+        for (const b of backends) {
+            if (!b.detected)
+                continue;
+            const spec = BACKENDS.find(s => s.id === b.id);
+            if (!spec)
+                continue;
+            let providerId = b.existingProviderId;
+            if (!providerId) {
+                providerId = await ensureProviderForBackend(spec);
+                if (providerId) {
+                    b.existingProviderId = providerId;
+                    addedProviderIds.push(providerId);
+                }
+            }
+            if (providerId)
+                syncLocalProfilesForBackend(providerId, b.models);
+        }
+        const catalog = joinCatalog(backends);
+        return c.json({ ok: true, backends, catalog, currentOs: currentOs(), addedProviderIds });
+    }
+    catch (e) {
+        return c.json({ ok: false, error: e?.message || String(e) }, 500);
+    }
+});
+export default router;

package/dist/dashboard/routes/models.js

@@ -0,0 +1,324 @@
+/**
+ * Dashboard API: Model layer (Providers, Profiles, BYOK bindings).
+ *
+ * Endpoints:
+ *   GET    /api/models/catalog                          → models.dev metadata
+ *   GET    /api/models/providers                        → list configured providers
+ *   POST   /api/models/providers                        → add new provider (paste key / use env)
+ *   PATCH  /api/models/providers/:id                    → update provider
+ *   DELETE /api/models/providers/:id                    → remove provider + bound profiles
+ *   POST   /api/models/providers/:id/validate           → Feishu-style validation
+ *
+ *   GET    /api/models/profiles                         → list profiles
+ *   POST   /api/models/profiles                         → add profile
+ *   PATCH  /api/models/profiles/:id                     → update profile
+ *   DELETE /api/models/profiles/:id                     → remove profile
+ *
+ *   GET    /api/models/agents                           → list active bindings
+ *   POST   /api/models/agents/:agent/active             → bind/unbind a Profile
+ */
+import { Hono } from 'hono';
+import { getModelsDevCatalog, searchCatalogProviders, listProviders, getProvider, addProvider, updateProvider, removeProvider, setProviderValidation, listProfiles, getProfile, addProfile, updateProfile, removeProfile, getActiveProfileId, setActiveProfile, validateProvider, getProviderModelList, invalidateProviderModels, } from '../../model/index.js';
+import { isCredentialRef, describeCredentialRef } from '../../core/secrets/index.js';
+import { allDriverIds } from '../../agent/index.js';
+const router = new Hono();
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+function publicProvider(p) {
+    return {
+        id: p.id,
+        kind: p.kind,
+        name: p.name,
+        baseURL: p.baseURL,
+        extraHeaders: p.extraHeaders,
+        credential: { source: p.credential.source, summary: describeCredentialRef(p.credential) },
+        validation: p.validation || null,
+        createdAt: p.createdAt,
+        updatedAt: p.updatedAt,
+    };
+}
+const VALID_KINDS = ['anthropic', 'openai', 'openai-compatible', 'google'];
+// ---------------------------------------------------------------------------
+// Catalog (read-only models.dev mirror)
+// ---------------------------------------------------------------------------
+router.get('/api/models/catalog', async (c) => {
+    const q = c.req.query('q') || '';
+    const refresh = c.req.query('refresh') === '1';
+    try {
+        if (refresh)
+            await getModelsDevCatalog({ forceRefresh: true });
+        const providers = await searchCatalogProviders(q);
+        return c.json({
+            ok: true,
+            providers: providers.map(p => ({
+                id: p.id,
+                name: p.name,
+                api: p.api,
+                doc: p.doc,
+                env: p.env || [],
+                modelCount: Object.keys(p.models || {}).length,
+            })),
+        });
+    }
+    catch (e) {
+        return c.json({ ok: false, error: e?.message || String(e) }, 500);
+    }
+});
+router.get('/api/models/catalog/:providerId', async (c) => {
+    const id = c.req.param('providerId');
+    try {
+        const cat = await getModelsDevCatalog();
+        const provider = cat[id];
+        if (!provider)
+            return c.json({ ok: false, error: 'Catalog provider not found' }, 404);
+        const models = Object.values(provider.models || {}).map(m => ({
+            id: m.id,
+            name: m.name || m.id,
+            reasoning: !!m.reasoning,
+            tool_call: !!m.tool_call,
+            context: m.limit?.context || null,
+            output: m.limit?.output || null,
+            cost: m.cost || null,
+            release_date: m.release_date || null,
+        }));
+        return c.json({
+            ok: true,
+            provider: {
+                id: provider.id,
+                name: provider.name,
+                api: provider.api,
+                doc: provider.doc,
+                env: provider.env || [],
+            },
+            models,
+        });
+    }
+    catch (e) {
+        return c.json({ ok: false, error: e?.message || String(e) }, 500);
+    }
+});
+// ---------------------------------------------------------------------------
+// Providers
+// ---------------------------------------------------------------------------
+router.get('/api/models/providers', c => {
+    return c.json({ ok: true, providers: listProviders().map(publicProvider) });
+});
+router.post('/api/models/providers', async (c) => {
+    let body;
+    try {
+        body = await c.req.json();
+    }
+    catch {
+        body = {};
+    }
+    const kind = body.kind;
+    const name = String(body.name || '').trim();
+    const baseURL = String(body.baseURL || '').trim();
+    const apiKey = typeof body.apiKey === 'string' ? body.apiKey : '';
+    const credentialRef = isCredentialRef(body.credentialRef) ? body.credentialRef : undefined;
+    const extraHeaders = body.extraHeaders && typeof body.extraHeaders === 'object' ? body.extraHeaders : undefined;
+    if (!VALID_KINDS.includes(kind))
+        return c.json({ ok: false, error: `Invalid kind. Use one of: ${VALID_KINDS.join(', ')}` }, 400);
+    if (!name)
+        return c.json({ ok: false, error: 'name is required' }, 400);
+    if (!baseURL)
+        return c.json({ ok: false, error: 'baseURL is required' }, 400);
+    if (!apiKey && !credentialRef)
+        return c.json({ ok: false, error: 'apiKey or credentialRef is required' }, 400);
+    try {
+        const provider = await addProvider({ kind, name, baseURL, apiKey: apiKey || undefined, credentialRef, extraHeaders });
+        return c.json({ ok: true, provider: publicProvider(provider) });
+    }
+    catch (e) {
+        return c.json({ ok: false, error: e?.message || String(e) }, 500);
+    }
+});
+router.patch('/api/models/providers/:id', async (c) => {
+    const id = c.req.param('id');
+    if (!getProvider(id))
+        return c.json({ ok: false, error: 'Provider not found' }, 404);
+    let body;
+    try {
+        body = await c.req.json();
+    }
+    catch {
+        body = {};
+    }
+    try {
+        const provider = await updateProvider(id, {
+            name: typeof body.name === 'string' ? body.name : undefined,
+            baseURL: typeof body.baseURL === 'string' ? body.baseURL : undefined,
+            apiKey: typeof body.apiKey === 'string' && body.apiKey.length > 0 ? body.apiKey : undefined,
+            credentialRef: isCredentialRef(body.credentialRef) ? body.credentialRef : undefined,
+            extraHeaders: body.extraHeaders === null ? null : (body.extraHeaders && typeof body.extraHeaders === 'object' ? body.extraHeaders : undefined),
+        });
+        invalidateProviderModels(id);
+        return c.json({ ok: true, provider: publicProvider(provider) });
+    }
+    catch (e) {
+        return c.json({ ok: false, error: e?.message || String(e) }, 500);
+    }
+});
+router.delete('/api/models/providers/:id', async (c) => {
+    const id = c.req.param('id');
+    const removed = await removeProvider(id);
+    if (!removed)
+        return c.json({ ok: false, error: 'Provider not found' }, 404);
+    invalidateProviderModels(id);
+    return c.json({ ok: true });
+});
+/**
+ * GET /api/models/providers/:id/models — model id list for the configured
+ * provider, served from a 30-minute in-memory TTL cache. The first hit (or any
+ * hit after a config edit) re-fetches from the provider's /models endpoint.
+ *
+ * Used by:
+ *   - Dashboard: per-agent unified config modal model picker
+ *   - IM /models command: when an agent is bound to this provider
+ *   - Agent status response: when an agent is bound to this provider
+ */
+router.get('/api/models/providers/:id/models', async (c) => {
+    const id = c.req.param('id');
+    const refresh = c.req.query('refresh') === '1';
+    try {
+        const result = await getProviderModelList(id, { forceRefresh: refresh });
+        if (!result)
+            return c.json({ ok: false, error: 'Provider not found' }, 404);
+        return c.json({
+            ok: true,
+            models: result.models,
+            modelInfos: result.modelInfos,
+            fetchedAt: new Date(result.fetchedAt).toISOString(),
+            fromCache: result.fromCache,
+        });
+    }
+    catch (e) {
+        return c.json({ ok: false, error: e?.message || String(e) }, 500);
+    }
+});
+router.post('/api/models/providers/:id/validate', async (c) => {
+    const id = c.req.param('id');
+    const provider = getProvider(id);
+    if (!provider)
+        return c.json({ ok: false, error: 'Provider not found' }, 404);
+    try {
+        const result = await validateProvider(provider);
+        setProviderValidation(id, result.status);
+        return c.json({ ok: true, validation: result.status, models: result.models });
+    }
+    catch (e) {
+        const status = {
+            state: 'error',
+            detail: e?.message || String(e),
+            checkedAt: new Date().toISOString(),
+        };
+        setProviderValidation(id, status);
+        return c.json({ ok: true, validation: status, models: [] });
+    }
+});
+// ---------------------------------------------------------------------------
+// Profiles
+// ---------------------------------------------------------------------------
+router.get('/api/models/profiles', c => {
+    return c.json({ ok: true, profiles: listProfiles() });
+});
+router.post('/api/models/profiles', async (c) => {
+    let body;
+    try {
+        body = await c.req.json();
+    }
+    catch {
+        body = {};
+    }
+    const providerId = String(body.providerId || '').trim();
+    const modelId = String(body.modelId || '').trim();
+    if (!providerId)
+        return c.json({ ok: false, error: 'providerId is required' }, 400);
+    if (!modelId)
+        return c.json({ ok: false, error: 'modelId is required' }, 400);
+    if (!getProvider(providerId))
+        return c.json({ ok: false, error: `Provider not found: ${providerId}` }, 404);
+    try {
+        const profile = addProfile({
+            name: typeof body.name === 'string' ? body.name : undefined,
+            providerId,
+            modelId,
+            effort: body.effort || null,
+            maxOutputTokens: typeof body.maxOutputTokens === 'number' ? body.maxOutputTokens : null,
+            extras: body.extras && typeof body.extras === 'object' ? body.extras : undefined,
+        });
+        return c.json({ ok: true, profile });
+    }
+    catch (e) {
+        return c.json({ ok: false, error: e?.message || String(e) }, 500);
+    }
+});
+router.patch('/api/models/profiles/:id', async (c) => {
+    const id = c.req.param('id');
+    if (!getProfile(id))
+        return c.json({ ok: false, error: 'Profile not found' }, 404);
+    let body;
+    try {
+        body = await c.req.json();
+    }
+    catch {
+        body = {};
+    }
+    try {
+        const profile = updateProfile(id, {
+            name: typeof body.name === 'string' ? body.name : undefined,
+            modelId: typeof body.modelId === 'string' ? body.modelId : undefined,
+            effort: 'effort' in body ? body.effort : undefined,
+            maxOutputTokens: 'maxOutputTokens' in body ? body.maxOutputTokens : undefined,
+            extras: 'extras' in body ? body.extras : undefined,
+        });
+        return c.json({ ok: true, profile });
+    }
+    catch (e) {
+        return c.json({ ok: false, error: e?.message || String(e) }, 500);
+    }
+});
+router.delete('/api/models/profiles/:id', c => {
+    const id = c.req.param('id');
+    const removed = removeProfile(id);
+    if (!removed)
+        return c.json({ ok: false, error: 'Profile not found' }, 404);
+    return c.json({ ok: true });
+});
+// ---------------------------------------------------------------------------
+// Agent bindings
+// ---------------------------------------------------------------------------
+router.get('/api/models/agents', c => {
+    const agents = allDriverIds();
+    return c.json({
+        ok: true,
+        bindings: agents.map(agent => ({
+            agent,
+            activeProfileId: getActiveProfileId(agent),
+        })),
+    });
+});
+router.post('/api/models/agents/:agent/active', async (c) => {
+    const agent = c.req.param('agent');
+    if (!allDriverIds().includes(agent))
+        return c.json({ ok: false, error: `Unknown agent: ${agent}` }, 400);
+    let body;
+    try {
+        body = await c.req.json();
+    }
+    catch {
+        body = {};
+    }
+    const profileId = body.profileId === null ? null : (typeof body.profileId === 'string' ? body.profileId : undefined);
+    if (profileId === undefined)
+        return c.json({ ok: false, error: 'profileId (string|null) is required' }, 400);
+    try {
+        setActiveProfile(agent, profileId);
+        return c.json({ ok: true, agent, activeProfileId: profileId });
+    }
+    catch (e) {
+        return c.json({ ok: false, error: e?.message || String(e) }, 400);
+    }
+});
+export default router;