@maudecode/talaria-web 1.16.1 → 1.18.0

package/dist/sessions/merge.js

@@ -3,11 +3,12 @@
  * `_merge_display_messages_after_agent_result`, `_message_identity`,
  * `_extract_tool_calls_from_messages`, `_build_partial_message`).
  */
-import { buildActiveTurnToken } from '../redact.js';
+import { buildActiveTurnToken, completedToolIndex } from '../redact.js';
+import { RunJournal } from './journal.js';
 import { str } from '../util.js';
-import { stripAttachedFilesMarker } from './session.js';
-export const WORKSPACE_PREFIX_RE = /^\s*\[Workspace::v1:\s*(?:\\.|[^\]\\])+\]\s*/;
-const LEGACY_WORKSPACE_PREFIX_RE = /^\s*\[Workspace:[^\]]+\]\s*/;
+import { stripAttachedFilesMarker, stripWorkspacePrefix } from './session.js';
+export { WORKSPACE_PREFIX_RE, stripWorkspacePrefix } from './session.js';
+import { decidedEditDiff, toolEditDiff, toolName } from './tool-display.js';
 const TOOL_RESULT_SNIPPET_MAX = 4000;
 // Python `_TOOL_ARG_CONTENT_KEYS`: file bodies, commands, and patch text keep up to the content cap; incidental args cut at 120.
 export const TOOL_ARG_CONTENT_KEYS = new Set(['command', 'cmd', 'script', 'code', 'patch', 'diff', 'old_string', 'new_string', 'content', 'path', 'file_path']);
@@ -16,16 +17,6 @@ export const isDict = (v) => Boolean(v) && typeof v === 'object' && !Array.isArr
 export function escapeWorkspacePrefixPath(path) {
     return path.replace(/\\/g, '\\\\').replace(/]/g, '\\]');
 }
-export function workspaceContextPrefix(path) {
-    return `[Workspace::v1: ${escapeWorkspacePrefixPath(path)}]\n`;
-}
-export function stripWorkspacePrefix(text, includeLegacy = false) {
-    const value = str(text);
-    let stripped = value.replace(WORKSPACE_PREFIX_RE, '');
-    if (includeLegacy && stripped === value)
-        stripped = value.replace(LEGACY_WORKSPACE_PREFIX_RE, '');
-    return stripped.trim();
-}
 /** Python `_message_text`: flatten string or multimodal content to text. */
 export function isReasoningBlock(part) {
     return part.type === 'reasoning' || part.type === 'thinking';
@@ -55,7 +46,7 @@ export function messageText(content) {
     }
     return str(content);
 }
