@maudecode/talaria-web 1.15.0 → 1.17.2

package/dist/sessions/merge.d.ts

@@ -1,4 +1,6 @@
+import { type JournalEvent } from './journal.js';
 import { type Message } from './session.js';
+import type { MediaProjection } from '../workspace/media-refs.js';
 export declare const WORKSPACE_PREFIX_RE: RegExp;
 export declare const TOOL_ARG_CONTENT_KEYS: Set<string>;
 export declare const TOOL_ARG_CONTENT_CAP = 4000;
@@ -11,9 +13,21 @@ export declare function isReasoningBlock(part: Record<string, unknown>): boolean
 /** The text of a structured reasoning or thinking content block. */
 export declare function reasoningBlockText(part: Record<string, unknown>): string;
 export declare function messageText(content: unknown): string;
-export declare function messageIdentity(msg: unknown): string | null;
+export declare function messageIdentity(msg: unknown, textLimit?: number): string | null;
 export declare function messagesHavePrefix(messages: unknown[], prefix: unknown[]): boolean;
+export type MarkerKind = 'context_compaction' | 'preserved_task_list';
+/**
+ * TAL-305: the one rule for the marker rows the Agent writes around context compaction. A flagged row, or a user or
+ * assistant row starting `[context compaction`, is a compaction summary; a user row starting with the preserved-task-list
+ * line is that list. Both ignore case and leading whitespace; prose that merely mentions compaction is no marker.
+ */
+export declare function markerKind(msg: unknown): MarkerKind | null;
 export declare function isContextCompressionMarker(msg: unknown): boolean;
+/**
+ * TAL-305: stamps `_marker_kind` on marker rows, and `_marker_body` (the list without its marker line) on a preserved
+ * task list, so clients render a marker card instead of a message. Returns copies; stored rows are untouched.
+ */
+export declare function withMarkerKinds<T>(messages: T[]): T[];
 export declare function looksLikeCurrentUserTurn(msg: unknown, msgText: string): boolean;
 export declare function findCurrentUserTurn(messages: unknown[], msgText: string): number | null;
 /** `attachments`: the turn's files, which let an attachment-only prompt (no text to match) open its own user row (TAL-276). */
@@ -33,17 +47,42 @@ export declare function sessionLacksFinalAssistantAnswer(messages: Message[]): b
  * explanation can live only in `final_response`, so it is appended as the turn's assistant answer.
  */
 export declare function injectMaxIterationSummaryFallback(messages: Message[], finalResponse: string): Message[];
+/**
+ * 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 declare function withoutMaxIterationSummaryRequest(messages: Message[], request: string, msgText: string): Message[];
 export declare function mergeDisplayMessagesAfterAgentResult(previousDisplay: Message[], previousContext: Message[], resultMessages: Message[], msgText: string, opts?: MergeOptions): Message[];
 export declare function toolResultSnippet(raw: unknown, limit?: number): string;
 export declare function truncateToolArgs(args: unknown, limit?: number): Record<string, string>;
+/** A tool result's display sections (TAL-315); clients label and render the fields present, in this order. */
+export interface ToolResultView {
+    text?: string;
+    stdout?: string;
+    stderr?: string;
+    error?: string;
+    exit_code?: number;
+}
+/**
+ * The server's one result view rule (TAL-315), ported from the iOS formatter so every client renders the same sections:
+ * a JSON result (nested JSON strings unwrapped, escaped line breaks undone) with `output`/`stdout`/`stderr` maps to its
+ * terminal sections; any other object shows the first readable `result`, `results`, `preview`, `content`, `text`,
+ * `message`, `summary`, `data` or `items`, else its `error` and exit code, else pretty JSON. A list of text parts joins
+ * by line; a scalar shows as text, and a result that is not JSON exactly as written. Each field is capped like the snippet
+ * (`limit`; TAL-331's whole-result read passes `Infinity`).
+ */
+export declare function toolResultView(raw: unknown, limit?: number): ToolResultView;
+/** A view the server already decided (a built scene row, or one stored with its scene): its known fields, capped. */
+export declare function decidedResultView(value: Record<string, unknown>): ToolResultView;
 /**
  * The server's one tool outcome rule (TAL-313), for a live `raw_result` and a persisted tool-role content alike: a result
  * is an error when it parses to an object with a non-empty `error`, a non-zero numeric `exit_code` / `exitCode`, or
- * `success: false`. `result_text` is the result's display snippet.
+ * `success: false`. `result_text` is the result's display snippet; `result_view` its display sections (TAL-315).
  */
 export declare function toolOutcome(raw: unknown): {
     is_error: boolean;
     result_text: string;
+    result_view: ToolResultView;
 };
 /**
  * Python `_extract_tool_calls_from_messages`, plus each call's outcome (TAL-313): `is_error` by `toolOutcome` of its
@@ -57,25 +96,73 @@ export declare function extractToolCallsFromMessages(messages: unknown[], liveTo
  * a call only the session-level list recorded joins the row at its `assistant_msg_idx`, a failed or cancelled turn's
  * partial snapshot shows the live calls it kept, and every call carries `done`
  * (answered, or outside the running turn), `is_error` (`toolOutcome` of its result, else the recorded value), `duration`
- * (recorded live, else `null`) and `result` (the result snippet, else `null`). Returns copies; stored rows are untouched.
+ * (recorded live, else `null`), `result` (the result snippet, else `null`) and `result_view` (its display sections, TAL-315,
+ * else `null`). Returns copies; stored rows are untouched.
  */
 export declare function withToolCallOutcomes<T>(messages: T[], sessionToolCalls: unknown[], activeTurnId: string | null): T[];
