@maudecode/talaria-web 1.14.0 → 1.16.1

package/dist/sessions/merge.d.ts

@@ -1,4 +1,5 @@
-import type { Message } from './session.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;
@@ -13,14 +14,28 @@ export declare function reasoningBlockText(part: Record<string, unknown>): strin
 export declare function messageText(content: unknown): string;
 export declare function messageIdentity(msg: unknown): 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). */
 export interface MergeOptions {
     source?: string;
     activeTurnToken?: string | null;
     now?: number;
     turnId?: string;
+    attachments?: unknown[];
 }
 /** Python `_assistant_reply_added_after_current_turn`: only the just-finished turn counts, never replayed history. */
 export declare function assistantReplyAddedAfterCurrentTurn(resultMessages: Message[], previousContext: Message[], msgText: string): boolean;
@@ -34,14 +49,34 @@ export declare function injectMaxIterationSummaryFallback(messages: Message[], f
 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
@@ -55,24 +90,46 @@ 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[];
 /** 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];
+/** 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.
  * 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;
 }): Message[];
 /**
  * TAL-316: the merged transcript without the running turn's output, which the run journal replays from its start. The turn
@@ -93,6 +150,23 @@ 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 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.
+ */
+export declare function withBodyExcerpts<T>(messages: T[], activeTurnId: string | null): T[];
 /** The running turn's prompt as eager save checkpoints it (Python `_checkpoint_user_message_for_eager_session_save`). */
 export declare function pendingUserRow(msg: string, attachments: unknown[], startedAt: number | null, source: string, turnId: string): Message;
 /**