@jini-ai/agent-runtime 0.4.1 → 0.4.3

package/dist/model-discovery-adapters.js

@@ -0,0 +1,391 @@
+import { execFile } from 'node:child_process';
+import { readFile, stat } from 'node:fs/promises';
+import { homedir } from 'node:os';
+import { join, dirname } from 'node:path';
+import { createCommandInvocation } from '@jini-ai/platform';
+import { detectAcpModelMetadata } from './agent-protocol/acp/models.js';
+import { CLAUDE_CODE_INITIALIZE_ARGS, CLAUDE_CODE_INITIALIZE_REQUEST } from './claude-code-models.js';
+import { listProviderModels } from './providers/model-catalog.js';
+import { execAgentFile } from './invocation.js';
+import { probeCopilotSdk, probeDroidSdk } from './model-discovery-sdk.js';
+import { parseSettingsJson, readModelConfiguration } from './model-discovery-config.js';
+import { ModelProbeError, modelIdentityKind, withModelProbeTimeout } from './model-discovery.js';
+const ACP_ARGS = {
+    amr: ['agent', 'run', '--runtime', 'opencode'],
+    auggie: ['--acp'], cline: ['--acp'], devin: ['--permission-mode', 'dangerous', '--respect-workspace-trust', 'false', 'acp'],
+    goose: ['acp'], hermes: ['acp', '--accept-hooks'], kilo: ['acp'], kimi: ['acp'], kiro: ['acp'], reasonix: ['acp'], 'trae-cli': ['acp', 'serve'], vibe: [],
+};
+const CLI_ARGS = {
+    // UNVERIFIED adapters: commands documented by upstream/the survey; schemas need installed checks.
+    amp: ['plugins', 'show-agent-options', '--json'], crush: ['models'], deepseek: ['models'], qoder: ['--list-models'],
+};
+export function modelProbeTimeoutMs(agentId) {
+    if (ACP_ARGS[agentId] || ['claude', 'codebuddy', 'pi', 'copilot', 'droid'].includes(agentId))
+        return 15_000;
+    return 10_000;
+}
+/** Shared CLI-subcommand adapter. Output parsers are pure def-owned functions, not vendor tools. */
+export async function probeCliSubcommand(context, config, deps, signal) {
+    // Reserve two seconds of the outer budget for CLI-owned cache recovery. The inner
+    // abort signal stops only the listing; the parent remains usable for reading fallback files.
+    const { stdout } = await withModelProbeTimeout(active => deps.process.run({ context, args: config.args || [], signal: active, timeoutMs: 8_000 }), 8_000, signal);
+    const models = config.parse?.({ stdout });
+    if (!models)
+        throw new ModelProbeError('malformed-response');
+    const defaultSelectionId = stdout.match(/^\s*Default model:\s*(\S+)\s*$/mi)?.[1];
+    return { models, source: 'cli', coverage: 'account', ...(defaultSelectionId ? { defaultSelectionId } : {}) };
+}
+/** ACP can create CLI session state/start services. It never sends a user prompt. */
+export async function probeAcpMetadata(context, args, deps, signal) {
+    return deps.acp.probe({ context, args, signal });
+}
+/** Keep selection IDs, resolved concrete IDs and display names, including capability variants.
+ * Default-policy display names become the exact resolved ID; malformed responses return null.
+ * @complexity O(s + n) time and space in stdout length s and listed models n.
+ */
+export function parseClaudeInitializeMetadata(stdout) {
+    for (const line of stdout.split('\n')) {
+        let obj;
+        try {
+            obj = JSON.parse(line);
+        }
+        catch {
+            continue;
+        }
+        if (obj?.type !== 'control_response')
+            continue;
+        const response = obj.response;
+        const rows = response?.subtype === 'success' ? response.response?.models : undefined;
+        if (!Array.isArray(rows))
+            continue;
+        const models = [];
+        let defaultSelectionId;
+        for (const row of rows) {
+            if (!row || typeof row.value !== 'string')
+                continue;
+            const id = row.value.trim();
+            const resolvedId = typeof row.resolvedModel === 'string' ? row.resolvedModel.trim() : undefined;
+            const label = typeof row.displayName === 'string' && row.displayName.trim() ? row.displayName.trim() : resolvedId || id;
+            if (id === 'default') {
+                // This displayName describes the CLI's default policy, not the model it resolves to.
+                if (resolvedId && modelIdentityKind(resolvedId) === 'concrete') {
+                    defaultSelectionId = resolvedId;
+                    models.push({ id: resolvedId, label: resolvedId, identityKind: 'concrete' });
+                }
+                continue;
+            }
+            models.push({ id, label, identityKind: id === resolvedId ? 'concrete' : resolvedId ? 'alias' : modelIdentityKind(id), ...(resolvedId ? { resolvedId } : {}) });
+            if (resolvedId && id !== resolvedId)
+                models.push({ id: resolvedId, label, identityKind: modelIdentityKind(resolvedId) });
+        }
+        return { models, source: 'rpc', coverage: 'account', ...(defaultSelectionId ? { defaultSelectionId } : {}) };
+    }
+    return null;
+}
+/** Shared initialize category; CodeBuddy compatibility remains UNVERIFIED locally. */
+export async function probeClaudeInitialize(context, deps, signal) {
+    const args = [...CLAUDE_CODE_INITIALIZE_ARGS];
+    if (context.settingSources)
+        args.push('--setting-sources', context.settingSources.join(','));
+    // The last settings argument must still disable hooks; the probe never executes hooks.
+    const raw = context.settings ? (context.settings.trim().startsWith('{') ? context.settings : await deps.fs.read(context.settings, { signal })) : null;
+    const settings = raw ? parseSettingsJson(raw) : undefined;
+    if (settings)
+        args.push('--settings', JSON.stringify({ ...settings, disableAllHooks: true }));
+    const result = await deps.process.run({ context, args, stdin: CLAUDE_CODE_INITIALIZE_REQUEST, signal, timeoutMs: 15_000 });
+    const metadata = parseClaudeInitializeMetadata(result.stdout);
+    if (!metadata?.models.length)
+        throw new ModelProbeError('malformed-response');
+    return metadata;
+}
+export async function probeProviderApi(agentId, context, deps, signal) {
+    const config = await readModelConfiguration(agentId, context, deps, signal);
+    const effectiveContext = config.selection ? { ...context, model: config.selection } : context;
+    const input = await deps.credential.connection({ agentId, context: effectiveContext, signal });
+    if (!input)
+        throw new ModelProbeError('auth-missing');
+    if (input.protocol === 'bedrock' || input.protocol === 'azure')
+        throw new ModelProbeError('unsupported-version');
+    const result = await deps.http.list({ ...input, signal });
+    if (!result.ok || !result.models)
+        throw new ModelProbeError(result.kind === 'auth_failed' ? 'auth-missing' : result.kind === 'timeout' ? 'timeout' : 'offline');
+    const prefix = agentId === 'aider' && config.selection?.includes('/') ? config.selection.slice(0, config.selection.indexOf('/') + 1) : '';
+    return { models: result.models.map((row) => ({ ...row, id: prefix && !row.id.startsWith(prefix) ? `${prefix}${row.id}` : row.id })), source: 'provider-api', coverage: 'provider' };
+}
+/** Caches are partial observed catalogs, always stale, never silently promoted to live. */
+export async function probeCliCache(agentId, context, deps, signal) {
+    const home = context.env.HOME || homedir();
+    const path = agentId === 'codex' ? join(context.env.CODEX_HOME || join(home, '.codex'), 'models_cache.json')
+        : agentId === 'opencode' ? join(context.env.XDG_CACHE_HOME || join(home, '.cache'), 'opencode/models.json')
+            : agentId === 'claude' ? join(context.env.CLAUDE_CONFIG_DIR || home, '.claude.json')
+                : agentId === 'codebuddy' ? join(home, '.codebuddy/settings.json') : '';
+    if (!path)
+        throw new ModelProbeError('unsupported-version');
+    const raw = await deps.fs.read(path, { signal });
+    const data = raw ? parseSettingsJson(raw) : null;
+    if (!data)
+        throw new ModelProbeError('offline');
+    if (agentId === 'codex' && raw)
+        return { models: configurationCacheModels(data.models), source: 'cli-cache', coverage: 'observed' };
+    if (agentId === 'opencode') {
+        const models = [];
+        for (const [provider, value] of Object.entries(data)) {
+            const entries = value && typeof value === 'object' ? value.models : undefined;
+            for (const [id, row] of Object.entries(entries || {}))
+                models.push({ id: `${provider}/${id}`, label: row.name || `${provider}/${id}`, provider, identityKind: modelIdentityKind(id) });
+        }
+        return { models, source: 'cli-cache', coverage: 'observed' };
+    }
+    // UNVERIFIED CodeBuddy cache schema. Configured model is weaker than an account catalog.
+    const entries = data.additionalModelOptionsCache;
+    return { models: configurationCacheModels(entries), source: 'cli-cache', coverage: 'observed' };
+}
+function configurationCacheModels(entries) {
+    if (!Array.isArray(entries))
+        return [];
+    return entries.flatMap((row) => {
+        const id = typeof row?.slug === 'string' ? row.slug : typeof row?.value === 'string' ? row.value : typeof row?.id === 'string' ? row.id : undefined;
+        return id ? [{ id, label: row.display_name || row.displayName || id, identityKind: modelIdentityKind(id) }] : [];
+    });
+}
+function parseGenericCliModels(stdout) {
+    let parsed;
+    try {
+        parsed = JSON.parse(stdout);
+    }
+    catch {
+        parsed = null;
+    }
+    if (parsed) {
+        const object = parsed;
+        const entries = Array.isArray(parsed) ? parsed : object.models;
+        if (Array.isArray(entries))
+            return entries.flatMap((row) => {
+                const id = typeof row === 'string' ? row : typeof row?.id === 'string' ? row.id : typeof row?.model === 'string' ? row.model : undefined;
+                return id ? [{ id, label: typeof row?.name === 'string' ? row.name : id, identityKind: modelIdentityKind(id) }] : [];
+            });
+    }
+    return stdout.split('\n').flatMap((line) => {
+        const match = line.trim().match(/^(?:[-*•]\s*)?([\w][\w./:[\]-]*)(?:\s+-\s+(.+))?$/);
+        if (!match || /^(models|available|provider|model)$/i.test(match[1]))
+            return [];
+        return [{ id: match[1], label: match[2] || match[1], identityKind: modelIdentityKind(match[1]) }];
+    });
+}
+export async function probeAgentCatalog(agentId, context, configuration, deps, signal) {
+    const acpArgs = ACP_ARGS[agentId];
+    // UNVERIFIED installed ACP agents: existing declared commands; metadata preserves native defaults.
+    if (acpArgs && agentId !== 'amr')
+        return probeAcpMetadata(context, acpArgs, deps, signal);
+    if (agentId === 'claude') {
+        try {
+            return await probeClaudeInitialize(context, deps, signal);
+        }
+        catch {
+            try {
+                return await probeProviderApi(agentId, context, deps, signal);
+            }
+            catch {
+                return probeCliCache(agentId, context, deps, signal);
+            }
+        }
+    }
+    if (agentId === 'pi' || agentId === 'copilot' || agentId === 'droid')
+        return deps.rpc.probe({ agentId, context, signal });
+    // UNVERIFIED CLI-owned effective credential adapters; OAuth/unknown endpoints require host ports.
+    if (agentId === 'aider' || agentId === 'qwen' || agentId === 'mimo')
+        return probeProviderApi(agentId, context, deps, signal);
+    if (agentId === 'codebuddy') {
+        // UNVERIFIED: survey identifies initialize compatibility as a candidate, not a guarantee.
+        // Try the same prompt-free metadata category; failed compatibility stays explicitly offline.
+        try {
+            return await probeClaudeInitialize(context, deps, signal);
+        }
+        catch {
+            return probeCliCache(agentId, context, deps, signal);
+        }
+    }
+    if (configuration.args) {
+        try {
+            return await probeCliSubcommand(context, configuration, deps, signal);
+        }
+        catch (error) {
+            if (agentId === 'codex' || agentId === 'opencode') {
+                try {
+                    return await probeCliCache(agentId, context, deps, signal);
+                }
+                catch {
+                    throw error;
+                }
+            }
+            throw error;
+        }
+    }
+    if (agentId === 'amr') {
+        // Every ACP def uses this category. Vela's documented list command remains a fallback
+        // when its ACP version omits the model catalog; launch still confirms explicit selection.
+        try {
+            const metadata = await probeAcpMetadata(context, ACP_ARGS.amr, deps, signal);
+            const first = metadata.models.find((row) => row.id !== 'default' && modelIdentityKind(row.id) === 'concrete');
+            if (!first)
+                throw new ModelProbeError('malformed-response');
+            return { ...metadata, defaultSelectionId: context.env.VELA_DEFAULT_MODEL || metadata.defaultSelectionId || first.id };
+        }
+        catch (error) {
+            if (signal.aborted)
+                throw error;
+        }
+        const result = await deps.process.run({ context, args: ['model', 'list', '--format', 'json'], signal, timeoutMs: 10_000 });
+        const models = configuration.parse?.({ stdout: result.stdout }) || [];
+        // Vela requires an explicit concrete set_model before prompting; retain the first native row.
+        const first = models.find((row) => row.id !== 'default');
+        return { models, source: 'cli', coverage: 'account', ...(first ? { defaultSelectionId: context.env.VELA_DEFAULT_MODEL || first.id } : {}) };
+    }
+    const args = CLI_ARGS[agentId];
+    if (!args)
+        throw new ModelProbeError('unsupported-version');
+    return probeCliSubcommand(context, { ...configuration, args, parse: ({ stdout }) => parseGenericCliModels(stdout) }, deps, signal);
+}
+function runProcess(input) {
+    if (input.stdin === undefined)
+        return execAgentFile({ command: input.context.executable, args: [...input.args] }, { options: {
+                cwd: input.context.cwd, env: input.context.env, signal: input.signal,
+                timeout: input.timeoutMs, killSignal: 'SIGKILL', maxBuffer: 8 * 1024 * 1024,
+            } }).then(({ stdout, stderr }) => ({ stdout: String(stdout), stderr: String(stderr) }));
+    return new Promise((resolve, reject) => {
+        let completed = false;
+        let captured = '';
+        const invocation = createCommandInvocation({ command: input.context.executable, args: [...input.args], env: input.context.env });
+        const tree = input.terminateProcessTree && process.platform !== 'win32';
+        let treeTimer;
+        const killTree = () => { if (tree && child.pid) {
+            try {
+                process.kill(-child.pid, 'SIGKILL');
+            }
+            catch { }
+        } };
+        // execFile forwards `detached` to spawn at runtime, but its typings omit it; a typed
+        // variable (not a literal) keeps the process-group option without a cast.
+        const options = { cwd: input.context.cwd, env: input.context.env,
+            timeout: input.timeoutMs, killSignal: 'SIGKILL', signal: input.signal, maxBuffer: 8 * 1024 * 1024,
+            detached: Boolean(tree),
+            windowsVerbatimArguments: invocation.windowsVerbatimArguments, };
+        const child = execFile(invocation.command, invocation.args, options, (error, stdout, stderr) => {
+            if (treeTimer)
+                clearTimeout(treeTimer);
+            input.signal.removeEventListener('abort', killTree);
+            if (error)
+                killTree();
+            error && !completed ? reject(error) : resolve({ stdout: String(stdout), stderr: String(stderr) });
+        });
+        if (tree) {
+            input.signal.addEventListener('abort', killTree, { once: true });
+            treeTimer = setTimeout(killTree, input.timeoutMs);
+            if (input.signal.aborted)
+                killTree();
+        }
+        if (input.complete)
+            child.stdout?.on('data', (chunk) => {
+                captured += String(chunk);
+                if (input.complete?.(captured)) {
+                    completed = true;
+                    child.kill('SIGKILL');
+                }
+            });
+        child.stdin?.on('error', () => { });
+        child.stdin?.end(input.stdin);
+    });
+}
+export const defaultModelDiscoveryDeps = {
+    process: { run: runProcess },
+    fs: {
+        read: (path, { signal }) => readFile(path, { encoding: 'utf8', signal }).catch(() => null),
+        async projectRoot({ cwd, signal }) {
+            let directory = cwd;
+            for (let depth = 0; depth < 64 && !signal.aborted; depth++) {
+                if (await stat(join(directory, '.git')).then(() => true, () => false))
+                    return directory;
+                const parent = dirname(directory);
+                if (parent === directory)
+                    break;
+                directory = parent;
+            }
+            return null;
+        },
+    },
+    http: { list: (input) => { const { protocol, baseUrl, apiKey, ...optional } = input; return listProviderModels({ protocol, baseUrl, apiKey }, optional); } },
+    credential: { async connection({ agentId, context }) {
+            // Deliberately do not steal tokens from another CLI's store. Hosts can inject keychain/OAuth
+            // handles. BYOK env is usable only when it identifies this CLI's effective provider.
+            const env = context.env;
+            if (agentId === 'claude' && env.ANTHROPIC_API_KEY)
+                return { protocol: 'anthropic', baseUrl: env.ANTHROPIC_BASE_URL || 'https://api.anthropic.com', apiKey: env.ANTHROPIC_API_KEY };
+            const selected = context.model || (agentId === 'aider' ? env.AIDER_MODEL : agentId === 'qwen' ? env.QWEN_MODEL || env.OPENAI_MODEL : undefined);
+            if (!selected)
+                return null;
+            if (/^(anthropic\/|claude-)/.test(selected) && env.ANTHROPIC_API_KEY)
+                return { protocol: 'anthropic', baseUrl: env.ANTHROPIC_BASE_URL || 'https://api.anthropic.com', apiKey: env.ANTHROPIC_API_KEY };
+            if (/^(gemini\/|google\/|gemini-)/.test(selected) && env.GEMINI_API_KEY)
+                return { protocol: 'google', baseUrl: 'https://generativelanguage.googleapis.com', apiKey: env.GEMINI_API_KEY };
+            if (/^openrouter\//.test(selected) && env.OPENROUTER_API_KEY)
+                return { protocol: 'openai', baseUrl: env.OPENROUTER_API_BASE || 'https://openrouter.ai/api/v1', apiKey: env.OPENROUTER_API_KEY };
+            if ((/^(openai\/|gpt-|o\d)/.test(selected) || agentId === 'qwen' && (env.OPENAI_MODEL || env.OPENAI_BASE_URL)) && env.OPENAI_API_KEY)
+                return { protocol: 'openai', baseUrl: env.OPENAI_BASE_URL || env.OPENAI_API_BASE || 'https://api.openai.com/v1', apiKey: env.OPENAI_API_KEY };
+            return null;
+        } },
+    acp: { async probe({ context, args, signal }) {
+            const invocation = createCommandInvocation({ command: context.executable, args: [...args], env: context.env });
+            const result = await detectAcpModelMetadata({ bin: invocation.command, args: invocation.args }, { cwd: context.cwd, env: context.env, timeoutMs: 15_000, signal });
+            return { models: result.models, source: 'rpc', coverage: 'account', ...(result.currentModelId ? { defaultSelectionId: result.currentModelId } : {}) };
+        } },
+    rpc: { async probe({ agentId, context, signal }) {
+            // UNVERIFIED locally: use official prompt-free SDK interfaces, not invented CLI flags.
+            if (agentId === 'copilot')
+                return probeCopilotSdk(context, signal);
+            if (agentId === 'droid')
+                return probeDroidSdk(context, defaultModelDiscoveryDeps, signal);
+            if (agentId !== 'pi')
+                throw new ModelProbeError('unsupported-version');
+            const { stdout } = await defaultModelDiscoveryDeps.process.run({ context, args: ['--mode', 'rpc'], stdin: '{"type":"get_available_models","id":"catalog"}\n{"type":"get_state","id":"state"}\n', signal, timeoutMs: 15_000,
+                complete: (output) => {
+                    try {
+                        const metadata = parsePiRpcMetadata(output);
+                        return Boolean(metadata.defaultSelectionId);
+                    }
+                    catch {
+                        return false;
+                    }
+                } });
+            return parsePiRpcMetadata(stdout);
+        } },
+    clock: { now: Date.now }, cache: new Map(),
+};
+/** Pi's native RPC supplies catalog AND current provider/id without making an inference call. */
+export function parsePiRpcMetadata(stdout) {
+    const models = [];
+    let defaultSelectionId;
+    for (const line of stdout.split('\n')) {
+        let response;
+        try {
+            response = JSON.parse(line);
+        }
+        catch {
+            continue;
+        }
+        if (response.type !== 'response' || !response.success)
+            continue;
+        if (response.command === 'get_available_models' && Array.isArray(response.data?.models)) {
+            for (const raw of response.data.models) {
+                const row = raw;
+                if (row.provider && row.id)
+                    models.push({ id: `${row.provider}/${row.id}`, label: row.name || row.id, provider: row.provider, identityKind: modelIdentityKind(row.id) });
+            }
+        }
+        if (response.command === 'get_state' && response.data?.model?.provider && response.data.model.id)
+            defaultSelectionId = `${response.data.model.provider}/${response.data.model.id}`;
+    }
+    if (!models.length)
+        throw new ModelProbeError('malformed-response');
+    return { models, source: 'rpc', coverage: 'account', ...(defaultSelectionId ? { defaultSelectionId } : {}) };
+}
+//# sourceMappingURL=model-discovery-adapters.js.map

package/dist/model-discovery-config.d.ts

@@ -0,0 +1,17 @@
+import type { ModelDiscoveryContext, ModelDiscoveryDeps } from './model-discovery-types.js';
+type ConfigFile = {
+    path: string;
+    format: 'json' | 'toml' | 'yaml';
+    key?: string;
+};
+/** Config-file resolvers read only settings, never auth-store contents. Precedence is applied
+ * from global to workspace/local. Unknown native priorities remain unresolved, not invented. */
+export declare function modelConfigFiles(agentId: string, context: ModelDiscoveryContext): ConfigFile[];
+export declare function parseSettingsJson(raw: string): Record<string, unknown> | null;
+export declare function parseConfiguredModel(file: ConfigFile, raw: string, profile?: string): string | undefined;
+export declare function readModelConfiguration(agentId: string, context: ModelDiscoveryContext, deps: ModelDiscoveryDeps, signal: AbortSignal): Promise<{
+    selection?: string;
+    fingerprintMaterial: string;
+}>;
+export {};
+//# sourceMappingURL=model-discovery-config.d.ts.map

package/dist/model-discovery-config.js

@@ -0,0 +1,137 @@
+import { join } from 'node:path';
+import { homedir } from 'node:os';
+const json = (path, key = 'model') => ({ path, format: 'json', key });
+/** Config-file resolvers read only settings, never auth-store contents. Precedence is applied
+ * from global to workspace/local. Unknown native priorities remain unresolved, not invented. */
+export function modelConfigFiles(agentId, context) {
+    const env = context.env;
+    const home = env.HOME || homedir();
+    const user = (name) => join(home, name);
+    const local = (name) => join(context.cwd, name);
+    const root = (name) => join(context.projectRoot || context.cwd, name);
+    const configHome = env.XDG_CONFIG_HOME || user('.config');
+    switch (agentId) {
+        case 'codex': {
+            const root = env.CODEX_HOME || user('.codex');
+            return [{ path: join(root, 'config.toml'), format: 'toml' },
+                ...(context.profile ? [{ path: join(root, `${context.profile}.config.toml`), format: 'toml' }] : []),
+                { path: local('.codex/config.toml'), format: 'toml' }];
+        }
+        case 'claude': {
+            const claudeRoot = env.CLAUDE_CONFIG_DIR || user('.claude');
+            const sources = context.settingSources ?? ['user', 'project', 'local'];
+            return [...(sources.includes('user') ? [json(join(claudeRoot, 'settings.json'))] : []),
+                ...(sources.includes('project') ? [json(root('.claude/settings.json'))] : []),
+                ...(sources.includes('local') ? [json(root('.claude/settings.local.json'))] : [])];
+        }
+        case 'antigravity': return [json(user('.gemini/antigravity-cli/settings.json'))];
+        case 'opencode': return [json(join(env.XDG_STATE_HOME || user('.local/state'), 'opencode/model.json'), 'recent'), json(join(configHome, 'opencode/opencode.json')), json(join(configHome, 'opencode/opencode.jsonc')), json(root('opencode.json')), json(root('opencode.jsonc')), json(local('opencode.json')), json(local('opencode.jsonc'))];
+        case 'pi': return [json(join(env.PI_CODING_AGENT_DIR || user('.pi/agent'), 'settings.json'), 'defaultModel'), json(local('.pi/settings.json'), 'defaultModel')];
+        case 'aider': return context.configPath ? [{ path: context.configPath, format: 'yaml' }] : [{ path: user('.aider.conf.yml'), format: 'yaml' }, { path: root('.aider.conf.yml'), format: 'yaml' }, { path: local('.aider.conf.yml'), format: 'yaml' }];
+        // UNVERIFIED locally: the survey documents these settings, not installed schema behavior.
+        case 'grok-build': return [{ path: user('.grok/config.toml'), format: 'toml', key: 'models.model' }];
+        case 'codebuddy': return [json(user('.codebuddy/settings.json')), json(local('.codebuddy/settings.json')), json(local('.codebuddy/settings.local.json'))];
+        case 'copilot': return [json(user('.copilot/config.json'))];
+        case 'cursor-agent': return [json(user('.cursor/cli-config.json'))];
+        case 'droid': return [json(user('.factory/settings.json'), 'sessionDefaultSettings.model')];
+        case 'qoder': return [json(join(env.QODER_CONFIG_DIR || user('.qoder'), 'settings.json'), 'model.name'), json(local('.qoder/settings.json'), 'model.name'), json(local('.qoder/settings.local.json'), 'model.name')];
+        case 'qwen': return [json(user('.qwen/settings.json'), 'model.name'), json(local('.qwen/settings.json'), 'model.name')];
+        case 'deepseek': return [{ path: user('.deepseek/config.toml'), format: 'toml' }, { path: user('.codewhale/config.toml'), format: 'toml' }];
+        case 'mimo': return [json(join(configHome, 'mimocode/mimocode.json')), json(local('.mimocode/mimocode.jsonc'))];
+        case 'crush': return [json(join(configHome, 'crush/crush.json'), 'models.large.model'), json(local('crush.json'), 'models.large.model')];
+        default: return [];
+    }
+}
+export function parseSettingsJson(raw) {
+    try {
+        // Preserve quoted strings (including URLs) while removing JSONC comments.
+        const stripped = raw.replace(/"(?:\\.|[^"\\])*"|\/\/[^\n]*|\/\*[\s\S]*?\*\//g, (token) => token.startsWith('"') ? token : '').replace(/,\s*([}\]])/g, '$1');
+        const value = JSON.parse(stripped);
+        return value && typeof value === 'object' && !Array.isArray(value) ? value : null;
+    }
+    catch {
+        return null;
+    }
+}
+function scalar(value) { return typeof value === 'string' && value.trim() ? value.trim() : undefined; }
+function dotted(value, key) {
+    return key.split('.').reduce((item, part) => item && typeof item === 'object' ? item[part] : undefined, value);
+}
+export function parseConfiguredModel(file, raw, profile) {
+    if (file.format === 'json') {
+        const settings = parseSettingsJson(raw);
+        const model = dotted(settings, file.key || 'model');
+        if (file.key === 'recent' && Array.isArray(model)) {
+            const first = model[0];
+            const provider = scalar(first?.providerID);
+            const id = scalar(first?.modelID);
+            return provider && id ? `${provider}/${id}` : undefined;
+        }
+        // Cursor's model object subkeys are undocumented: never guess which one is the effective id.
+        const id = scalar(model);
+        if (file.key === 'defaultModel' && id) {
+            const provider = scalar(settings?.defaultProvider);
+            return provider ? `${provider}/${id}` : undefined;
+        }
+        return id;
+    }
+    if (file.format === 'yaml')
+        return scalar(raw.match(/^model\s*:\s*["']?([^\n"'#]+)["']?\s*(?:#.*)?$/m)?.[1]);
+    let section = '';
+    let chosen;
+    let profileChoice;
+    for (const line of raw.split('\n')) {
+        const header = line.match(/^\s*\[([^\]]+)\]/);
+        if (header) {
+            section = header[1];
+            continue;
+        }
+        const match = line.match(/^\s*model\s*=\s*["']([^"']+)["']/);
+        if (!match)
+            continue;
+        if (profile && section === `profiles.${profile}`)
+            profileChoice = match[1];
+        if (section === (file.key === 'models.model' ? 'models' : ''))
+            chosen = match[1];
+    }
+    return profileChoice || chosen;
+}
+const MODEL_ENV = {
+    claude: ['ANTHROPIC_MODEL'], aider: ['AIDER_MODEL'], amr: ['VELA_DEFAULT_MODEL'],
+    deepseek: ['CODEWHALE_MODEL', 'DEEPSEEK_MODEL'], qwen: ['QWEN_MODEL', 'OPENAI_MODEL', 'ANTHROPIC_MODEL', 'GEMINI_MODEL'],
+};
+export async function readModelConfiguration(agentId, context, deps, signal) {
+    if (!context.projectRoot && ['claude', 'aider', 'opencode'].includes(agentId) && deps.fs.projectRoot) {
+        const projectRoot = await deps.fs.projectRoot({ cwd: context.cwd, signal });
+        if (projectRoot)
+            context = { ...context, projectRoot };
+    }
+    const files = modelConfigFiles(agentId, context);
+    const contents = await Promise.all(files.map(async (file) => ({ file, raw: await deps.fs.read(file.path, { signal }) })));
+    let extraMaterial = '';
+    let selection;
+    for (const { file, raw } of contents)
+        if (raw !== null)
+            selection = parseConfiguredModel(file, raw, context.profile) || selection;
+    if (agentId === 'pi') {
+        const effective = Object.assign({}, ...contents.map(({ raw }) => raw ? parseSettingsJson(raw) || {} : {}));
+        const provider = scalar(effective.defaultProvider);
+        const id = scalar(effective.defaultModel);
+        selection = provider && id ? `${provider}/${id}` : undefined;
+    }
+    const inline = agentId === 'opencode' ? context.env.OPENCODE_CONFIG_CONTENT : agentId === 'mimo' ? context.env.MIMOCODE_CONFIG_CONTENT : undefined;
+    if (inline)
+        selection = scalar(parseSettingsJson(inline)?.model) || selection;
+    for (const key of [...(MODEL_ENV[agentId] || [])].reverse())
+        selection = scalar(context.env[key]) || selection;
+    if (agentId === 'claude' && context.settings) {
+        const raw = context.settings.trim().startsWith('{') ? context.settings : await deps.fs.read(context.settings, { signal });
+        extraMaterial = raw || '';
+        if (raw)
+            selection = scalar(parseSettingsJson(raw)?.model) || selection;
+    }
+    selection = context.model || selection;
+    // Material is hashed by the orchestration layer and is never exposed over HTTP.
+    return { ...(selection ? { selection } : {}), fingerprintMaterial: JSON.stringify([contents.map(({ file, raw }) => [file.path, raw]), extraMaterial]) };
+}
+//# sourceMappingURL=model-discovery-config.js.map

package/dist/model-discovery-sdk.d.ts

@@ -0,0 +1,18 @@
+import type { ModelDiscoveryContext, ModelDiscoveryDeps, ModelProbeResult } from './model-discovery-types.js';
+/** UNVERIFIED locally. The host may install the official SDK or inject the RPC port.
+ * Use the CLI's authenticated server, not an unrelated HTTP token or an inference prompt.
+ * https://github.com/github/copilot-sdk/blob/main/nodejs/src/client.ts */
+interface CopilotMetadataClient {
+    start(): Promise<unknown>;
+    listModels(): Promise<{
+        id: string;
+        name?: string;
+    }[]>;
+    forceStop(): Promise<unknown>;
+}
+export declare function probeCopilotSdk(context: ModelDiscoveryContext, signal: AbortSignal, optional?: {
+    createClient?: (context: ModelDiscoveryContext) => Promise<CopilotMetadataClient>;
+}): Promise<ModelProbeResult>;
+export declare function probeDroidSdk(context: ModelDiscoveryContext, deps: ModelDiscoveryDeps, signal: AbortSignal): Promise<ModelProbeResult>;
+export {};
+//# sourceMappingURL=model-discovery-sdk.d.ts.map

package/dist/model-discovery-sdk.js

@@ -0,0 +1,56 @@
+import { ModelProbeError, modelIdentityKind } from './model-discovery.js';
+export async function probeCopilotSdk(context, signal, optional = {}) {
+    const client = await (optional.createClient ?? createCopilotMetadataClient)(context);
+    if (signal.aborted) {
+        await client.forceStop().catch(() => { });
+        throw new ModelProbeError('timeout');
+    }
+    const stop = () => { void Promise.resolve(client.forceStop()).catch(() => { }); };
+    signal.addEventListener('abort', stop, { once: true });
+    try {
+        await client.start();
+        if (signal.aborted)
+            throw new ModelProbeError('timeout');
+        const rows = await client.listModels();
+        return { models: rows.map((row) => ({ id: row.id, label: row.name || row.id, identityKind: modelIdentityKind(row.id) })), source: 'rpc', coverage: 'account' };
+    }
+    finally {
+        signal.removeEventListener('abort', stop);
+        // forceStop also closes the child when a failed handshake never reached connected state.
+        await client.forceStop().catch(() => { });
+    }
+}
+async function createCopilotMetadataClient(context) {
+    const packageName = '@github/copilot-sdk';
+    const sdk = await import(packageName);
+    const env = Object.fromEntries(Object.entries(context.env).filter((entry) => typeof entry[1] === 'string'));
+    // RuntimeConnection is the current SDK API; older SDKs expose cliPath/cwd/useStdio.
+    const connection = sdk.RuntimeConnection?.forStdio({ path: context.executable, env });
+    return new sdk.CopilotClient(connection
+        ? { connection, workingDirectory: context.cwd, autoRestart: false }
+        : { cliPath: context.executable, cwd: context.cwd, env, useStdio: true, autoRestart: false });
+}
+/** UNVERIFIED locally. Official Python SDK metadata bridge; no session/inference call.
+ * SDK installation belongs to the host's Python environment.
+ * https://docs.factory.com/sdk/python#discover-available-models */
+const DROID_METADATA_SCRIPT = `import asyncio, json, os, sys
+from droid_sdk import Runtime, list_models
+async def main():
+    rows = await list_models(cwd=os.getcwd(), runtime=Runtime(executable=sys.argv[1]))
+    print(json.dumps({"models": [{"id": m.id, "name": m.display_name, "provider": str(m.provider)} for m in rows if not m.disabled]}))
+asyncio.run(main())
+`;
+export async function probeDroidSdk(context, deps, signal) {
+    const { stdout } = await deps.process.run({ context: { ...context, executable: 'python3' }, args: ['-c', DROID_METADATA_SCRIPT, context.executable], stdin: '', signal, timeoutMs: 15_000, terminateProcessTree: true });
+    let data;
+    try {
+        data = JSON.parse(stdout);
+    }
+    catch {
+        throw new ModelProbeError('malformed-response');
+    }
+    if (!Array.isArray(data.models))
+        throw new ModelProbeError('malformed-response');
+    return { models: data.models.filter((row) => typeof row.id === 'string').map((row) => ({ id: row.id, label: row.name || row.id, provider: row.provider, identityKind: modelIdentityKind(row.id) })), source: 'rpc', coverage: 'account' };
+}
+//# sourceMappingURL=model-discovery-sdk.js.map