dot-studio 0.0.1

package/dist/server/lib/cache.js

@@ -0,0 +1,31 @@
+// ── Server-side TTL Cache ────────────────────────────────
+// In-memory cache with configurable TTL per key.
+// Prevents repeated slow calls to OpenCode SDK and filesystem scans.
+const store = new Map();
+export function cached(key, ttlMs, fetcher) {
+    const now = Date.now();
+    const entry = store.get(key);
+    if (entry && entry.expiresAt > now) {
+        return Promise.resolve(entry.data);
+    }
+    return fetcher().then(data => {
+        store.set(key, { data, expiresAt: now + ttlMs });
+        return data;
+    });
+}
+export function invalidate(keyPrefix) {
+    for (const key of store.keys()) {
+        if (key.startsWith(keyPrefix)) {
+            store.delete(key);
+        }
+    }
+}
+export function invalidateAll() {
+    store.clear();
+}
+// Default TTLs
+export const TTL = {
+    ASSETS: 30_000, // 30s — local files may change
+    MCP_SERVERS: 30_000, // 30s
+    PROVIDERS: 60_000, // 60s
+};

package/dist/server/lib/config.js

@@ -0,0 +1,53 @@
+// Server Configuration & Studio Config Helpers
+import fs from 'fs/promises';
+import path from 'path';
+import os from 'os';
+function resolvePort(value, fallback) {
+    const parsed = Number.parseInt(value || '', 10);
+    return Number.isInteger(parsed) && parsed > 0 ? parsed : fallback;
+}
+function resolveDefaultProjectDir() {
+    if (process.env.PROJECT_DIR) {
+        return path.resolve(process.env.PROJECT_DIR);
+    }
+    if (process.env.DOT_STUDIO_PRODUCTION === '1') {
+        return path.resolve(process.cwd());
+    }
+    return path.resolve(process.cwd(), '..');
+}
+// ── Constants ───────────────────────────────────────────
+export const PORT = resolvePort(process.env.PORT, 3001);
+export const OPENCODE_URL = process.env.OPENCODE_URL || 'http://localhost:4096';
+export const OPENCODE_MANAGED = !process.env.OPENCODE_URL;
+export const DEFAULT_PROJECT_DIR = resolveDefaultProjectDir();
+export const STUDIO_DIR = process.env.STUDIO_DIR || path.join(os.homedir(), '.dot-studio');
+export const STUDIO_CONFIG_PATH = path.join(STUDIO_DIR, 'studio-config.json');
+export const IS_PRODUCTION = process.env.DOT_STUDIO_PRODUCTION === '1';
+// ── Mutable Active Project Dir ──────────────────────────
+let _activeProjectDir = DEFAULT_PROJECT_DIR;
+export function getActiveProjectDir() {
+    return _activeProjectDir;
+}
+export function setActiveProjectDir(dir) {
+    _activeProjectDir = dir;
+}
+export async function readStudioConfig() {
+    try {
+        const raw = await fs.readFile(STUDIO_CONFIG_PATH, 'utf-8');
+        return JSON.parse(raw);
+    }
+    catch {
+        return {};
+    }
+}
+export async function writeStudioConfig(partial) {
+    await fs.mkdir(STUDIO_DIR, { recursive: true });
+    const current = await readStudioConfig();
+    const merged = { ...current, ...partial };
+    await fs.writeFile(STUDIO_CONFIG_PATH, JSON.stringify(merged, null, 2), 'utf-8');
+    return merged;
+}
+// ── Stages Dir ──────────────────────────────────────────
+export function stagesDir() {
+    return path.join(STUDIO_DIR, 'stages');
+}

package/dist/server/lib/dot-authoring.js

