mixdog 0.9.55 → 0.9.59

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

@@ -461,7 +461,7 @@ export class AnthropicOAuthProvider {
             const fresh = loadCredentials();
             if (fresh?.accessToken) {
                 this.credentials = fresh;
-                process.stderr.write(`[anthropic-oauth] Credentials reloaded from disk (mtime change)\n`);
+                if (!process.env.MIXDOG_QUIET_PROVIDER_LOG) process.stderr.write(`[anthropic-oauth] Credentials reloaded from disk (mtime change)\n`);
             }
         }
 
@@ -493,7 +493,7 @@ export class AnthropicOAuthProvider {
         if (disk?.accessToken && disk.accessToken !== currentToken
             && (!disk.expiresAt || disk.expiresAt >= validAfter)) {
             this.credentials = disk;
-            process.stderr.write(`[anthropic-oauth] Credentials reloaded from disk\n`);
+            if (!process.env.MIXDOG_QUIET_PROVIDER_LOG) process.stderr.write(`[anthropic-oauth] Credentials reloaded from disk\n`);
             return disk;
         }
         if (!this.credentials && disk) this.credentials = disk;
@@ -510,13 +510,13 @@ export class AnthropicOAuthProvider {
             const latestValidAfter = Date.now() + (force ? 0 : TOKEN_REFRESH_SKEW_MS);
             if (latest?.accessToken && latest.accessToken !== currentToken
                 && (!latest.expiresAt || latest.expiresAt >= latestValidAfter)) {
-                process.stderr.write(`[anthropic-oauth] Credentials reloaded from disk\n`);
+                if (!process.env.MIXDOG_QUIET_PROVIDER_LOG) process.stderr.write(`[anthropic-oauth] Credentials reloaded from disk\n`);
                 return latest;
             }
 
             if (!latest?.refreshToken) {
                 if (!force && latest?.accessToken && (!latest.expiresAt || latest.expiresAt > Date.now())) {
-                    process.stderr.write(`[anthropic-oauth] WARNING: token expiring but no refresh token; using current token until expiry\n`);
+                    if (!process.env.MIXDOG_QUIET_PROVIDER_LOG) process.stderr.write(`[anthropic-oauth] WARNING: token expiring but no refresh token; using current token until expiry\n`);
                     return latest;
                 }
                 throw new Error('Anthropic OAuth refresh token not available. Open /providers in mixdog to sign in again.');
@@ -525,12 +525,12 @@ export class AnthropicOAuthProvider {
             try {
                 if (!process.env.MIXDOG_QUIET_PROVIDER_LOG) process.stderr.write(`[anthropic-oauth] Token ${reason}, refreshing...\n`);
                 const refreshed = await refreshOAuthCredentials(latest);
-                process.stderr.write(`[anthropic-oauth] Token refreshed, expires in ${Math.round(((refreshed.expiresAt || Date.now()) - Date.now()) / 1000)}s\n`);
+                if (!process.env.MIXDOG_QUIET_PROVIDER_LOG) process.stderr.write(`[anthropic-oauth] Token refreshed, expires in ${Math.round(((refreshed.expiresAt || Date.now()) - Date.now()) / 1000)}s\n`);
                 return refreshed;
             } catch (err) {
                 if (!force && latest?.accessToken && (!latest.expiresAt || latest.expiresAt > Date.now())) {
                     const msg = err instanceof Error ? err.message : String(err);
-                    process.stderr.write(`[anthropic-oauth] Refresh failed (${msg}); using still-valid current token\n`);
+                    if (!process.env.MIXDOG_QUIET_PROVIDER_LOG) process.stderr.write(`[anthropic-oauth] Refresh failed (${msg}); using still-valid current token\n`);
                     return latest;
                 }
                 throw err;

package/src/runtime/agent/orchestrator/providers/media-normalization.mjs

@@ -27,6 +27,17 @@ function geminiInlineInfo(block) {
     return { data, mimeType: cleanMimeType(inline.mimeType || inline.mime_type || inline.mediaType || inline.media_type) };
 }
 
+// Inline document/file part ({ type: 'file', data, mimeType, filename? }) as
+// submitted by the desktop composer (PDF attachments). Providers receive it
+// as their native document shape; estimators must never serialize its base64.
+function fileInfo(block) {
+    if (!block || typeof block !== 'object' || block.type !== 'file') return null;
+    if (typeof block.data !== 'string' || !block.data) return null;
+    const mimeType = String(block.mimeType || block.mediaType || 'application/pdf').trim().toLowerCase() || 'application/pdf';
+    const filename = typeof block.filename === 'string' && block.filename ? block.filename : '';
+    return { data: block.data, mimeType, filename };
+}
+
 function imageUrlFromPart(block) {
     if (!block || typeof block !== 'object') return null;
     if (block.type === 'image_url') {
@@ -100,7 +111,8 @@ function contentParts(content) {
     }
     if (content && typeof content === 'object'
         && (imageUrlFromPart(content) || imageFileIdFromPart(content)
-            || imageFileUriFromPart(content) || geminiInlineInfo(content))) return [content];
+            || imageFileUriFromPart(content) || geminiInlineInfo(content)
+            || fileInfo(content))) return [content];
     return null;
 }
 
@@ -108,7 +120,7 @@ function jsonFallbackFromPart(block) {
     const text = textFromPart(block);
     if (text) return text;
     if (!block || typeof block !== 'object') return block == null ? '' : String(block);
-    if (imageUrlFromPart(block) || imageFileIdFromPart(block) || imageFileUriFromPart(block) || geminiInlineInfo(block)) return '';
+    if (imageUrlFromPart(block) || imageFileIdFromPart(block) || imageFileUriFromPart(block) || geminiInlineInfo(block) || fileInfo(block)) return '';
     return stringifyFallback(block);
 }
 
@@ -170,6 +182,17 @@ export function contentImageDescriptors(content) {
     return parts.map(imageDescriptor).filter(Boolean);
 }
 
+// Byte-free descriptors for inline file/document parts (context estimation).
+export function contentFileDescriptors(content) {
+    const parts = contentParts(content);
+    if (!parts) return [];
+    return parts.flatMap((part) => {
+        const file = fileInfo(part);
+        if (!file) return [];
+        return [{ mimeType: file.mimeType, sizeBytes: Math.floor((file.data.length * 3) / 4) }];
+    });
+}
+
 export function contentToText(content, fallback = '') {
     if (typeof content === 'string') return content;
     const parts = contentParts(content);
@@ -192,6 +215,10 @@ function sanitizePartForStoredHistory(part) {
     if (part.type === 'image' || part.type === 'image_url' || part.type === 'input_image' || imageUrlFromPart(part) || imageFileIdFromPart(part) || imageFileUriFromPart(part) || geminiInlineInfo(part)) {
         return { type: 'text', text: storedHistoryImagePlaceholder(part) };
     }
+    const file = fileInfo(part);
+    if (file) {
+        return { type: 'text', text: `[File omitted from stored history: ${file.filename || file.mimeType}]` };
+    }
     if (Array.isArray(part.content)) {
         const nextContent = sanitizeContentForStoredHistory(part.content);
         if (nextContent !== part.content) return { ...part, content: nextContent };
@@ -217,6 +244,16 @@ export function normalizeContentForAnthropic(content) {
     const parts = contentParts(content);
     if (!parts) return content;
     return parts.map((part) => {
+        const file = fileInfo(part);
+        if (file) {
+            const out = {
+                type: 'document',
+                source: { type: 'base64', media_type: file.mimeType, data: file.data },
+                ...(file.filename ? { title: file.filename } : {}),
+            };
+            if (part.cache_control) out.cache_control = part.cache_control;
+            return out;
+        }
         const info = imageInfo(part);
         if (info) {
             const out = {
@@ -276,6 +313,14 @@ export function normalizeContentForOpenAIChat(content, { role = 'user' } = {}) {
     if (!parts) return content;
     const out = [];
     for (const part of parts) {
+        const file = fileInfo(part);
+        if (file) {
+            out.push({
+                type: 'file',
+                file: { filename: file.filename || 'document.pdf', file_data: `data:${file.mimeType};base64,${file.data}` },
+            });
+            continue;
+        }
         const fileId = imageFileIdFromPart(part);
         if (fileId) {
             out.push({ type: 'text', text: `[unsupported image file_id for OpenAI Chat-compatible request: ${fileId}]` });
@@ -308,6 +353,15 @@ export function normalizeContentForOpenAIResponses(content, { role = 'user' } =
     }
     const out = [];
     for (const part of parts) {
+        const file = fileInfo(part);
+        if (file) {
+            out.push({
+                type: 'input_file',
+                filename: file.filename || 'document.pdf',
+                file_data: `data:${file.mimeType};base64,${file.data}`,
+            });
+            continue;
+        }
         const fileId = imageFileIdFromPart(part);
         if (fileId) {
             out.push({ type: 'input_image', file_id: fileId });
@@ -338,6 +392,11 @@ export function normalizeContentForGeminiParts(content) {
     }
     const out = [];
     for (const part of parts) {
+        const file = fileInfo(part);
+        if (file) {
+            out.push({ inlineData: { mimeType: file.mimeType, data: file.data } });
+            continue;
+        }
         const inlineInfo = geminiInlineInfo(part);
         if (inlineInfo) {
             out.push({ inlineData: { mimeType: inlineInfo.mimeType, data: inlineInfo.data } });

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

@@ -144,6 +144,15 @@ const MAX_OUTPUT_EXHAUSTED_NOTICE = '[mixdog-runtime] Output remained truncated
 // was not done — re-prompt instead of accepting empty as final.
 // Covers Anthropic (pause_turn, max_tokens), OpenAI (length), Gemini
 // (MAX_TOKENS, OTHER), and case variants.
+export function attachAssistantTranscriptMetadata(message, opts = {}) {
+    const transcript = typeof opts.takeAssistantTranscriptMetadata === 'function'
+        ? opts.takeAssistantTranscriptMetadata()
+        : null;
+    if (!transcript) return message;
+    const meta = message?.meta && typeof message.meta === 'object' ? message.meta : {};
+    return { ...message, meta: { ...meta, transcript } };
+}
+
 export async function agentLoop(provider, messages, model, tools, onToolCall, cwd, sendOpts) {
     let iterations = 0;
     let toolCallsTotal = 0;
@@ -253,7 +262,7 @@ export async function agentLoop(provider, messages, model, tools, onToolCall, cw
             ? resp.providerMetadata
             : null;
         if (!content && !reasoningContent && !reasoningItems && !thinkingBlocks) return false;
-        const message = {
+        const message = attachAssistantTranscriptMetadata({
             role: 'assistant',
             content,
             // Anthropic adaptive-thinking signatures must be replayed verbatim
@@ -262,7 +271,7 @@ export async function agentLoop(provider, messages, model, tools, onToolCall, cw
             ...(reasoningItems ? { reasoningItems } : {}),
             ...(reasoningContent ? { reasoningContent } : {}),
             ...(providerMetadata ? { providerMetadata } : {}),
-        };
+        }, opts);
         messages.push(message);
         try { opts.onAssistantMessageCommitted?.(message); } catch {}
         return true;
@@ -781,7 +790,7 @@ export async function agentLoop(provider, messages, model, tools, onToolCall, cw
         // openai-oauth.convertMessagesToResponsesInput emits matching
         // type:'reasoning' input items on the next turn to keep the openai-oauth
         // server-side cache prefix stable.
-        const _assistantTurnMsg = {
+        const _assistantTurnMsg = attachAssistantTranscriptMetadata({
             role: 'assistant',
             // Sub-agent tool-call turns carry only mid-turn preamble in
             // response.content (the real result rides the later final-answer
@@ -805,7 +814,7 @@ export async function agentLoop(provider, messages, model, tools, onToolCall, cw
             ...(response.providerMetadata && typeof response.providerMetadata === 'object'
                 ? { providerMetadata: response.providerMetadata }
                 : {}),
-        };
+        }, opts);
         messages.push(_assistantTurnMsg);
         try { opts.onAssistantMessageCommitted?.(_assistantTurnMsg); } catch {}
         // Hard-cap final turn: tools are disabled but the model still emitted

package/src/runtime/agent/orchestrator/session/compact/engine.mjs

@@ -48,6 +48,37 @@ import {
     RECALL_TAIL_TRUNCATION_MARKER,
     RECALL_TAIL_SHORT_TRUNCATION_MARKER,
 } from './summary.mjs';
+import { buildPostCompactFileAttachment } from './file-reattach.mjs';
+
+// Post-compact file re-attachment (claude-code parity): re-inject fresh reads
+// of files the summarized-away head was working with, when they still fit the
+// budget. Applied identically by the semantic and recall-fasttrack paths.
+// Follows the `Reference files:` + assistant `.` ack convention from
+// session-lifecycle.mjs so provider turn alternation and ingest exclusion
+// both hold. Best-effort: on any failure the plain result stands.
+function withFileReattachment(result, finalTokens, budget, headMessages, tailMessages, cwd) {
+    try {
+        const attachment = buildPostCompactFileAttachment(
+            headMessages,
+            tailMessages,
+            budget - finalTokens,
+            { cwd },
+        );
+        if (!attachment) return { result, finalTokens, reattached: false };
+        const summaryIdx = result.length - tailMessages.length;
+        const augmented = reconcileDedupStubs(dedupToolResultBodies(sanitizeToolPairs([
+            ...result.slice(0, summaryIdx),
+            attachment,
+            { role: 'assistant', content: '.' },
+            ...result.slice(summaryIdx),
+        ])));
+        const augmentedTokens = estimateMessagesTokens(augmented);
+        if (augmentedTokens > budget) return { result, finalTokens, reattached: false };
+        return { result: augmented, finalTokens: augmentedTokens, reattached: true };
+    } catch {
+        return { result, finalTokens, reattached: false };
+    }
+}
 
 const DEFAULT_TAIL_TURNS = 2;
 const COMPACTION_PROMPT_HEADROOM = 0.85;
@@ -433,10 +464,15 @@ export async function semanticCompactMessages(provider, messages, model, budgetT
     // is both measured and emitted in redacted form.
     let result = sanitizeToolPairs([...selected.system, summaryMessage, ...selected.tail]);
     result = reconcileDedupStubs(dedupToolResultBodies(result));
-    const finalTokens = estimateMessagesTokens(result);
+    let finalTokens = estimateMessagesTokens(result);
     if (finalTokens > budget) {
         throw new Error(`semanticCompactMessages: compacted result exceeds budget=${budget} (result=${finalTokens})`);
     }
+    // Re-attach fresh reads of head files. Uses the RAW (pre-ingest-filter)
+    // head so tool_call read paths are visible even on the /compact path.
+    const reattach = withFileReattachment(result, finalTokens, budget, selectedRaw.head, selected.tail, opts.cwd);
+    result = reattach.result;
+    finalTokens = reattach.finalTokens;
     const diagnostics = {
         noOp: false,
         inputMessages: Array.isArray(messages) ? messages.length : 0,
@@ -471,6 +507,7 @@ export async function semanticCompactMessages(provider, messages, model, budgetT
         summaryChars: String(summary || '').length,
         rawSummaryChars: String(rawSummary || '').length,
         summaryRepaired: enforced.repaired === true,
+        fileReattached: reattach.reattached,
         previousSummary: !!selected.previousSummary,
         durationMs: Date.now() - startedAt,
     };
@@ -767,10 +804,13 @@ function _recallFastTrackCompactMessages(messages, budgetTokens, opts = {}) {
 
     let result = sanitizeToolPairs([...safeSystem, summaryMessage, ...recallTail]);
     result = reconcileDedupStubs(dedupToolResultBodies(result));
-    const finalTokens = estimateMessagesTokens(result);
+    let finalTokens = estimateMessagesTokens(result);
     if (finalTokens > budget) {
         throw new Error(`recallFastTrackCompactMessages: compacted result exceeds budget=${budget} (result=${finalTokens})`);
     }
+    const reattach = withFileReattachment(result, finalTokens, budget, recallHead, recallTail, opts.cwd);
+    result = reattach.result;
+    finalTokens = reattach.finalTokens;
     const summaryContent = String(summaryMessage?.content || '');
     const diagnostics = {
         noOp: false,
@@ -807,6 +847,7 @@ function _recallFastTrackCompactMessages(messages, budgetTokens, opts = {}) {
         recallTruncatedInSummary: !!recallFit.recall && !summaryContent.includes(recallFit.recall),
         priorTruncatedInSummary: !!recallFit.prior && !summaryContent.includes(recallFit.prior),
         tailTruncated: recallTail.some((m) => messageContentHasMarker(m, RECALL_TAIL_TRUNCATION_MARKER) || messageContentHasMarker(m, RECALL_TAIL_SHORT_TRUNCATION_MARKER)),
+        fileReattached: reattach.reattached,
         tailOptions: recallTailOpts,
         previousSummary: !!previousSummary,
         durationMs: Date.now() - startedAt,

package/src/runtime/agent/orchestrator/session/compact/file-reattach.mjs

@@ -0,0 +1,112 @@
+// Post-compact file re-attachment (claude-code createPostCompactFileAttachments
+// parity). Files the summarized-away head had `read` are re-read FRESH from
+// disk and re-injected right after the summary message, so the model does not
+// burn a turn (and tokens) re-reading files it was actively working with.
+//  - newest-first, capped at MAX_REATTACH_FILES and per-file/total token caps
+//  - files whose `read` tool_call survives in the preserved tail are skipped
+//    (the model can already see that content — re-injecting is pure waste)
+//  - message shape reuses the existing `Reference files:` user-row convention
+//    (session-lifecycle.mjs), which memory ingest already excludes.
+// Best-effort: any fs/parse failure skips the file, never fails the compact.
+import { readFileSync, statSync } from 'node:fs';
+import { isAbsolute, resolve as resolvePath } from 'node:path';
+import { estimateTokens } from '../context-utils.mjs';
+
+export const MAX_REATTACH_FILES = 3;
+export const REATTACH_MAX_TOKENS_PER_FILE = 5_000;
+export const REATTACH_MAX_TOTAL_TOKENS = 8_000;
+const REATTACH_MIN_ROOM_TOKENS = 1_024;
+const REATTACH_MAX_FILE_BYTES = 512 * 1024;
+
+function reattachDisabled() {
+    return String(process.env.MIXDOG_COMPACT_FILE_REATTACH || '').trim() === '0';
+}
+
+function pathsFromReadArgs(rawArgs) {
+    let args = rawArgs;
+    if (typeof args === 'string') {
+        try { args = JSON.parse(args); } catch { return []; }
+    }
+    if (!args || typeof args !== 'object') return [];
+    const value = args.path;
+    const entries = Array.isArray(value) ? value : [value];
+    const out = [];
+    for (const entry of entries) {
+        if (typeof entry === 'string' && entry.trim()) out.push(entry.trim());
+        else if (entry && typeof entry === 'object' && typeof entry.path === 'string' && entry.path.trim()) {
+            out.push(entry.path.trim());
+        }
+    }
+    return out;
+}
+
+// Ordered (oldest -> newest) file paths read via the `read` tool in `messages`.
+export function collectReadToolPaths(messages) {
+    const out = [];
+    for (const m of Array.isArray(messages) ? messages : []) {
+        if (m?.role !== 'assistant' || !Array.isArray(m.toolCalls)) continue;
+        for (const tc of m.toolCalls) {
+            const name = String(tc?.name || tc?.function?.name || '').toLowerCase();
+            if (name !== 'read') continue;
+            out.push(...pathsFromReadArgs(tc?.arguments ?? tc?.function?.arguments));
+        }
+    }
+    return out;
+}
+
+function truncateToTokenCap(content, cap) {
+    if (estimateTokens(content) <= cap) return content;
+    const marker = '\n[truncated after compaction — Read the full file if needed]';
+    // ~4 chars/token head-keep; iterate down until the estimate fits.
+    let chars = Math.max(0, cap * 4);
+    let out = content.slice(0, chars) + marker;
+    while (chars > 256 && estimateTokens(out) > cap) {
+        chars = Math.floor(chars * 0.8);
+        out = content.slice(0, chars) + marker;
+    }
+    return out;
+}
+
+/**
+ * Build ONE `Reference files:` user message re-attaching the freshest files the
+ * compacted-away head had read, or null when nothing qualifies/fits.
+ * `roomTokens` is the remaining post-compact budget the attachment may use.
+ */
+export function buildPostCompactFileAttachment(headMessages, tailMessages, roomTokens, { cwd } = {}) {
+    if (reattachDisabled()) return null;
+    const room = Math.min(Number(roomTokens) || 0, REATTACH_MAX_TOTAL_TOKENS);
+    if (room < REATTACH_MIN_ROOM_TOKENS) return null;
+    const headPaths = collectReadToolPaths(headMessages);
+    if (headPaths.length === 0) return null;
+    const tailPaths = new Set(collectReadToolPaths(tailMessages));
+    // newest-first unique selection
+    const selected = [];
+    const seen = new Set();
+    for (let i = headPaths.length - 1; i >= 0 && selected.length < MAX_REATTACH_FILES; i -= 1) {
+        const p = headPaths[i];
+        if (seen.has(p) || tailPaths.has(p)) continue;
+        seen.add(p);
+        selected.push(p);
+    }
+    if (selected.length === 0) return null;
+    const sections = [];
+    const prefix = 'Reference files:\n\nRe-attached after compaction (fresh reads of files the summarized history was working with):\n\n';
+    for (const p of selected) {
+        try {
+            const abs = isAbsolute(p) ? p : (cwd ? resolvePath(cwd, p) : null);
+            if (!abs) continue;
+            const stat = statSync(abs);
+            if (!stat.isFile() || stat.size > REATTACH_MAX_FILE_BYTES) continue;
+            const body = truncateToTokenCap(readFileSync(abs, 'utf8'), REATTACH_MAX_TOKENS_PER_FILE);
+            const section = `### ${p}\n\`\`\`\n${body}\n\`\`\``;
+            const candidate = `${prefix}${[...sections, section].join('\n\n')}`;
+            if (estimateTokens(candidate) > room) continue;
+            sections.push(section);
+        } catch { /* unreadable/missing file — skip, never fail the compact */ }
+    }
+    if (sections.length === 0) return null;
+    return {
+        role: 'user',
+        content: `${prefix}${sections.join('\n\n')}`,
+    };
+}