mixdog 0.9.84 → 0.9.86

package/src/runtime/agent/orchestrator/session/context-utils.mjs

@@ -1,6 +1,12 @@
 import { isOffloadedToolResultText } from './tool-result-offload.mjs';
 import { createHash } from 'node:crypto';
 import { createRequire } from 'node:module';
+import { bpeEncodeCount } from './token-bpe.mjs';
+import {
+    countTokensNative,
+    nativeTokenCounterEnabled,
+    prewarmNativeTokenCounter,
+} from './token-native.mjs';
 import {
     isFinalizedProviderRequestTools,
     providerNativeToolPrefixCount,
@@ -78,48 +84,49 @@ function bpeEncoder() {
 const TOKEN_COUNT_CACHE_MIN_CHARS = 512;
 const TOKEN_COUNT_CACHE_MAX_ENTRIES = 1_024;
 const tokenCountCache = new Map();
-// BPE merge cost is quadratic in WORD length, not text length: a degenerate
-// single-word run ('p'.repeat(250k), base64/minified blobs) forms one giant
-// pat_str word and encode() spins for minutes while the event loop is blocked
-// (observed live via inspector: compact-smoke hung inside tiktoken encode).
-// Encoding fixed-size slices caps the worst-case word at the chunk size, so
-// cost stays linear. Chunk cuts snap back to the nearest whitespace so the
-// next slice starts at a natural ` word` boundary — o200k tokenizes that
-// identically to the unsliced text, keeping estimates EXACT for prose
-// (compact-smoke asserts est === real o200k count). Only a whitespace-free
-// degenerate run falls back to a hard cut (±1 token per boundary, safely
-// inside the estimate's safety multiplier). Hard cuts avoid splitting a
-// surrogate pair so sliced emoji/CJK-ext code points still encode cleanly.
-const BPE_ENCODE_CHUNK_CHARS = 4_096;
-const BPE_CHUNK_BOUNDARY_SCAN = 512;
-function bpeEncodeCount(enc, s) {
-    if (s.length <= BPE_ENCODE_CHUNK_CHARS) return enc.encode(s, undefined, []).length;
-    let total = 0;
-    let i = 0;
-    while (i < s.length) {
-        let end = Math.min(s.length, i + BPE_ENCODE_CHUNK_CHARS);
-        if (end < s.length) {
-            // Prefer cutting BEFORE a whitespace run: the next chunk then
-            // starts with ` word`, which o200k merges exactly as it would
-            // mid-text. Scan a bounded window so degenerate inputs stay O(1).
-            let ws = -1;
-            const scanFloor = Math.max(i + 1, end - BPE_CHUNK_BOUNDARY_SCAN);
-            for (let j = end - 1; j >= scanFloor; j -= 1) {
-                const c = s.charCodeAt(j);
-                if (c === 0x20 || c === 0x0A || c === 0x0D || c === 0x09) { ws = j; break; }
-            }
-            if (ws > i) {
-                end = ws; // next chunk starts at the whitespace
-            } else {
-                const last = s.charCodeAt(end - 1);
-                if (last >= 0xD800 && last <= 0xDBFF) end += 1;
-            }
-        }
-        total += enc.encode(s.slice(i, end), undefined, []).length;
-        i = end;
+
+function _tokenCacheSet(key, count) {
+    if (tokenCountCache.size >= TOKEN_COUNT_CACHE_MAX_ENTRIES) {
+        tokenCountCache.delete(tokenCountCache.keys().next().value);
     }
-    return total;
+    tokenCountCache.set(key, count);
+}
+
+// ── Native offload for large encodes ────────────────────────────────────────
+// estimateTokens is a SYNC api polled from context gauges and compaction
+// pressure checks. A large fresh string (big tool result) costs tens of ms to
+// encode; under many parallel agents those encodes serialize the one shared
+// event loop. Strings at/above BPE_ASYNC_THRESHOLD_CHARS with no cache entry
+// are therefore counted by the mixdog-token native server (SINGLE offload
+// engine — no worker-thread fallback by design): the caller immediately gets
+// the conservative legacy heuristic, the precise count lands in
+// tokenCountCache, and the next poll returns the exact value. Smaller
+// strings (the vast majority) keep exact synchronous counting. With the
+// native server unavailable (MIXDOG_TOKEN_NATIVE=0, missing binary before
+// the first token-v release), large strings encode synchronously — exact,
+// pre-offload semantics.
+const BPE_ASYNC_THRESHOLD_CHARS = 32_768;
+const _nativePendingKeys = new Set();
+
+// Offload one large count to the native mixdog-token server. Returns false
+// when the native path cannot be attempted (caller encodes synchronously). A
+// mid-flight failure just drops the pending key: the next poll re-evaluates
+// and encodes synchronously if the server is really gone.
+function _offloadTokenCountNative(key, s) {
+    if (!nativeTokenCounterEnabled()) return false;
+    _nativePendingKeys.add(key);
+    countTokensNative(s).then((count) => {
+        if (!_nativePendingKeys.delete(key)) return;
+        if (Number.isFinite(count) && count >= 0) _tokenCacheSet(key, count);
+    }).catch(() => {
+        _nativePendingKeys.delete(key);
+    });
+    return true;
 }
+
+// Returns the exact count, or null when the string was handed to the native
+// server
+// (caller falls back to the legacy heuristic until the precise count lands).
 function bpeTokenCount(enc, s) {
     if (s.length < TOKEN_COUNT_CACHE_MIN_CHARS) return bpeEncodeCount(enc, s);
     const key = `${s.length}:${createHash('sha1').update(s).digest('base64')}`;
@@ -129,11 +136,12 @@ function bpeTokenCount(enc, s) {
         tokenCountCache.set(key, hit);
         return hit;
     }
-    const count = bpeEncodeCount(enc, s);
-    if (tokenCountCache.size >= TOKEN_COUNT_CACHE_MAX_ENTRIES) {
-        tokenCountCache.delete(tokenCountCache.keys().next().value);
+    if (s.length >= BPE_ASYNC_THRESHOLD_CHARS) {
+        if (!_nativePendingKeys.has(key)) _offloadTokenCountNative(key, s);
+        if (_nativePendingKeys.has(key)) return null;
     }
-    tokenCountCache.set(key, count);
+    const count = bpeEncodeCount(enc, s);
+    _tokenCacheSet(key, count);
     return count;
 }
 
@@ -203,12 +211,32 @@ export function estimateTokens(text) {
     const enc = bpeEncoder();
     if (enc) {
         try {
-            return Math.ceil(bpeTokenCount(enc, s) * TOKEN_ESTIMATE_SAFETY_MULTIPLIER);
+            const count = bpeTokenCount(enc, s);
+            // null = precise count is being computed in the worker; return the
+            // conservative heuristic until it lands in the cache.
+            if (count !== null) return Math.ceil(count * TOKEN_ESTIMATE_SAFETY_MULTIPLIER);
         } catch { /* corrupt input — degrade to the heuristic below */ }
     }
     return legacyEstimateTokens(s);
 }
 
+/**
+ * Boot prewarm: load the o200k encoder (WASM init), run one small encode
+ * (JIT), and spawn the token-count worker so the first large transcript
+ * estimate of a session neither blocks on WASM init nor waits for the
+ * worker spawn. Best-effort; returns true when the encoder is live.
+ */
+export function prewarmTokenEstimator() {
+    const enc = bpeEncoder();
+    if (enc) {
+        try { bpeEncodeCount(enc, 'mixdog tokenizer warmup — 워밍업 텍스트 0123456789'); } catch { /* best-effort */ }
+    }
+    // Native server boots its encoder (~100-300ms) off the first estimate;
+    // with no binary yet, this also kicks the one-shot release fetch.
+    try { prewarmNativeTokenCounter(); } catch { /* best-effort */ }
+    return !!enc;
+}
+
 // Legacy conservative Unicode-aware estimate (fallback only). Iterates by
 // code point, takes the max of the weighted sum and the chars/4 ASCII floor,
 // then applies the safety multiplier.

package/src/runtime/agent/orchestrator/session/eager-dispatch.mjs

@@ -1,9 +1,10 @@
 // Eager tool-dispatch controller, extracted from agent-loop.mjs. Owns the
 // per-turn pending promise map, the intra-turn in-flight signature set, and
-// the mutation epoch. Read-only tool calls start executing the instant the
-// provider streams a tool_use event so execution overlaps the remaining SSE
-// parse; writes/unknown tools wait for the serial batch loop. Behavior
-// identical to the inline closures it replaced.
+// the mutation epoch. FULL-PARALLEL policy: every tool call starts executing
+// the instant the provider streams its tool_use event (or at batch start),
+// shell/MCP/writes included — the model owns ordering by splitting dependent
+// work into separate turns. Only apply_patch (ordered mutation) waits for the
+// serial batch loop.
 import { normalizeToolEnvelope } from './tool-envelope.mjs';
 import { isInvalidToolArgsMarker } from '../providers/openai-compat-stream.mjs';
 import { _intraTurnSig, _isReadTool, _isScopedCacheableTool, _stripMcpPrefix } from './loop/tool-classify.mjs';
@@ -11,7 +12,7 @@ import { tryReadCached, tryScopedToolCached } from './read-dedup.mjs';
 import { preDispatchDenyForSession } from './loop/pre-dispatch-deny.mjs';
 import { executeTool } from './loop/tool-exec.mjs';
 import { crossTurnSignature } from './loop/completion-guards.mjs';
-import { getToolKind, isEagerDispatchable, isToolCallDedupEligible } from './loop/tool-helpers.mjs';
+import { getToolKind, isParallelDispatchable, isToolCallDedupEligible } from './loop/tool-helpers.mjs';
 
 export function createEagerDispatcher({
     tools, cwd, sessionId, sessionRef, signal, opts,
@@ -40,7 +41,7 @@ export function createEagerDispatcher({
         const _eagerInFlightSigs = new Map();
         const epoch = { mutation: 0 };
         const startEagerTool = (call) => {
-            if (!call?.id || pending.has(call.id) || !isEagerDispatchable(call.name, tools)) return null;
+            if (!call?.id || pending.has(call.id) || !isParallelDispatchable(call.name)) return null;
             // Never eager-execute a call whose arguments failed to parse
             // (invalid-args marker). It has no usable arguments; the serial
             // body handles it via the invalid-args feedback path.
@@ -157,26 +158,22 @@ export function createEagerDispatcher({
         const startEagerRun = (calls, startIndex, dupSet) => {
             for (let j = startIndex; j < calls.length; j += 1) {
                 const call = calls[j];
-                if (!call?.id || !isEagerDispatchable(call.name, tools)) break;
+                // Full-parallel: only the ordered mutation (apply_patch) is
+                // skipped — it executes in the serial batch body. No barrier:
+                // later calls keep starting in parallel past it.
+                if (!call?.id || !isParallelDispatchable(call.name)) continue;
                 if (dupSet && dupSet.has(call.id)) continue;
-                // A null return here is NOT a state barrier: the loop above
-                // already breaks at the first non-eager (mutation/bash/unknown)
-                // tool, so every call reached here is read-only. A null means a
+                // A null return here is NOT a state barrier. It means a
                 // non-barrier stub — intra-turn in-flight dup, repeat-failure /
                 // cross-turn dedup, pre-dispatch-deny, invalid-args, or a cache
                 // short-circuit. `continue` (not `break`) so a stub in the
-                // middle of a contiguous eager run does not stop LATER
-                // independent eager reads from starting early.
+                // middle of the run does not stop LATER independent calls from
+                // starting early.
                 if (!startEagerTool(call) && !pending.has(call.id)) continue;
             }
         };
-        let _streamEagerBlocked = false;
         const onToolCall = (call) => {
-            if (!isEagerDispatchable(call?.name, tools)) {
-                _streamEagerBlocked = true;
-                return;
-            }
-            if (_streamEagerBlocked) return;
+            if (!isParallelDispatchable(call?.name)) return;
             startEagerTool(call);
         };
     return { pending, epoch, startEagerTool, startEagerRun, onToolCall };

package/src/runtime/agent/orchestrator/session/loop/context-overflow.mjs

@@ -42,7 +42,7 @@ export function agentContextOverflowError({ stage, sessionId, sessionRef, model,
 // etc.). This is NOT "latest turn cannot fit the context budget" — masking it
 // as AGENT_CONTEXT_OVERFLOW hides the real failure and misroutes downstream
 // overflow handling. Genuine provider send overflow keeps AgentContextOverflowError.
-export class AgentCompactFailedError extends Error {
+class AgentCompactFailedError extends Error {
     constructor({ stage, sessionId, provider, model }, cause) {
         const target = [provider, model].filter(Boolean).join('/') || 'target model';
         const causeMsg = cause && cause.message ? `: ${cause.message}` : '';

package/src/runtime/agent/orchestrator/session/loop/steering.mjs

@@ -14,21 +14,48 @@ export function steeringContentText(content) {
     return String(content ?? '');
 }
 
+function steeringEntryMetadata(entry) {
+    if (!entry || typeof entry !== 'object') return {};
+    const sourceIds = Array.isArray(entry.ids)
+        ? entry.ids
+        : (entry.id !== undefined && entry.id !== null ? [entry.id] : []);
+    const ids = [...new Set(sourceIds.filter((id) => id !== undefined && id !== null))];
+    const submittedAt = Number(entry.submittedAt);
+    return {
+        ...(ids.length ? { ids } : {}),
+        ...(Number.isFinite(submittedAt) && submittedAt > 0 ? { submittedAt } : {}),
+        ...(Array.isArray(entry.images) && entry.images.length ? { images: entry.images } : {}),
+    };
+}
+
 function normalizeSteeringEntry(entry) {
     if (typeof entry === 'string') {
         const text = entry.trim();
         return text ? { content: text, text } : null;
     }
     if (!entry || typeof entry !== 'object') return null;
+    const metadata = steeringEntryMetadata(entry);
     const content = Object.prototype.hasOwnProperty.call(entry, 'content') ? entry.content : entry;
     const text = typeof entry.text === 'string' ? entry.text.trim() : steeringContentText(content).trim();
-    if (Array.isArray(content)) return content.length > 0 ? { content, text } : null;
+    if (Array.isArray(content)) return content.length > 0 ? { content, text, ...metadata } : null;
     if (typeof content === 'string') {
         const value = content.trim();
-        return value ? { content: value, text: text || value } : null;
+        return value ? { content: value, text: text || value, ...metadata } : null;
     }
     const fallback = steeringContentText(content).trim();
-    return fallback ? { content: fallback, text: text || fallback } : null;
+    return fallback ? { content: fallback, text: text || fallback, ...metadata } : null;
+}
+
+function mergeSteeringMetadata(entries) {
+    const ids = [...new Set(entries.flatMap((entry) => Array.isArray(entry.ids) ? entry.ids : []))];
+    const submittedTimes = entries.map((entry) => Number(entry.submittedAt))
+        .filter((value) => Number.isFinite(value) && value > 0);
+    const images = entries.flatMap((entry) => Array.isArray(entry.images) ? entry.images : []);
+    return {
+        ...(ids.length ? { ids } : {}),
+        ...(submittedTimes.length ? { submittedAt: Math.min(...submittedTimes) } : {}),
+        ...(images.length ? { images } : {}),
+    };
 }
 
 export function mergeSteeringEntries(entries) {
@@ -36,6 +63,7 @@ export function mergeSteeringEntries(entries) {
         .map(normalizeSteeringEntry)
         .filter(Boolean);
     if (normalized.length === 0) return null;
+    const metadata = mergeSteeringMetadata(normalized);
     const displayText = normalized.map((entry) => entry.text || steeringContentText(entry.content))
         .filter((text) => String(text || '').trim())
         .join('\n');
@@ -44,6 +72,7 @@ export function mergeSteeringEntries(entries) {
             content: normalized.map((entry) => entry.content).filter(Boolean).join('\n'),
             text: displayText,
             count: normalized.length,
+            ...metadata,
         };
     }
     const parts = [];
@@ -59,5 +88,10 @@ export function mergeSteeringEntries(entries) {
         parts.push({ type: 'text', text: '\n' });
     }
     while (parts.length && parts[parts.length - 1]?.type === 'text' && parts[parts.length - 1]?.text === '\n') parts.pop();
-    return { content: parts, text: displayText || steeringContentText(parts), count: normalized.length };
+    return {
+        content: parts,
+        text: displayText || steeringContentText(parts),
+        count: normalized.length,
+        ...metadata,
+    };
 }

package/src/runtime/agent/orchestrator/session/loop/tool-helpers.mjs

@@ -12,6 +12,7 @@ import {
     isSkillDisabled,
 } from '../../context/collect.mjs';
 import { isAgentOwner } from '../../agent-owner.mjs';
+import { _isMutationTool } from './tool-classify.mjs';
 
 // Eager-dispatch: tools with readOnlyHint:true in their declaration are safe
 // to execute during SSE parsing so tool work overlaps with the rest of the
@@ -40,6 +41,18 @@ export function isEagerDispatchable(name, tools) {
     return set.has(name);
 }
 
+// Full-parallel dispatch policy: EVERY tool call in an assistant turn starts
+// executing immediately — ordering across dependent work is the MODEL's job
+// (split into separate turns). The only exception is the ordered mutation
+// (apply_patch), which stays in the serial batch body so multi-patch turns
+// keep deterministic order, the all-or-nothing failure gate, and cache
+// invalidation sequencing. isEagerDispatchable above remains the READ-ONLY
+// classifier used for dedup eligibility, steering, and post-mutation result
+// invalidation.
+export function isParallelDispatchable(name) {
+    return typeof name === 'string' && name.length > 0 && !_isMutationTool(name);
+}
+
 // Read-only is necessary but not sufficient for result deduplication. Loader
 // calls mutate the active session tool surface and must execute on every
 // explicit invocation so repeats can truthfully report `alreadyActive`.