mixdog 1.2.1 → 1.2.3

package/src/runtime/shared/llm/provider-model-identities.mjs

@@ -1,6 +1,7 @@
 // Model identities are shared by transport and pricing. Keep this module
 // independent of credentials, tracing and provider initialization.
-function fallbackModel(id, display, family, contextWindow, wire) {
+// `levels` names the thinkingLevel values a single-wire model takes.
+function fallbackModel(id, display, family, contextWindow, wire, levels = []) {
   const tiered = wire && typeof wire === 'object';
   return {
     id,
@@ -12,7 +13,7 @@ function fallbackModel(id, display, family, contextWindow, wire) {
     supportsVision: true,
     supportsReasoning: true,
     supportsFunctionCalling: true,
-    reasoningLevels: tiered ? Object.keys(wire) : [],
+    reasoningLevels: tiered ? Object.keys(wire) : [...levels],
     wire,
   };
 }
@@ -27,8 +28,16 @@ export const ANTIGRAVITY_MODELS = Object.freeze([
     low: 'gemini-3.1-pro-low',
     high: 'gemini-3.1-pro-high',
   }),
-  fallbackModel('claude-opus-4-6-thinking', 'Claude Opus 4.6 (Thinking)', null, 250000, 'claude-opus-4-6-thinking'),
-  fallbackModel('claude-sonnet-4-6', 'Claude Sonnet 4.6 (Thinking)', null, 250000, 'claude-sonnet-4-6'),
+  fallbackModel('claude-opus-4-6-thinking', 'Claude Opus 4.6 (Thinking)', null, 250000, 'claude-opus-4-6-thinking', [
+    'low',
+    'medium',
+    'high',
+  ]),
+  fallbackModel('claude-sonnet-4-6', 'Claude Sonnet 4.6 (Thinking)', null, 250000, 'claude-sonnet-4-6', [
+    'low',
+    'medium',
+    'high',
+  ]),
   fallbackModel('gpt-oss-120b-medium', 'GPT-OSS 120B (Medium)', 'gpt-oss', 131072, 'gpt-oss-120b-medium'),
 ]);
 

package/src/runtime/shared/llm/usage-accounting.mjs

@@ -8,6 +8,7 @@ import { currentProviderAccountId } from '../provider-auth-binding.mjs';
 // fallback, catalog retry) runs its own accounting and its result or error
 // then returns through the enclosing send, which must not write it again.
 const recorded = new WeakSet();
+const UNMEASURED_USAGE = Object.freeze({ inputTokens: null, inputTokensKnown: false });
 const hasTokens = (usage) =>
   ['inputTokens', 'outputTokens', 'cachedTokens', 'cacheWriteTokens'].some((key) => Number(usage?.[key]) > 0);
 // One rule for every reported usage object: tokens, or a provider-reported
