@prometheus-ai/agent 0.5.3 → 0.5.8

package/dist/types/session/messages.d.ts

@@ -7,21 +7,20 @@
 import type { AgentMessage } from "@prometheus-ai/agent-core";
 import { type BranchSummaryMessage, type CompactionSummaryMessage } from "@prometheus-ai/agent-core/compaction/messages";
 import type { AssistantMessage, ImageContent, Message, MessageAttribution, TextContent } from "@prometheus-ai/ai";
-export { type BranchSummaryMessage, type CompactionSummaryMessage, createBranchSummaryMessage, createCompactionSummaryMessage, } from "@prometheus-ai/agent-core/compaction/messages";
+export { type BranchSummaryMessage, type CompactionSummaryMessage, createBranchSummaryMessage, createCompactionSummaryMessage, createCustomMessage, } from "@prometheus-ai/agent-core/compaction/messages";
 import type { OutputMeta } from "../tools/output-meta";
 export declare const SKILL_PROMPT_MESSAGE_TYPE = "skill-prompt";
+export declare const LSP_LATE_DIAGNOSTIC_MESSAGE_TYPE = "lsp-late-diagnostic";
 export interface SkillPromptDetails {
     name: string;
     path: string;
     args?: string;
     lineCount: number;
-    /** Internal: tag used by AgentSession to remove the pending-display chip
-     *  from `#steeringMessages` / `#followUpMessages` when the agent consumes
-     *  this message. Not surfaced to renderers; the `__` prefix signals
-     *  "private". Optional — non-streaming skill prompts never set it. Stripped
-     *  from persisted `details` by `SessionManager.appendCustomMessageEntry`
-     *  via the `INTERNAL_DETAILS_FIELDS` allowlist below. */
-    __pendingDisplayTag?: string;
+    /** Internal: compact label shown for a queued custom message. Optional —
+     *  non-streaming skill prompts never set it. Stripped from persisted
+     *  `details` by `SessionManager.appendCustomMessageEntry` via the
+     *  `INTERNAL_DETAILS_FIELDS` allowlist below. */
+    __queueChipText?: string;
 }
 /** Sentinel value for `AssistantMessage.errorMessage` indicating that the abort
  *  was an *expected internal transition* (plan-mode → execution compaction)
@@ -32,24 +31,38 @@ export interface SkillPromptDetails {
  *
  *  Consumers: `AgentSession.#handleAgentEvent` (stamper) writes this value;
  *  `EventController.#handleMessageEnd`, `AssistantMessageComponent`,
- *  `ui-helpers.addMessageToChat` (renderers), `SessionObserverOverlay
+ *  `ui-helpers.addMessageToChat` (renderers), `AgentHubOverlayComponent
  *  #buildTranscriptLines`, `runPrintMode`, and `AcpAgent#replayAssistantMessage`
  *  (fallback error emission) read it via `isSilentAbort`. */
-export declare const SILENT_ABORT_MARKER = "__prometheus.silent_abort__";
+export declare const SILENT_ABORT_MARKER = "__omp.silent_abort__";
 /** Type-guard for `SILENT_ABORT_MARKER`. Renderers MUST branch on this rather
  *  than string-comparing inline so refactors to the marker constant (e.g.,
  *  namespacing changes) propagate through every consumer in lockstep. */
 export declare function isSilentAbort(errorMessage: string | undefined): boolean;
