m3triq 0.2.10 → 0.2.12

package/dist/cli.js

@@ -10,6 +10,7 @@ import { registerSessionCommands } from './commands/sessions.js';
 import { registerJobCommands } from './commands/jobs.js';
 import { registerDockingCommands } from './commands/docking.js';
 import { registerPredictCommands } from './commands/predict.js';
+import { registerMsaCommands } from './commands/msa.js';
 import { registerChemblCommands } from './commands/chembl.js';
 import { registerSandboxCommands } from './commands/sandbox.js';
 import { registerDesignCommands } from './commands/design.js';
@@ -24,7 +25,7 @@ const program = new Command();
 program
     .name('m3t')
     .description('M3TRIQ — protein-ligand analysis from the terminal')
-    .version('0.2.10')
+    .version('0.2.12')
     .option('--json', 'Output as JSON (machine-readable)')
     .hook('preAction', (thisCommand) => {
     const opts = thisCommand.optsWithGlobals();
@@ -37,6 +38,7 @@ registerSessionCommands(program);
 registerJobCommands(program);
 registerDockingCommands(program);
 registerPredictCommands(program);
+registerMsaCommands(program);
 registerChemblCommands(program);
 registerSandboxCommands(program);
 registerDesignCommands(program);

package/dist/client.d.ts

@@ -81,9 +81,33 @@ export declare class M3triqClient {
     }): Promise<{
         job_id: string;
     }>;
+    createMsaJob(params: {
+        project_id: string;
+        chains: {
+            id: string;
+            sequence: string;
+        }[];
+        depth: 'fast' | 'deep' | 'exhaustive' | 'custom';
+        pair: boolean;
+        templates?: boolean;
+        custom?: {
+            databases: string[];
+            max_sequences?: number;
+            pair?: boolean;
+        };
+        title?: string;
+    }): Promise<{
+        job_id: string;
+        task_id?: string;
+        depth?: string;
+        n_chains?: number;
+    }>;
     createBoltz2Job(params: Boltz2JobParams): Promise<{
         job_id: string;
     }>;
+    createOpenfold3Job(params: Boltz2JobParams): Promise<{
+        job_id: string;
+    }>;
     createSandboxJob(params: SandboxParams): Promise<{
         job_id: string;
     }>;

package/dist/client.js

@@ -126,6 +126,30 @@ export class M3triqClient {
     async createEsmfold2BatchJob(params) {
         return this.request('POST', '/api/jobs/create_esmfold2_batch/', params);
     }
+    async createMsaJob(params) {
+        // MSA generation is an async job created via the internal prediction endpoint
+        // (same path Boltz-2 uses). The server's is_msa branch keys off job_type.
+        const url = `${this.baseUrl}/api/jobs/create_prediction_internal/`;
+        const res = await fetch(url, {
+            method: 'POST',
+            headers: { ...this.headers, 'X-Internal-Service': 'true' },
+            body: JSON.stringify({
+                project_id: params.project_id,
+                job_type: 'msa_generation',
+                title: params.title,
+                chains: params.chains,
+                depth: params.depth,
+                pair: params.pair,
+                templates: params.templates ?? false,
+                ...(params.custom ? { custom: params.custom } : {}),
+            }),
+        });
+        if (!res.ok) {
+            const text = await res.text();
+            throw new Error(`API error ${res.status}: ${text.substring(0, 200)}`);
+        }
+        return res.json();
+    }
     async createBoltz2Job(params) {
         // Boltz-2 prediction is run client-side via the agents MCP, then saved here as a completed job.
         // Mirrors the RFantibody internal flow but with status='completed' and result_data already populated.
@@ -150,6 +174,27 @@ export class M3triqClient {
         }
         return res.json();
     }
+    async createOpenfold3Job(params) {
+        // OpenFold3 prediction runs client-side via the agents MCP, then is saved here
+        // as a completed job (same internal path Boltz-2 uses; server is_openfold3 branch).
+        const url = `${this.baseUrl}/api/jobs/create_prediction_internal/`;
+        const res = await fetch(url, {
+            method: 'POST',
+            headers: { ...this.headers, 'X-Internal-Service': 'true' },
+            body: JSON.stringify({
+                project_id: params.project_id,
+                job_type: 'openfold3_prediction',
+                title: params.title,
+                description: params.description ?? '',
+                result_data: params.result_data,
+            }),
+        });
+        if (!res.ok) {
+            const text = await res.text();
+            throw new Error(`API error ${res.status}: ${text.substring(0, 200)}`);
+        }
+        return res.json();
+    }
     async createSandboxJob(params) {
         return this.request('POST', '/api/jobs/create_sandbox_job/', params);
     }

package/dist/commands/msa.d.ts

@@ -0,0 +1,2 @@
+import type { Command } from 'commander';
+export declare function registerMsaCommands(program: Command): void;

package/dist/commands/msa.js

@@ -0,0 +1,116 @@
+import fs from 'node:fs';
+import { createClient, getConsoleUrl } from '../cli.js';
+import { requireProject } from '../config.js';
+import { output } from '../output.js';
+import { jobUrl, maybeOpenBrowser } from '../url.js';
+// m3t msa — generate a multiple-sequence alignment (a3m) for one or more chains,
+// all on the self-hosted ColabFold MSA-search engine (GPU-MMseqs2):
+//   fast        = UniRef30, shallow, no pairing (quick triage)
+//   deep        = UniRef30, full depth + species pairing (complexes/hard families)
+//   exhaustive  = deep + the metagenomic envDB (remote-homology / orphan families)
+//   custom      = you pick the databases (+ max_sequences / pairing)
+// --templates also searches the PDB and saves per-chain structural templates.
+// Produces a downloadable .a3m artifact per chain (+ templates_<chain>.json).
+const MSA_DEPTHS = ['fast', 'deep', 'exhaustive', 'custom'];
+export function registerMsaCommands(program) {
+    program.command('msa')
+        .description('Generate a multiple-sequence alignment (a3m) — per-chain and (for complexes) species-paired')
+        .option('--chain <id:seq>', 'Chain as "id:sequence" or "id:@path". Repeatable for multi-chain (paired) MSAs.', collectArg, [])
+        .option('--sequence <seq>', 'Single-chain shortcut (chain id "A"). Use --chain for multi-chain.')
+        .option('--depth <tier>', 'MSA depth: fast | deep | exhaustive | custom (see `m3t msa --help`)', 'fast')
+        .option('--templates', 'Also search the PDB for structural templates; saves a templates_<chain>.json per chain.')
+        .option('--databases <csv>', 'For --depth custom: comma-separated database ids (e.g. "uniref30,envdb"). See get_msa_capabilities.')
+        .option('--max-sequences <n>', 'For --depth custom: alignment depth/breadth cap.', (v) => parseInt(v, 10))
+        .option('--pair', 'Compute species-paired MSA across chains (complexes). Default on for ≥2 distinct chains.')
+        .option('--no-pair', 'Skip paired MSA (per-chain only).')
+        .option('--name <name>', 'Custom job title')
+        .action(async (opts) => {
+        await runMsa(opts);
+    });
+}
+async function runMsa(opts) {
+    const depth = (opts.depth || 'fast').toLowerCase();
+    if (!MSA_DEPTHS.includes(depth)) {
+        process.stderr.write(`Error: --depth must be one of ${MSA_DEPTHS.join(' | ')}, got "${opts.depth}".\n`);
+        process.exit(1);
+    }
+    // Build the custom config when depth=custom.
+    let custom;
+    if (depth === 'custom') {
+        const databases = (opts.databases || '').split(',').map(s => s.trim()).filter(Boolean);
+        if (databases.length === 0) {
+            process.stderr.write('Error: --depth custom requires --databases (e.g. --databases "uniref30,envdb").\n');
+            process.exit(1);
+        }
+        custom = { databases, max_sequences: opts.maxSequences, pair: opts.pair };
+    }
+    const chains = [];
+    for (const raw of opts.chain) {
+        const colon = raw.indexOf(':');
+        if (colon <= 0) {
+            process.stderr.write(`Error: --chain must be "id:sequence" or "id:@path", got "${raw}".\n`);
+            process.exit(1);
+        }
+        const id = raw.slice(0, colon).trim();
+        const seq = resolveSequence(raw.slice(colon + 1));
+        if (!id) {
+            process.stderr.write('Error: --chain id cannot be empty.\n');
+            process.exit(1);
+        }
+        chains.push({ id, sequence: seq });
+    }
+    if (chains.length === 0 && opts.sequence) {
+        chains.push({ id: 'A', sequence: resolveSequence(opts.sequence) });
+    }
+    if (chains.length === 0) {
+        process.stderr.write('Error: provide at least one --chain "id:seq" or --sequence "<seq>".\n');
+        process.exit(1);
+    }
+    // pair only matters for ≥2 distinct chains; let the server make the final call too.
+    const distinct = new Set(chains.map(c => c.sequence));
+    const pair = opts.pair && chains.length >= 2 && distinct.size >= 2;
+    const templates = !!opts.templates;
+    const project = requireProject();
+    const client = createClient();
+    const consoleUrl = getConsoleUrl();
+    const result = await client.createMsaJob({
+        project_id: project.id,
+        chains,
+        depth: depth,
+        pair,
+        templates,
+        custom,
+        title: opts.name,
+    });
+    const url = jobUrl(consoleUrl, project.id, result.job_id);
+    maybeOpenBrowser(url);
+    const timeEst = depth === 'exhaustive'
+        ? '~4-6 min (ColabFold UniRef30 + envDB on 2 T4s; +cold start if scaled to zero)'
+        : depth === 'fast'
+            ? '~2-4 min (ColabFold UniRef30; +cold start if scaled to zero)'
+            : '~3-5 min (ColabFold UniRef30 + paired; +cold start if scaled to zero)';
+    const extras = [pair ? 'paired' : '', templates ? '+templates' : ''].filter(Boolean).join(', ');
+    const lines = [
+        `MSA job queued (${chains.length} chain${chains.length > 1 ? 's' : ''}, depth=${depth}${extras ? `, ${extras}` : ''})`,
+        `Job ID: ${result.job_id.substring(0, 8)}`,
+        `Estimated: ${timeEst}`,
+        `Output: one .a3m artifact per chain${templates ? ' (+ templates_<chain>.json)' : ''} (Files tab)`,
+        `View: ${url}`,
+    ];
+    output({ job_id: result.job_id, n_chains: chains.length, depth, pair, templates, url }, lines.join('\n'));
+}
+function collectArg(value, prev) {
+    return [...prev, value];
+}
+function resolveSequence(input) {
+    // @path → read file (FASTA-aware: strip header/whitespace)
+    if (input.startsWith('@')) {
+        const path = input.slice(1);
+        if (!fs.existsSync(path)) {
+            throw new Error(`Sequence file not found: ${path}`);
+        }
+        const raw = fs.readFileSync(path, 'utf-8');
+        return raw.split('\n').filter(line => !line.startsWith('>')).join('').replace(/\s+/g, '').toUpperCase();
+    }
+    return input.replace(/\s+/g, '').toUpperCase();
+}

package/dist/commands/predict.js

@@ -13,13 +13,19 @@ export function registerPredictCommands(program) {
         .action(async (sequence, opts) => {
         await runPredict(sequence, 'esmfold', opts.name);
     });
-    // m3t predict alphafold2
+    // m3t predict alphafold2 — RETIRED (the alphafold2-nim VM was decommissioned in
+    // favour of ESMFold2). Kept as a signpost so scripts get a clear redirect instead
+    // of a job that silently fails on the deleted backend.
     predict.command('alphafold2')
-        .argument('<sequence>', 'Amino acid sequence (single letter codes, max 2048aa)')
+        .argument('[sequence]', 'Amino acid sequence (single letter codes)')
         .option('--name <name>', 'Name for the prediction')
-        .description('High-accuracy prediction with AlphaFold2 (~15-20 min, varies with length; scale-to-zero VM)')
-        .action(async (sequence, opts) => {
-        await runPredict(sequence, 'alphafold2', opts.name);
+        .description('[RETIRED → use `predict esmfold2`] AlphaFold2 single-sequence prediction')
+        .action(async () => {
+        process.stderr.write('AlphaFold2 has been retired (the self-hosted backend was decommissioned).\n' +
+            'Use ESMFold2 instead — higher accuracy and it folds complexes too:\n' +
+            '  m3t predict esmfold2 --sequence <seq>            # monomer\n' +
+            '  m3t predict esmfold2 --chain A:<seq> --chain B:<seq>   # complex\n');
+        process.exit(2);
     });
     // m3t predict esmfold2 — monomer OR multi-chain (antibody-antigen, PPI)
     predict.command('esmfold2')
@@ -68,6 +74,20 @@ export function registerPredictCommands(program) {
         .action(async (opts) => {
         await runBoltz2(opts);
     });
+    // m3t predict openfold3
+    predict.command('openfold3')
+        .description('Predict biomolecular complex (protein + DNA/RNA + ligand) with OpenFold3 / AlphaFold3-class (NVIDIA NIM). Real MSAs + optional PDB templates.')
+        .option('--protein <seq>', 'Protein sequence (or @path to file). Repeatable for multi-chain complexes.', collectArg, [])
+        .option('--dna <seq>', 'DNA sequence (or @path to file). Repeatable.', collectArg, [])
+        .option('--rna <seq>', 'RNA sequence (or @path to file). Repeatable.', collectArg, [])
+        .option('--ligand <smiles_or_ccd>', 'Ligand as SMILES or CCD code (e.g. ATP). Repeatable.', collectArg, [])
+        .option('--depth <tier>', 'MSA depth for protein chains: fast | deep | exhaustive | none (default fast)', 'fast')
+        .option('--templates', 'Seed the fold with PDB structural templates per protein chain (OpenFold3 self-aligns).')
+        .option('--samples <n>', 'Number of diffusion samples (1-25, default: 1)', (v) => parseInt(v, 10), 1)
+        .option('--name <name>', 'Custom job title')
+        .action(async (opts) => {
+        await runOpenfold3(opts);
+    });
 }
 async function runPredict(sequence, method, name) {
     const project = requireProject();
@@ -165,6 +185,94 @@ async function runBoltz2(opts) {
         url,
     }, lines.join('\n'));
 }
+async function runOpenfold3(opts) {
+    const depth = (opts.depth || 'fast').toLowerCase();
+    const OF3_DEPTHS = ['fast', 'deep', 'exhaustive', 'custom', 'none'];
+    if (!OF3_DEPTHS.includes(depth)) {
+        process.stderr.write(`Error: --depth must be one of ${OF3_DEPTHS.join(' | ')}, got "${opts.depth}".\n`);
+        process.exit(1);
+    }
+    // Build the OpenFold3 molecules array (proteins get chain ids A, B, ...).
+    const molecules = [];
+    const chainIds = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ';
+    let ci = 0;
+    for (const seq of opts.protein)
+        molecules.push({ type: 'protein', sequence: resolveSequence(seq), id: chainIds[ci++] });
+    for (const seq of opts.dna)
+        molecules.push({ type: 'dna', sequence: resolveSequence(seq), id: chainIds[ci++] });
+    for (const seq of opts.rna)
+        molecules.push({ type: 'rna', sequence: resolveSequence(seq), id: chainIds[ci++] });
+    for (const lig of opts.ligand) {
+        const parsed = parseLigand(lig);
+        molecules.push({ type: 'ligand', id: chainIds[ci++], ...('ccd_code' in parsed ? { ccd_codes: [parsed.ccd_code] } : { smiles: parsed.smiles }) });
+    }
+    if (molecules.length === 0) {
+        process.stderr.write('Error: at least one --protein, --dna, --rna, or --ligand is required.\n');
+        process.exit(1);
+    }
+    const project = requireProject();
+    const client = createClient();
+    const agents = createAgentsClient();
+    const consoleUrl = getConsoleUrl();
+    const summary = molecules.map(m => `${m.type}(${m.id})`).join(' + ');
+    process.stderr.write(`OpenFold3: ${summary} (depth=${depth}${opts.templates ? ', +templates' : ''})\n`);
+    process.stderr.write('Running prediction (NVIDIA NIM; real MSA may cold-start the engine, up to a few min)...');
+    const startTime = Date.now();
+    const mcpData = await agents.callMcpTool('bionemo', 'predict_complex_structure_openfold3', {
+        molecules,
+        msa_depth: depth,
+        templates: !!opts.templates,
+        diffusion_samples: opts.samples,
+        output_format: 'pdb',
+    });
+    const result = mcpData;
+    if (result.error || !result.success) {
+        const msg = result.error ?? result.message ?? 'Unknown error';
+        process.stderr.write(`\nFailed: ${msg}\n`);
+        process.exit(1);
+    }
+    const elapsed = Math.round((Date.now() - startTime) / 1000);
+    process.stderr.write(` done (${elapsed}s).\n`);
+    const conf = result.confidence ?? {};
+    const title = opts.name ?? `OpenFold3: ${result.complex || summary}`;
+    const job = await client.createOpenfold3Job({
+        project_id: project.id,
+        title,
+        description: `OpenFold3 complex prediction. ${result.quality ?? ''}`.trim(),
+        result_data: {
+            complex: result.complex,
+            structure_data: result.structure_data,
+            output_format: result.output_format,
+            confidence: result.confidence,
+            quality: result.quality,
+            num_structures_returned: result.num_structures_returned,
+            diffusion_samples: result.diffusion_samples,
+            inference_time_seconds: result.inference_time_seconds,
+            msa_depth: depth,
+            templates_requested: !!opts.templates,
+            templates_applied: !!result.templates_applied,
+            model: 'openfold3',
+        },
+    });
+    const url = jobUrl(consoleUrl, project.id, job.job_id);
+    maybeOpenBrowser(url);
+    const lines = [
+        `OpenFold3 prediction complete in ${elapsed}s`,
+        `Job ID: ${job.job_id.substring(0, 8)}`,
+        `Complex: ${result.complex}`,
+        `Quality: ${result.quality ?? 'unknown'}`,
+    ];
+    if (conf.iptm !== null && conf.iptm !== undefined)
+        lines.push(`ipTM: ${conf.iptm.toFixed(3)}`);
+    if (conf.ptm !== null && conf.ptm !== undefined)
+        lines.push(`pTM: ${conf.ptm.toFixed(3)}`);
+    if (conf.plddt !== null && conf.plddt !== undefined)
+        lines.push(`pLDDT: ${conf.plddt}`);
+    if (opts.templates)
+        lines.push(`Templates: ${result.templates_applied ? 'applied' : 'requested but not applied (NIM dropped them)'}`);
+    lines.push(`View: ${url}`);
+    output({ job_id: job.job_id, elapsed_seconds: elapsed, complex: result.complex, quality: result.quality, confidence: result.confidence, msa_depth: depth, templates_requested: !!opts.templates, templates_applied: !!result.templates_applied, url }, lines.join('\n'));
+}
 function collectArg(value, prev) {
     return [...prev, value];
 }

package/dist/types.d.ts

@@ -129,6 +129,34 @@ export interface Boltz2JobParams {
     result_data: Record<string, unknown>;
     description?: string;
 }
+export interface Openfold3Molecule {
+    type: 'protein' | 'dna' | 'rna' | 'ligand';
+    sequence?: string;
+    id?: string;
+    smiles?: string;
+    ccd_codes?: string[];
+}
+export interface Openfold3McpResult {
+    success?: boolean;
+    model?: string;
+    complex?: string;
+    output_format?: string;
+    diffusion_samples?: number;
+    num_structures_returned?: number;
+    structure_data?: string;
+    confidence?: {
+        plddt?: number | null;
+        ptm?: number | null;
+        iptm?: number | null;
+        confidence_score?: number | null;
+        pde?: number | null;
+    } | null;
+    quality?: string;
+    templates_applied?: boolean;
+    inference_time_seconds?: number | null;
+    message?: string;
+    error?: string;
+}
 export interface SandboxParams {
     project_id: string;
     script: string;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "m3triq",
-  "version": "0.2.10",
+  "version": "0.2.12",
   "description": "M3TRIQ \u2014 protein-ligand analysis from the terminal",
   "type": "module",
   "bin": {