@@ -0,0 +1,245 @@
+import fs from 'fs/promises';
+import path from 'path';
+import { assetFilePath, ensureDotDir, getGlobalDotDir } from 'dance-of-tal/lib/registry';
+import { getPayloadTags, loadLocalAssetByUrn, parseUrn, publishSingleAsset, resolveDependencies, } from 'dance-of-tal/lib/publishing';
+const SLUG_RE = /^[a-z0-9][a-z0-9._-]{1,98}[a-z0-9]$/;
+function isRecord(value) {
+    return !!value && typeof value === 'object' && !Array.isArray(value);
+}
+function sanitizeSlug(value) {
+    const slug = value.trim();
+    if (!SLUG_RE.test(slug)) {
+        throw new Error('Slug must use lowercase letters, numbers, dots, underscores, or hyphens (2-100 chars).');
+    }
+    return slug;
+}
+function sanitizeTags(value) {
+    if (!Array.isArray(value)) {
+        return [];
+    }
+    return value
+        .filter((tag) => typeof tag === 'string')
+        .map((tag) => tag.trim())
+        .filter(Boolean);
+}
+function sanitizeAuthor(value) {
+    const author = value.trim().replace(/^@/, '');
+    if (!author) {
+        throw new Error('Author is required.');
+    }
+    return author;
+}
+function todayIsoDate() {
+    return new Date().toISOString().split('T')[0];
+}
+function normalizeDescription(name, value) {
+    return typeof value === 'string' && value.trim() ? value.trim() : name;
+}
+function ensureUrn(value, kind) {
+    if (typeof value !== 'string') {
+        throw new Error(`${kind} reference must be a string URN.`);
+    }
+    const urn = value.trim();
+    const parts = urn.split('/');
+    if (parts.length !== 3 || parts[0] !== kind || !parts[1].startsWith('@') || !parts[2]) {
+        throw new Error(`Invalid URN '${urn}'. Expected ${kind}/@<author>/<name>.`);
+    }
+    return urn;
+}
+function normalizeTalPayload(author, slug, payload) {
+    const name = typeof payload.name === 'string' && payload.name.trim() ? payload.name.trim() : slug;
+    const content = typeof payload.content === 'string' ? payload.content : '';
+    return {
+        type: `tal/@${author}/${slug}`,
+        slug,
+        name,
+        description: normalizeDescription(name, payload.description),
+        tags: sanitizeTags(payload.tags),
+        featuredScore: typeof payload.featuredScore === 'number' ? payload.featuredScore : 0,
+        createdAt: typeof payload.createdAt === 'string' && payload.createdAt.trim() ? payload.createdAt : todayIsoDate(),
+        content,
+    };
+}
+function normalizeDancePayload(author, slug, payload) {
+    const name = typeof payload.name === 'string' && payload.name.trim() ? payload.name.trim() : slug;
+    const content = typeof payload.content === 'string' ? payload.content : '';
+    return {
+        type: `dance/@${author}/${slug}`,
+        slug,
+        name,
+        description: normalizeDescription(name, payload.description),
+        tags: sanitizeTags(payload.tags),
+        content,
+        ...(isRecord(payload.schema) ? { schema: payload.schema } : {}),
+        ...(isRecord(payload.exemplarSet) ? { exemplarSet: payload.exemplarSet } : {}),
+    };
+}
+function normalizePerformerPayload(author, slug, payload) {
+    const name = typeof payload.name === 'string' && payload.name.trim() ? payload.name.trim() : slug;
+    const danceValue = payload.dance;
+    const dance = typeof danceValue === 'string'
+        ? ensureUrn(danceValue, 'dance')
+        : Array.isArray(danceValue)
+            ? danceValue.map((value) => ensureUrn(value, 'dance'))
+            : undefined;
+    const tal = payload.tal !== undefined && payload.tal !== null ? ensureUrn(payload.tal, 'tal') : undefined;
+    const act = payload.act !== undefined && payload.act !== null ? ensureUrn(payload.act, 'act') : undefined;
+    if (!tal && (!dance || dance.length === 0)) {
+        throw new Error("Performer assets require at least one Tal or Dance reference.");
+    }
+    return {
+        type: `performer/@${author}/${slug}`,
+        slug,
+        name,
+        description: normalizeDescription(name, payload.description),
+        tags: sanitizeTags(payload.tags),
+        ...(tal ? { tal } : {}),
+        ...(dance
+            ? { dance: Array.isArray(dance) && dance.length === 1 ? dance[0] : dance }
+            : {}),
+        ...(act ? { act } : {}),
+        ...(typeof payload.model === 'string' && payload.model.trim() ? { model: payload.model.trim() } : {}),
+        ...(isRecord(payload.mcp_config) ? { mcp_config: payload.mcp_config } : {}),
+    };
+}
+function normalizeActPayload(author, slug, payload) {
+    const name = typeof payload.name === 'string' && payload.name.trim() ? payload.name.trim() : slug;
+    return {
+        type: `act/@${author}/${slug}`,
+        slug,
+        name,
+        description: normalizeDescription(name, payload.description),
+        tags: sanitizeTags(payload.tags),
+        entryNode: typeof payload.entryNode === 'string' ? payload.entryNode : '',
+        nodes: isRecord(payload.nodes) ? payload.nodes : {},
+        edges: Array.isArray(payload.edges) ? payload.edges : [],
+        ...(typeof payload.maxIterations === 'number' ? { maxIterations: payload.maxIterations } : {}),
+    };
+}
+export function normalizeStudioAssetPayload(kind, authorInput, slugInput, payloadInput) {
+    if (!isRecord(payloadInput)) {
+        throw new Error('Asset payload must be a JSON object.');
+    }
+    const author = sanitizeAuthor(authorInput);
+    const slug = sanitizeSlug(slugInput);
+    switch (kind) {
+        case 'tal':
+            return normalizeTalPayload(author, slug, payloadInput);
+        case 'dance':
+            return normalizeDancePayload(author, slug, payloadInput);
+        case 'performer':
+            return normalizePerformerPayload(author, slug, payloadInput);
+        case 'act':
+            return normalizeActPayload(author, slug, payloadInput);
+    }
+}
+export async function readDotAuthUser() {
+    try {
+        const raw = await fs.readFile(path.join(getGlobalDotDir(), 'auth.json'), 'utf-8');
+        const parsed = JSON.parse(raw);
+        if (!parsed?.token || !parsed?.username) {
+            return null;
+        }
+        return {
+            token: String(parsed.token),
+            username: sanitizeAuthor(String(parsed.username)),
+        };
+    }
+    catch {
+        return null;
+    }
+}
+export async function clearDotAuthUser() {
+    try {
+        await fs.unlink(path.join(getGlobalDotDir(), 'auth.json'));
+    }
+    catch (error) {
+        if (error?.code !== 'ENOENT') {
+            throw error;
+        }
+    }
+}
+export async function saveLocalStudioAsset(options) {
+    const normalized = normalizeStudioAssetPayload(options.kind, options.author, options.slug, options.payload);
+    const urn = `${options.kind}/@${sanitizeAuthor(options.author)}/${sanitizeSlug(options.slug)}`;
+    await ensureDotDir(options.cwd);
+    const filePath = assetFilePath(options.cwd, urn);
+    await fs.mkdir(path.dirname(filePath), { recursive: true });
+    let existed = true;
+    try {
+        await fs.access(filePath);
+    }
+    catch {
+        existed = false;
+    }
+    await fs.writeFile(filePath, JSON.stringify(normalized, null, 2), 'utf-8');
+    return {
+        urn,
+        path: filePath,
+        existed,
+        payload: normalized,
+    };
+}
+export async function publishStudioAsset(options) {
+    const slug = sanitizeSlug(options.slug);
+    const username = sanitizeAuthor(options.auth.username);
+    let localPayload;
+    if (options.payload !== undefined) {
+        const saved = await saveLocalStudioAsset({
+            cwd: options.cwd,
+            kind: options.kind,
+            author: username,
+            slug,
+            payload: options.payload,
+        });
+        localPayload = saved.payload;
+    }
+    else {
+        const urn = `${options.kind}/@${username}/${slug}`;
+        const existing = await loadLocalAssetByUrn(options.cwd, urn);
+        if (!existing) {
+            throw new Error(`Local asset '${urn}' was not found. Save it locally before publishing.`);
+        }
+        localPayload = existing;
+    }
+    const dependenciesPublished = [];
+    const dependenciesSkipped = [];
+    const dependenciesExisting = [];
+    if (options.kind === 'performer' || options.kind === 'act') {
+        const dependencies = await resolveDependencies(options.cwd, options.kind, localPayload, username);
+        const foreignMissing = dependencies.filter((dep) => dep.status === 'foreign_missing');
+        if (foreignMissing.length > 0) {
+            throw new Error(`Cannot publish because some dependencies are missing from the registry and belong to other authors: ${foreignMissing.map((dep) => dep.urn).join(', ')}.`);
+        }
+        for (const dependency of dependencies) {
+            if (dependency.status === 'exists') {
+                dependenciesExisting.push(dependency.urn);
+                continue;
+            }
+            if (!dependency.payload) {
+                continue;
+            }
+            const parsed = parseUrn(dependency.urn);
+            if (!parsed) {
+                continue;
+            }
+            const published = await publishSingleAsset(parsed.kind, parsed.name, dependency.payload, sanitizeTags(getPayloadTags(dependency.payload)), options.auth.token);
+            if (published) {
+                dependenciesPublished.push(dependency.urn);
+            }
+            else {
+                dependenciesSkipped.push(dependency.urn);
+            }
+        }
+    }
+    const tags = options.tags && options.tags.length > 0 ? sanitizeTags(options.tags) : sanitizeTags(getPayloadTags(localPayload));
+    const mainPublished = await publishSingleAsset(options.kind, slug, localPayload, tags, options.auth.token);
+    const urn = `${options.kind}/@${username}/${slug}`;
+    return {
+        urn,
+        published: mainPublished,
+        dependenciesPublished,
+        dependenciesSkipped,
+        dependenciesExisting,
+    };
+}