+/** The prompt text naming every attached file by path after it (TAL-276), so an attachment-only turn still asks something. */
+export declare function attachedFilesPrompt(text: string, attachments: readonly unknown[]): string;
+/**
+ * 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 declare function withoutToolImages(messages: Message[]): Message[];
+/** A settled model context without an assistant row repeated back to back, and without tool-result images. */
+export declare function dedupeContext(messages: Message[]): Message[];
 /** Python `_build_partial_message`. */
 export declare function buildPartialMessage(contentText: string, reasoningText: string, toolCalls: unknown[], now?: number): Message | null;
-export declare function stripXmlToolCalls(text: string): string;
-/** Split inline `<think>` blocks out of assistant content (Python `_split_thinking_from_content`, reduced). */
-export declare function splitThinkingFromContent(content: string, existingReasoning?: string): [string, string];
+/**
+ * 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 declare function journalOutputRows(events: JournalEvent[], turnId: string): {
+    rows: Message[];
+    answered: boolean;
+};
+/** Remove provider tool-call XML (`<function_calls>…`, DSML variants, `<tool_call>`), closed or cut off, that leaks into text. */
+export declare function stripToolCallXml(text: string): string;
+/**
+ * Split assistant text into its visible prose and its inline thinking: every `<think>`, `<thinking>`,
+ * `<|channel|>thought` and `<|turn|>thinking` block anywhere in the text, an unterminated one running to the end.
+ * A tag written inside Markdown code is prose. Tool-call XML leaves both halves; both come back trimmed.
+ */
+export declare function splitDisplayText(text: string): [string, string];
+/**
+ * Reasoning parts as one display string: tool-call XML removed, blank-line joined, each part once. A part that is
+ * whole paragraphs of another (a settled row's `reasoning` that already took in its `reasoning_content`) is dropped.
+ */
+export declare function joinReasoning(parts: string[]): string;
+/** A message's reasoning fields as one string: `reasoning_content`, `reasoning` (text or a list of text parts), `thinking`. */
+export declare function reasoningFieldsText(m: Record<string, unknown>): string;
+/**
+ * The one display shape of an assistant row: `content` without inline thinking or tool-call XML (typed `thinking` /
+ * `reasoning` parts leave a list), and every piece of reasoning in one `reasoning` string. `reasoning_content` and
+ * `thinking` are not sent. Idempotent; other rows pass through. A copy: stored rows and model history are untouched.
+ */
+export declare function normalizeAssistantDisplay<T>(message: T): T;
 /**
  * Python `merge_session_messages_append_only`, bounded to its load-bearing rules: state.db rows never delete a local
  * row; rows that replay the sidecar (same role, timestamp, and content) are skipped; rows at or before the sidecar's
  * newest timestamp are already represented locally; a truncation watermark hides rows the user cut (0 blocks every
- * replay). Rows past the sidecar tail (a conversation continued from the CLI) are appended in state.db order.
+ * 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.
  */
 export declare function mergeSessionMessagesAppendOnly(sidecar: Message[], state: Message[], opts?: {
     truncationWatermark?: unknown;
+    compressedWatermark?: boolean;
+    stateDbSeenId?: number | null;
 }): Message[];
+/** TAL-493: the `state_db_seen_id` after reading `rows`: their highest id, or null when they carry none. */
+export declare function stateDbSeenId(rows: Message[]): number | null;
 /**
  * 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
@@ -95,10 +182,18 @@ export declare function withoutRunningTurnOutput(rows: Message[], turn: {
 export declare function attachmentObjects(items: unknown[]): unknown[];
 /** `attachmentObjects` over every message's attachments. Returns copies; stored rows are untouched. */
 export declare function withAttachmentObjects<T>(messages: T[]): T[];
+/** A scene's prose rows with `display_text` and `media` where `project` rewrites their text; the same array when none does. */
+export declare function withSceneRowMedia(rows: unknown, project: (text: string) => MediaProjection | null): unknown;
+/**
+ * TAL-186: assistant rows with `_display_content` and `_media`, and their scenes with `final_answer_display` /
+ * `final_answer_media` and prose rows' `display_text` / `media`, wherever `project` rewrites media references in the
+ * text. Runs after scene hydration and before body excerpts, which are cut from the display text. Returns copies.
+ */
+export declare function withDisplayMedia<T>(messages: T[], project: (text: string) => MediaProjection | null): T[];
 /** TAL-456: a settled user or assistant body longer than this ships a collapsed excerpt for clients to render. */
 export declare const BODY_EXCERPT_LIMIT = 3000;
 /**
- * TAL-456: stamps `_display_excerpt` and `_display_truncated` on settled user and assistant rows whose text is longer than
+ * TAL-456: stamps `_display_excerpt` and `_display_truncated` on settled user and assistant rows whose display text is longer than
  * `BODY_EXCERPT_LIMIT`, and `final_answer_excerpt` on a settled scene whose final answer is, so clients render a bounded
  * excerpt instead of laying out the whole body. Full text stays for copy and edit; the running turn's rows are left alone.
  * Runs after scene hydration. Returns copies; stored rows are untouched.
@@ -141,5 +236,23 @@ export declare function agentSteerText(m: Message): string | null;
  * 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 for turn history; compression and other projections strip it.
+ */
+export declare function sanitizeMessagesForApi(messages: Message[], { preserveApiContent }?: {
+    preserveApiContent?: boolean | undefined;
+}): Message[];
+/** True when any row's content carries a native `image_url` part. */
+export declare function hasNativeImages(messages: Message[]): boolean;
+/**
+ * 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 declare function withoutNativeImages(messages: Message[]): Message[];
+/**
+ * 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 declare function sanitizeMessagesForApi(messages: Message[]): Message[];
+export declare function withNativeImagesRestored<T extends Record<string, unknown>>(rows: T[], sent: Message[], original: Message[]): T[];