@maudecode/talaria-web 1.15.0 → 1.17.2

package/dist/sessions/service.d.ts

@@ -10,11 +10,16 @@ import type { SessionEventBus } from './events.js';
 import { type ListParams, type ListResponse, type Row, type RuntimeOverlay } from './list.js';
 import { Session, titleFrom, type Message } from './session.js';
 import { type SessionStore } from './store.js';
+import { type ClaudeCodeSessionSource } from './claude-code.js';
+import { type StateDbRead } from './state-db.js';
 import { type CompressionJob } from './compress.js';
 import { type SidecarLike } from '../sidecar/client.js';
+import { type ToolResultView } from './merge.js';
 import { type Receipt } from './background-tasks.js';
-import type { WorkspaceRegistry } from '../workspace/workspaces.js';
+import { type WorkspaceRegistry } from '../workspace/workspaces.js';
 import { type ShareStore } from './shares.js';
+import { type MediaAccessDeps } from '../workspace/media.js';
+import { type MediaProjection } from '../workspace/media-refs.js';
 import type { ProjectStore } from '../projects.js';
 export declare class HttpFailure extends Error {
     readonly status: number;
@@ -57,7 +62,8 @@ export interface SessionServiceDeps {
         journalDegraded: (streamId: string) => boolean;
         /** TAL-424: the live stream's pending steers, as clients show them. */
         pendingSteers?: (streamId: string) => PendingSteer[];
-        evictAgent: (sid: string) => void;
+        /** Drop the session's cached agent; `endSession` (delete/clear) also ends its approval grants and parked approvals. */
+        evictAgent: (sid: string, endSession?: boolean) => void;
         closeTerminal: (sid: string) => void;
         /** Python `delete_cli_session`: remove the session's rows from the profile's state.db; resolves false on failure. */
         deleteCliSession: (profile: string | null, sid: string) => Promise<boolean>;
@@ -73,10 +79,18 @@ export interface SessionServiceDeps {
     syncTitle: (session: Session) => Promise<void>;
     /** Context length lookup for a model (checkpoint 7 wires the catalog). */
     contextLengthFor: (model: string | null, provider: string | null) => number | null;
+    /** TAL-301: the catalog entry id a stored `(model, provider)` pair selects (null when none or not yet known). */
+    modelOptionFor?: (model: string | null, provider: string | null) => string | null;
+    /** Builds the catalog `modelOptionFor` reads, so a first detail load already carries `model_option_id`. */
+    warmModelOptions?: () => Promise<void>;
     /** Authoritative lookup through the sidecar (`models.context_length`), cached; used where the caller can await. */
     resolveContextLength?: (model: string | null, provider: string | null, profile: string | null) => Promise<number | null>;
     /** `(model, provider)` normalisation from a request (checkpoint 7 wires provider-qualified ids). */
     modelStateFromRequest: (model: unknown, requestedProvider: unknown, currentProvider: string | null) => [string | null, string | null];
+    /** TAL-542: the pair a stale session model starts on, from the profile's catalog; `null` keeps it. */
+    repairSessionModel?: (profile: string | null, model: string, provider: string | null) => [string, string] | null;
+    /** TAL-542: builds the catalog `repairSessionModel` reads unless a fresh enough one exists. */
+    warmSessionModelRepair?: (profile?: string | null) => Promise<void>;
     yolo: {
         isEnabled: (sid: string) => boolean;
         set: (sid: string, enabled: boolean) => void;
@@ -89,9 +103,16 @@ export interface SessionServiceDeps {
         rows: Row[];
         truncated: ReadonlySet<string>;
     };
+    /** TAL-551: read-only Claude Code transcripts, listed with the CLI rows when both toggles are on. */
+    claudeCode?: ClaudeCodeSessionSource;
     profileHome: (profile: string) => string;
     /** Python `commit_session_memory` (fire-and-forget): the cached Agent flushes memory for a session the user left. */
     commitSessionMemory?: (sid: string) => void;
+    /** TAL-186: the `/api/media` allow-list the transcript media projection rewrites against; without it nothing local is rewritten. */
+    media?: {
+        access: MediaAccessDeps;
+        localIo: (profile: string | null) => boolean;
+    };
 }
 export declare class SessionService {
     readonly deps: SessionServiceDeps;
@@ -99,6 +120,11 @@ export declare class SessionService {
     private readonly compressionJobs;
     constructor(deps: SessionServiceDeps);
     private get store();
+    /**
+     * TAL-186: rewrites a session's media references to their URLs. A local path is rewritten only when `/api/media`
+     * serves it for this session, under the same resolution, so every rewritten reference loads.
+     */
+    mediaProjector(s: Session): (text: string) => MediaProjection | null;
     publish(reason: string, profile?: string | null, sessionId?: string | null): void;
     visibleToActiveProfile(profile: string | null | undefined): boolean;
     /**
@@ -120,20 +146,51 @@ export declare class SessionService {
     private get404;
     /** The Agent's state.db rows for this session (empty for subagent views, which never merge). */
     stateDbRows(s: Session): Message[];
+    /** `stateDbRows` and whether the read succeeded on a state.db whose messages carry ids (TAL-493). */
+    stateDbRead(s: Session): StateDbRead;
+    private stateDbPath;
     /**
      * Python `_merged_session_messages_for_display`: the sidecar transcript merged append-only with the Agent's state.db
      * rows (a WebUI conversation continued from the CLI shows the CLI turns). This is the coordinate space `GET
      * /api/session` exposes, so branching and the next model history slice/extend the same list.
      */
     mergedTranscript(s: Session, local?: Message[], stateRows?: Message[]): Message[];
+    /**
+     * TAL-493: record the highest state.db id this boundary or settled turn read, under the session lock in the same save,
+     * so the merge never replays a covered row and appends every row committed after the read. Call it after the boundary
+     * fields are set: the marker holds only while they and the row it names stay as recorded.
+     */
+    markStateDbSeen(s: Session, read?: StateDbRead, opts?: {
+        boundary?: boolean;
+    }): void;
+    /**
+     * TAL-493: a turn's settlement. Each state.db row the merge shows now is matched to what the turn holds: a row already
+     * in the context it started from (by id), or one row the Agent added this turn (`agentRows` past that context, matched
+     * one to one by full text). An unmatched row is a CLI or gateway row committed while the turn ran: it joins the
+     * transcript and the model context before the marker passes it. Without the Agent's rows (`agentRows` empty), rows past
+     * `startId` (the highest id the turn read when it started) are its own unreported work: covered, never shown. Rows the
+     * turn started from but the transcript lacks (a CLI continuation read into its context) are kept before the turn.
+     */
+    settleStateDb(s: Session, turn: {
+        turnId: string;
+        previousContext: Message[];
+        agentRows?: Message[] | null;
+        startId?: number | null;
+    }): void;
     /**
      * Python `reconciled_state_db_messages_for_session(prefer_context=True)`: the model history is the owner context
      * extended append-only with the Agent's state.db rows (a CLI continuation of this session reaches the model), except
      * for a compressed context whose anchor cannot be verified — that stays context-only.
      */
     modelContext(s: Session, stateRows?: Message[]): Message[];
+    /**
+     * TAL-518: the model context a `/btw` clone inherits: the chat's history plus its running turn's prompt, which
+     * deferred save keeps out of `messages` and `context_messages` until settlement.
+     */
+    sideQuestionContext(s: Session): Message[];
     /** Python `_lookup_cli_session_metadata`: the sidebar row for a state.db session in the active profile. */
     private lookupCliMeta;
+    private claudeCodeRows;
     /** Python `_session_index_marks_was_webui`: an index row that once owned a WebUI sidecar (self-heal 404). */
     private indexMarksWasWebui;
     /**
@@ -146,6 +203,11 @@ export declare class SessionService {
         reason: 'materialized' | 'not_claimable' | 'was_webui' | 'no_foreign_state' | 'invalid_sid';
     };
     private mutationTarget;
+    /**
+     * TAL-551: a Claude Code import is a live view of a transcript Claude Code keeps writing. Web never stores a copy,
+     * which would freeze its messages and pin it to one profile.
+     */
+    private rejectClaudeCode;
     private rejectSubagent;
     /** TAL-372: each delegation row of a turn's scene carries the status of the work it started. */
     backgroundLinked(s: Session, messages: unknown[]): unknown[];
@@ -153,6 +215,14 @@ export declare class SessionService {
     publicSession(s: Session, withMessages?: boolean): Record<string, unknown>;
     /** `compact()` with the wire streaming/read-only flags (TAL-312), for replies that return the session row. */
     wireRow(s: Session): Record<string, unknown>;
+    /**
+     * TAL-303: the label for a session's workspace, from its own profile's registry (a profileless row is the root's).
+     * One resolver serves one response, so each profile's registry is read once however many rows it names.
+     */
+    workspaceNames(): (row: {
+        profile?: unknown;
+        workspace?: unknown;
+    }) => string | null;
     /** The agent's display name for a session's profile (`assistant_name`). */
     assistantName(s: Session): string;
     /** Python `public_session_projection(s.__dict__)`: every persisted field, redacted (session export). */
@@ -176,7 +246,7 @@ export declare class SessionService {
     private foreignSession;
     /** Python `_handle_session_get` without a sidecar: the state.db transcript as a (read-only or claimable) foreign stub. */
     private foreignSessionDetail;
-    /** Clear persisted streaming flags when no live stream backs them (Python `_clear_stale_stream_state`, no journal recovery). */
+    /** Clear persisted streaming flags when no live stream backs them (Python `_clear_stale_stream_state`). */
     clearStaleStreamState(session: Session): boolean;
     list(params: Omit<ListParams, 'activeProfile' | 'isolatedProfileMode' | 'profilesMatch' | 'cliRows' | 'gatewayIdentity' | 'stateDbSources' | 'truncatedSources'>): {
         body: ListResponse;
@@ -187,9 +257,22 @@ export declare class SessionService {
         depth: number;
         allProfiles: boolean;
     }): Record<string, unknown>;
+    /**
+     * TAL-308: the sidebar search. The candidates are exactly the `/api/sessions` rows for `params` (visibility, source,
+     * archived, projection and order), narrowed to `projectId` (`none`: rows without a project), then matched on the
+     * title, then the metadata the row shows (workspace path and name, model, provider, profile, source label), then message content.
+     */
+    sidebarSearch(q: string, params: Parameters<SessionService['list']>[0], opts: {
+        content: boolean;
+        depth: number;
+        projectId: string | null;
+    }): Record<string, unknown>;
+    /** The first of a stored session's first `depth` messages (0: all) containing every term, with its redacted excerpt. */
+    private contentMatch;
     status(sid: string): Record<string, unknown>;
     usage(sid: string): Record<string, unknown>;
     resolveNewSessionWorkspace(body: Record<string, unknown>, visiblePrevSessionId: string | null, profile: string | null): string | null;
+    /** The server owns the names' normalization (TAL-631): trimmed, blanks dropped, and nothing left is the profile's defaults. */
     validateToolsetsShape(toolsets: unknown): string[] | null;
     create(body: Record<string, unknown>, opts?: {
         worktree?: {
@@ -234,13 +317,26 @@ export declare class SessionService {
     undo(sid: string): Promise<Record<string, unknown>>;
     duplicate(sid: string): Record<string, unknown>;
     branch(sid: string, body: Record<string, unknown>): Record<string, unknown>;
+    /** The run that keeps `delete` answering 409, if any; stream status reports it so a draining client can wait on it (TAL-622). */
+    activeRunBlocking(sid: string): string | null;
     delete(sid: string): Promise<Record<string, unknown>>;
     cleanup(zeroOnly: boolean): Record<string, unknown>;
     import(body: Record<string, unknown>): Record<string, unknown>;
     readDraft(sid: string): Record<string, unknown>;
     writeDraft(body: Record<string, unknown>): Promise<Record<string, unknown>>;
     saveAnchorScene(body: Record<string, unknown>): Promise<Record<string, unknown>>;
+    /** The session and the full transcript its detail is built from; a state.db-only session gives its synthesized one. */
+    private fullTranscript;
     readAnchorScene(query: Record<string, string | null | undefined>): Record<string, unknown>;
+    /** TAL-331: one tool call's whole result, which a limited response clipped (`result_truncated`), redacted like the detail. */
+    readToolResult(query: {
+        session_id: string;
+        tool_call_id: string;
+    }): {
+        tool_call_id: string;
+        result: string;
+        result_view: ToolResultView;
+    };
     createShare(sid: string): Record<string, unknown>;
     revokeShare(sid: string): Record<string, unknown>;
     loadShare(token: string): Record<string, unknown>;
@@ -253,7 +349,7 @@ export declare function applySessionTitleRename(session: Session, rawTitle: unkn
 export declare function markSessionTitleGenerated(session: Session): void;
 /** Python `_sanitize_error`: absolute paths in an error message never reach the client. */
 export declare function sanitizePaths(error: unknown): string;
-/** Align model context with the display prefix (Python `truncate_context_for_display_keep`, simplified to the row-count contract). */
+/** Align model context with the display prefix `full[:keep]` (Python `truncate_context_for_display_keep`, #5096/#5563). */
 export declare function truncateContextForDisplayKeep(context: Message[] | null | undefined, full: unknown[], keep: number): Message[];
 export declare function truncateSessionAtKeep(session: Session, keep: number): [number, number];
 /** Python `_extract_text`: flatten content to the user-typed text. */