package/dist/server/lib/dot-loader.js

@@ -0,0 +1,61 @@
+import path from 'path';
+import { createHash } from 'crypto';
+import { getOpencode } from './opencode.js';
+import { unwrapOpencodeResult } from './opencode-errors.js';
+import { resolvePackageBin } from './package-bin.js';
+export const CAPABILITY_LOADER_TOOL_NAME = 'load_capability_context';
+function resolveDotCommand() {
+    return resolvePackageBin('dance-of-tal', 'dance-of-tal') || 'dance-of-tal';
+}
+export function dotLoaderServerName(cwd) {
+    const hash = createHash('sha1').update(path.resolve(cwd)).digest('hex').slice(0, 10);
+    return `dot-stage-${hash}`;
+}
+function resolveCapabilityToolId(toolIds) {
+    const exact = toolIds.find((toolId) => toolId === CAPABILITY_LOADER_TOOL_NAME);
+    if (exact) {
+        return exact;
+    }
+    return toolIds.find((toolId) => (toolId.endsWith(`/${CAPABILITY_LOADER_TOOL_NAME}`)
+        || toolId.endsWith(`:${CAPABILITY_LOADER_TOOL_NAME}`)
+        || toolId.endsWith(`.${CAPABILITY_LOADER_TOOL_NAME}`))) || null;
+}
+export async function ensureDotLoaderServer(cwd) {
+    const serverName = dotLoaderServerName(cwd);
+    const oc = await getOpencode();
+    const params = { directory: path.resolve(cwd) };
+    const statusData = unwrapOpencodeResult(await oc.mcp.status(params)) || {};
+    const existing = statusData[serverName];
+    if (!existing) {
+        unwrapOpencodeResult(await oc.mcp.add({
+            ...params,
+            name: serverName,
+            config: {
+                type: 'local',
+                command: [resolveDotCommand()],
+                enabled: true,
+                environment: {
+                    DANCE_OF_TAL_PROJECT_DIR: path.resolve(cwd),
+                },
+            },
+        }));
+    }
+    const refreshedStatusData = unwrapOpencodeResult(await oc.mcp.status(params)) || {};
+    const status = refreshedStatusData[serverName];
+    if (!status || status.status !== 'connected') {
+        unwrapOpencodeResult(await oc.mcp.connect({
+            name: serverName,
+            ...params,
+        }));
+    }
+    const toolIds = unwrapOpencodeResult(await oc.tool.ids(params)) || [];
+    const resolvedToolId = resolveCapabilityToolId(toolIds);
+    if (!resolvedToolId) {
+        throw new Error(`Capability loader tool '${CAPABILITY_LOADER_TOOL_NAME}' is unavailable after MCP connection.`);
+    }
+    return {
+        available: true,
+        serverName,
+        toolName: resolvedToolId,
+    };
+}

