@melaya/runner 1.0.29 → 1.0.31

package/dist/connection.js

@@ -117,38 +117,35 @@ export async function connect(opts) {
                 // Surface bootstrap progress to the FE so the launching
                 // animation reflects the real state instead of staying on a
                 // generic spinner during the 1-2 min first-time install.
+                // FLAT shape — server reads payload.run_id at top level
+                // (runnerNamespace.ts:202). My earlier nested {runId, payload:{}}
+                // shape was silently dropped by `if (!runId) return`.
                 socket.emit("runner:event", {
-                    runId: payload.runId,
-                    payload: {
-                        event_type: "pipeline_phase",
-                        run_id: payload.runId,
-                        project: payload.project,
-                        step: 1,
-                        total: 5,
-                        label: `venv: ${msg}`,
-                        status: "started",
-                    },
+                    run_id: payload.runId,
+                    event_type: "pipeline_phase",
+                    project: payload.project,
+                    step: 1,
+                    total: 5,
+                    label: `venv: ${msg}`,
+                    status: "started",
                 });
             });
             if (!envResult.ok) {
                 console.log(chalk.red(`  ✗ python venv bootstrap failed: ${envResult.reason}`));
                 socket.emit("runner:event", {
-                    runId: payload.runId,
-                    payload: {
-                        event_type: "agent_message",
-                        run_id: payload.runId,
-                        project: payload.project,
-                        replyId: `venv-${payload.runId}`,
-                        replyName: "Runner",
-                        replyRole: "system",
-                        msg: {
-                            id: `venv-${payload.runId}`,
-                            name: "Runner",
-                            role: "system",
-                            content: [{ type: "text", text: `Python env bootstrap failed: ${envResult.reason}` }],
-                            metadata: {},
-                            timestamp: new Date().toISOString(),
-                        },
+                    run_id: payload.runId,
+                    event_type: "agent_message",
+                    project: payload.project,
+                    replyId: `venv-${payload.runId}`,
+                    replyName: "Runner",
+                    replyRole: "system",
+                    msg: {
+                        id: `venv-${payload.runId}`,
+                        name: "Runner",
+                        role: "system",
+                        content: [{ type: "text", text: `Python env bootstrap failed: ${envResult.reason}` }],
+                        metadata: {},
+                        timestamp: new Date().toISOString(),
                     },
                 });
                 socket.emit("runner:runComplete", { runId: payload.runId, status: "failed" });
@@ -178,20 +175,17 @@ export async function connect(opts) {
             const { preflightModel } = await import("./modelLoader.js");
             const onPreflightProgress = (msg) => {
                 console.log(chalk.gray(`  [model] ${msg}`));
-                // Surface to the FE via a pipeline_phase event so the launching
-                // animation reflects "Loading qwen3-vl-8b…" instead of staying
-                // on a generic spinner.
+                // Flat shape — server reads payload.run_id at top level
+                // (runnerNamespace.ts:202). Earlier nested {runId, payload:{}}
+                // was silently dropped by `if (!runId) return`.
                 socket.emit("runner:event", {
-                    runId: payload.runId,
-                    payload: {
-                        event_type: "pipeline_phase",
-                        run_id: payload.runId,
-                        project: payload.project,
-                        step: 1,
-                        total: 5,
-                        label: msg,
-                        status: "started",
-                    },
+                    run_id: payload.runId,
+                    event_type: "pipeline_phase",
+                    project: payload.project,
+                    step: 1,
+                    total: 5,
+                    label: msg,
+                    status: "started",
                 });
             };
             const preflight = await preflightModel(payload.configJson, onPreflightProgress);
@@ -199,22 +193,19 @@ export async function connect(opts) {
                 const detail = `${preflight.reason ?? "unknown"}${preflight.hint ? ` — ${preflight.hint}` : ""}`;
                 console.log(chalk.red(`  ✗ model preflight failed: ${detail}`));
                 socket.emit("runner:event", {
-                    runId: payload.runId,
-                    payload: {
-                        event_type: "agent_message",
-                        run_id: payload.runId,
-                        project: payload.project,
-                        replyId: `preflight-${payload.runId}`,
-                        replyName: "Runner",
-                        replyRole: "system",
-                        msg: {
-                            id: `preflight-${payload.runId}`,
-                            name: "Runner",
-                            role: "system",
-                            content: [{ type: "text", text: `Model preflight failed: ${detail}` }],
-                            metadata: {},
-                            timestamp: new Date().toISOString(),
-                        },
+                    run_id: payload.runId,
+                    event_type: "agent_message",
+                    project: payload.project,
+                    replyId: `preflight-${payload.runId}`,
+                    replyName: "Runner",
+                    replyRole: "system",
+                    msg: {
+                        id: `preflight-${payload.runId}`,
+                        name: "Runner",
+                        role: "system",
+                        content: [{ type: "text", text: `Model preflight failed: ${detail}` }],
+                        metadata: {},
+                        timestamp: new Date().toISOString(),
                     },
                 });
                 socket.emit("runner:runComplete", { runId: payload.runId, status: "failed" });
@@ -223,8 +214,18 @@ export async function connect(opts) {
             // Build env vars for the subprocess
             const relayUrl = `http://127.0.0.1:${relay.port}/events/relay/${relay.nonce}`;
             const sharedDir = getSharedDir();
+            // Defense in depth: scrub any MEL_MODEL_* the operator may have
+            // exported in their shell before launching the runner. Without
+            // this, a stale leak (e.g. operator set MEL_MODEL_DISABLE_THINKING=1
+            // while debugging Qwen3, then ran a non-Qwen pipeline) would
+            // bypass the preflight gate and corrupt model.py's profile read.
+            const inherited = { ...process.env };
+            for (const k of Object.keys(inherited)) {
+                if (k.startsWith("MEL_MODEL_"))
+                    delete inherited[k];
+            }
             const env = {
-                ...process.env,
+                ...inherited,
                 PYTHONPATH: sharedDir,
                 PYTHONIOENCODING: "utf-8",
                 PYTHONUTF8: "1",
@@ -250,7 +251,47 @@ export async function connect(opts) {
                         MEL_LUMA_BROWSER_TOKEN: lumaBridge.token,
                     }
                     : {}),
+                // Per-model profile from preflight detection. Empty when
+                // preflight didn't classify (cloud-spawn or capable model with
+                // defaults intact). When set, shared/runtime/model.py reads
+                // these and overrides max_tokens / max_iters / thinking-disable
+                // for THIS model only (text-only / agentic-marginal). Run
+                // f9fd5e596e7f4c9a (qwen3-1.7b looped in <think>) was the
+                // canary that motivated this.
+                ...(preflight.profile
+                    ? {
+                        MEL_MODEL_TIER: preflight.profile.tier,
+                        MEL_MODEL_FAMILY: preflight.profile.family ?? "",
+                        MEL_MODEL_PARAMS_B: String(preflight.profile.paramsBillion ?? ""),
+                        MEL_MODEL_MAX_TOKENS: String(preflight.profile.recommendedMaxTokens),
+                        MEL_MODEL_MAX_ITERS: String(preflight.profile.recommendedMaxIters),
+                        MEL_MODEL_DISABLE_THINKING: preflight.profile.thinkingDefault === "off" ? "1" : "0",
+                    }
+                    : {}),
             };
+            // Surface the tier to the chat panel as a system message so the
+            // operator sees WHY a small model is running with tighter caps.
+            if (preflight.profile && preflight.profile.tier !== "agentic-capable") {
+                socket.emit("runner:event", {
+                    run_id: payload.runId,
+                    event_type: "agent_message",
+                    project: payload.project,
+                    replyId: `model-tier-${payload.runId}`,
+                    replyName: "Runner",
+                    replyRole: "system",
+                    msg: {
+                        id: `model-tier-${payload.runId}`,
+                        name: "Runner",
+                        role: "system",
+                        content: [{
+                                type: "text",
+                                text: `⚠ Model tier: **${preflight.profile.tier}** (${preflight.profile.id}, ${preflight.profile.paramsBillion ?? "?"}B). ${preflight.profile.reason}. Caps: max_tokens=${preflight.profile.recommendedMaxTokens}, max_iters=${preflight.profile.recommendedMaxIters}${preflight.profile.thinkingDefault === "off" ? ", thinking=off" : ""}. For full agentic capability use a ≥7B model or a cloud provider.`,
+                            }],
+                        metadata: { tier: preflight.profile.tier, params_b: preflight.profile.paramsBillion },
+                        timestamp: new Date().toISOString(),
+                    },
+                });
+            }
             // Spawn Python subprocess (uses the bootstrapped venv python).
             const proc = spawn(pipelinePython, ["-u", join(runDir, "main.py")], {
                 cwd: runDir,

package/dist/modelLoader.d.ts

@@ -26,11 +26,36 @@
  *   3. For ollama: GET /api/tags. If model not present → fail fast with
  *      `ollama pull <name>` instruction. If present, ollama auto-loads.
  */
+export declare function classifyModel(id: string, lmstudioMeta?: LMStudioModelInfo): ModelProfile;
+type LMStudioModelState = "loaded" | "not-loaded" | "loading" | string;
+interface LMStudioModelInfo {
+    id: string;
+    state?: LMStudioModelState;
+    type?: string;
+    arch?: string;
+    params?: string | number;
+    max_context_length?: number;
+}
+export type ModelTier = "agentic-capable" | "agentic-marginal" | "text-only";
+export interface ModelProfile {
+    schemaVersion: number;
+    id: string;
+    tier: ModelTier;
+    paramsBillion: number | null;
+    family: string | null;
+    supportsToolCalling: boolean;
+    thinkingDefault: "on" | "off" | "n/a";
+    recommendedMaxTokens: number;
+    recommendedMaxIters: number;
+    detectedAt: string;
+    reason: string;
+}
 export interface ModelPreflightResult {
     ok: boolean;
     reason?: string;
     hint?: string;
     loaded?: boolean;
+    profile?: ModelProfile;
 }
 export declare function preflightLmStudio(modelName: string, onProgress?: (msg: string) => void): Promise<ModelPreflightResult>;
 export declare function preflightOllama(modelName: string, onProgress?: (msg: string) => void): Promise<ModelPreflightResult>;
@@ -40,3 +65,4 @@ export declare function preflightOllama(modelName: string, onProgress?: (msg: st
  * non-local providers (cloud-spawn shouldn't reach the runner anyway).
  */
 export declare function preflightModel(configJson: string, onProgress?: (msg: string) => void): Promise<ModelPreflightResult>;
+export {};

package/dist/modelLoader.js

@@ -27,6 +27,194 @@
  *      `ollama pull <name>` instruction. If present, ollama auto-loads.
  */
 import chalk from "chalk";
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "fs";
+import { join } from "path";
+import { homedir } from "os";
+// ── Model classification ───────────────────────────────────────────────────────
+//
+// Goal: detect when a local model is too small / weak to drive an
+// agentic ReAct pipeline, BEFORE we spawn the python subprocess. The
+// pipeline can then receive a tighter profile (max_tokens, max_iters,
+// thinking-disable) so it fails fast or runs reliably instead of
+// silently looping inside <think> tags forever (run f9fd5e596e7f4c9a
+// canary: qwen3-1.7b produced 81 thinking blocks, 0 tool_use, 0 text).
+//
+// Classification is deterministic from (a) LM Studio metadata, (b)
+// param-count regex on the model id, (c) a hard family table for known
+// edge cases that don't match the regex. NO network probe today —
+// keeps the preflight cheap; we lean on Layer 3 (runtime loop guard)
+// to catch detection misses.
+const PROFILE_DIR = join(homedir(), ".melaya-runner", "model-profiles");
+// Models BELOW this param count are forced to `agentic-marginal` or
+// `text-only` regardless of family. Above it, family table overrides.
+const TIER_PARAM_THRESHOLDS = {
+    agenticCapable: 7.0, // 7B+ is the empirical floor for reliable tool_use
+    agenticMarginal: 4.0, // 4-7B can do simple tool_use, struggles with multi-step ReAct
+    // <4B is text-only — too small for reliable agentic work
+};
+// Family hints for models that don't expose param count cleanly via
+// name OR are known special cases regardless of size. Match against
+// the lowercased model id; first match wins. ORDER MATTERS — put
+// MORE-SPECIFIC patterns first (e.g. qwen3-vl-4b before qwen3-4b),
+// otherwise the looser pattern claims the id. All `\b...b\b` anchors
+// use \b so `qwen3-14b` doesn't accidentally match `4b`.
+const FAMILY_OVERRIDES = [
+    // Qwen3 family — thinking is on by default; for the small variants
+    // (which can't escape <think>) we need to disable it via
+    // chat_template_kwargs.enable_thinking=false. The vl-* and 8B+ keep
+    // thinking ON because they're capable enough to use it for ReAct.
+    // ── Qwen3 — VL (vision) variants FIRST (more specific than non-vl) ──
+    { pattern: /qwen3.*vl.*\b4b\b/i, family: "qwen3", tier: "agentic-marginal", thinking: "on", reason: "qwen3-vl-4b: vision variant has stronger reasoning, marginal but keep thinking on" },
+    { pattern: /qwen3.*vl.*\b8b\b/i, family: "qwen3", tier: "agentic-capable", thinking: "on", reason: "qwen3-vl-8b: agentic-capable, full thinking" },
+    // ── Qwen3 — capable (≥8B) BEFORE the smaller non-vl 4b pattern, so
+    //    14b / 32b don't get caught by the 4b regex's stem match. ──
+    { pattern: /qwen3.*\b(8b|14b|32b)\b/i, family: "qwen3", tier: "agentic-capable", thinking: "on", reason: "qwen3 ≥8b: agentic-capable" },
+    // ── Qwen3 — small variants ──
+    { pattern: /qwen3.*\b1\.7b\b/i, family: "qwen3", tier: "text-only", thinking: "off", reason: "qwen3-1.7b: param count below the agentic 7B floor; thinking disabled to prevent <think> loops" },
+    { pattern: /qwen3.*\b0\.5b\b/i, family: "qwen3", tier: "text-only", thinking: "off", reason: "qwen3-0.5b: too small for agentic work" },
+    { pattern: /qwen3.*\b4b\b/i, family: "qwen3", tier: "agentic-marginal", thinking: "off", reason: "qwen3-4b non-vl: marginal — thinking off, tighter caps" },
+    // ── DeepSeek-R1 — also emits <think> blocks. Capable variants keep
+    //    thinking on; small distills get thinking off. R1's runtime
+    //    accepts the same chat_template_kwargs.enable_thinking=false
+    //    extra_body via the OpenAI-compat server (LM Studio / vLLM). ──
+    { pattern: /deepseek.*r1.*\b1\.5b\b/i, family: "deepseek-r1", tier: "text-only", thinking: "off", reason: "deepseek-r1-distill-1.5b: too small for agentic, thinking off to prevent <think> loops" },
+    { pattern: /deepseek.*r1.*\b7b\b/i, family: "deepseek-r1", tier: "agentic-marginal", thinking: "on", reason: "deepseek-r1-distill-7b: marginal, thinking on" },
+    { pattern: /deepseek.*r1.*\b(8b|14b|32b|70b|671b)\b/i, family: "deepseek-r1", tier: "agentic-capable", thinking: "on", reason: "deepseek-r1-distill ≥8b: agentic-capable" },
+    // Gemma3 — small variants are text-completion oriented. Use \b
+    // anchors so gemma-3-12b doesn't collide with the 1b/2b rule via
+    // substring match (the previous unanchored pattern misclassified
+    // every gemma-N{1,2}b variant containing '1b' or '2b' as a substring).
+    { pattern: /gemma-?3?.*\b(1b|2b)\b/i, family: "gemma", tier: "text-only", thinking: "n/a", reason: "gemma 1-2b: text-only, no reliable tool_use" },
+    { pattern: /gemma-?3?.*\b4b\b/i, family: "gemma", tier: "agentic-marginal", thinking: "n/a", reason: "gemma 4b: marginal" },
+    { pattern: /gemma-?3?.*\b(7b|9b|12b|21b|27b)\b/i, family: "gemma", tier: "agentic-capable", thinking: "n/a", reason: "gemma ≥7b: agentic-capable" },
+    // Llama3.2 small variants
+    { pattern: /llama-?3\.?2.*\b(1b|3b)\b/i, family: "llama", tier: "text-only", thinking: "n/a", reason: "llama3.2 1-3b: text-only" },
+    // Phi-4 (14B) and Phi-4-mini (3.8B) — name has no \bNb\b token.
+    // Phi-3.5 mini (3.8B) covered separately.
+    { pattern: /phi-?4(?!-?mini)/i, family: "phi", tier: "agentic-capable", thinking: "n/a", reason: "phi-4: 14B, agentic-capable" },
+    { pattern: /phi-?4-?mini/i, family: "phi", tier: "agentic-marginal", thinking: "n/a", reason: "phi-4-mini: 3.8B, marginal" },
+    { pattern: /phi-?3\.?5.*mini/i, family: "phi", tier: "agentic-marginal", thinking: "n/a", reason: "phi-3.5-mini: 3.8B, marginal" },
+];
+function _parseParamCount(id) {
+    // Match formats: "8b", "1.7b", "32B", "8x7b" (mixture-of-experts → use the active param count, e.g. mixtral-8x7b ≈ 12.9B active)
+    const m = id.match(/(\d+x)?(\d+(?:\.\d+)?)\s*[bB]\b/);
+    if (!m)
+        return null;
+    const moe = m[1];
+    const base = parseFloat(m[2]);
+    if (isNaN(base))
+        return null;
+    // For MoE, we approximate active params (rough — Mixtral 8x7B is ~12.9B active).
+    // Treat conservatively as 1.5× the base for the tier check.
+    return moe ? base * 1.5 : base;
+}
+function _classify(id, lmstudioMeta) {
+    const lower = id.toLowerCase();
+    // 1. Family override wins if matched.
+    for (const ov of FAMILY_OVERRIDES) {
+        if (ov.pattern.test(lower)) {
+            const params = _parseParamCount(id);
+            return _buildProfile(id, ov.tier, params, ov.family, ov.thinking, ov.reason);
+        }
+    }
+    // 2. LM Studio metadata if present.
+    let params = null;
+    if (lmstudioMeta?.params != null) {
+        const raw = String(lmstudioMeta.params);
+        const m = raw.match(/(\d+(?:\.\d+)?)/);
+        if (m) {
+            const n = parseFloat(m[1]);
+            // LM Studio reports either a raw count (e.g. 7000000000) or a
+            // human string ("7B"). Normalise to billions.
+            params = raw.toLowerCase().includes("b") ? n : (n > 1e6 ? n / 1e9 : n);
+        }
+    }
+    if (params == null)
+        params = _parseParamCount(id);
+    // 3. Tier from param count.
+    let tier;
+    let reason;
+    if (params == null) {
+        tier = "agentic-marginal";
+        reason = `couldn't infer param count from "${id}" — defaulting to marginal (Layer 3 loop guard remains active)`;
+    }
+    else if (params >= TIER_PARAM_THRESHOLDS.agenticCapable) {
+        tier = "agentic-capable";
+        reason = `${params}B params ≥ ${TIER_PARAM_THRESHOLDS.agenticCapable}B threshold`;
+    }
+    else if (params >= TIER_PARAM_THRESHOLDS.agenticMarginal) {
+        tier = "agentic-marginal";
+        reason = `${params}B params: between ${TIER_PARAM_THRESHOLDS.agenticMarginal}B and ${TIER_PARAM_THRESHOLDS.agenticCapable}B — marginal, tighter caps applied`;
+    }
+    else {
+        tier = "text-only";
+        reason = `${params}B params < ${TIER_PARAM_THRESHOLDS.agenticMarginal}B threshold — text-only, abort if used for tool-using pipeline`;
+    }
+    return _buildProfile(id, tier, params, null, "n/a", reason);
+}
+function _buildProfile(id, tier, paramsBillion, family, thinkingDefault, reason) {
+    // Per-tier resource caps. Smaller models get tighter ceilings to
+    // bound runaway thinking loops.
+    const recommendedMaxTokens = tier === "agentic-capable" ? 8192
+        : tier === "agentic-marginal" ? 4096
+            : 2048;
+    const recommendedMaxIters = tier === "agentic-capable" ? 10
+        : tier === "agentic-marginal" ? 5
+            : 3;
+    return {
+        schemaVersion: PROFILE_SCHEMA_VERSION,
+        id,
+        tier,
+        paramsBillion,
+        family,
+        supportsToolCalling: tier !== "text-only",
+        thinkingDefault,
+        recommendedMaxTokens,
+        recommendedMaxIters,
+        detectedAt: new Date().toISOString(),
+        reason,
+    };
+}
+function _saveProfile(p) {
+    try {
+        mkdirSync(PROFILE_DIR, { recursive: true });
+        const safe = p.id.replace(/[^a-zA-Z0-9_.-]+/g, "_");
+        writeFileSync(join(PROFILE_DIR, `${safe}.json`), JSON.stringify(p, null, 2), "utf-8");
+    }
+    catch { /* best-effort — profile is regenerated on next preflight */ }
+}
+function _loadCachedProfile(id) {
+    try {
+        const safe = id.replace(/[^a-zA-Z0-9_.-]+/g, "_");
+        const p = join(PROFILE_DIR, `${safe}.json`);
+        if (!existsSync(p))
+            return null;
+        const parsed = JSON.parse(readFileSync(p, "utf-8"));
+        // Reject cached profiles produced by an older classifier — they
+        // may carry stale tiers (e.g. gemma-3-12b mis-tagged 'text-only'
+        // by the pre-v2 unanchored regex). Forces a fresh classification.
+        if ((parsed.schemaVersion ?? 1) !== PROFILE_SCHEMA_VERSION)
+            return null;
+        return parsed;
+    }
+    catch {
+        return null;
+    }
+}
+export function classifyModel(id, lmstudioMeta) {
+    // Cache hit if we've classified this id before. Cheap optimization
+    // to avoid redoing the regex/family walk on every spawn.
+    const cached = _loadCachedProfile(id);
+    if (cached && cached.id === id)
+        return cached;
+    const profile = _classify(id, lmstudioMeta);
+    _saveProfile(profile);
+    return profile;
+}
+// Bump whenever FAMILY_OVERRIDES, tier thresholds, or any classifier
+// logic changes in a way that could re-tier an existing cached model.
+// Cached profiles with a mismatched version are ignored and re-classified.
+const PROFILE_SCHEMA_VERSION = 2;
 const LMSTUDIO_BASE = process.env.LMSTUDIO_BASE_URL || "http://127.0.0.1:1234";
 const OLLAMA_BASE = process.env.OLLAMA_BASE_URL || "http://127.0.0.1:11434";
 // JIT-load timeout. 8B-class quantised models on M-series Macs typically
@@ -124,10 +312,17 @@ export async function preflightLmStudio(modelName, onProgress = () => { }) {
             hint: `Model "${modelName}" not found in LM Studio. Open LM Studio → Search → download it. Available: ${available || "(none)"}`,
         };
     }
+    const profile = classifyModel(match.id, match);
+    if (profile.tier !== "agentic-capable") {
+        onProgress(`⚠ ${match.id} classified ${profile.tier} (${profile.reason})`);
+    }
+    else {
+        onProgress(`✓ ${match.id} classified ${profile.tier} (${profile.paramsBillion ?? "?"}B)`);
+    }
     const state = (match.state ?? "unknown");
     if (state === "loaded") {
         onProgress(`✓ ${match.id} already loaded in LM Studio`);
-        return { ok: true, loaded: true };
+        return { ok: true, loaded: true, profile };
     }
     onProgress(`Loading ${match.id} into LM Studio (this can take 30-120s for first load)…`);
     const loaded = await jitLoadLmStudioModel(match.id, onProgress);
@@ -136,10 +331,11 @@ export async function preflightLmStudio(modelName, onProgress = () => { }) {
             ok: false,
             reason: "load_failed",
             hint: `LM Studio could not load "${match.id}". Check available RAM and the LM Studio server log.`,
+            profile,
         };
     }
     onProgress(`✓ ${match.id} loaded`);
-    return { ok: true, loaded: true };
+    return { ok: true, loaded: true, profile };
 }
 export async function preflightOllama(modelName, onProgress = () => { }) {
     try {
@@ -160,8 +356,14 @@ export async function preflightOllama(modelName, onProgress = () => { }) {
                 hint: `Model "${modelName}" not pulled in Ollama. Run: ollama pull ${modelName}`,
             };
         }
-        onProgress(`✓ ${modelName} present in Ollama`);
-        return { ok: true, loaded: true };
+        const profile = classifyModel(modelName);
+        if (profile.tier !== "agentic-capable") {
+            onProgress(`⚠ ${modelName} classified ${profile.tier} (${profile.reason})`);
+        }
+        else {
+            onProgress(`✓ ${modelName} classified ${profile.tier} (${profile.paramsBillion ?? "?"}B)`);
+        }
+        return { ok: true, loaded: true, profile };
     }
     catch (e) {
         return { ok: false, reason: "ollama_error", hint: e.message };
@@ -221,5 +423,14 @@ export async function preflightModel(configJson, onProgress = (m) => console.log
         return { ok: true };
     const results = await Promise.all(tasks);
     const failed = results.find((r) => !r.ok);
-    return failed ?? { ok: true, loaded: true };
+    if (failed)
+        return failed;
+    // Pick the most-restrictive profile across every model the pipeline
+    // uses — if ANY agent is on a text-only model, the whole pipeline
+    // gets the text-only caps. Agentic-capable < marginal < text-only
+    // (most restrictive last).
+    const tierRank = { "agentic-capable": 0, "agentic-marginal": 1, "text-only": 2 };
+    const profiles = results.map((r) => r.profile).filter((p) => !!p);
+    const worst = profiles.reduce((acc, p) => (!acc || tierRank[p.tier] > tierRank[acc.tier]) ? p : acc, undefined);
+    return { ok: true, loaded: true, profile: worst };
 }

package/dist/pythonEnv.js

@@ -69,6 +69,7 @@ const PIP_DEPS = [
     "openpyxl",
     "python-docx",
     "python-pptx",
+    "ddgs", // duckduckgo search rebrand — shared.tools.core imports DDGS
 ];
 export function venvPython() {
     return platform() === "win32"

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@melaya/runner",
-  "version": "1.0.29",
+  "version": "1.0.31",
   "description": "Run Melaya AI pipelines locally with your own LM Studio or Ollama models",
   "license": "UNLICENSED",
   "private": false,