shennian 0.3.85 → 0.3.86

package/dist/src/agents/model-registry/discovery.js

@@ -1,2 +1,188 @@
-import{createInterface as m}from"node:readline";import{resolveBuiltinCommand as c,spawnResolvedCommand as v}from"../command-spec.js";import{fallbackClaudeAliasModels as M,discoverClaudeAliasModelsFromEnv as w,fallbackCodexModels as y,fallbackWorkBuddyModels as C,fallbackGeminiModels as h,parseCodexAppServerModels as g,parseCursorModels as E,parseOpenCodeModels as k}from"./parsers.js";import{runResolvedCommand as f}from"./runner.js";import{DISCOVERY_WORKDIR as b}from"./types.js";import{buildAgentProcessEnv as x,readLatestUserEnv as O}from"../../agent-env.js";import{CODEX_APP_SERVER_CLIENT_INFO as R}from"../codex-utils.js";function l(e,r,o,i,a,n){return e.stdin?new Promise((t,s)=>{const u=setTimeout(()=>{r.delete(o),s(new Error(`codex app-server request timed out: ${i}`))},n);r.set(o,{resolve:t,reject:s,timer:u}),e.stdin.write(`${JSON.stringify({id:o,method:i,params:a})}
-`,p=>{p&&(clearTimeout(u),r.delete(o),s(p))})}):Promise.reject(new Error("codex app-server stdin unavailable"))}async function A(e){const r=v(e,["app-server","--listen","stdio://"],{cwd:b,stdio:["pipe","pipe","pipe"],env:x({NO_COLOR:"1"})}),o=new Map;let i=1;m({input:r.stdout}).on("line",n=>{if(!n.trim())return;let t;try{t=JSON.parse(n)}catch{return}if(t.id==null)return;const s=o.get(t.id);s&&(clearTimeout(s.timer),o.delete(t.id),t.error?s.reject(new Error(t.error.message||`codex app-server error ${t.error.code??""}`.trim())):s.resolve(t.result))});try{await l(r,o,i++,"initialize",{clientInfo:R,capabilities:{experimentalApi:!0}},1e4);const[n,t]=await Promise.all([l(r,o,i++,"model/list",{},15e3),l(r,o,i++,"config/read",{},15e3).catch(()=>null)]),s=typeof t=="object"&&t!==null&&"config"in t?t.config:void 0;return g({...typeof n=="object"&&n!==null?n:{},config:s})}finally{for(const[n,t]of o)clearTimeout(t.timer),t.reject(new Error("codex app-server stopped")),o.delete(n);r.kill("SIGTERM"),setTimeout(()=>r.kill("SIGKILL"),1e3).unref()}}async function S(){const e=c("cursor");if(!e)return[];const r=await f(e,["--list-models"]);return E(r.stdout)}async function I(){const e=c("opencode");if(!e)return[];const r=await f(e,["models"]);return k(r.stdout)}async function P(){if(!c("claude"))return[];const e=w(O());return e.length>0?e:M()}async function T(){const e=c("codex");if(!e)return[];const r=await A(e).catch(()=>[]);return r.length>0?r:y()}async function _(){return c("gemini")?h():[]}const d=[{id:"qwen3.6-plus",name:"Qwen 3.6 Plus",provider:"dashscope",isDefault:!0}],D=[{id:"codex",name:"Codex",provider:"shennian",isDefault:!0},{id:"claude",name:"Claude Code",provider:"shennian"}];async function L(e){if(!e.serverUrl||!e.authToken)return d;try{const r=await fetch(`${e.serverUrl.replace(/\/$/,"")}/api/models`,{headers:{Authorization:`Bearer ${e.authToken}`}});if(!r.ok)return d;const o=await r.json(),i=(o.models??[]).map(a=>({id:a.id,name:a.name?.trim()||a.id,provider:a.provider,isDefault:a.id===o.default}));return i.length>0?i:d}catch{return d}}async function $(e,r){switch(e){case"claude":return P();case"codex":return T();case"workbuddy":return c("workbuddy")?C():[];case"gemini":return _();case"cursor":return S();case"openclaw":return[];case"opencode":return I();case"pi":return L(r);case"manager":return D}}async function V(e,r){return e.type.startsWith("custom:")?e.models??[]:$(e.type,r)}export{V as discoverModelsForAgent};
+// @arch docs/architecture/cli/model-discovery.md
+// @test src/__tests__/model-switching.test.ts
+import { createInterface } from 'node:readline';
+import { resolveBuiltinCommand, spawnResolvedCommand } from '../command-spec.js';
+import { fallbackClaudeAliasModels, discoverClaudeAliasModelsFromEnv, fallbackCodexModels, fallbackWorkBuddyModels, fallbackGeminiModels, parseCodexAppServerModels, parseCursorModels, parseOpenCodeModels, } from './parsers.js';
+import { runResolvedCommand } from './runner.js';
+import { DISCOVERY_WORKDIR } from './types.js';
+import { buildAgentProcessEnv, readLatestUserEnv } from '../../agent-env.js';
+import { CODEX_APP_SERVER_CLIENT_INFO } from '../codex-utils.js';
+function sendAppServerRpc(proc, pending, id, method, params, timeoutMs) {
+    if (!proc.stdin)
+        return Promise.reject(new Error('codex app-server stdin unavailable'));
+    return new Promise((resolve, reject) => {
+        const timer = setTimeout(() => {
+            pending.delete(id);
+            reject(new Error(`codex app-server request timed out: ${method}`));
+        }, timeoutMs);
+        pending.set(id, { resolve, reject, timer });
+        proc.stdin.write(`${JSON.stringify({ id, method, params })}\n`, (error) => {
+            if (!error)
+                return;
+            clearTimeout(timer);
+            pending.delete(id);
+            reject(error);
+        });
+    });
+}
+async function discoverCodexModelsViaAppServer(spec) {
+    const proc = spawnResolvedCommand(spec, ['app-server', '--listen', 'stdio://'], {
+        cwd: DISCOVERY_WORKDIR,
+        stdio: ['pipe', 'pipe', 'pipe'],
+        env: buildAgentProcessEnv({ NO_COLOR: '1' }),
+    });
+    const pending = new Map();
+    let seq = 1;
+    const rl = createInterface({ input: proc.stdout });
+    rl.on('line', (line) => {
+        if (!line.trim())
+            return;
+        let msg;
+        try {
+            msg = JSON.parse(line);
+        }
+        catch {
+            return;
+        }
+        if (msg.id == null)
+            return;
+        const request = pending.get(msg.id);
+        if (!request)
+            return;
+        clearTimeout(request.timer);
+        pending.delete(msg.id);
+        if (msg.error) {
+            request.reject(new Error(msg.error.message || `codex app-server error ${msg.error.code ?? ''}`.trim()));
+        }
+        else {
+            request.resolve(msg.result);
+        }
+    });
+    try {
+        await sendAppServerRpc(proc, pending, seq++, 'initialize', {
+            clientInfo: CODEX_APP_SERVER_CLIENT_INFO,
+            capabilities: { experimentalApi: true },
+        }, 10_000);
+        const [modelList, configRead] = await Promise.all([
+            sendAppServerRpc(proc, pending, seq++, 'model/list', {}, 15_000),
+            sendAppServerRpc(proc, pending, seq++, 'config/read', {}, 15_000).catch(() => null),
+        ]);
+        const config = typeof configRead === 'object' && configRead !== null && 'config' in configRead
+            ? configRead.config
+            : undefined;
+        return parseCodexAppServerModels({
+            ...(typeof modelList === 'object' && modelList !== null ? modelList : {}),
+            config,
+        });
+    }
+    finally {
+        for (const [id, request] of pending) {
+            clearTimeout(request.timer);
+            request.reject(new Error('codex app-server stopped'));
+            pending.delete(id);
+        }
+        proc.kill('SIGTERM');
+        setTimeout(() => proc.kill('SIGKILL'), 1000).unref();
+    }
+}
+async function discoverCursorModels() {
+    const spec = resolveBuiltinCommand('cursor');
+    if (!spec)
+        return [];
+    const result = await runResolvedCommand(spec, ['--list-models']);
+    return parseCursorModels(result.stdout);
+}
+// OpenClaw support is intentionally disabled.
+// async function discoverOpenClawModels(): Promise<ModelInfo[]> {
+//   const spec = resolveBuiltinCommand('openclaw')
+//   if (!spec) return []
+//   const result = await runResolvedCommand(spec, ['models', 'list', '--json'])
+//   return parseOpenClawModels(result.stdout)
+// }
+async function discoverOpenCodeModels() {
+    const spec = resolveBuiltinCommand('opencode');
+    if (!spec)
+        return [];
+    const result = await runResolvedCommand(spec, ['models']);
+    return parseOpenCodeModels(result.stdout);
+}
+async function discoverClaudeModels() {
+    if (!resolveBuiltinCommand('claude'))
+        return [];
+    const shellEnvModels = discoverClaudeAliasModelsFromEnv(readLatestUserEnv());
+    if (shellEnvModels.length > 0)
+        return shellEnvModels;
+    return fallbackClaudeAliasModels();
+}
+async function discoverCodexModels() {
+    const spec = resolveBuiltinCommand('codex');
+    if (!spec)
+        return [];
+    const appServerModels = await discoverCodexModelsViaAppServer(spec).catch(() => []);
+    return appServerModels.length > 0 ? appServerModels : fallbackCodexModels();
+}
+async function discoverGeminiModels() {
+    if (!resolveBuiltinCommand('gemini'))
+        return [];
+    return fallbackGeminiModels();
+}
+const fallbackPiModels = [
+    { id: 'qwen3.6-plus', name: 'Qwen 3.6 Plus', provider: 'dashscope', isDefault: true },
+];
+const managerModels = [
+    { id: 'codex', name: 'Codex', provider: 'shennian', isDefault: true },
+    { id: 'claude', name: 'Claude Code', provider: 'shennian' },
+];
+async function discoverPiModels(context) {
+    if (!context.serverUrl || !context.authToken)
+        return fallbackPiModels;
+    try {
+        const response = await fetch(`${context.serverUrl.replace(/\/$/, '')}/api/models`, {
+            headers: {
+                Authorization: `Bearer ${context.authToken}`,
+            },
+        });
+        if (!response.ok)
+            return fallbackPiModels;
+        const data = (await response.json());
+        const models = (data.models ?? []).map((model) => ({
+            id: model.id,
+            name: model.name?.trim() || model.id,
+            provider: model.provider,
+            isDefault: model.id === data.default,
+        }));
+        return models.length > 0 ? models : fallbackPiModels;
+    }
+    catch {
+        return fallbackPiModels;
+    }
+}
+async function discoverBuiltinModels(type, context) {
+    switch (type) {
+        case 'claude':
+            return discoverClaudeModels();
+        case 'codex':
+            return discoverCodexModels();
+        case 'workbuddy':
+            return resolveBuiltinCommand('workbuddy') ? fallbackWorkBuddyModels() : [];
+        case 'gemini':
+            return discoverGeminiModels();
+        case 'cursor':
+            return discoverCursorModels();
+        case 'openclaw':
+            // OpenClaw support is intentionally disabled.
+            return [];
+        case 'opencode':
+            return discoverOpenCodeModels();
+        case 'pi':
+            return discoverPiModels(context);
+        case 'manager':
+            return managerModels;
+    }
+}
+export async function discoverModelsForAgent(agent, context) {
+    if (agent.type.startsWith('custom:')) {
+        return agent.models ?? [];
+    }
+    return discoverBuiltinModels(agent.type, context);
+}