tripo-cli 0.1.0 → 0.2.1

package/dist/config/config.js

@@ -1,10 +1,25 @@
 /**
- * Global config at ~/.tripo/config.json (mode 0600 — it holds the API key).
+ * Global config at ~/.tripo/config.json (mode 0600 — it holds API keys).
+ *
+ * Multi-account model: credentials live in named *profiles* (a dict plus an
+ * `active_profile` pointer — same shape as AWS CLI profiles / kubectl
+ * contexts). Everything account-bound (key, region, URL overrides) is
+ * per-profile; user preferences (language, llm, output dir) stay top-level.
+ *
+ * v0.1.0 stored a single key at the top level. That format is normalized
+ * into `profiles.default` on *every* load, so old files keep working
+ * untouched and the rest of the codebase only ever sees one shape. Writes
+ * always persist the normalized form, so any write migrates the file.
+ *
  * Precedence for every setting: env var > directory context > global config.
+ * Profile selection: TRIPO_PROFILE env (set by the global --profile flag
+ * too) > active_profile > "default". TRIPO_API_KEY bypasses profiles
+ * entirely — agent/CI setups never touch the profile machinery.
  */
 import { chmodSync, existsSync, mkdirSync, readFileSync, unlinkSync, writeFileSync } from 'node:fs';
 import { homedir } from 'node:os';
 import { join } from 'node:path';