-/** Extract the optional `__pendingDisplayTag` field from a CustomMessage's
+/** Reason threaded through `AbortController.abort(reason)` when the user aborts
+ *  the turn with Esc (see `AgentSession.abort`). The agent keeps it on the
+ *  aborted assistant message's `errorMessage` so queued follow-ups/tool-result
+ *  placeholders can distinguish a deliberate interrupt from a bare lifecycle
+ *  abort, but interactive renderers suppress this redundant transcript line. */
+export declare const USER_INTERRUPT_LABEL = "Interrupted by user";
+export declare function isUserInterruptAbort(errorMessage: string | undefined): boolean;
+export declare function shouldRenderAbortReason(errorMessage: string | undefined): boolean;
+/** Resolve the operator-facing label for an aborted assistant turn. A custom
+ *  abort reason threaded onto `errorMessage` is returned verbatim; aborts with
+ *  no threaded reason fall back to the retry-aware generic label. Call
+ *  `shouldRenderAbortReason` before rendering when user interrupts should stay
+ *  visually quiet. */
+export declare function resolveAbortLabel(errorMessage: string | undefined, retryAttempt?: number): string;
+/** Extract the optional `__queueChipText` field from a CustomMessage's
  *  `details` blob. Safe over `unknown`; returns undefined when the field is
  *  absent or non-string. */
-export declare function readPendingDisplayTag(details: unknown): string | undefined;
+export declare function readQueueChipText(details: unknown): string | undefined;
 /** Explicit allowlist of `details` field names that are AgentSession-internal
  *  transient bookkeeping and MUST be removed before SessionManager persists
  *  the CustomMessageEntry to disk. Scoped intentionally narrow: only fields
  *  declared here are stripped. Adding a new entry is a deliberate, reviewed
  *  change — unrelated future payload fields are never silently dropped. */
-export declare const INTERNAL_DETAILS_FIELDS: readonly ["__pendingDisplayTag"];
+export declare const INTERNAL_DETAILS_FIELDS: readonly ["__queueChipText"];
 /** Return a `details` copy with every key in `INTERNAL_DETAILS_FIELDS`
  *  removed. Returns the input unchanged when there is nothing to strip
  *  (null/non-object, or no listed fields present) so callers don't pay a
@@ -160,8 +173,6 @@ export declare function bashExecutionToText(msg: BashExecutionMessage): string;
  */
 export declare function pythonExecutionToText(msg: PythonExecutionMessage): string;
 export declare function sanitizeRehydratedOpenAIResponsesAssistantMessage(message: AssistantMessage): AssistantMessage;
-/** Convert CustomMessageEntry to AgentMessage format */
-export declare function createCustomMessage(customType: string, content: string | (TextContent | ImageContent)[], display: boolean, details: unknown | undefined, timestamp: string, attribution?: MessageAttribution): CustomMessage;
 /**
  * Transform AgentMessages (including custom types) to LLM-compatible Messages.
  *

package/dist/types/session/session-context.d.ts

@@ -0,0 +1,39 @@
+import type { AgentMessage } from "@prometheus-ai/agent-core";
+import type { ServiceTier } from "@prometheus-ai/ai";
+import { type CompactionEntry, type SessionEntry } from "./session-entries";
+export interface SessionContext {
+    messages: AgentMessage[];
+    thinkingLevel?: string;
+    serviceTier?: ServiceTier;
+    /** Model roles: { default: "provider/modelId", small: "provider/modelId", ... } */
+    models: Record<string, string>;
+    /** Names of TTSR rules that have been injected this session */
+    injectedTtsrRules: string[];
+    /** MCP tool names selected through discovery for this session branch. */
+    selectedMCPToolNames: string[];
+    /** Whether this branch contains an explicit persisted MCP selection entry. */
+    hasPersistedMCPToolSelection: boolean;
+    /** Active mode (e.g. "plan") or "none" if no special mode is active */
+    mode: string;
+    /** Mode-specific data from the last mode_change entry */
+    modeData?: Record<string, unknown>;
+}
+/** Lists session model strings to try when restoring, in fallback order. */
+export declare function getRestorableSessionModels(models: Readonly<Record<string, string>>, lastModelChangeRole: string | undefined): string[];
+export declare function getLatestCompactionEntry(entries: SessionEntry[]): CompactionEntry | null;
+export interface BuildSessionContextOptions {
+    /**
+     * Build the full-history display transcript instead of the LLM context:
+     * every path entry in chronological order, with each compaction emitted
+     * inline as a `compactionSummary` message at the position it fired rather
+     * than replacing the history before it. Display-only — never send the
+     * result to a provider.
+     */
+    transcript?: boolean;
+}
+/**
+ * Build the session context from entries using tree traversal.
+ * If leafId is provided, walks from that entry to root.
+ * Handles compaction and branch summaries along the path.
+ */
+export declare function buildSessionContext(entries: SessionEntry[], leafId?: string | null, byId?: Map<string, SessionEntry>, options?: BuildSessionContextOptions): SessionContext;

