tripo-cli 0.7.2 → 0.8.0

package/dist/commands/ai.js

@@ -9,10 +9,10 @@ import * as p from '@clack/prompts';
 import { resolveReference } from '../config/history.js';
 import { CliError } from '../core/errors.js';
 import { isInteractive, isYes, log, warn } from '../core/output.js';
-import { t } from '../i18n.js';
 import { EXIT } from '../knowledge/error-catalog.js';
+import { getScenario } from '../knowledge/scenarios.js';
 import { executeMake, planMake } from '../pipeline/make.js';
-import { renderPlanCard } from '../ai/plan-card.js';
+import { cardFromMakePlan, renderPlanCard } from '../ai/plan-card.js';
 import { resolveLlmConfig } from '../ai/llm.js';
 import { buildExpertPlan } from '../ai/experts.js';
 import { runWizard } from '../ai/wizard.js';
@@ -22,7 +22,7 @@ export function registerAiCommand(program) {
     const cmd = program
         .command('ai')
         .description('describe what you want in natural language; experts plan it, you confirm, it runs')
-        .argument('[request...]', 'e.g. "给我的手游做一个低模骑士,要跑步动画"')
+        .argument('[request...]', 'e.g. "a low-poly knight for my mobile game, with a run animation"')
         .option('--wizard', 'force wizard mode even when an LLM is configured');
     withTaskOptions(cmd);
     cmd.action(async (request, flags) => {
@@ -31,14 +31,15 @@ export function registerAiCommand(program) {
         let card;
         let makeOptions;
         if (llm && !flags.wizard && text) {
-            log(t({ zh: `对话模式(${llm.model})…`, en: `conversation mode (${llm.model})…` }));
+            log(`conversation mode (${llm.model})…`);
             try {
-                const plan = await buildExpertPlan(text, isInteractive() ? askUser : undefined);
+                const plan = await buildExpertPlan(text, isInteractive() ? askUser : undefined, flags.param);
                 card = plan.card;
                 makeOptions = {
                     inputs: [plan.prompt],
                     scenario: plan.scenarioId,
                     chain: plan.chain,
+                    model: plan.card.model,
                     params: plan.params,
                     name: flags.name,
                     outDir: flags.out,
@@ -47,10 +48,7 @@ export function registerAiCommand(program) {
                 };
             }
             catch (err) {
-                warn(t({
-                    zh: `LLM 编排失败(${err instanceof Error ? err.message : err}),回落到向导模式`,
-                    en: `LLM planning failed (${err instanceof Error ? err.message : err}); falling back to the wizard`,
-                }));
+                warn(`LLM planning failed (${err instanceof Error ? err.message : err}); falling back to the wizard`);
                 const wizard = await runWizard(text);
                 card = wizard.card;
                 makeOptions = wizardToOptions(wizard.options, flags);
@@ -59,24 +57,28 @@ export function registerAiCommand(program) {
         else {
             // The wizard is interactive by nature — never enter it headless.
             if (!isInteractive()) {
-                throw new CliError(t({
-                    zh: '向导模式需要交互终端;无头环境请用 tripo make --for <场景>(或配置 llm.base_url/llm.model 走对话模式)',
-                    en: 'wizard mode needs an interactive terminal; headless callers should use "tripo make --for <scenario>" (or configure llm.base_url/llm.model for conversation mode)',
-                }), EXIT.USAGE);
+                throw new CliError('wizard mode needs an interactive terminal; headless callers should use "tripo make --for <scenario>" (or configure llm.base_url/llm.model for conversation mode)', EXIT.USAGE);
             }
             const wizard = await runWizard(text || undefined);
             card = wizard.card;
             makeOptions = wizardToOptions(wizard.options, flags);
         }
+        // An explicit chain counts as a --then override in planMake, which drops the preset's dual delivery.
+        const preset = getScenario(makeOptions.scenario ?? '');
+        if (preset && JSON.stringify(makeOptions.chain) === JSON.stringify(preset.chain))
+            makeOptions.chain = undefined;
+        const client = newClient();
+        const preview = await planMake(client, { ...makeOptions, dryRun: true });
+        card = { ...card, ...cardFromMakePlan(preview, makeOptions), notes: card.notes };
+        makeOptions.model = preview.model;
         process.stderr.write(renderPlanCard(card) + '\n');
         if (!isYes()) {
-            const go = await p.confirm({ message: t({ zh: '按方案执行?', en: 'Run this plan?' }) });
+            const go = await p.confirm({ message: 'Run this plan?' });
             if (p.isCancel(go) || !go) {
-                log(t({ zh: '已取消,未消耗积分', en: 'cancelled; no credits spent' }));
+                log('cancelled; no credits spent');
                 return;
             }
         }
-        const client = newClient();
         const plan = await planMake(client, makeOptions);
         const outcome = await executeMake(client, plan, makeOptions);
         emitMakeOutcome({ results: [outcome.primary], chainResults: outcome.chainResults, stoppedEarly: outcome.stoppedEarly });

package/dist/commands/batch.js

@@ -1,6 +1,8 @@
 /**
  * `tripo batch run <manifest.yaml>` — bulk production with concurrency,
  * retries, and resumable state (skip jobs already succeeded on re-run).
+ * A job is never resubmitted once a paid task may exist for it: such jobs
+ * stop as needs_attention instead of retrying.
  *
  * Manifest:
  *   concurrency: 2
@@ -14,10 +16,10 @@
  */
 import { readFileSync, writeFileSync } from 'node:fs';
 import { resolve } from 'node:path';
+import pc from 'picocolors';
 import { parse as parseYaml } from 'yaml';
-import { UsageError } from '../core/errors.js';
-import { emitResult, errorLine, log, success } from '../core/output.js';
-import { t } from '../i18n.js';
+import { CliError, TaskFailedError, UsageError } from '../core/errors.js';
+import { emitResult, errorLine, log, success, warn } from '../core/output.js';
 import { parseThenExpression } from '../knowledge/chains.js';
 import { executeMake, planMake } from '../pipeline/make.js';
 import { newClient } from './shared.js';
@@ -27,7 +29,7 @@ export function registerBatchCommand(program) {
         .command('run <manifest>')
         .description('run all jobs (resumable: finished jobs are skipped on re-run)')
         .option('--concurrency <n>', 'parallel jobs (default from manifest or 2)', (v) => Number(v))
-        .option('--retries <n>', 'retries per failed job', (v) => Number(v), 1)
+        .option('--retries <n>', 'retries per failed job (only when no paid task was left behind)', (v) => Number(v), 1)
         .option('--fresh', 'ignore previous state and re-run everything')
         .action(async (manifestPath, opts) => {
         const absPath = resolve(manifestPath);
@@ -46,12 +48,17 @@ export function registerBatchCommand(program) {
             seen.add(key);
         }
         const concurrency = Math.max(1, opts.concurrency ?? manifest.concurrency ?? 2);
-        const queue = jobs.filter(({ key }) => state.jobs[key]?.status !== 'success');
-        const skipped = jobs.length - queue.length;
+        const queue = jobs.filter(({ key }) => state.jobs[key]?.status !== 'success' && state.jobs[key]?.status !== 'needs_attention');
+        const attention = jobs.filter(({ key }) => state.jobs[key]?.status === 'needs_attention');
+        const skipped = jobs.length - queue.length - attention.length;
         if (skipped > 0) {
-            log(t({ zh: `跳过 ${skipped} 个已完成任务(断点续跑)`, en: `skipping ${skipped} already-finished job(s) (resume)` }));
+            log(`skipping ${skipped} already-finished job(s) (resume)`);
         }
-        log(t({ zh: `批量执行 ${queue.length} 个任务,并发 ${concurrency}`, en: `running ${queue.length} job(s), concurrency ${concurrency}` }));
+        for (const { key } of attention) {
+            const ids = (state.jobs[key].tasks ?? []).map((t) => t.task_id).join(', ') || 'unknown';
+            warn(`[${key}] needs attention, not resubmitted (tasks: ${ids}); delete its entry in ${statePath} or use --fresh to run it again`);
+        }
+        log(`running ${queue.length} job(s), concurrency ${concurrency}`);
         const client = newClient();
         let cursor = 0;
         const runNext = async () => {
@@ -64,20 +71,34 @@ export function registerBatchCommand(program) {
                 const maxAttempts = 1 + opts.retries;
                 for (let attempt = jobState.attempts + 1; attempt <= maxAttempts; attempt++) {
                     jobState.attempts = attempt;
+                    const created = [];
                     try {
-                        const outcome = await runJob(client, item.key, item.spec);
+                        const outcome = await runJob(client, item.key, item.spec, (task) => {
+                            created.push(task);
+                            (jobState.tasks ??= []).push(task);
+                            saveState(statePath, state);
+                        });
                         jobState.status = 'success';
                         jobState.task_id = outcome.taskId;
                         jobState.output_dir = outcome.outputDir;
                         delete jobState.error;
+                        delete jobState.suggestion;
                         success(`[${item.key}] done${outcome.outputDir ? ` → ${outcome.outputDir}` : ''}`);
                         break;
                     }
                     catch (err) {
                         const message = err instanceof Error ? err.message : String(err);
-                        jobState.status = 'failed';
+                        const retryable = mayRetry(err, created);
+                        jobState.status = retryable ? 'failed' : 'needs_attention';
                         jobState.error = message;
-                        errorLine(`[${item.key}] attempt ${attempt}/${maxAttempts} failed: ${message}`);
+                        jobState.suggestion = retryable
+                            ? err instanceof CliError ? err.suggestion : undefined
+                            : attentionSuggestion(err, jobState.tasks ?? []);
+                        errorLine(`[${item.key}] attempt ${attempt}/${maxAttempts} failed${retryable ? '' : ' (needs attention: a paid task may exist, not retried)'}: ${message}`);
+                        if (jobState.suggestion)
+                            process.stderr.write(pc.dim(`  → ${jobState.suggestion}\n`));
+                        if (!retryable)
+                            break;
                     }
                     finally {
                         saveState(statePath, state);
@@ -90,19 +111,18 @@ export function registerBatchCommand(program) {
             total: jobs.length,
             success: Object.values(state.jobs).filter((j) => j.status === 'success').length,
             failed: Object.values(state.jobs).filter((j) => j.status === 'failed').length,
+            needs_attention: Object.values(state.jobs).filter((j) => j.status === 'needs_attention').length,
             state_file: statePath,
             jobs: state.jobs,
         };
-        const failed = summary.failed;
-        emitResult(summary, t({
-            zh: `批量完成: 成功 ${summary.success}/${summary.total}${failed ? `,失败 ${failed}(重跑同一命令续跑)` : ''}`,
-            en: `batch finished: ${summary.success}/${summary.total} succeeded${failed ? `, ${failed} failed (re-run the same command to resume)` : ''}`,
-        }));
-        if (failed > 0)
+        const { failed, needs_attention: needsAttention } = summary;
+        emitResult(summary, `batch finished: ${summary.success}/${summary.total} succeeded${failed ? `, ${failed} failed (re-run the same command to resume)` : ''}` +
+            `${needsAttention ? `, ${needsAttention} need attention (never resubmitted automatically; see "suggestion" in ${statePath})` : ''}`);
+        if (failed > 0 || needsAttention > 0)
             process.exitCode = 6;
     });
 }
-async function runJob(client, key, spec) {
+async function runJob(client, key, spec, onTaskCreated) {
     const inputs = spec.inputs ?? (spec.input !== undefined ? [spec.input] : []);
     if (inputs.length === 0)
         throw new UsageError(`job "${key}" has no input`);
@@ -115,12 +135,32 @@ async function runJob(client, key, spec) {
         params: spec.params ?? {},
         name: spec.name ?? key,
         outDir: spec.out,
+        onTaskCreated,
     };
     const plan = await planMake(client, options);
     const outcome = await executeMake(client, plan, options);
     const finalResult = outcome.chainResults[outcome.chainResults.length - 1] ?? outcome.primary;
     return { taskId: finalResult.task_id, outputDir: finalResult.output_dir ?? outcome.primary.output_dir };
 }
+/**
+ * Retrying is safe only when the failed attempt left no billed or still-running
+ * task behind: it failed before anything was submitted, or its only task failed
+ * server-side (failed/cancelled tasks are refunded).
+ */
+function mayRetry(err, created) {
+    if (created.length === 0)
+        return !(err instanceof CliError && err.submissionUncertain);
+    return (created.length === 1 &&
+        err instanceof TaskFailedError &&
+        err.taskId === created[0].task_id &&
+        (err.status === 'failed' || err.status === 'cancelled'));
+}
+function attentionSuggestion(err, tasks) {
+    if (err instanceof CliError && err.suggestion)
+        return err.suggestion;
+    const list = tasks.map((t) => `${t.task_id} (${t.type})`).join(', ');
+    return `paid tasks already exist for this job: ${list}; do not rerun the whole job, continue from the last successful one (tripo make <task_id> --then <remaining steps>)`;
+}
 function loadManifest(path) {
     let raw;
     try {

package/dist/commands/completion.js

@@ -9,7 +9,7 @@ const COMMANDS = [
 ];
 const SUBS = {
     generate: ['text-to-model', 'image-to-model', 'multiview-to-model', 'text-to-image', 'image-to-image', 'image-to-multiview', 'edit-multiview', 'image-to-splat'],
-    model: ['refine', 'texture', 'convert', 'import'],
+    model: ['texture', 'convert', 'import'],
     anim: ['check', 'rig', 'retarget'],
     mesh: ['segment', 'complete', 'decimate', 'uv', ...(isMeshEditEnabled() ? ['edit'] : []), 'smartsegment'],
     task: ['get', 'list', 'watch'],

package/dist/commands/config-cmd.js

@@ -7,7 +7,7 @@ import { coerceValue } from './shared.js';
 /** Account-bound settings — these live in the *active profile*. */
 const PROFILE_SETTABLE = new Set(['region', 'api_base_url', 'platform_base_url']);
 /** User preferences — top-level, shared by all profiles. */
-const GLOBAL_SETTABLE = new Set(['language', 'default_output_dir', 'llm.base_url', 'llm.api_key', 'llm.model']);
+const GLOBAL_SETTABLE = new Set(['default_output_dir', 'llm.base_url', 'llm.api_key', 'llm.model']);
 const SETTABLE = [...PROFILE_SETTABLE, ...GLOBAL_SETTABLE];
 export function registerConfigCommands(program) {
     const config = program.command('config').description('global config (~/.tripo) and directory context (.tripo)');

package/dist/commands/doctor.js

@@ -2,7 +2,7 @@
 import { statSync } from 'node:fs';
 import { join } from 'node:path';
 import pc from 'picocolors';
-import { configFileExists, describeKeySource, listProfiles, loadConfig, resolveApiBaseUrl, resolveApiKey, resolveRegion, tripoHome } from '../config/config.js';
+import { configFileExists, describeKeySource, listProfiles, resolveApiBaseUrl, resolveApiKey, resolveRegion, tripoHome } from '../config/config.js';
 import { TripoClient } from '../core/client.js';
 import { CliError } from '../core/errors.js';
 import { detectRegionForKey } from '../core/region.js';
@@ -93,8 +93,6 @@ export function registerDoctorCommand(program) {
             detail: `${process.stdout.isTTY ? 'interactive TTY' : 'non-TTY (headless mode)'}${terminalSupportsInlineImages() ? ' · inline images supported' : ''}`,
             critical: false,
         });
-        const language = loadConfig().language ?? 'auto';
-        checks.push({ name: 'language', ok: true, detail: language, critical: false });
         const failedCritical = checks.some((c) => c.critical && !c.ok);
         const human = checks
             .map((c) => `${c.ok ? pc.green('✓') : c.critical ? pc.red('✗') : pc.yellow('!')} ${c.name.padEnd(34)} ${c.detail}`)

package/dist/commands/generate.js

@@ -3,8 +3,9 @@ import { UsageError } from '../core/errors.js';
 import { warn } from '../core/output.js';
 import { buildEditMultiview, buildImageToImage, buildImageToModel, buildImageToMultiview, buildImageToSplat, buildMultiviewToModel, buildTextToImage, buildTextToModel, } from '../core/requests.js';
 import { resolveInputValue, runTask } from '../core/task-service.js';
-import { chooseModel } from '../knowledge/models.js';
+import { chooseModel, detectDenseGeometryIntent, detectLowPolyIntent, detectRealtimeIntent } from '../knowledge/models.js';
 import { assignViews } from '../pipeline/make.js';
+import { detectInput } from '../util/input-detect.js';
 import { newClient, printTaskResult, withTaskOptions } from './shared.js';
 export function registerGenerateCommands(program) {
     const generate = program.command('generate').description('deterministic generation endpoints (text/image/multiview → model/image/splat)');
@@ -38,29 +39,70 @@ export function registerGenerateCommands(program) {
     };
     add('text-to-model', 'text → 3D model', 'prompt', async (_c, inputs, flags) => {
         const prompt = inputs.join(' ');
-        const { model } = chooseModel({ explicit: flags.model, faceLimit: numberParam(flags, 'face_limit') });
+        const { model } = chooseModel({
+            explicit: flags.model,
+            faceLimit: numberParam(flags, 'face_limit'),
+            quad: flags.param.quad === true,
+            lowPoly: detectLowPolyIntent(prompt),
+            realtime: detectRealtimeIntent(prompt),
+            denseGeometry: detectDenseGeometryIntent(prompt),
+            params: flags.param,
+        });
         return buildTextToModel(prompt, model, flags.param);
     });
     add('image-to-model', 'single image → 3D model', 'single', async (client, inputs, flags) => {
+        const intent = flags.prompt ?? '';
+        const { model } = chooseModel({
+            explicit: flags.model,
+            faceLimit: numberParam(flags, 'face_limit'),
+            quad: flags.param.quad === true,
+            lowPoly: detectLowPolyIntent(intent),
+            realtime: detectRealtimeIntent(intent),
+            denseGeometry: detectDenseGeometryIntent(intent),
+            params: flags.param,
+        });
+        buildImageToModel(inputs[0], model, flags.param);
         const { value } = await resolveInputValue(client, inputs[0]);
-        const { model } = chooseModel({ explicit: flags.model, faceLimit: numberParam(flags, 'face_limit') });
         return buildImageToModel(value, model, flags.param);
     });
-    add('multiview-to-model', '2–4 view images → 3D model', 'multi', async (client, inputs, flags) => {
+    add('multiview-to-model', '2–4 view images, or one image-to-multiview/edit-multiview task → 3D model', 'multi', async (client, inputs, flags) => {
+        const intent = flags.prompt ?? '';
+        const { model } = chooseModel({
+            explicit: flags.model,
+            faceLimit: numberParam(flags, 'face_limit'),
+            quad: flags.param.quad === true,
+            lowPoly: detectLowPolyIntent(intent),
+            realtime: detectRealtimeIntent(intent),
+            denseGeometry: detectDenseGeometryIntent(intent),
+            params: flags.param,
+        });
+        const kind = inputs.length === 1 ? detectInput(inputs[0]).kind : undefined;
+        if (kind === 'task-id' || kind === 'history-ref') {
+            const { value, sourceTaskType } = await resolveInputValue(client, inputs[0]);
+            if (sourceTaskType && sourceTaskType !== 'generate_multiview_image' && sourceTaskType !== 'edit_multiview_image') {
+                throw new UsageError(`multiview-to-model reuses an image-to-multiview / edit-multiview task, not ${sourceTaskType}`);
+            }
+            return buildMultiviewToModel({ task_id: value }, model, flags.param);
+        }
+        const previewViews = await assignViews(client, inputs, { dryRun: true });
+        buildMultiviewToModel(previewViews, model, flags.param);
         const views = await assignViews(client, inputs);
-        const { model } = chooseModel({ explicit: flags.model, faceLimit: numberParam(flags, 'face_limit') });
         return buildMultiviewToModel(views, model, flags.param);
     });
     add('text-to-image', 'text → image (concept art / t_pose templates)', 'prompt', async (_c, inputs, flags) => buildTextToImage(inputs.join(' '), { ...(flags.model ? { model: flags.model } : {}), ...flags.param }));
-    add('image-to-image', 'image + prompt → edited image', 'single', async (client, inputs, flags) => {
-        const { value } = await resolveInputValue(client, inputs[0]);
+    add('image-to-image', 'image(s) + prompt → edited image (several images: cite them as image[1], image[2], ...)', 'multi', async (client, inputs, flags) => {
         const params = { ...(flags.model ? { model: flags.model } : {}), ...flags.param };
         if (flags.prompt)
             params.prompt = flags.prompt;
         if (!params.prompt && !params.template) {
             throw new UsageError('image-to-image needs --prompt or --param template=...');
         }
-        return buildImageToImage(value, params);
+        // Validate deterministic parameters before resolving any local uploads.
+        buildImageToImage(inputs, params);
+        const values = [];
+        for (const input of inputs)
+            values.push((await resolveInputValue(client, input)).value);
+        return buildImageToImage(values, params);
     });
     add('image-to-multiview', 'single image → 4-view sheet', 'single', async (client, inputs, flags) => {
         const { value } = await resolveInputValue(client, inputs[0]);

package/dist/commands/home.js

@@ -5,7 +5,6 @@ import { activeProfileName, listProfiles, loadConfig, resolveApiKey } from '../c
 import { readHistory } from '../config/history.js';
 import { TripoClient } from '../core/client.js';
 import { isInteractive, log } from '../core/output.js';
-import { t } from '../i18n.js';
 import { runLogin } from './login.js';
 export function registerHomeAction(program) {
     program.action(async () => {
@@ -16,30 +15,30 @@ export function registerHomeAction(program) {
         p.intro(pc.bold('tripo'));
         const key = resolveApiKey(loadConfig());
         if (!key) {
-            log(t({ zh: '还没有配置 API Key,先登录吧(新用户可领免费额度)', en: 'no API key yet — log in first (new accounts get free credits)' }));
+            log('no API key yet — log in first (new accounts get free credits)');
             await runLogin({});
             return;
         }
         let balanceLine = '';
         try {
             const balance = await new TripoClient().getBalance();
-            balanceLine = t({ zh: `余额 ${balance.balance} 积分`, en: `${balance.balance} credits` });
+            balanceLine = `${balance.balance} credits`;
         }
         catch {
-            balanceLine = t({ zh: '余额获取失败', en: 'balance unavailable' });
+            balanceLine = 'balance unavailable';
         }
         const last = readHistory().filter((e) => e.status === 'success').pop();
         const config = loadConfig();
-        const profileNote = listProfiles(config).length > 1 ? t({ zh: ` · 账号 ${activeProfileName(config)}`, en: ` · profile ${activeProfileName(config)}` }) : '';
-        log(`${balanceLine}${profileNote}${last ? t({ zh: ` · 上次任务 @${last.name}`, en: ` · last task @${last.name}` }) : ''}`);
+        const profileNote = listProfiles(config).length > 1 ? ` · profile ${activeProfileName(config)}` : '';
+        log(`${balanceLine}${profileNote}${last ? ` · last task @${last.name}` : ''}`);
         const action = await p.select({
-            message: t({ zh: '想做什么?', en: 'What do you want to do?' }),
+            message: 'What do you want to do?',
             options: [
-                { value: 'ai', label: t({ zh: '描述需求,让专家帮我定方案 (tripo ai)', en: 'describe what I want, experts plan it (tripo ai)' }) },
-                { value: 'make', label: t({ zh: '直接生成 (tripo make ...)', en: 'generate directly (tripo make ...)' }) },
-                ...(last ? [{ value: 'view', label: t({ zh: '看看上一个结果 (tripo view)', en: 'view the last result (tripo view)' }) }] : []),
-                { value: 'topup', label: t({ zh: '充值 (tripo topup)', en: 'top up credits (tripo topup)' }) },
-                { value: 'help', label: t({ zh: '看全部命令', en: 'show all commands' }) },
+                { value: 'ai', label: 'describe what I want, experts plan it (tripo ai)' },
+                { value: 'make', label: 'generate directly (tripo make ...)' },
+                ...(last ? [{ value: 'view', label: 'view the last result (tripo view)' }] : []),
+                { value: 'topup', label: 'top up credits (tripo topup)' },
+                { value: 'help', label: 'show all commands' },
             ],
         });
         if (p.isCancel(action))
@@ -50,7 +49,7 @@ export function registerHomeAction(program) {
                 break;
             case 'make': {
                 const promptText = await p.text({
-                    message: t({ zh: '输入一句描述或文件路径', en: 'enter a description or file path' }),
+                    message: 'enter a description or file path',
                 });
                 if (p.isCancel(promptText) || !promptText.trim())
                     return;