+export const DEFAULT_PROFILE = 'default';
 /**
  * Everything region-specific reduces to these three URLs: the generation API
  * (`api`), the console website (`platform`), and the console's own backend
@@ -35,9 +50,33 @@ export function tripoHome() {
 function configPath() {
     return join(tripoHome(), 'config.json');
 }
+/**
+ * Fold v0.1.0 top-level credential fields into `profiles.default`, so no
+ * other code ever branches on "old format vs new format". If a default
+ * profile already exists its fields win (the file was already migrated;
+ * stray top-level leftovers must not resurrect a replaced key).
+ */
+export function normalizeConfig(raw) {
+    const { api_key, region, api_base_url, platform_base_url, ...rest } = raw;
+    const legacy = {};
+    if (api_key)
+        legacy.api_key = api_key;
+    if (region)
+        legacy.region = region;
+    if (api_base_url)
+        legacy.api_base_url = api_base_url;
+    if (platform_base_url)
+        legacy.platform_base_url = platform_base_url;
+    if (Object.keys(legacy).length === 0)
+        return rest;
+    return {
+        ...rest,
+        profiles: { ...rest.profiles, [DEFAULT_PROFILE]: { ...legacy, ...rest.profiles?.[DEFAULT_PROFILE] } },
+    };
+}
 export function loadConfig() {
     try {
-        return JSON.parse(readFileSync(configPath(), 'utf8'));
+        return normalizeConfig(JSON.parse(readFileSync(configPath(), 'utf8')));
     }
     catch {
         return {};
@@ -47,7 +86,9 @@ export function saveConfig(config) {
     const dir = tripoHome();
     mkdirSync(dir, { recursive: true, mode: 0o700 });
     const file = configPath();
-    writeFileSync(file, JSON.stringify(config, null, 2) + '\n', { mode: 0o600 });
+    // Writes always persist the normalized shape — this is what migrates
+    // legacy files, and it keeps a single on-disk format going forward.
+    writeFileSync(file, JSON.stringify(normalizeConfig(config), null, 2) + '\n', { mode: 0o600 });
     // writeFileSync mode only applies on creation; enforce on every save.
     chmodSync(file, 0o600);
 }
@@ -56,37 +97,85 @@ export function updateConfig(patch) {
     saveConfig(next);
     return next;
 }
-export function deleteApiKey() {
+/** Names are shell-friendly and short — they appear in key names and flags. */
+export function isValidProfileName(name) {
+    return /^[a-z0-9][a-z0-9_-]{0,31}$/.test(name);
+}
+/** Selected profile name: TRIPO_PROFILE (or --profile) > config > default. */
+export function activeProfileName(config = loadConfig()) {
+    return process.env.TRIPO_PROFILE || config.active_profile || DEFAULT_PROFILE;
+}
+/** The selected profile's data; {} when it does not exist (yet). */
+export function activeProfile(config = loadConfig()) {
+    return config.profiles?.[activeProfileName(config)] ?? {};
+}
+export function listProfiles(config = loadConfig()) {
+    const active = activeProfileName(config);
+    return Object.entries(config.profiles ?? {}).map(([name, profile]) => ({
+        name,
+        profile,
+        active: name === active,
+    }));
+}
+/** Create/update one profile and (by default) make it the active one. */
+export function updateProfile(name, patch, opts = {}) {
     const config = loadConfig();
-    delete config.api_key;
-    if (Object.keys(config).length === 0) {
+    const profiles = { ...config.profiles, [name]: { ...config.profiles?.[name], ...patch } };
+    saveConfig({ ...config, profiles, ...(opts.activate !== false ? { active_profile: name } : {}) });
+}
+export function setActiveProfile(name) {
+    updateConfig({ active_profile: name });
+}
+/** Remove a profile (logout). Active pointer falls back to default. */
+export function deleteProfile(name) {
+    const config = loadConfig();
+    if (!config.profiles?.[name])
+        return false;
+    const profiles = { ...config.profiles };
+    delete profiles[name];
+    const next = { ...config, profiles };
+    if (Object.keys(profiles).length === 0)
+        delete next.profiles;
+    if (next.active_profile === name)
+        delete next.active_profile;
+    if (Object.keys(next).length === 0) {
         try {
             unlinkSync(configPath());
         }
         catch { }
+        return true;
     }
-    else {
-        saveConfig(config);
-    }
+    saveConfig(next);
+    return true;
 }
-/** Resolve the API key: env wins, then global config. */
+/** Resolve the API key: env wins, then the active profile. */
 export function resolveApiKey(config = loadConfig()) {
-    return process.env.TRIPO_API_KEY || config.api_key;
+    return process.env.TRIPO_API_KEY || activeProfile(config).api_key;
+}
+/**
+ * Where the effective key comes from, for whoami/doctor and for the
+ * "no key" error message — so a mistyped --profile says "profile not
+ * found", never a misleading "you are not logged in".
+ */
+export function describeKeySource(config = loadConfig()) {
+    if (process.env.TRIPO_API_KEY)
+        return 'env:TRIPO_API_KEY';
+    return `profile:${activeProfileName(config)}`;
 }
 export function resolveRegion(config = loadConfig()) {
     const env = process.env.TRIPO_REGION;
     if (env === 'cn' || env === 'ov')
         return env;
-    return config.region ?? 'ov';
+    return activeProfile(config).region ?? 'ov';
 }
 export function resolveApiBaseUrl(config = loadConfig()) {
     return (process.env.TRIPO_API_BASE_URL ||
-        config.api_base_url ||
+        activeProfile(config).api_base_url ||
         REGION_DEFAULTS[resolveRegion(config)].api);
 }
 export function resolvePlatformBaseUrl(config = loadConfig()) {
     return (process.env.TRIPO_PLATFORM_BASE_URL ||
-        config.platform_base_url ||
+        activeProfile(config).platform_base_url ||
         REGION_DEFAULTS[resolveRegion(config)].platform);
 }
 export function configFileExists() {

package/dist/core/client.js

@@ -3,7 +3,8 @@
  * Handles the response envelope, error translation, timeouts, and
  * exponential-backoff retries for transient failures (429/5xx/network).
  */
-import { loadConfig, resolveApiBaseUrl, resolveApiKey } from '../config/config.js';
+import { activeProfileName, DEFAULT_PROFILE, listProfiles, loadConfig, resolveApiBaseUrl, resolveApiKey } from '../config/config.js';
+import { t } from '../i18n.js';
 import { ApiError, AuthError, NetworkError } from './errors.js';
 export class TripoClient {
     baseUrl;
@@ -16,7 +17,20 @@ export class TripoClient {
         this.baseUrl = (options.baseUrl ?? resolveApiBaseUrl(config)).replace(/\/$/, '');
         const key = options.apiKey ?? resolveApiKey(config);
         if (!key) {
-            throw new AuthError('no API key configured');
+            // A mistyped --profile must say so — "not logged in" would send the
+            // user to re-login while their key sits in another profile.
+            const wanted = activeProfileName(config);
+            const known = listProfiles(config).map((p) => p.name);
+            if (wanted !== DEFAULT_PROFILE && !known.includes(wanted)) {
+                throw new AuthError(t({
+                    zh: `没有叫「${wanted}」的 profile${known.length ? `(现有: ${known.join(', ')})` : ''}`,
+                    en: `profile "${wanted}" not found${known.length ? ` (have: ${known.join(', ')})` : ''}`,
+                }), t({
+                    zh: `用 tripo login --profile ${wanted} 登录,或 tripo use 切换`,
+                    en: `run "tripo login --profile ${wanted}" to create it, or "tripo use" to switch`,
+                }));
+            }
+            throw new AuthError(t({ zh: '未配置 API Key', en: 'no API key configured' }));
         }
         this.apiKey = key;
         this.timeoutMs = options.timeoutMs ?? 60_000;

package/dist/core/device-auth.js

@@ -7,8 +7,11 @@
  * The flow is optional by design — when the backend feature flag is off the
  * /cli/device endpoints 404 and the caller falls back to paste login.
  */
+import { randomBytes } from 'node:crypto';
+import { mkdirSync, readFileSync, writeFileSync } from 'node:fs';
 import { hostname } from 'node:os';
-import { REGION_DEFAULTS } from '../config/config.js';
+import { join } from 'node:path';
+import { REGION_DEFAULTS, tripoHome } from '../config/config.js';
 import { sleep } from './client.js';
 export const DEVICE_CODE_EXPIRED = 4290;
 export const DEVICE_CODE_SLOW_DOWN = 4291;
@@ -32,19 +35,48 @@ export class DeviceAuthUnavailableError extends Error {
 export function consoleApiBaseUrl(region) {
     return process.env.TRIPO_CONSOLE_API_BASE_URL || REGION_DEFAULTS[region].consoleApi;
 }
+/**
+ * A persistent per-machine fingerprint (4 hex chars in ~/.tripo/device-id).
+ * The backend rotates keys *by name*, and the name used to be derived from
+ * the hostname alone — but default hostnames collide constantly (every
+ * other Mac is "MacBook-Pro.local"), and a collision means machine B's
+ * login silently revokes machine A's key. The fingerprint makes "same
+ * machine" mean "same fingerprint", not "same hostname by luck".
+ */
+export function deviceId() {
+    const file = join(tripoHome(), 'device-id');
+    try {
+        const existing = readFileSync(file, 'utf8').trim();
+        if (/^[0-9a-f]{4}$/.test(existing))
+            return existing;
+    }
+    catch { }
+    const fresh = randomBytes(2).toString('hex');
+    try {
+        mkdirSync(tripoHome(), { recursive: true, mode: 0o700 });
+        writeFileSync(file, fresh + '\n');
+    }
+    catch { } // unwritable home: fall back to a per-login id — worst case is key buildup, never cross-machine revocation
+    return fresh;
+}
 /**
  * The backend whitelists key names to [a-zA-Z0-9 _.-]{1,32} — hostnames with
  * anything else (e.g. non-ASCII machine names) would get a hard 400, so strip
- * offending characters up front and fall back to a constant when nothing
- * survives.
+ * offending characters up front. The backend also *rotates* keys by name
+ * (same name → old key revoked), so the name must be unique per (machine,
+ * profile): the device fingerprint separates same-named machines, the
+ * profile separates accounts on one machine. The hostname is only there for
+ * humans reading the /keys page; it is the part that gets truncated first.
  */
-export function deviceKeyName(host = hostname()) {
-    const cleaned = `CLI - ${host}`.replace(/[^a-zA-Z0-9 _.-]/g, '').replace(/\s+/g, ' ').trim();
-    const capped = cleaned.slice(0, 32).trim();
-    return capped.length >= 7 ? capped : 'Tripo CLI';
+export function deviceKeyName(profile, host = hostname(), id = deviceId()) {
+    const prefix = profile ? `CLI ${profile}` : 'CLI';
+    const cleanedHost = host.replace(/[^a-zA-Z0-9 _.-]/g, '').replace(/\s+/g, ' ').trim();
+    const budget = 32 - `${prefix} -  ${id}`.length;
+    const shownHost = cleanedHost.slice(0, Math.max(budget, 0)).trim();
+    return `${prefix} - ${shownHost} ${id}`.replace(/\s+/g, ' ').slice(0, 32).trim();
 }
-export async function requestDeviceCode(region) {
-    const body = await post(`${consoleApiBaseUrl(region)}/cli/device/code`, { name: deviceKeyName() });
+export async function requestDeviceCode(region, profile) {
+    const body = await post(`${consoleApiBaseUrl(region)}/cli/device/code`, { name: deviceKeyName(profile) });
     const grant = body.data;
     if (!grant ||
         typeof grant.device_code !== 'string' ||

package/dist/program.js

@@ -37,6 +37,7 @@ export function buildProgram() {
         .option('--yes', 'skip confirmations (auto-enabled when headless)')
         .option('--quiet', 'suppress progress logs on stderr')
         .option('--no-open', 'never auto-open the browser/viewer')
+        .option('--profile <name>', 'use a named account profile for this command (like TRIPO_PROFILE)')
         .enablePositionalOptions()
         .showSuggestionAfterError(true);
     program.hook('preAction', (_thisCommand, actionCommand) => {
@@ -46,6 +47,11 @@ export function buildProgram() {
             quiet: resolveGlobalFlag(actionCommand, 'quiet', false),
             noOpen: !resolveGlobalFlag(actionCommand, 'open', true),
         });
+        // --profile rides the TRIPO_PROFILE env var: config resolution already
+        // reads it, so one assignment covers every code path.
+        const profile = resolveGlobalString(actionCommand, 'profile');
+        if (profile)
+            process.env.TRIPO_PROFILE = profile;
         const lang = loadConfig().language;
         if (lang)
             setLocale(lang);
@@ -70,7 +76,7 @@ export function buildProgram() {
     return program;
 }
 /**
- * The 4 global flags live on every leaf command so `tripo balance --json`
+ * The global flags live on every leaf command so `tripo balance --json`
  * works the way people type it (prefix `tripo --json balance` works too).
  */
 function attachGlobalFlags(cmd) {
@@ -87,6 +93,9 @@ function attachGlobalFlags(cmd) {
         cmd.option('--quiet', 'suppress progress logs on stderr');
     if (!has('--no-open'))
         cmd.option('--no-open', 'never auto-open the browser/viewer');
+    // login/logout keep their own --profile (same semantics, different help text).
+    if (!has('--profile'))
+        cmd.option('--profile <name>', 'use a named account profile');
 }
 /**
  * Resolve a flag along the command chain, innermost explicit value first.
@@ -101,6 +110,17 @@ function resolveGlobalFlag(cmd, key, def) {
     }
     return def;
 }
+/** Same walk for string-valued global options (--profile). */
+function resolveGlobalString(cmd, key) {
+    for (let c = cmd; c; c = c.parent) {
+        const source = c.getOptionValueSource(key);
+        if (source !== undefined && source !== 'default') {
+            const value = c.getOptionValue(key);
+            return typeof value === 'string' ? value : undefined;
+        }
+    }
+    return undefined;
+}
 /** Run the CLI; converts errors into the stable exit-code contract. */
 export async function runCli(argv) {
     const program = buildProgram();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tripo-cli",
-  "version": "0.1.0",
+  "version": "0.2.1",
   "description": "Tripo 3D intelligent CLI — turn a prompt or an image into engine-ready 3D assets from your terminal (Tripo V3 API)",
   "keywords": [
     "tripo",
@@ -34,7 +34,7 @@
     "url": "https://github.com/vast-enterprise/Tripo-API-CLI/issues"
   },
   "scripts": {
-    "build": "tsc -p tsconfig.build.json && node scripts/postbuild.mjs",
+    "build": "node -e \"fs.rmSync('dist',{recursive:true,force:true})\" && tsc -p tsconfig.build.json && node scripts/postbuild.mjs",
     "dev": "tsx src/cli.ts",
     "typecheck": "tsc --noEmit",
     "lint": "eslint src tests",

package/skill/SKILL.md

@@ -11,7 +11,19 @@ export TRIPO_API_KEY=tsk_...    # highest-priority auth; no interaction needed
 tripo doctor                    # verify key, network, balance
 ```
 
-If there is no key, ask the human to run `tripo login` or to provide `TRIPO_API_KEY`.
+If there is no key, run the device login **yourself** — it works without a TTY:
+
+```bash
+tripo login --region ov      # ov = international, cn = China mainland
+```
+
+It prints a verification URL and a one-time code, then blocks until the human
+approves in a browser (up to ~15 minutes — do not kill it early). Relay the URL
+and code to the human and tell them: sign in on that page first if it asks
+(sign-up gives free credits), enter the code, pick an API key if the account has
+several (one is created automatically if there are none), click Authorize. The
+key is then saved locally; never ask the human to paste a key into the chat. If
+the code expires (exit 3), just run the same command again.
 
 Regions (ov = international, cn = China mainland) share one CLI: `tripo login --key tsk_...` auto-detects which region the key belongs to. On exit code 3 (auth), run `tripo doctor` — it diagnoses key-vs-region mismatches and prints the exact fix (`tripo config set region cn|ov`).
 

package/skill/commands/account.md

@@ -3,15 +3,28 @@
 ## Auth
 
 ```bash
-export TRIPO_API_KEY=tsk_...     # best for agents/CI — zero interaction
-tripo login                      # humans: browser flow (or --paste / --key tsk_...)
+export TRIPO_API_KEY=tsk_...     # zero interaction when a key is already provisioned
+tripo login                      # humans in a terminal: interactive browser flow
+tripo login --region ov|cn       # agents/CI without a key: headless device flow — prints a
+                                 # verification URL + one-time code on stderr, waits for the
+                                 # human to authorize in a browser (≤15 min), saves the key
 tripo login --key tsk_... --region ov|cn
-tripo whoami                     # masked key + region + balance
-tripo logout                     # removes the local key only
+tripo whoami                     # masked key + active profile + region + balance
+tripo logout                     # removes the local key of the active profile only
 ```
 
 Region decides the API host: ov → `openapi.tripo3d.ai`, cn → `openapi.tripo3d.com`.
 
+## Multiple accounts (profiles)
+
+```bash
+tripo login --profile work-cn    # log a second account into its own profile (becomes active)
+tripo use work-cn                # switch the active profile (no arg = interactive picker)
+tripo balance --profile work-cn  # one-shot override on any command; TRIPO_PROFILE env works too
+```
+
+One profile = one account (key + region). Unknown `--profile` fails with exit 3 and the fix in the message — do not retry blindly.
+
 ## Credits
 
 ```bash
@@ -34,7 +47,8 @@ tripo config set llm.model gpt-4o-mini
 tripo config context default_scenario=game-mobile output_dir=./assets   # per-directory .tripo/context.json
 ```
 
-Env overrides: `TRIPO_API_KEY` `TRIPO_REGION` `TRIPO_API_BASE_URL` `TRIPO_LLM_BASE_URL` `TRIPO_LLM_API_KEY` `TRIPO_LLM_MODEL`.
+Env overrides: `TRIPO_API_KEY` `TRIPO_PROFILE` `TRIPO_REGION` `TRIPO_API_BASE_URL` `TRIPO_LLM_BASE_URL` `TRIPO_LLM_API_KEY` `TRIPO_LLM_MODEL`.
+`region`/`api_base_url`/`platform_base_url` are stored per profile; `language`/`llm.*`/`default_output_dir` are shared.
 
 ## tripo doctor
 

package/dist/src/ai/experts.js

@@ -1,115 +0,0 @@
-/**
- * Multi-expert agent orchestration (conversation mode).
- *
- * Producer (router) → domain specialist(s) → plan card. The LLM only parses
- * intent and phrases advice; every decision it may make is constrained to the
- * knowledge base (scenario ids, step names, parameter windows), and the
- * result is re-validated locally before anything is spent.
- */
-import { getLocale, t, tList } from '../i18n.js';
-import { parseThenExpression, validateChain, STEPS } from '../knowledge/chains.js';
-import { chooseModel, detectLowPolyIntent } from '../knowledge/models.js';
-import { getScenario, SCENARIOS } from '../knowledge/scenarios.js';
-import { chatJson } from './llm.js';
-const SCENARIO_TABLE = SCENARIOS.map((s) => `- ${s.id}: ${s.description.en} | model=${s.model} | chain=${s.chain.map((c) => c.step).join('→') || 'none'} | deliver=${s.deliverables.join('/')}`).join('\n');
-const STEP_TABLE = STEPS.map((s) => s.name).join(', ');
-const PRODUCER_SYSTEM = `You are the producer/router of the Tripo 3D generation CLI.
-Classify the user's request into exactly one scenario and extract a clean English 3D generation prompt.
-
-Scenarios:
-${SCENARIO_TABLE}
-
-Rules:
-- "prompt" must describe the object to generate (translate to English, keep it concrete, <= 200 chars).
-- Set "face_limit" only when the user states a face/polygon budget.
-- Set "needs_animation" true only when the user wants skeleton/animations.
-- If one critical piece of information is missing and materially changes the plan, set "question" (one short question in the user's language). Otherwise omit it.
-Respond with JSON only: {"scenario","prompt","face_limit","needs_animation","question","notes"}`;
-const SPECIALIST_PROMPTS = {
-    'game-mobile': `You are a senior game technical artist (mobile). Budgets: 500–20000 faces, 1–2K textures, clean topology, FBX/GLB delivery. P1 model is used (no quad/parts/geometry_quality).`,
-    'game-pc': `You are a senior game technical artist (PC/console). PBR detailed textures, optional decimate for LODs (bake=true), FBX delivery with engine presets.`,
-    film: `You are a film/offline-rendering artist. quad=true subdivision-friendly topology (FBX output), geometry_quality=detailed, texture_quality=detailed, 4K textures, USD/OBJ handoff via convert.`,
-    print: `You are a 3D-printing engineer. Geometry only (texture=false,pbr=false), watertight meshes, flatten_bottom for FDM, STL or colored 3MF via convert, real-world sizing via scale_factor/auto_size.`,
-    'ar-web': `You are a realtime AR/Web 3D engineer. Keep faces <= 20000 via decimate, 2K textures, deliver GLB + USDZ (iOS QuickLook).`,
-    anim: `You are a character animation TD. Chain: rig-check → rig (rig-v2.0, spec tripo|mixamo) → retarget (<=5 preset animations, billed per animation). Mixamo/Unity Humanoid → spec=mixamo.`,
-    toy: `You are a stylized collectible designer. P1 low-poly or stylize steps (lego/voxel/voronoi/minecraft). STL via convert for physical prints.`,
-};
-function specialistSystem(scenarioId) {
-    const persona = SPECIALIST_PROMPTS[scenarioId] ?? SPECIALIST_PROMPTS['game-mobile'];
-    return `${persona}
-You fine-tune a Tripo generation plan. You may adjust generation params and the processing chain.
-Valid chain steps: ${STEP_TABLE}. Chain syntax: "step:key=value,step2" (e.g. "texture,rig,convert:format=FBX").
-Constraints: pbr=>texture; generate_parts excludes texture/pbr/quad; P1 face_limit 48-20000 and forbids quad/smart_low_poly/generate_parts/geometry_quality; retarget <= 5 animations.
-Respond with JSON only: {"params":{...},"chain":"...","notes":["short practical notes in ${getLocale() === 'zh' ? 'Chinese' : 'English'}"]}. Omit fields you don't want to change.`;
-}
-/**
- * Run the expert pipeline. `askUser` is called when the producer needs one
- * clarification (interactive mode only); return undefined to skip.
- */
-export async function buildExpertPlan(request, askUser) {
-    const messages = [
-        { role: 'system', content: PRODUCER_SYSTEM },
-        { role: 'user', content: request },
-    ];
-    let producer = await chatJson(messages);
-    if (producer.question && askUser) {
-        const answer = await askUser(producer.question);
-        if (answer) {
-            messages.push({ role: 'assistant', content: JSON.stringify(producer) });
-            messages.push({ role: 'user', content: `Additional info: ${answer}. Re-classify with the complete picture; do not ask again.` });
-            producer = await chatJson(messages);
-        }
-    }
-    const scenario = getScenario(producer.scenario) ?? getScenario('game-mobile');
-    const specialist = await chatJson([
-        { role: 'system', content: specialistSystem(scenario.id) },
-        {
-            role: 'user',
-            content: `User request: ${request}\nPrompt: ${producer.prompt}\nBase plan: model=${scenario.model} params=${JSON.stringify(scenario.genParams)} chain=${scenario.chain.map((c) => c.step).join('→') || 'none'}\nneeds_animation=${producer.needs_animation ?? false} face_limit=${producer.face_limit ?? 'default'}`,
-        },
-    ]).catch(() => ({}));
-    // Merge + re-validate everything the LLM produced.
-    const params = { ...scenario.genParams, ...(specialist.params ?? {}) };
-    if (producer.face_limit)
-        params.face_limit = producer.face_limit;
-    let chain = scenario.chain;
-    if (specialist.chain) {
-        try {
-            chain = parseThenExpression(specialist.chain);
-        }
-        catch {
-            chain = scenario.chain; // discard invalid expert chain, keep the preset
-        }
-    }
-    if (producer.needs_animation && !chain.some((s) => s.step === 'rig')) {
-        chain = [
-            ...chain.filter((s) => s.step !== 'convert'),
-            { step: 'rig-check', args: {} },
-            { step: 'rig', args: { model: 'rig-v2.0' } },
-            { step: 'retarget', args: { animations: ['preset:idle', 'preset:walk'] } },
-        ];
-    }
-    const choice = chooseModel({
-        explicit: scenario.model,
-        faceLimit: typeof params.face_limit === 'number' ? params.face_limit : undefined,
-        lowPoly: detectLowPolyIntent(request),
-    });
-    try {
-        validateChain(chain, 'text_to_model');
-    }
-    catch {
-        chain = scenario.chain;
-    }
-    const card = {
-        inputSummary: producer.prompt,
-        scenario: scenario.id,
-        model: choice.model,
-        modelReason: t({ zh: '制片人路由 + 场景预设', en: 'producer routing + scenario preset' }),
-        genParams: params,
-        chain,
-        deliverables: scenario.deliverables,
-        notes: tList(scenario.notes),
-        expertNotes: [...(producer.notes ?? []), ...(specialist.notes ?? [])],
-    };
-    return { card, scenarioId: scenario.id, prompt: producer.prompt, chain, params };
-}

package/dist/src/ai/llm.js

@@ -1,88 +0,0 @@
-/**
- * BYO-LLM client: any OpenAI-compatible /chat/completions endpoint.
- * Configure via `tripo config set llm.base_url/llm.api_key/llm.model`
- * or env TRIPO_LLM_BASE_URL / TRIPO_LLM_API_KEY / TRIPO_LLM_MODEL.
- */
-import { loadConfig } from '../config/config.js';
-import { CliError } from '../core/errors.js';
-import { EXIT } from '../knowledge/error-catalog.js';
-export function resolveLlmConfig() {
-    const env = {
-        base_url: process.env.TRIPO_LLM_BASE_URL,
-        api_key: process.env.TRIPO_LLM_API_KEY,
-        model: process.env.TRIPO_LLM_MODEL,
-    };
-    if (env.base_url && env.model)
-        return { base_url: env.base_url, api_key: env.api_key, model: env.model };
-    const config = loadConfig().llm;
-    if (config?.base_url && config.model)
-        return config;
-    return undefined;
-}
-export async function chatCompletion(messages, options = {}) {
-    const config = resolveLlmConfig();
-    if (!config)
-        throw new CliError('no LLM configured', EXIT.USAGE);
-    const url = `${config.base_url.replace(/\/$/, '')}/chat/completions`;
-    const controller = new AbortController();
-    const timer = setTimeout(() => controller.abort(), 60_000);
-    let response;
-    try {
-        response = await fetch(url, {
-            method: 'POST',
-            headers: {
-                'Content-Type': 'application/json',
-                ...(config.api_key ? { Authorization: `Bearer ${config.api_key}` } : {}),
-            },
-            body: JSON.stringify({
-                model: config.model,
-                messages,
-                temperature: 0.2,
-                ...(options.json ? { response_format: { type: 'json_object' } } : {}),
-            }),
-            signal: controller.signal,
-        });
-    }
-    catch (err) {
-        throw new CliError(`LLM request failed: ${err instanceof Error ? err.message : String(err)}`, EXIT.NETWORK);
-    }
-    finally {
-        clearTimeout(timer);
-    }
-    if (!response.ok) {
-        const body = await response.text().catch(() => '');
-        throw new CliError(`LLM endpoint returned HTTP ${response.status}: ${body.slice(0, 300)}`, EXIT.NETWORK);
-    }
-    const data = (await response.json());
-    const content = data.choices?.[0]?.message?.content;
-    if (!content)
-        throw new CliError('LLM returned an empty response', EXIT.NETWORK);
-    return content;
-}
-/** Chat expecting a JSON object back; tolerates markdown fences. */
-export async function chatJson(messages) {
-    const raw = await chatCompletion(messages, { json: true }).catch(async (err) => {
-        // Some endpoints reject response_format; retry without it.
-        if (err instanceof CliError && err.exitCode === EXIT.NETWORK) {
-            return chatCompletion(messages, { json: false });
-        }
-        throw err;
-    });
-    return extractJson(raw);
-}
-export function extractJson(raw) {
-    const trimmed = raw.trim();
-    const fenced = /```(?:json)?\s*([\s\S]*?)```/.exec(trimmed);
-    const candidate = fenced ? fenced[1] : trimmed;
-    const start = candidate.indexOf('{');
-    const end = candidate.lastIndexOf('}');
-    if (start === -1 || end === -1 || end < start) {
-        throw new CliError(`LLM did not return JSON: ${raw.slice(0, 200)}`, EXIT.NETWORK);
-    }
-    try {
-        return JSON.parse(candidate.slice(start, end + 1));
-    }
-    catch {
-        throw new CliError(`LLM returned invalid JSON: ${candidate.slice(0, 200)}`, EXIT.NETWORK);
-    }
-}