package/dist/server/lib/dot-login.js

@@ -0,0 +1,190 @@
+import fs from 'fs/promises';
+import path from 'path';
+import http from 'http';
+import crypto from 'crypto';
+import open from 'open';
+import { getGlobalDotDir } from 'dance-of-tal/lib/registry';
+import { readDotAuthUser } from './dot-authoring.js';
+const SUPABASE_URL = process.env.DOT_SUPABASE_URL || 'https://qbildcrfjencoqkngyfw.supabase.co';
+const SUPABASE_ANON_KEY = process.env.DOT_SUPABASE_ANON_KEY || 'eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJpc3MiOiJzdXBhYmFzZSIsInJlZiI6InFiaWxkY3JmamVuY29xa25neWZ3Iiwicm9sZSI6ImFub24iLCJpYXQiOjE3NzIyNjE5MzYsImV4cCI6MjA4NzgzNzkzNn0.9aI9FU-j20w3UIG7BuVtmpAPh3qClz7xTNXjcq7ofNQ';
+const DOT_LOGIN_REDIRECT_URI = 'http://localhost:4242/callback';
+const LOGIN_SERVER_TIMEOUT_MS = 180_000;
+let loginState = null;
+function getAuthFilePath() {
+    return path.join(getGlobalDotDir(), 'auth.json');
+}
+async function saveAuthToken(token, username) {
+    const authFile = getAuthFilePath();
+    await fs.mkdir(path.dirname(authFile), { recursive: true });
+    await fs.writeFile(authFile, JSON.stringify({ token, username }, null, 2), 'utf-8');
+}
+function generateCodeVerifier() {
+    return crypto.randomBytes(32).toString('base64url');
+}
+function generateCodeChallenge(verifier) {
+    return crypto.createHash('sha256').update(verifier).digest('base64url');
+}
+function clearLoginState() {
+    if (!loginState) {
+        return;
+    }
+    clearTimeout(loginState.timeout);
+    loginState.server.close();
+    loginState = null;
+}
+async function releaseStaleLoginPort() {
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), 1_500);
+    try {
+        // Legacy dot login closes itself when /callback is hit without a code.
+        await fetch(DOT_LOGIN_REDIRECT_URI, {
+            method: 'GET',
+            signal: controller.signal,
+        }).catch(() => { });
+        await new Promise((resolve) => setTimeout(resolve, 250));
+    }
+    finally {
+        clearTimeout(timer);
+    }
+}
+async function listenOnLoginPort(server) {
+    const tryListen = async () => new Promise((resolve, reject) => {
+        const onError = (error) => {
+            server.off('listening', onListening);
+            reject(error);
+        };
+        const onListening = () => {
+            server.off('error', onError);
+            resolve();
+        };
+        server.once('error', onError);
+        server.once('listening', onListening);
+        server.listen(4242);
+    });
+    try {
+        await tryListen();
+    }
+    catch (error) {
+        if (error?.code !== 'EADDRINUSE') {
+            throw error;
+        }
+        await releaseStaleLoginPort();
+        try {
+            await tryListen();
+        }
+        catch (retryError) {
+            if (retryError?.code === 'EADDRINUSE') {
+                throw new Error('Port 4242 is already in use by another process. Finish or close the other DOT login flow, then try again.');
+            }
+            throw retryError;
+        }
+    }
+}
+export async function startDotLogin() {
+    const auth = await readDotAuthUser();
+    if (auth) {
+        return {
+            started: false,
+            alreadyAuthenticated: true,
+            username: auth.username,
+        };
+    }
+    if (loginState) {
+        return {
+            started: false,
+            alreadyRunning: true,
+            authUrl: loginState.authUrl,
+            browserOpened: false,
+        };
+    }
+    const codeVerifier = generateCodeVerifier();
+    const codeChallenge = generateCodeChallenge(codeVerifier);
+    const authUrl = `${SUPABASE_URL}/auth/v1/authorize?provider=github&redirect_to=${encodeURIComponent(DOT_LOGIN_REDIRECT_URI)}&code_challenge=${codeChallenge}&code_challenge_method=s256`;
+    const server = http.createServer(async (req, res) => {
+        try {
+            const url = new URL(req.url || '/', DOT_LOGIN_REDIRECT_URI);
+            if (url.pathname !== '/callback') {
+                res.writeHead(404).end('Not Found');
+                return;
+            }
+            const code = url.searchParams.get('code');
+            if (!code) {
+                res.writeHead(400, { 'Content-Type': 'text/html' });
+                res.end("<h2 style='color: red; text-align: center; font-family: sans-serif; margin-top: 50px;'>Authentication failed: No code received. You can close this window.</h2>");
+                clearLoginState();
+                return;
+            }
+            res.writeHead(200, { 'Content-Type': 'text/html' });
+            res.write("<h2 style='font-family: sans-serif; text-align: center; margin-top: 50px;'>Completing authentication... Please wait.</h2>");
+            try {
+                const tokenRes = await fetch(`${SUPABASE_URL}/auth/v1/token?grant_type=pkce`, {
+                    method: 'POST',
+                    headers: {
+                        'Content-Type': 'application/json',
+                        apikey: SUPABASE_ANON_KEY,
+                    },
+                    body: JSON.stringify({
+                        auth_code: code,
+                        code_verifier: codeVerifier,
+                    }),
+                });
+                const data = await tokenRes.json();
+                if (!tokenRes.ok || !data.access_token) {
+                    throw new Error(data.error_description || data.msg || 'Failed to exchange token');
+                }
+                const username = data.user?.user_metadata?.preferred_username || data.user?.user_metadata?.user_name;
+                if (!username) {
+                    throw new Error('Could not determine GitHub username from token.');
+                }
+                await saveAuthToken(data.access_token, username);
+                res.end(`
+                    <script>
+                        document.body.innerHTML = "<h2 style='color: green; font-family: sans-serif; text-align: center; margin-top: 50px;'>Authentication Successful! You can safely close this window.</h2>";
+                        setTimeout(() => window.close(), 3000);
+                    </script>
+                `);
+            }
+            catch (error) {
+                res.end(`
+                    <script>
+                        document.body.innerHTML = "<h2 style='color: red; font-family: sans-serif; text-align: center; margin-top: 50px;'>Authentication Failed. ${String(error?.message || 'Unknown error')}</h2>";
+                    </script>
+                `);
+            }
+            finally {
+                clearLoginState();
+            }
+        }
+        catch {
+            try {
+                res.writeHead(500).end('Server Error');
+            }
+            catch {
+                // ignore
+            }
+            clearLoginState();
+        }
+    });
+    await listenOnLoginPort(server);
+    loginState = {
+        server,
+        authUrl,
+        timeout: setTimeout(() => {
+            clearLoginState();
+        }, LOGIN_SERVER_TIMEOUT_MS),
+    };
+    let browserOpened = true;
+    try {
+        await open(authUrl);
+    }
+    catch {
+        browserOpened = false;
+    }
+    return {
+        started: true,
+        alreadyRunning: false,
+        alreadyAuthenticated: false,
+        authUrl,
+        browserOpened,
+    };
+}