package/dist/types/session/session-entries.d.ts

@@ -0,0 +1,159 @@
+import type { AgentMessage } from "@prometheus-ai/agent-core";
+import type { ImageContent, MessageAttribution, ServiceTier, TextContent } from "@prometheus-ai/ai";
+export declare const CURRENT_SESSION_VERSION = 3;
+export declare const EPHEMERAL_MODEL_CHANGE_ROLE = "fallback";
+export interface SessionHeader {
+    type: "session";
+    version?: number;
+    id: string;
+    title?: string;
+    titleSource?: "auto" | "user";
+    timestamp: string;
+    cwd: string;
+    parentSession?: string;
+}
+export interface NewSessionOptions {
+    parentSession?: string;
+    /** Skip flushing the current session and delete it instead of saving. */
+    drop?: boolean;
+}
+export interface SessionEntryBase {
+    type: string;
+    id: string;
+    parentId: string | null;
+    timestamp: string;
+}
+export interface SessionMessageEntry extends SessionEntryBase {
+    type: "message";
+    message: AgentMessage;
+}
+export interface ThinkingLevelChangeEntry extends SessionEntryBase {
+    type: "thinking_level_change";
+    thinkingLevel?: string | null;
+}
+export interface ModelChangeEntry extends SessionEntryBase {
+    type: "model_change";
+    /** Model in "provider/modelId" format */
+    model: string;
+    /** Role: "default", "smol", "slow", etc. Undefined treated as "default" */
+    role?: string;
+}
+export interface ServiceTierChangeEntry extends SessionEntryBase {
+    type: "service_tier_change";
+    serviceTier: ServiceTier | null;
+}
+export interface CompactionEntry<T = unknown> extends SessionEntryBase {
+    type: "compaction";
+    summary: string;
+    shortSummary?: string;
+    firstKeptEntryId: string;
+    tokensBefore: number;
+    /** Extension-specific data (e.g., ArtifactIndex, version markers for structured compaction) */
+    details?: T;
+    /** Hook-provided data to persist across compaction */
+    preserveData?: Record<string, unknown>;
+    /** True if generated by an extension, undefined/false if pi-generated (backward compatible) */
+    fromExtension?: boolean;
+}
+export interface BranchSummaryEntry<T = unknown> extends SessionEntryBase {
+    type: "branch_summary";
+    fromId: string;
+    summary: string;
+    /** Extension-specific data (not sent to LLM) */
+    details?: T;
+    /** True if generated by an extension, false if pi-generated */
+    fromExtension?: boolean;
+}
+/**
+ * Custom entry for extensions to store extension-specific data in the session.
+ * Use customType to identify your extension's entries.
+ *
+ * Purpose: Persist extension state across session reloads. On reload, extensions can
+ * scan entries for their customType and reconstruct internal state.
+ *
+ * Does NOT participate in LLM context (ignored by buildSessionContext).
+ * For injecting content into context, see CustomMessageEntry.
+ */
+export interface CustomEntry<T = unknown> extends SessionEntryBase {
+    type: "custom";
+    customType: string;
+    data?: T;
+}
+/** Label entry for user-defined bookmarks/markers on entries. */
+export interface LabelEntry extends SessionEntryBase {
+    type: "label";
+    targetId: string;
+    label: string | undefined;
+}
+/** TTSR injection entry - tracks which time-traveling rules have been injected this session. */
+export interface TtsrInjectionEntry extends SessionEntryBase {
+    type: "ttsr_injection";
+    /** Names of rules that were injected */
+    injectedRules: string[];
+}
+/** Persisted MCP discovery selection state for a session branch. */
+export interface MCPToolSelectionEntry extends SessionEntryBase {
+    type: "mcp_tool_selection";
+    /** MCP tool names selected for visibility in discovery mode. */
+    selectedToolNames: string[];
+}
+/** Session init entry - captures initial context for subagent sessions (debugging/replay). */
+export interface SessionInitEntry extends SessionEntryBase {
+    type: "session_init";
+    /** Full system prompt sent to the model */
+    systemPrompt: string;
+    /** Initial task/user message */
+    task: string;
+    /** Tools available to the agent */
+    tools: string[];
+    /** Output schema if structured output was requested */
+    outputSchema?: unknown;
+}
+/** Mode change entry - tracks agent mode transitions (e.g. plan mode). */
+export interface ModeChangeEntry extends SessionEntryBase {
+    type: "mode_change";
+    /** Current mode name, or "none" when exiting a mode */
+    mode: string;
+    /** Optional mode-specific data (e.g. plan file path) */
+    data?: Record<string, unknown>;
+}
+/**
+ * Custom message entry for extensions to inject messages into LLM context.
+ * Use customType to identify your extension's entries.
+ *
+ * Unlike CustomEntry, this DOES participate in LLM context.
+ * The content participates in LLM context through convertToLlm().
+ * Use details for extension-specific metadata (not sent to LLM).
+ *
+ * display controls TUI rendering:
+ * - false: hidden entirely
+ * - true: rendered with distinct styling (different from user messages)
+ */
+export interface CustomMessageEntry<T = unknown> extends SessionEntryBase {
+    type: "custom_message";
+    customType: string;
+    content: string | (TextContent | ImageContent)[];
+    details?: T;
+    display: boolean;
+    /** Who initiated this message for billing/attribution semantics. */
+    attribution?: MessageAttribution;
+}
+/** Session entry - has id/parentId for tree structure (returned by "read" methods in SessionManager) */
+export type SessionEntry = SessionMessageEntry | ThinkingLevelChangeEntry | ModelChangeEntry | ServiceTierChangeEntry | CompactionEntry | BranchSummaryEntry | CustomEntry | CustomMessageEntry | LabelEntry | TtsrInjectionEntry | MCPToolSelectionEntry | SessionInitEntry | ModeChangeEntry;
+/** Raw file entry (includes header) */
+export type FileEntry = SessionHeader | SessionEntry;
+/** Tree node for getTree() - defensive copy of session structure */
+export interface SessionTreeNode {
+    entry: SessionEntry;
+    children: SessionTreeNode[];
+    /** Resolved label for this entry, if any */
+    label?: string;
+}
+export interface UsageStatistics {
+    input: number;
+    output: number;
+    cacheRead: number;
+    cacheWrite: number;
+    premiumRequests: number;
+    cost: number;
+}

