@melaya/runner 1.1.82 → 1.1.83

package/dist/modelLoader.d.ts

@@ -35,6 +35,7 @@ interface LMStudioModelInfo {
     arch?: string;
     params?: string | number;
     max_context_length?: number;
+    loaded_context_length?: number;
 }
 export type ModelTier = "agentic-capable" | "agentic-marginal" | "text-only";
 export interface ModelProfile {
@@ -60,6 +61,17 @@ export interface ModelPreflightResult {
 }
 export declare function preflightLmStudio(modelName: string, onProgress?: (msg: string) => void): Promise<ModelPreflightResult>;
 export declare function preflightOllama(modelName: string, onProgress?: (msg: string) => void): Promise<ModelPreflightResult>;
+/**
+ * MEL_MODEL_* env for a runner-hosted Assistant session on ollama / lmstudio.
+ * Pipeline runs get theirs from preflightModel; the Assistant host had none, so
+ * it ran with no output cap, no sampling and the 12K "unknown local" memory
+ * budget on a 256K model (2026-11-09, conv ab3933f3: runaway generation and a
+ * compaction every few rounds). Never loads a model and never throws: an
+ * unreachable app or unknown model returns {} and model.py's own defaults
+ * apply. No MEL_MODEL_MAX_ITERS (the Assistant sets its round budget per turn
+ * type) and thinking stays the model's default.
+ */
+export declare function assistantModelEnv(provider: string, modelName: string): Promise<Record<string, string>>;
 /**
  * Top-level preflight — resolves the provider/model from the pipeline
  * config and dispatches to the right helper. Returns immediately for

package/dist/modelLoader.js

@@ -411,6 +411,57 @@ export async function preflightOllama(modelName, onProgress = () => { }) {
         return { ok: false, reason: "ollama_error", hint: e.message };
     }
 }
+// Per-response output cap for a capable local model in the Assistant: room for
+// a reasoning pass plus the tool call or answer (the pipeline tier cap, 8192,
+// cuts a thinking model's tool call short). model.py falls back to the same.
+const ASSISTANT_LOCAL_MAX_TOKENS = 16384;
+/**
+ * MEL_MODEL_* env for a runner-hosted Assistant session on ollama / lmstudio.
+ * Pipeline runs get theirs from preflightModel; the Assistant host had none, so
+ * it ran with no output cap, no sampling and the 12K "unknown local" memory
+ * budget on a 256K model (2026-11-09, conv ab3933f3: runaway generation and a
+ * compaction every few rounds). Never loads a model and never throws: an
+ * unreachable app or unknown model returns {} and model.py's own defaults
+ * apply. No MEL_MODEL_MAX_ITERS (the Assistant sets its round budget per turn
+ * type) and thinking stays the model's default.
+ */
+export async function assistantModelEnv(provider, modelName) {
+    const p = (provider || "").toLowerCase();
+    if (!modelName || (p !== "lmstudio" && p !== "ollama"))
+        return {};
+    try {
+        let profile;
+        let contextTokens = null;
+        if (p === "lmstudio") {
+            const models = (await listLmStudioModels()) ?? [];
+            const match = models.find((m) => m.id === modelName)
+                ?? models.find((m) => m.id.endsWith(`/${modelName}`) || m.id.endsWith(`:${modelName}`));
+            profile = classifyModel(match?.id ?? modelName, match);
+            // Read fresh, never from the cached profile: the user can reload the
+            // model with another context length at any time.
+            if (match?.state === "loaded" && (match.loaded_context_length ?? 0) > 0)
+                contextTokens = match.loaded_context_length;
+        }
+        else {
+            // model.py reads Ollama's loaded (/api/ps) and trained (/api/show) context itself.
+            profile = classifyModel(modelName);
+        }
+        const maxTokens = profile.tier === "agentic-capable"
+            ? Math.max(profile.recommendedMaxTokens, ASSISTANT_LOCAL_MAX_TOKENS)
+            : profile.recommendedMaxTokens;
+        return {
+            MEL_MODEL_TIER: profile.tier,
+            MEL_MODEL_FAMILY: profile.family ?? "",
+            MEL_MODEL_PARAMS_B: String(profile.paramsBillion ?? ""),
+            MEL_MODEL_MAX_TOKENS: String(maxTokens),
+            ...(contextTokens ? { MEL_MODEL_CONTEXT_TOKENS: String(contextTokens) } : {}),
+            MEL_MODEL_DISABLE_THINKING: "0",
+        };
+    }
+    catch {
+        return {};
+    }
+}
 /**
  * Top-level preflight — resolves the provider/model from the pipeline
  * config and dispatches to the right helper. Returns immediately for

package/dist/turnSummary.d.ts

@@ -0,0 +1,9 @@
+export interface TurnSummary {
+    stop?: unknown;
+    finish?: unknown;
+    tools?: unknown;
+    seconds?: unknown;
+    ctxUsed?: unknown;
+    ctxBudget?: unknown;
+}
+export declare function formatTurnSummary(s: TurnSummary): string;

package/dist/turnSummary.js

@@ -0,0 +1,29 @@
+// The per-turn line the runner logs for an Assistant turn, from the `summary`
+// the host puts on its `done` frame (assistantHost.py `_turn_summary`), e.g.
+//   done in 12.4s: stop=repeat_guard finish=tool_calls, 7 tool calls (activate_tool×7), context 21K/157K
+const kTok = (n) => (n >= 1000 ? `${Math.round(n / 1000)}K` : String(n));
+export function formatTurnSummary(s) {
+    const parts = [];
+    const secs = Number(s.seconds);
+    const head = Number.isFinite(secs) ? `done in ${secs}s:` : "done:";
+    parts.push(`stop=${String(s.stop ?? "?")}${s.finish ? ` finish=${String(s.finish)}` : ""}`);
+    const tools = s.tools && typeof s.tools === "object" ? Object.entries(s.tools) : [];
+    const calls = tools.reduce((n, [, c]) => n + (Number(c) || 0), 0);
+    if (calls > 0) {
+        const top = tools
+            .map(([name, c]) => [name, Number(c) || 0])
+            .sort((a, b) => b[1] - a[1])
+            .slice(0, 4)
+            .map(([name, c]) => (c > 1 ? `${name}×${c}` : name))
+            .join(", ");
+        parts.push(`${calls} tool call${calls === 1 ? "" : "s"} (${top}${tools.length > 4 ? ", …" : ""})`);
+    }
+    else {
+        parts.push("no tool calls");
+    }
+    const used = Number(s.ctxUsed) || 0;
+    const budget = Number(s.ctxBudget) || 0;
+    if (budget > 0)
+        parts.push(`context ${kTok(used)}/${kTok(budget)}`);
+    return `${head} ${parts.join(", ")}`;
+}