mixdog 0.9.85 → 0.9.87

package/src/runtime/agent/orchestrator/providers/oauth-usage.mjs

@@ -2,6 +2,7 @@ import {
   existsSync,
   readFileSync,
 } from 'fs';
+import { createHash } from 'crypto';
 import { join } from 'path';
 import { updateJsonAtomicSync } from '../../../shared/atomic-file.mjs';
 import { resolvePluginData } from '../../../shared/plugin-paths.mjs';
@@ -15,6 +16,8 @@ const STALE_DISK_CACHE_TTL_MS = 7 * 24 * 60 * 60_000;
 const NEGATIVE_CACHE_TTL_MS = 5 * 60_000;
 const FETCH_TIMEOUT_MS = 4500;
 const WARN_TTL_MS = 5 * 60_000;
+const CODEX_RESET_CREDITS_URL = 'https://chatgpt.com/backend-api/wham/rate-limit-reset-credits';
+const CODEX_RESET_CONSUME_URL = `${CODEX_RESET_CREDITS_URL}/consume`;
 
 const memoryCache = new Map();
 const inflight = new Map();
@@ -199,6 +202,110 @@ function resetAtMs(value, fallbackSeconds = null) {
   return secs > 0 ? Date.now() + secs * 1000 : null;
 }
 