@@ -51,7 +52,9 @@ export async function accountProviderSend(provider, instance, send, model, opts
   // abandoned attempt or a failure shares that clock with the final attempt,
   // so timing it too would count the same seconds twice and understate speed.
   const record = async (result, id, owner, timed) => {
-    if (!result?.usage) return;
+    // A completed call that reported no usage is still a call: it is recorded
+    // as unmeasured (unknown input, unpriced) instead of vanishing from totals.
+    if (!result?.usage && !(timed && result && typeof result === 'object')) return;
     // A nested send (e.g. a fallback model re-send) already stamped its own
     // final attempt's tier; the outer context only saw the abandoned attempt.
     result.requestServiceTier ??= identity.requestServiceTier || '';
@@ -59,7 +62,7 @@ export async function accountProviderSend(provider, instance, send, model, opts
     if (openingError) throw openingError;
     if (!ledger) return;
     recorded.add(owner);
-    const usage = result.usage;
+    const usage = result.usage || UNMEASURED_USAGE;
     const row = makeUsageRecord({
       id: result.responseId ? undefined : id,
       ts: Date.now(),

package/src/runtime/shared/llm/usage-ledger-rollup.mjs

@@ -61,6 +61,8 @@ const add = (target, row) => {
     costBilled: row.cost_source === 'provider' ? row.cost_usd : 0,
     costEstimated: row.cost_source === 'provider' ? 0 : row.cost_usd,
   });
+  // A call recorded without provider usage is unmeasured whatever its provider.
+  if (row.unmeasured && !usage.unmeasuredTurns) usage.unmeasuredTurns = usage.turns || 0;
   for (const field of [
     'turns',
     'input',
@@ -311,6 +313,7 @@ export function readSessionUsage(db, sessionIds) {
                     json_extract(r.signature,'$[1]') AS model,
                     json_extract(r.signature,'$[4]') AS cost_source,
                     json_extract(r.signature,'$[7]') AS rank,
+                    COALESCE(json_extract(json_extract(r.signature,'$[5]'),'$.inputTokensKnown'),1)=0 AS unmeasured,
                     m.turns,m.input,m.output,m.cache_read,m.cache_write,m.cost_usd,m.duration_ms,
                     m.speed_output,m.speed_ms
                 FROM mine m JOIN usage_routes r ON r.id=m.route

package/src/runtime/shared/llm/usage-rollup.mjs

@@ -59,7 +59,6 @@ const MAX_SESSION_TOKENS_PER_DAY = 400;
 const DAY_MS = 24 * 60 * 60 * 1000;
 const UNSAFE_KEYS = new Set(['__proto__', 'constructor', 'prototype']);
 
-// Shared with usage-session-history.mjs, which folds the same bucket shape.
 export function num(value) {
   const n = Number(value);
   return Number.isFinite(n) && n > 0 ? n : 0;

package/src/runtime/shared/loopback-listener.mjs

@@ -9,6 +9,15 @@ export function createLoopbackListener({
   let current = null;
   let closing = null;
 
+  // close() drops only the keep-alive sockets idle at that moment; one whose
+  // in-flight response ends later would hold the close for the server's whole
+  // keepAliveTimeout (~5 s). Drop each as its response settles while stopping.
+  server.on('request', (_req, res) => {
+    res.once('close', () => {
+      if (closing) server.closeIdleConnections();
+    });
+  });
+
   function start() {
     if (closing) return Promise.reject(new Error('HTTP listener is stopping'));
     if (current) return current.promise;

package/src/runtime/shared/model-display.mjs

@@ -3,6 +3,19 @@
  * No I/O, catalog, or gateway imports — safe for static TUI bundling.
  */
 
+const titleCaseOption = (value) =>
+  String(value || '')
+    .split(/([\s_-]+)/)
+    .map((part) => (/^[\s_-]+$/.test(part) ? part : `${part.charAt(0).toUpperCase()}${part.slice(1).toLowerCase()}`))
+    .join('');
+
+export const effortDisplayLabel = (value) => {
+  const text = String(value || '').trim();
+  if (!text) return '';
+  if (text.toLowerCase() === 'xhigh') return 'XHigh';
+  return titleCaseOption(text);
+};
+
 export function titleModelPart(part) {
   const text = String(part || '').trim();
   if (!text) return '';

package/src/runtime/shared/provider-api-key.mjs

@@ -72,12 +72,14 @@ export function getAgentApiKey(provider) {
 /** The one API-key resolver for key-based providers: an explicit config key
  *  wins, otherwise the environment/keychain (getAgentApiKey). */
 export function resolveProviderApiKey(provider, config) {
+  if (config?.apiKeyEnv) return process.env[config.apiKeyEnv] || '';
   return config?.apiKey || getAgentApiKey(provider) || '';
 }
 
 /** Auth-error reload: the stored/environment key is re-read first so a
  *  rotated key beats the stale one captured in config. */
 export function reloadProviderApiKey(provider, config) {
+  if (config?.apiKeyEnv) return process.env[config.apiKeyEnv] || '';
   return getAgentApiKey(provider) || config?.apiKey || '';
 }
 

package/src/runtime/shared/quota-resume-store.mjs

@@ -236,6 +236,17 @@ export function forgetQuotaSuspendedGoal(sessionId) {
   return true;
 }
 
+/** Whether a session record belongs to a delegated agent child (declared
+ *  agent-only visibility, or a legacy non-Lead agent-owned child with a distinct
+ *  parent). Such a session never owns a quota resume: the Lead decides retries. */
+export function isAgentOnlySession(session) {
+  if (!session || typeof session !== 'object') return false;
+  const lower = (value) => text(value).toLowerCase();
+  if (lower(session.visibility) === 'agent-only') return true;
+  const parentId = text(session.parentSessionId || session.ownerSessionId);
+  return lower(session.owner) === 'agent' && lower(session.agent) !== 'lead' && parentId !== '' && parentId !== text(session.id);
+}
+
 /** Global setting, default on. */
 export function quotaAutoResumeEnabled() {
   return readSection(SETTING_SECTION)?.autoResume !== false;

package/src/runtime/shared/review-diff.mjs

@@ -1,5 +1,57 @@
 const TRUNCATED = '… [diff truncated for display]';
 
+// Review replies always list every changed file with its counts. Patch text
+// is carried per file within these caps (UTF-8 bytes); a file past either one
+// is listed `patchOmitted` with reason PATCH_TOO_LARGE and is read on its own,
+// up to the larger "show anyway" cap, when it is opened.
+/** Largest single-file patch a review reply carries inline. */
+export const REVIEW_FILE_PATCH_MAX_BYTES = 1024 * 1024;
+/** Largest total patch text a review reply carries. */
+export const REVIEW_PATCH_MAX_BYTES = 2 * 1024 * 1024;
+/** Largest single-file patch a file-patch read returns. */
+export const REVIEW_FILE_PATCH_SHOW_MAX_BYTES = 8 * 1024 * 1024;
+export const PATCH_TOO_LARGE = 'too_large';
+
+/** A reply file listed with its counts but without its patch, for size. */
+export function patchOmittedFile(file) {
+  return { ...file, patchOmitted: true, reason: PATCH_TOO_LARGE };
+}
+
+/** A `diff --git` section (string or Buffer) whose hunks boundReviewPatch cut. */
+export function reviewSectionTruncated(section) {
+  return section.includes(TRUNCATED);
+}
+
+/** Nothing of the reply's patch fit: no patch text, a file omitted for size. */
+export function reviewDiffTooLarge(files, patch) {
+  return !patch && (files || []).some((file) => file?.patchOmitted === true && file.reason === PATCH_TOO_LARGE);
+}
+
+/** The per-file and total caps of one reply. `admit(bytes)` takes a patch of
+ *  that size from the remaining total, or refuses it. */
+export function createReviewPatchBudget(total = REVIEW_PATCH_MAX_BYTES) {
+  let remaining = total;
+  return {
+    get remaining() {
+      return remaining;
+    },
+    admit(bytes) {
+      if (bytes > REVIEW_FILE_PATCH_MAX_BYTES || bytes > remaining) return false;
+      remaining -= bytes;
+      return true;
+    },
+  };
+}
+
+/** One file-patch read's reply: its patch, or none when past `maxBytes`. */
+export function filePatchReply(path, patch, maxBytes = REVIEW_FILE_PATCH_SHOW_MAX_BYTES) {
+  const text = typeof patch === 'string' ? patch : '';
+  if (Buffer.byteLength(text, 'utf8') > maxBytes) {
+    return { supported: true, path, patch: '', patchOmitted: true, reason: PATCH_TOO_LARGE };
+  }
+  return { supported: true, path, patch: text };
+}
+
 /** Bound hunk bodies, never the inventory of changed files. Headers are kept
  * even when the inventory itself exceeds the display budget. */
 export function boundReviewPatch(patch, maxChars) {