-export function messageIdentity(msg) {
+export function messageIdentity(msg, textLimit = 500) {
     if (!isDict(msg))
         return null;
     const role = str(msg.role);
@@ -75,7 +66,7 @@ export function messageIdentity(msg) {
         return null;
     }
     const toolCalls = Array.isArray(msg.tool_calls) ? msg.tool_calls : [];
-    return JSON.stringify([role, text.split(/\s+/).join(' ').trim().slice(0, 500), str(msg.tool_call_id), JSON.stringify(sortKeysDeep(toolCalls))]);
+    return JSON.stringify([role, text.split(/\s+/).join(' ').trim().slice(0, textLimit), str(msg.tool_call_id), JSON.stringify(sortKeysDeep(toolCalls))]);
 }
 function sortKeysDeep(value) {
     if (Array.isArray(value))
@@ -226,6 +217,17 @@ export function injectMaxIterationSummaryFallback(messages, finalResponse) {
         return messages;
     return [...messages, { role: 'assistant', content: finalResponse, _max_iteration_summary_fallback: true }];
 }
+/**
+ * TAL-537: the user row the Agent appends to ask for that summary is its own prompt, neither shown nor sent back. It is
+ * the exhausted turn's last user row; any other row with the same text (one the user typed) stays.
+ */
+export function withoutMaxIterationSummaryRequest(messages, request, msgText) {
+    const at = messages.findLastIndex((m) => m.role === 'user');
+    const row = messages[at];
+    if (!request || row?.content !== request || looksLikeCurrentUserTurn(row, msgText))
+        return messages;
+    return messages.filter((_, i) => i !== at);
+}
 export function mergeDisplayMessagesAfterAgentResult(previousDisplay, previousContext, resultMessages, msgText, opts = {}) {
     const display = previousDisplay.filter((m) => !isContextCompressionMarker(m));
     const seenPartial = new Set();
@@ -670,26 +672,70 @@ export function withToolCallOutcomes(messages, sessionToolCalls, activeTurnId) {
         if (!calls.length && !records.length)
             return m;
         const running = Boolean(activeTurnId) && m._turn_id === activeTurnId;
-        const resolve = (id, rec, answered) => {
+        const resolve = (id, name, rec, answered) => {
             const reply = id ? replies.get(key(index, id)) : undefined;
             const outcome = reply ? { ...toolOutcome(reply.content), flagged: reply.is_error } : null;
+            // TAL-448: a file edit's change, from its full reply, else the one its live record decided.
+            const editDiff = reply ? toolEditDiff(name, reply.content) : decidedEditDiff(rec?.edit_diff);
             return {
+                ...(editDiff ? { edit_diff: editDiff } : {}),
                 done: Boolean(reply) || answered || !running, is_error: outcome ? outcome.flagged || outcome.is_error : rec?.is_error === true,
                 duration: finiteOrNull(rec?.duration), result: outcome ? outcome.result_text : typeof rec?.snippet === 'string' ? rec.snippet : null,
                 result_view: outcome ? outcome.result_view : isDict(rec?.result_view) ? decidedResultView(rec.result_view) : typeof rec?.snippet === 'string' ? toolResultView(rec.snippet) : null,
             };
         };
         const projected = [
-            ...calls.map((call) => (isDict(call) ? { ...call, ...resolve(callId(call), recorded.get(callId(call)), false) } : call)),
+            ...calls.map((call) => (isDict(call) ? { ...call, ...resolve(callId(call), toolName(call), recorded.get(callId(call)), false) } : call)),
             ...records.map((tc) => ({
                 ...(str(tc.tid) ? { id: str(tc.tid) } : {}), type: 'function', function: { name: str(tc.name), arguments: JSON.stringify(tc.args ?? {}) },
                 // A session-level entry was answered; a live call says whether it completed.
-                ...resolve(str(tc.tid), tc, typeof tc.done === 'boolean' ? tc.done : true),
+                ...resolve(str(tc.tid), tc.name, tc, typeof tc.done === 'boolean' ? tc.done : true),
             })),
         ];
         return { ...m, tool_calls: projected };
     });
 }
+/** The prompt text naming every attached file by path after it (TAL-276), so an attachment-only turn still asks something. */
+export function attachedFilesPrompt(text, attachments) {
+    const named = attachments.map((att) => (isDict(att) ? str(att.path).trim() : '')).filter(Boolean).map(escapeWorkspacePrefixPath);
+    return named.length ? `${text}\n\n[Attached files: ${named.join(', ')}]` : text;
+}
+const TOOL_IMAGE_PART_TYPES = new Set(['image', 'image_url', 'input_image']);
+/**
+ * TAL-544, Python `_compact_image_parts_for_persistence`: a settled turn's tool-result images (browser and vision
+ * screenshots) become `[screenshot]` text, so saves, loads and later turns stop carrying the base64. A result is a `tool`
+ * row or an Anthropic-style `tool_result` block in a user row; the user's own attachments stay.
+ */
+export function withoutToolImages(messages) {
+    const isImage = (p) => isDict(p) && TOOL_IMAGE_PART_TYPES.has(p.type);
+    const hasImage = (parts) => Array.isArray(parts) && parts.some(isImage);
+    const compact = (parts) => parts.map((p) => (isImage(p) ? { type: 'text', text: '[screenshot]' } : p));
+    const isImageResult = (p) => isDict(p) && p.type === 'tool_result' && hasImage(p.content);
+    const out = messages.map((m) => {
+        const content = m.content;
+        if (m.role === 'tool' && hasImage(content))
+            return { ...m, content: compact(content) };
+        if (m.role === 'user' && Array.isArray(content) && content.some(isImageResult)) {
+            return { ...m, content: content.map((p) => (isImageResult(p) ? { ...p, content: compact(p.content) } : p)) };
+        }
+        return m;
+    });
+    // The same array when nothing changed, so a caller can tell whether its rows were rewritten.
+    return out.some((m, i) => m !== messages[i]) ? out : messages;
+}
+/** A settled model context without an assistant row repeated back to back, and without tool-result images. */
+export function dedupeContext(messages) {
+    const out = [];
+    let lastKey = null;
+    for (const m of withoutToolImages(messages)) {
+        const key = messageIdentity(m);
+        if (key !== null && key === lastKey && m.role === 'assistant')
+            continue;
+        out.push(m);
+        lastKey = key;
+    }
+    return out;
+}
 /** Python `_build_partial_message`. */
 export function buildPartialMessage(contentText, reasoningText, toolCalls, now = Date.now() / 1000) {
     let stripped = '';
@@ -709,6 +755,69 @@ export function buildPartialMessage(contentText, reasoningText, toolCalls, now =
         msg._partial_tool_calls = [...toolCalls];
     return msg;
 }
+/**
+ * TAL-536: a dead run's journaled output as partial rows, in order: each row is a stretch of reasoning and prose with the
+ * tool calls that followed it, the shape a Stop's snapshot keeps. A run that ended in `done` gets its answer as a settled
+ * row: its last prose row, else the one the `done` frame's session carries (an answer that never streamed, like the
+ * tool-limit summary). `answered` says the run finished with one.
+ */
+export function journalOutputRows(events, turnId) {
+    const rows = [];
+    const calls = [];
+    let text = '';
+    let reasoning = '';
+    let tools = [];
+    let at = 0;
+    const flush = () => {
+        const row = buildPartialMessage(text, reasoning, tools, at);
+        if (row)
+            rows.push({ ...row, _turn_id: turnId });
+        text = '';
+        reasoning = '';
+        tools = [];
+    };
+    for (const e of events) {
+        const p = isDict(e.payload) ? e.payload : {};
+        if ((e.event === 'token' || e.event === 'reasoning') && tools.length)
+            flush();
+        if (e.event === 'token')
+            text += str(p.text);
+        else if (e.event === 'reasoning')
+            reasoning += str(p.text);
+        else if (e.event === 'tool') {
+            const call = { name: p.name, args: p.args ?? {}, tid: str(p.id), done: false };
+            calls.push(call);
+            tools.push(call);
+        }
+        else if (e.event === 'tool_complete') {
+            // The record is shared with the row that holds it, so a completion after its row closed still lands.
+            const call = calls[completedToolIndex(calls, str(p.id), p.name)];
+            if (call)
+                Object.assign(call, { done: true, snippet: p.preview, is_error: p.is_error === true, duration: p.duration ?? null, ...(isDict(p.result_view) ? { result_view: p.result_view } : {}), ...(isDict(p.edit_diff) ? { edit_diff: p.edit_diff } : {}) });
+        }
+        else
+            continue;
+        at = e.created_at || at;
+    }
+    flush();
+    const done = RunJournal.selectAuthoritativeTerminalEvent(events);
+    if (done?.event !== 'done')
+        return { rows, answered: false };
+    // The last row answers only with visible prose and no calls after it (a reasoning-only segment is no answer).
+    const last = rows[rows.length - 1];
+    if (last && !last._partial_tool_calls && str(last.content)) {
+        delete last._partial;
+        return { rows, answered: true };
+    }
+    const settled = isDict(done.payload) && isDict(done.payload.session) && Array.isArray(done.payload.session.messages) ? done.payload.session.messages : [];
+    const answer = settled.findLast((m) => isDict(m) && m.role === 'assistant' && m._turn_id === turnId);
+    // Its visible prose, from string or structured content, as the scene's final answer reads it.
+    const content = answer && !answer._error && !(Array.isArray(answer.tool_calls) && answer.tool_calls.length) ? splitDisplayText(messageText(answer.content))[0] : '';
+    if (!content)
+        return { rows, answered: false };
+    rows.push({ role: 'assistant', content, timestamp: Math.trunc(done.created_at), _turn_id: turnId });
+    return { rows, answered: true };
+}
 const DSML = '(?:\\s*｜\\s*DSML\\s*[｜|]\\s*)?';
 /** Markdown code (fenced blocks, an unclosed one running to the end, and inline spans): markup written there is literal. */
 function codeRanges(text) {
@@ -833,6 +942,9 @@ export function normalizeAssistantDisplay(message) {
  * replay): rows at or before it, and, for a truncation cut, rows after it until the sidecar advances past it (TAL-504).
  * A compression watermark only covers the compressed rows. Rows past the sidecar tail (a conversation continued from the
  * CLI) are appended in state.db order.
+ * TAL-493: once a boundary or settled turn recorded the highest state.db id it read (`stateDbSeenId`) and the rows carry
+ * ids, identity replaces the timestamp rules: rows up to that id are covered, and every newer row not already in the
+ * sidecar is appended, even one a writer stamped before the newest local row or the watermark but committed later.
  * ponytail: the Python identity memo (api_content sidecars, message ids, workspace-prefix normalisation) is not ported;
  * add it if a mixed WebUI/CLI transcript shows duplicated turns.
  */
@@ -843,6 +955,31 @@ export function mergeSessionMessagesAppendOnly(sidecar, state, opts = {}) {
         return sidecar;
     const ts = (m) => { const n = Number(m.timestamp); return Number.isFinite(n) ? n : null; };
     const key = (m) => `${String(m.role)}\0${String(ts(m) ?? '')}\0${typeof m.content === 'string' ? m.content : JSON.stringify(m.content ?? null)}`;
+    const seenId = opts.stateDbSeenId;
+    if (typeof seenId === 'number' && Number.isFinite(seenId) && state.some((m) => stateDbRowId(m) !== null)) {
+        // Each local row stands for at most one new state.db row: a persisted copy by its id, any other by its key.
+        const localIds = new Set(sidecar.map(stateDbRowId));
+        const localKeys = new Map();
+        for (const m of sidecar)
+            if (stateDbRowId(m) === null)
+                localKeys.set(key(m), (localKeys.get(key(m)) ?? 0) + 1);
+        const merged = [...sidecar];
+        for (const m of state) {
+            const id = stateDbRowId(m);
+            if (id !== null && localIds.has(id))
+                continue;
+            // In state.db order, so a covered row matches its own local copy before a newer duplicate can.
+            const left = localKeys.get(key(m)) ?? 0;
+            if (left > 0) {
+                localKeys.set(key(m), left - 1);
+                continue;
+            }
+            if (id === null || id <= seenId)
+                continue;
+            merged.push(m);
+        }
+        return merged;
+    }
     if (!sidecar.length) {
         if (!hasWatermark) {
             const seen = new Set();
@@ -877,6 +1014,21 @@ export function mergeSessionMessagesAppendOnly(sidecar, state, opts = {}) {
     }
     return merged;
 }
+/** The state.db row id a row was read with (a compaction copy reads as the row it copies; TAL-709), or null for a database without the column. */
+function stateDbRowId(m) {
+    const id = m._state_db_row_id;
+    return typeof id === 'number' && Number.isFinite(id) ? id : null;
+}
+/** TAL-493: the `state_db_seen_id` after reading `rows`: their highest id, or null when they carry none. */
+export function stateDbSeenId(rows) {
+    let max = null;
+    for (const m of rows) {
+        const id = stateDbRowId(m);
+        if (id !== null && (max === null || id > max))
+            max = id;
+    }
+    return max;
+}
 /**
  * TAL-316: the merged transcript without the running turn's output, which the run journal replays from its start. The turn
  * begins at its checkpointed prompt, else at its first stamped row or the first state.db row appended past the sidecar
@@ -1066,7 +1218,8 @@ export function stoppedTurnContext(previousContext, checkpoint, prompt, msgText,
     // A tool result is a `tool` row or an Anthropic-style user row of `tool_result` blocks. A steer the Agent applied is
     // neither a prompt nor a result: the boundary goes after it, and it never makes the turn look unanswered.
     const toolResult = (m) => m?.role === 'tool' || (m?.role === 'user' && Array.isArray(m.content) && m.content.some((part) => isDict(part) && part.type === 'tool_result'));
-    const tail = () => sanitizeMessagesForApi(rows.filter((m) => agentSteerText(m) === null)).at(-1);
+    // The next turn's own history projection, so an answer the Agent replays from `api_content` counts.
+    const tail = () => sanitizeMessagesForApi(rows.filter((m) => agentSteerText(m) === null), { preserveApiContent: true }).at(-1);
     if (toolResult(tail()))
         rows.push({ role: 'assistant', content: unsettled || 'Operation interrupted.' });
     else if (unsettled)
@@ -1091,6 +1244,10 @@ export function agentSteerText(m) {
         return inner.trim();
     return m.display_kind === 'steer' ? content.trim() : null;
 }
+/** The Agent's `api_content` replay sidecar: the exact bytes a user/assistant row was sent as, else undefined. */
+function apiContent(msg) {
+    return (msg.role === 'user' || msg.role === 'assistant') && typeof msg.api_content === 'string' && msg.api_content ? msg.api_content : undefined;
+}
 /** Python `_is_reasoning_only_assistant_message`: a display-only Thinking card with no visible reply. */
 function isReasoningOnlyAssistant(msg) {
     if (msg.role !== 'assistant' || (Array.isArray(msg.tool_calls) && msg.tool_calls.length))
@@ -1115,8 +1272,10 @@ function stripOobBlocks(content) {
  * reasoning-only assistants), orphaned tool rows and unanswered tool calls, keeps only API-safe keys, strips consumed
  * out-of-band blocks, and keeps a cancelled (`_recovered`) user prompt only where it separates two assistant turns —
  * otherwise the neighbours fuse cleanly or the prompt is stale, and replaying it would answer it again.
+ * `preserveApiContent` (Python `_sanitize_messages_for_agent`) keeps the Agent's `api_content` replay sidecar on
+ * user/assistant rows and every row's `timestamp` for turn history; compression and other projections strip both.
  */
-export function sanitizeMessagesForApi(messages) {
+export function sanitizeMessagesForApi(messages, { preserveApiContent = false } = {}) {
     // Calls are OpenAI `tool_calls` or Anthropic-style `tool_use` content blocks; results name them by `tool_call_id`,
     // `tool_use_id`, or a user row's `tool_result` blocks.
     const toolUseIds = (msg) => (Array.isArray(msg.content) ? msg.content.flatMap((part) => (isDict(part) && part.type === 'tool_use' && str(part.id) ? [str(part.id)] : [])) : []);
@@ -1136,7 +1295,9 @@ export function sanitizeMessagesForApi(messages) {
     for (const msg of messages) {
         if (!msg || typeof msg !== 'object')
             continue;
-        if (isReasoningOnlyAssistant(msg))
+        // A reasoning-only clean stop the Agent answered from `api_content` is a reply, not a Thinking card.
+        const replay = preserveApiContent ? apiContent(msg) : undefined;
+        if (isReasoningOnlyAssistant(msg) && !replay)
             continue;
         // The Agent already received a steer mid-turn; its persisted row is display-only.
         if (msg._error || isDict(msg._steer))
@@ -1152,6 +1313,12 @@ export function sanitizeMessagesForApi(messages) {
         const sanitized = Object.fromEntries(Object.entries(msg).filter(([k]) => API_SAFE_MSG_KEYS.has(k)));
         if (Array.isArray(sanitized.tool_calls) && !sanitized.tool_calls.length)
             Reflect.deleteProperty(sanitized, 'tool_calls');
+        if (replay)
+            sanitized.api_content = replay;
+        // TAL-681: the Agent re-inserts turn history when it prunes and keys display dedupe on the row timestamp, so turn
+        // history keeps it (persistence-only: the Agent strips it before the provider call).
+        if (preserveApiContent && msg.timestamp != null)
+            sanitized.timestamp = msg.timestamp;
         if (recovered)
             sanitized._recovered = true;
         if ('content' in sanitized)
@@ -1174,7 +1341,7 @@ export function sanitizeMessagesForApi(messages) {
                 continue;
             msg = { ...msg, content: parts };
             // Reasoning left behind by a dropped call is not an answer either.
-            if (isReasoningOnlyAssistant(msg))
+            if (isReasoningOnlyAssistant(msg) && !apiContent(msg))
                 continue;
         }
         if (msg.role === 'assistant' && Array.isArray(msg.tool_calls) && msg.tool_calls.length) {
@@ -1203,4 +1370,33 @@ export function sanitizeMessagesForApi(messages) {
     }
     return final;
 }
+const isNativeImagePart = (part) => isDict(part) && (part.type === 'image_url' || 'image_url' in part);
+/** True when any row's content carries a native `image_url` part. */
+export function hasNativeImages(messages) {
+    return messages.some((msg) => Array.isArray(msg.content) && msg.content.some(isNativeImagePart));
+}
+/**
+ * Python `_strip_native_image_parts_from_content` (TAL-545): the history for a turn whose image mode resolved to text.
+ * Native `image_url` parts are dropped and the text kept; a lone text part collapses to its string, as a text-only
+ * provider rejects a replayed image before the Agent's own strip-and-retry guard can recover.
+ */
+export function withoutNativeImages(messages) {
+    return messages.map((msg) => {
+        if (!Array.isArray(msg.content) || !msg.content.some(isNativeImagePart))
+            return msg;
+        const parts = msg.content.filter((part) => isDict(part) && !isNativeImagePart(part));
+        const content = !parts.length ? '' : parts.length === 1 && parts[0].type === 'text' ? str(parts[0].text) : parts;
+        return { ...msg, content };
+    });
+}
+/**
+ * TAL-545: the image-free history is one request's projection, never the session's. The Agent hands the history it got
+ * back ahead of its own rows, so each row it returned exactly as sent (`sent[i]`, stripped from `original[i]`) is swapped
+ * back for the original; a row the Agent rewrote stays its own.
+ */
+export function withNativeImagesRestored(rows, sent, original) {
+    if (sent === original)
+        return rows;
+    return rows.map((row, i) => (i < sent.length && sent[i] !== original[i] && JSON.stringify(row) === JSON.stringify(sent[i]) ? original[i] : row));
+}
 //# sourceMappingURL=merge.js.map