+function codexAuthShape(auth) {
+  const token = auth?.access_token || auth?.accessToken;
+  if (!token) return null;
+  return {
+    token,
+    accountId: cleanString(auth?.account_id || auth?.accountId),
+  };
+}
+
+function codexHeaders(auth, beta = 'codex-1') {
+  return {
+    Authorization: `Bearer ${auth.token}`,
+    originator: 'Codex Desktop',
+    ...(auth.accountId ? { 'chatgpt-account-id': auth.accountId } : {}),
+    'OpenAI-Beta': beta,
+    Accept: 'application/json',
+  };
+}
+
+function normalizedResetCreditRows(value) {
+  return (Array.isArray(value) ? value : []).map((credit) => ({
+    status: cleanString(credit?.status).toLowerCase(),
+    expiresAt: resetAtMs(credit?.expires_at ?? credit?.expiresAt),
+    grantedAt: resetAtMs(credit?.granted_at ?? credit?.grantedAt),
+  }));
+}
+
+function normalizeOpenAICodexResetCredits(data, accountId = '') {
+  if (!data || typeof data !== 'object') return null;
+  const credits = normalizedResetCreditRows(data.credits);
+  const explicitCount = num(data.available_count ?? data.availableCount, null);
+  const availableRows = credits.filter((credit) => credit.status === 'available');
+  if (explicitCount === null && !credits.length) return null;
+  const availableCount = Math.max(0, Math.floor(explicitCount ?? availableRows.length));
+  const expiryCandidates = availableRows
+    .map((credit) => credit.expiresAt)
+    .filter((value) => Number.isFinite(value) && value > 0);
+  const nextExpiresAt = resetAtMs(data.next_expires_at ?? data.nextExpiresAt)
+    || (expiryCandidates.length ? Math.min(...expiryCandidates) : null);
+  const offerRevision = `v1:${createHash('sha256').update(JSON.stringify({
+    accountId,
+    availableCount,
+    nextExpiresAt,
+    credits,
+  })).digest('hex')}`;
+  return {
+    availableCount,
+    ...(nextExpiresAt ? { nextExpiresAt } : {}),
+    offerRevision,
+  };
+}
+
+async function resolveOpenAICodexAuth(providerObj) {
+  return codexAuthShape(await providerObj?.ensureAuth?.({ reason: 'usage' }));
+}
+
+async function fetchOpenAICodexResetCreditsWithAuth(auth) {
+  const response = await fetch(CODEX_RESET_CREDITS_URL, fetchOptions(codexHeaders(auth)));
+  if (!response.ok) return null;
+  return normalizeOpenAICodexResetCredits(await response.json(), auth.accountId);
+}
+
+export async function fetchOpenAICodexResetCredits(providerObj) {
+  const auth = await resolveOpenAICodexAuth(providerObj);
+  return auth ? await fetchOpenAICodexResetCreditsWithAuth(auth) : null;
+}
+
+function codexResetOutcome(code) {
+  if (code === 'reset') return 'reset';
+  if (code === 'nothing_to_reset') return 'nothingToReset';
+  if (code === 'no_credit') return 'noCredit';
+  if (code === 'already_redeemed') return 'alreadyRedeemed';
+  throw new Error(`Unknown Codex reset outcome: ${cleanString(code) || 'missing'}`);
+}
+
+export async function consumeOpenAICodexResetCredit(providerObj, options = {}) {
+  const expectedOfferRevision = cleanString(options?.expectedOfferRevision);
+  const idempotencyKey = cleanString(options?.idempotencyKey);
+  if (!/^v1:[a-f0-9]{64}$/i.test(expectedOfferRevision)) {
+    throw new TypeError('Codex reset offer revision is invalid');
+  }
+  if (!/^[a-f0-9]{8}-[a-f0-9]{4}-[1-5][a-f0-9]{3}-[89ab][a-f0-9]{3}-[a-f0-9]{12}$/i.test(idempotencyKey)) {
+    throw new TypeError('Codex reset idempotency key is invalid');
+  }
+  const auth = await resolveOpenAICodexAuth(providerObj);
+  if (!auth) throw new Error('Codex is not signed in');
+  const current = await fetchOpenAICodexResetCreditsWithAuth(auth);
+  if (!current || current.availableCount < 1 || current.offerRevision !== expectedOfferRevision) {
+    return { status: 'offerChanged', resetCredits: current };
+  }
+  const response = await fetch(CODEX_RESET_CONSUME_URL, {
+    ...fetchOptions({
+      ...codexHeaders(auth),
+      'Content-Type': 'application/json',
+    }, 15_000),
+    method: 'POST',
+    body: JSON.stringify({ redeem_request_id: idempotencyKey }),
+  });
+  if (!response.ok) throw new Error(`Codex reset failed: HTTP ${response.status}`);
+  const outcome = codexResetOutcome((await response.json())?.code);
+  const resetCredits = await fetchOpenAICodexResetCreditsWithAuth(auth).catch(() => null);
+  return { outcome, resetCredits };
+}
+
 function labelForDuration(seconds, fallback) {
   const s = num(seconds, 0);
   if (s > 0) {
@@ -482,19 +589,18 @@ function latestClaudeStatuslineUsage() {
 }
 
 async function fetchOpenAICodexUsage(providerObj) {
-  const auth = await providerObj?.ensureAuth?.({ reason: 'usage' });
-  const token = auth?.access_token || auth?.accessToken;
-  if (!token) return null;
-  const res = await fetch('https://chatgpt.com/backend-api/wham/usage', fetchOptions({
-    Authorization: `Bearer ${token}`,
-    originator: 'codex_cli_rs',
-    'chatgpt-account-id': auth.account_id || auth.accountId || '',
-    'OpenAI-Beta': 'responses=experimental',
-    Accept: 'application/json',
-  }));
+  const auth = await resolveOpenAICodexAuth(providerObj);
+  if (!auth) return null;
+  const [res, resetCredits] = await Promise.all([
+    fetch('https://chatgpt.com/backend-api/wham/usage', fetchOptions(
+      codexHeaders(auth, 'responses=experimental'),
+    )),
+    fetchOpenAICodexResetCreditsWithAuth(auth).catch(() => null),
+  ]);
   if (!res.ok) throw new Error(`openai-oauth usage ${res.status}`);
   const data = await res.json();
-  return normalizeOpenAIWhamUsage(data);
+  const usage = normalizeOpenAIWhamUsage(data);
+  return usage && resetCredits ? { ...usage, resetCredits } : usage;
 }
 
 async function fetchAnthropicUsage(providerObj) {
@@ -589,15 +695,18 @@ async function fetchGrokUsage(providerObj, routeInfo) {
   return null;
 }
 
-export async function fetchOAuthUsageSnapshot(routeInfo, providerObj, log = () => {}) {
+export async function fetchOAuthUsageSnapshot(routeInfo, providerObj, log = () => {}, options = {}) {
   const provider = providerKey(routeInfo);
   if (!provider.includes('oauth')) return null;
   const key = routeKey(routeInfo);
   const providerOnly = providerKey(routeInfo);
-  const cached = freshSnapshot(memoryCache.get(key), LIVE_CACHE_TTL_MS)
-    || freshSnapshot(memoryCache.get(providerOnly), LIVE_CACHE_TTL_MS);
-  if (cached) return cached;
-  if (negativeFresh(key) || negativeFresh(providerOnly)) return null;
+  const force = options?.force === true;
+  if (!force) {
+    const cached = freshSnapshot(memoryCache.get(key), LIVE_CACHE_TTL_MS)
+      || freshSnapshot(memoryCache.get(providerOnly), LIVE_CACHE_TTL_MS);
+    if (cached) return cached;
+    if (negativeFresh(key) || negativeFresh(providerOnly)) return null;
+  }
   if (inflight.has(key)) return inflight.get(key);
 
   const task = (async () => {

package/src/runtime/agent/orchestrator/providers/openai-codex-metadata.mjs

@@ -4,7 +4,7 @@
 // Extracted from openai-oauth-ws.mjs, which now owns transport flow only.
 import { createHash } from 'crypto';
 
-export function _cleanMetaString(value) {
+function _cleanMetaString(value) {
     return typeof value === 'string' ? value.trim() : '';
 }
 
@@ -38,7 +38,7 @@ function _codexInstallationId(sendOpts) {
 // The identity block codex rebuilds per request (responses_metadata.rs
 // client_metadata()): never cached on the pooled socket, or a later turn would
 // replay the first turn's identity.
-export function _codexMetadataBase(entry, { poolKey, cacheKey, sendOpts, handshake = false } = {}) {
+function _codexMetadataBase(entry, { poolKey, cacheKey, sendOpts, handshake = false } = {}) {
     const sessionId = _cleanMetaString(sendOpts?.codexSessionId || sendOpts?.session?.codexSessionId || poolKey || cacheKey)
         || 'mixdog-session';
     const threadId = _cleanMetaString(sendOpts?.threadId || sendOpts?.codexThreadId || sendOpts?.session?.threadId || cacheKey || sessionId)

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/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`.