package/dist/types/session/session-history-format.d.ts

@@ -0,0 +1,12 @@
+export interface HistoryFormatOptions {
+    /** Optional H1 prepended to the transcript. */
+    title?: string;
+}
+/**
+ * Format a session's message array as a concise markdown transcript.
+ *
+ * `messages` is the session's in-memory message array (or the read-only
+ * equivalent loaded from a session file) — the same shapes
+ * `session-dump-format.ts` consumes.
+ */
+export declare function formatSessionHistoryMarkdown(messages: unknown[], opts?: HistoryFormatOptions): string;

package/dist/types/session/session-listing.d.ts

@@ -0,0 +1,69 @@
+import { type SessionStorage } from "./session-storage";
+/**
+ * Coarse lifecycle status of a session, derived from its last persisted message.
+ *
+ * - `complete` — the last assistant turn ended with no unanswered tool calls, i.e.
+ *   the agent yielded control back to the user.
+ * - `interrupted` — work was cut off mid-flight: a trailing assistant turn with
+ *   pending tool calls, a trailing tool result the agent never continued from, or
+ *   a length-truncated turn.
+ * - `aborted` — the last assistant turn was cancelled by the user.
+ * - `error` — the last assistant turn ended in an error.
+ * - `pending` — a trailing user message with no assistant reply persisted after it.
+ * - `unknown` — status could not be determined (empty/header-only session, or the
+ *   final message was larger than the tail window that was read).
+ */
+export type SessionStatus = "complete" | "interrupted" | "aborted" | "error" | "pending" | "unknown";
+export interface SessionInfo {
+    path: string;
+    id: string;
+    /** Working directory where the session was started. Empty string for old sessions. */
+    cwd: string;
+    title?: string;
+    /** Path to the parent session (if this session was forked). */
+    parentSessionPath?: string;
+    created: Date;
+    modified: Date;
+    messageCount: number;
+    /** File size in bytes on disk; used for compact list rendering. */
+    size: number;
+    firstMessage: string;
+    allMessagesText: string;
+    /**
+     * Coarse lifecycle status from the session's last persisted message. Optional:
+     * synthesized {@link SessionInfo}s (cross-project stubs, tests) leave it unset.
+     */
+    status?: SessionStatus;
+}
+export interface ResolvedSessionMatch {
+    session: SessionInfo;
+    scope: "local" | "global";
+}
+/** Lightweight metadata for a recent session, used in welcome/picker UI. */
+export interface RecentSessionInfo {
+    path: string;
+    name: string;
+    timeAgo: string;
+}
+/**
+ * Promote orphaned `<basename>.jsonl.<snowflake>.bak` backups created by the
+ * EPERM-rewrite path back to their primary path when the primary is missing.
+ * This runs once per session-dir scan, before the main `*.jsonl` glob, so a
+ * crash between the two renames in the EPERM-rewrite path does not leave the
+ * user's last good state stranded outside the loader's view.
+ *
+ * Exported for testing.
+ */
+export declare function recoverOrphanedBackups(sessionDir: string, storage: SessionStorage): Promise<void>;
+/**
+ * List sessions in a resolved session directory (newest first), reading each
+ * file's lifecycle {@link SessionStatus}.
+ */
+export declare function listSessions(sessionDir: string, storage: SessionStorage): Promise<SessionInfo[]>;
+/** List all sessions across all project directories (newest first). */
+export declare function listAllSessions(storage?: SessionStorage): Promise<SessionInfo[]>;
+/** Exported for testing */
+export declare function findMostRecentSession(sessionDir: string, storage?: SessionStorage): Promise<string | null>;
+/** Get recent sessions for display in the welcome screen. */
+export declare function getRecentSessions(sessionDir: string, limit?: number, storage?: SessionStorage): Promise<RecentSessionInfo[]>;
+export declare function resolveResumableSession(sessionArg: string, cwd: string, sessionDir?: string, storage?: SessionStorage): Promise<ResolvedSessionMatch | undefined>;

package/dist/types/session/session-loader.d.ts

@@ -0,0 +1,16 @@
+import type { AgentMessage } from "@prometheus-ai/agent-core";
+import { BlobStore } from "./blob-store";
+import type { FileEntry } from "./session-entries";
+import { type SessionStorage } from "./session-storage";
+/** Exported for compaction.test.ts */
+export declare function parseSessionEntries(content: string): FileEntry[];
+/** Exported for testing */
+export declare function loadEntriesFromFile(filePath: string, storage?: SessionStorage): Promise<FileEntry[]>;
+export declare function resolveBlobRefsInEntries(entries: FileEntry[], blobStore: BlobStore): Promise<void>;
+/**
+ * Read-only message view of a session file: load entries, migrate to the
+ * current version, resolve blob refs, and build the context along the
+ * persisted leaf path (last entry). Does NOT create a writer or take the
+ * session lock — safe to call against a file another session is writing.
+ */
+export declare function loadSessionMessagesReadOnly(filePath: string): Promise<AgentMessage[]>;