package/dist/server/lib/model-catalog.js

@@ -0,0 +1,111 @@
+import { getOpencode } from './opencode.js';
+import { readStoredProviderAuthType } from './opencode-auth.js';
+import { normalizeRuntimeVariants, } from '../../shared/model-variants.js';
+const incompatibleModelsByAuthType = {
+    openai: {
+        // ChatGPT account-backed OpenAI auth rejects these at runtime today.
+        oauth: new Set([
+            'codex-mini-latest',
+            'gpt-5.3-codex-spark',
+        ]),
+    },
+};
+function readCapabilityFlag(model, ...keys) {
+    const capabilityRecord = model.capabilities && typeof model.capabilities === 'object'
+        ? model.capabilities
+        : {};
+    for (const key of keys) {
+        if (typeof capabilityRecord[key] === 'boolean') {
+            return capabilityRecord[key];
+        }
+        if (typeof model[key] === 'boolean') {
+            return model[key];
+        }
+    }
+    return false;
+}
+function readModalities(model) {
+    const capabilityRecord = model.capabilities && typeof model.capabilities === 'object'
+        ? model.capabilities
+        : {};
+    const input = Array.isArray(capabilityRecord.input)
+        ? capabilityRecord.input.filter((value) => typeof value === 'string')
+        : Array.isArray(model.modalities?.input)
+            ? model.modalities.input.filter((value) => typeof value === 'string')
+            : ['text'];
+    const output = Array.isArray(capabilityRecord.output)
+        ? capabilityRecord.output.filter((value) => typeof value === 'string')
+        : Array.isArray(model.modalities?.output)
+            ? model.modalities.output.filter((value) => typeof value === 'string')
+            : ['text'];
+    return { input, output };
+}
+function isModelVisibleForAuthType(providerId, modelId, authType) {
+    if (!authType) {
+        return true;
+    }
+    const blocked = incompatibleModelsByAuthType[providerId]?.[authType];
+    if (!blocked) {
+        return true;
+    }
+    return !blocked.has(modelId);
+}
+export async function listRuntimeModels(cwd) {
+    const oc = await getOpencode();
+    const res = await oc.provider.list({ directory: cwd });
+    const data = res.data;
+    if (!data?.all || !Array.isArray(data.all)) {
+        return [];
+    }
+    const connectedProviders = new Set(Array.isArray(data.connected)
+        ? data.connected.filter((value) => typeof value === 'string')
+        : []);
+    const authTypes = new Map();
+    const models = [];
+    for (const provider of data.all) {
+        const providerId = typeof provider.id === 'string' ? provider.id : '';
+        const providerName = typeof provider.name === 'string' ? provider.name : providerId;
+        const connected = connectedProviders.has(providerId);
+        if (!authTypes.has(providerId)) {
+            authTypes.set(providerId, connected ? await readStoredProviderAuthType(providerId) : null);
+        }
+        const authType = authTypes.get(providerId) || null;
+        const rawModels = provider.models && typeof provider.models === 'object'
+            ? provider.models
+            : {};
+        for (const model of Object.values(rawModels)) {
+            const record = model;
+            const id = typeof record.id === 'string' ? record.id : '';
+            if (!id) {
+                continue;
+            }
+            if (!isModelVisibleForAuthType(providerId, id, authType)) {
+                continue;
+            }
+            models.push({
+                provider: providerId,
+                providerName,
+                id,
+                name: typeof record.name === 'string' ? record.name : id,
+                connected,
+                context: Number(record.limit?.context || 0),
+                output: Number(record.limit?.output || 0),
+                toolCall: readCapabilityFlag(record, 'toolcall', 'toolCall', 'tool_call'),
+                reasoning: readCapabilityFlag(record, 'reasoning'),
+                attachment: readCapabilityFlag(record, 'attachment'),
+                temperature: readCapabilityFlag(record, 'temperature'),
+                modalities: readModalities(record),
+                variants: normalizeRuntimeVariants(record.variants),
+            });
+        }
+    }
+    return models;
+}
+export async function resolveRuntimeModel(cwd, selection) {
+    if (!selection) {
+        return null;
+    }
+    const models = await listRuntimeModels(cwd);
+    return models.find((model) => (model.provider === selection.provider
+        && model.id === selection.modelId)) || null;
+}