@prometheus-ai/agent 0.5.0

package/dist/types/session/agent-storage.d.ts

@@ -0,0 +1,94 @@
+import { type AuthCredential, type AuthCredentialStore, type StoredAuthCredential } from "@prometheus-ai/ai";
+import type { RawSettings as Settings } from "../config/settings";
+/**
+ * Unified SQLite storage for agent settings, model usage, and auth credentials.
+ * Delegates auth credential operations to AuthCredentialStore from @prometheus-ai/ai.
+ * Uses singleton pattern per database path; access via AgentStorage.open().
+ */
+export declare class AgentStorage {
+    #private;
+    private constructor();
+    /**
+     * Returns singleton instance for the given database path, creating if needed.
+     * Retries on SQLITE_BUSY with exponential backoff.
+     * @param dbPath - Path to the SQLite database file (defaults to config path)
+     * @returns AgentStorage instance for the given path
+     */
+    static open(dbPath?: string): Promise<AgentStorage>;
+    /**
+     * Reads legacy settings persisted in the agent.db `settings` table.
+     * The canonical settings store is `config.yml`; this accessor only
+     * exists so the config loader can migrate values from older installs.
+     * @returns Settings object, or null if no settings are stored
+     */
+    getSettings(): Settings | null;
+    /**
+     * Records model usage, updating the last-used timestamp.
+     * @param modelKey - Model key in "provider/modelId" format
+     */
+    recordModelUsage(modelKey: string): void;
+    /**
+     * Gets model keys ordered by most recently used.
+     * Results are cached until recordModelUsage is called.
+     * @returns Array of model keys ("provider/modelId") in MRU order
+     */
+    getModelUsageOrder(): string[];
+    /**
+     * Checks if any auth credentials exist in storage.
+     * @returns True if at least one credential is stored
+     */
+    hasAuthCredentials(): boolean;
+    /**
+     * Returns the underlying {@link AuthCredentialStore} so callers that need
+     * the lower-level @prometheus-ai/ai abstraction (e.g. `findAnthropicAuth(store)`) can
+     * reuse this storage's open database connection instead of opening their
+     * own.
+     */
+    get authStore(): AuthCredentialStore;
+    /**
+     * Lists auth credentials, optionally filtered by provider.
+     * Only returns active (non-disabled) credentials by default.
+     * @param provider - Optional provider name to filter by
+     * @param includeDisabled - If true, includes disabled credentials
+     * @returns Array of stored credentials with their database IDs
+     */
+    listAuthCredentials(provider?: string, includeDisabled?: boolean): StoredAuthCredential[];
+    /**
+     * Atomically replaces all credentials for a provider.
+     * Useful for OAuth token refresh where old tokens should be discarded.
+     * @param provider - Provider name (e.g., "anthropic", "openai")
+     * @param credentials - New credentials to store
+     * @returns Array of newly stored credentials with their database IDs
+     */
+    replaceAuthCredentialsForProvider(provider: string, credentials: AuthCredential[]): StoredAuthCredential[];
+    /**
+     * Updates an existing auth credential by ID.
+     * @param id - Database row ID of the credential to update
+     * @param credential - New credential data
+     */
+    updateAuthCredential(id: number, credential: AuthCredential): void;
+    /**
+     * Disables an auth credential by ID with a persisted cause.
+     * @param id - Database row ID of the credential to disable
+     * @param disabledCause - Human-readable cause stored with the disabled row
+     */
+    deleteAuthCredential(id: number, disabledCause: string): void;
+    /**
+     * Disables all auth credentials for a provider with a persisted cause.
+     * @param provider - Provider name whose credentials should be disabled
+     * @param disabledCause - Human-readable cause stored with the disabled rows
+     */
+    deleteAuthCredentialsForProvider(provider: string, disabledCause: string): void;
+    /**
+     * Gets a cached value by key. Returns null if not found or expired.
+     */
+    getCache(key: string): string | null;
+    /**
+     * Sets a cached value with expiry time (unix seconds).
+     */
+    setCache(key: string, value: string, expiresAtSec: number): void;
+    /**
+     * Deletes expired cache entries. Call periodically for cleanup.
+     */
+    cleanExpiredCache(): void;
+}

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

@@ -0,0 +1,61 @@
+/**
+ * Manages artifact storage for a session.
+ *
+ * Artifacts are stored with sequential IDs in the session's artifact directory.
+ * The directory is created lazily on first write.
+ *
+ * Subagents do not own their own `ArtifactManager`. The parent's instance is
+ * adopted via `SessionManager.adoptArtifactManager`, so the whole parent +
+ * subagent tree shares one ID space and one directory.
+ */
+export declare class ArtifactManager {
+    #private;
+    /**
+     * @param dir Directory that will hold artifact files. Created lazily on first save.
+     */
+    constructor(dir: string);
+    /**
+     * Artifact directory path.
+     * Directory may not exist until first artifact is saved.
+     */
+    get dir(): string;
+    /**
+     * Atomically allocate next artifact ID.
+     * IDs are sequential within the session.
+     */
+    allocateId(): number;
+    /**
+     * Allocate a new artifact path and ID without writing content.
+     *
+     * @param toolType Tool name for file extension (e.g., "bash", "read")
+     */
+    allocatePath(toolType: string): Promise<{
+        id: string;
+        path: string;
+    }>;
+    /**
+     * Save content as an artifact and return the artifact ID.
+     *
+     * @param content Full content to save
+     * @param toolType Tool name for file extension (e.g., "bash", "read")
+     * @returns Artifact ID (numeric string)
+     */
+    save(content: string, toolType: string): Promise<string>;
+    /**
+     * Check if an artifact exists.
+     * @param id Artifact ID (numeric string)
+     */
+    exists(id: string): Promise<boolean>;
+    /**
+     * List all artifact files in the directory.
+     * Returns empty array if directory doesn't exist.
+     */
+    listFiles(): Promise<string[]>;
+    /**
+     * Get the full path to an artifact file.
+     * Returns null if artifact doesn't exist.
+     *
+     * @param id Artifact ID (numeric string)
+     */
+    getPath(id: string): Promise<string | null>;
+}

package/dist/types/session/auth-broker-config.d.ts

@@ -0,0 +1,13 @@
+export interface AuthBrokerClientConfig {
+    url: string;
+    token: string;
+}
+/** Path to the local bearer token file. Created on the broker host by `prometheus auth-broker token`. */
+export declare function getAuthBrokerTokenFilePath(): string;
+/**
+ * Read broker configuration. Returns null when the URL is missing
+ * (broker disabled — local store is used). Throws when URL is set but no
+ * token is available — the caller cannot fall back silently because the
+ * user explicitly asked to use the broker.
+ */
+export declare function resolveAuthBrokerConfig(): Promise<AuthBrokerClientConfig | null>;

package/dist/types/session/auth-storage.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Re-exports from @prometheus-ai/ai.
+ * All credential storage types and the AuthStorage class now live in the ai package.
+ */
+export type { ApiKeyCredential, AuthCredential, AuthCredentialEntry, AuthCredentialStore, AuthStorageData, AuthStorageOptions, OAuthCredential, SerializedAuthStorage, SnapshotResponse, StoredAuthCredential, } from "@prometheus-ai/ai";
+export { AuthBrokerClient, AuthStorage, DEFAULT_SNAPSHOT_CACHE_TTL_MS, REMOTE_REFRESH_SENTINEL, RemoteAuthCredentialStore, readAuthBrokerSnapshotCache, SqliteAuthCredentialStore, writeAuthBrokerSnapshotCache, } from "@prometheus-ai/ai";

package/dist/types/session/blob-store.d.ts

@@ -0,0 +1,64 @@
+export interface BlobPutOptions {
+    /** Optional file extension for a sidecar hardlink/copy that OS openers can type-detect. */
+    extension?: string;
+}
+export interface BlobPutResult {
+    hash: string;
+    /** Canonical content-addressed path, always `<dir>/<sha256-hex>`. */
+    path: string;
+    /** Path with the requested extension when supplied, otherwise the canonical path. */
+    displayPath: string;
+    get ref(): string;
+}
+export declare function blobExtensionForImageMimeType(mimeType: string | undefined): string | undefined;
+export declare class BlobStore {
+    readonly dir: string;
+    constructor(dir: string);
+    /**
+     * Write binary data to the blob store.
+     * @returns SHA-256 hex hash of the data
+     */
+    put(data: Buffer, options?: BlobPutOptions): Promise<BlobPutResult>;
+    /**
+     * Synchronous variant of {@link put}. Use on persistence hot paths where the caller
+     * cannot afford the microtask hops of the async version (e.g. OOM-safe session writes).
+     * Returns once the bytes are in the kernel page cache.
+     */
+    putSync(data: Buffer, options?: BlobPutOptions): BlobPutResult;
+    /** Read blob by hash, returns Buffer or null if not found. */
+    get(hash: string): Promise<Buffer | null>;
+    /** Check if a blob exists. */
+    has(hash: string): Promise<boolean>;
+}
+/** Check if a data string is a blob reference. */
+export declare function isBlobRef(data: string): boolean;
+/** Extract the SHA-256 hash from a blob reference string. */
+export declare function parseBlobRef(data: string): string | null;
+/** Identify provider transport image data URLs so persistence can externalize and restore them losslessly. */
+export declare function isImageDataUrl(data: string): boolean;
+/**
+ * Externalize a provider image data URL to the blob store, returning a blob reference.
+ * The full data URL string is preserved so transport-native history can be reconstructed on resume.
+ */
+export declare function externalizeImageDataUrl(blobStore: BlobStore, dataUrl: string): Promise<string>;
+/** Synchronous variant of {@link externalizeImageDataUrl}. */
+export declare function externalizeImageDataUrlSync(blobStore: BlobStore, dataUrl: string): string;
+/**
+ * Externalize an image's base64 data to the blob store, returning a blob reference.
+ * If the data is already a blob reference, returns it unchanged.
+ */
+export declare function externalizeImageData(blobStore: BlobStore, base64Data: string, mimeType?: string): Promise<string>;
+/** Synchronous variant of {@link externalizeImageData}. */
+export declare function externalizeImageDataSync(blobStore: BlobStore, base64Data: string, mimeType?: string): string;
+/**
+ * Resolve an externalized provider image data URL back to its original string.
+ * If the data is not a blob reference, returns it unchanged.
+ * If the blob is missing, logs a warning and returns the reference as-is.
+ */
+export declare function resolveImageDataUrl(blobStore: BlobStore, data: string): Promise<string>;
+/**
+ * Resolve a blob reference back to base64 data.
+ * If the data is not a blob reference, returns it unchanged.
+ * If the blob is missing, logs a warning and returns a placeholder.
+ */
+export declare function resolveImageData(blobStore: BlobStore, data: string): Promise<string>;

package/dist/types/session/client-bridge.d.ts

@@ -0,0 +1,88 @@
+/**
+ * ClientBridge — abstraction over capabilities provided by an external client
+ * (e.g. ACP editor host) that the agent can route through instead of operating
+ * directly on the local filesystem / spawning local subprocesses.
+ *
+ * When `undefined`, tools fall back to local IO. When populated (currently
+ * only by `AcpAgent`), tools route requests through the client so it can
+ * surface unsaved buffer state, render terminals in the IDE, or gate
+ * destructive operations behind user permission prompts.
+ */
+export interface ClientBridgeCapabilities {
+    /** Client implements `fs/read_text_file`. */
+    readTextFile?: boolean;
+    /** Client implements `fs/write_text_file`. */
+    writeTextFile?: boolean;
+    /** Client implements the `terminal/*` family. */
+    terminal?: boolean;
+    /** Client implements `session/request_permission`. */
+    requestPermission?: boolean;
+}
+export interface ClientBridgePermissionToolCall {
+    toolCallId: string;
+    toolName: string;
+    title: string;
+    kind?: string;
+    status?: "pending" | "in_progress" | "completed" | "failed";
+    rawInput?: unknown;
+    content?: unknown[];
+    locations?: {
+        path: string;
+        line?: number;
+    }[];
+}
+export type ClientBridgePermissionOptionKind = "allow_once" | "allow_always" | "reject_once" | "reject_always";
+export interface ClientBridgePermissionOption {
+    optionId: string;
+    name: string;
+    kind: ClientBridgePermissionOptionKind;
+}
+export type ClientBridgePermissionOutcome = {
+    outcome: "cancelled";
+} | {
+    outcome: "selected";
+    optionId: string;
+    kind?: ClientBridgePermissionOptionKind;
+};
+export interface ClientBridgeTerminalExitStatus {
+    exitCode?: number | null;
+    signal?: string | null;
+}
+export interface ClientBridgeTerminalOutput {
+    output: string;
+    truncated: boolean;
+    exitStatus?: ClientBridgeTerminalExitStatus | null;
+}
+export interface ClientBridgeTerminalHandle {
+    terminalId: string;
+    waitForExit(): Promise<ClientBridgeTerminalExitStatus>;
+    currentOutput(): Promise<ClientBridgeTerminalOutput>;
+    kill(): Promise<void>;
+    release(): Promise<void>;
+}
+export interface ClientBridgeCreateTerminalParams {
+    command: string;
+    args?: string[];
+    env?: Array<{
+        name: string;
+        value: string;
+    }>;
+    cwd?: string;
+    outputByteLimit?: number;
+}
+export interface ClientBridge {
+    readonly capabilities: ClientBridgeCapabilities;
+    /** ACP v1 clients cannot show server-initiated turns as busy after prompt response. */
+    readonly deferAgentInitiatedTurns?: boolean;
+    readTextFile?(params: {
+        path: string;
+        line?: number;
+        limit?: number;
+    }): Promise<string>;
+    writeTextFile?(params: {
+        path: string;
+        content: string;
+    }): Promise<void>;
+    createTerminal?(params: ClientBridgeCreateTerminalParams): Promise<ClientBridgeTerminalHandle>;
+    requestPermission?(toolCall: ClientBridgePermissionToolCall, options: ClientBridgePermissionOption[], signal?: AbortSignal): Promise<ClientBridgePermissionOutcome>;
+}

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

@@ -0,0 +1,30 @@
+export interface HistoryEntry {
+    id: number;
+    prompt: string;
+    created_at: number;
+    cwd?: string;
+    /** ID of the session the prompt was submitted from, if known. */
+    sessionId?: string;
+}
+export declare class HistoryStorage {
+    #private;
+    private constructor();
+    static open(dbPath?: string): HistoryStorage;
+    /** @internal Reset the singleton — test-only. */
+    static resetInstance(): void;
+    /**
+     * Register a resolver that supplies the current session ID for prompts added
+     * without an explicit `sessionId`. Evaluated synchronously at `add()` time so
+     * batched writes capture the session active when the prompt was submitted.
+     */
+    setSessionResolver(resolver: () => string | undefined): void;
+    add(prompt: string, cwd?: string, sessionId?: string): Promise<void>;
+    getRecent(limit: number): HistoryEntry[];
+    search(query: string, limit: number): HistoryEntry[];
+    /**
+     * IDs of the sessions whose stored prompts match `query`, ordered by prompt
+     * recency and de-duplicated. Used to augment session ranking in the resume
+     * picker with prompts that the 4KB session-list prefix never sees.
+     */
+    matchingSessionIds(query: string, limit?: number): string[];
+}

package/dist/types/session/indexed-session-storage.d.ts

@@ -0,0 +1,59 @@
+import type { SessionStorage, SessionStorageStat, SessionStorageWriter } from "./session-storage";
+export interface SessionStorageIndexEntry {
+    path: string;
+    size: number;
+    mtimeMs: number;
+}
+export interface SessionStorageBackend {
+    init(): Promise<void>;
+    loadIndex(): Promise<Iterable<SessionStorageIndexEntry>>;
+    readFull(path: string): Promise<string | null>;
+    readSlices(path: string, prefixBytes: number, suffixBytes: number): Promise<[string, string]>;
+    writeFull(path: string, content: string, mtimeMs: number): Promise<void>;
+    append(path: string, line: string, mtimeMs: number): Promise<void>;
+    truncate(path: string, mtimeMs: number): Promise<void>;
+    remove(paths: string[]): Promise<void>;
+    move(src: string, dst: string, mtimeMs: number): Promise<void>;
+}
+export declare class IndexedSessionStorage implements SessionStorage {
+    #private;
+    constructor(backend: SessionStorageBackend);
+    initialize(): Promise<void>;
+    refresh(): Promise<void>;
+    drain(): Promise<void>;
+    ensureDirSync(_dir: string): void;
+    existsSync(path: string): boolean;
+    writeTextSync(path: string, content: string): void;
+    statSync(path: string): SessionStorageStat;
+    listFilesSync(dir: string, pattern: string): string[];
+    exists(path: string): Promise<boolean>;
+    readText(path: string): Promise<string>;
+    readTextSlices(path: string, prefixBytes: number, suffixBytes: number): Promise<[string, string]>;
+    writeText(path: string, content: string): Promise<void>;
+    rename(src: string, dst: string): Promise<void>;
+    unlink(path: string): Promise<void>;
+    deleteSessionWithArtifacts(sessionPath: string): Promise<void>;
+    openWriter(path: string, options?: {
+        flags?: "a" | "w";
+        onError?: (err: Error) => void;
+    }): SessionStorageWriter;
+    _writerClosed(writer: IndexedSessionStorageWriter): void;
+    _truncateForWriter(path: string): number;
+    _queueTruncate(path: string, mtimeMs: number, getError?: () => Error | undefined): Promise<void>;
+    _appendForWriter(path: string, line: string): number;
+    _queueAppend(path: string, line: string, mtimeMs: number, getError?: () => Error | undefined): Promise<void>;
+}
+declare class IndexedSessionStorageWriter implements SessionStorageWriter {
+    #private;
+    constructor(storage: IndexedSessionStorage, path: string, options?: {
+        flags?: "a" | "w";
+        onError?: (err: Error) => void;
+    });
+    writeLineSync(line: string): void;
+    writeLine(line: string): Promise<void>;
+    flush(): Promise<void>;
+    fsync(): Promise<void>;
+    close(): Promise<void>;
+    getError(): Error | undefined;
+}
+export {};

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

@@ -0,0 +1,173 @@
+/**
+ * Custom message types and transformers for the coding agent.
+ *
+ * Extends the base AgentMessage type with coding-agent specific message types,
+ * and provides a transformer to convert them to LLM-compatible messages.
+ */
+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";
+import type { OutputMeta } from "../tools/output-meta";
+export declare const SKILL_PROMPT_MESSAGE_TYPE = "skill-prompt";
+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;
+}
+/** Sentinel value for `AssistantMessage.errorMessage` indicating that the abort
+ *  was an *expected internal transition* (plan-mode → execution compaction)
+ *  and must NOT surface as a red "Operation aborted" line. Distinct from
+ *  `undefined` (default) so user-cancel aborts with no errorMessage still
+ *  render normally. Persists through SessionManager so history replay
+ *  branches identically.
+ *
+ *  Consumers: `AgentSession.#handleAgentEvent` (stamper) writes this value;
+ *  `EventController.#handleMessageEnd`, `AssistantMessageComponent`,
+ *  `ui-helpers.addMessageToChat` (renderers), `SessionObserverOverlay
+ *  #buildTranscriptLines`, `runPrintMode`, and `AcpAgent#replayAssistantMessage`
+ *  (fallback error emission) read it via `isSilentAbort`. */
+export declare const SILENT_ABORT_MARKER = "__prometheus.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
+ *  `details` blob. Safe over `unknown`; returns undefined when the field is
+ *  absent or non-string. */
+export declare function readPendingDisplayTag(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"];
+/** 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
+ *  clone cost on the common path. */
+export declare function stripInternalDetailsFields<T>(details: T | undefined): T | undefined;
+export declare function wrapSteeringForModel(messages: AgentMessage[]): AgentMessage[];
+/**
+ * Strip image content blocks from `message` in place. Returns the count of
+ * images removed across `content` (every role that carries `ImageContent`) and
+ * any tool-result `details.images` payload. Callers MUST rewrite session
+ * entries (`SessionManager.rewriteEntries`) and replay them through
+ * `Agent.replaceMessages` afterwards so persisted state and provider-side
+ * caches stay aligned with the mutated tree — `stripImagesFromMessage` is a
+ * pure local mutation and intentionally does neither.
+ */
+export declare function stripImagesFromMessage(message: AgentMessage): number;
+/**
+ * Message type for bash executions via the ! command.
+ */
+export interface BashExecutionMessage {
+    role: "bashExecution";
+    command: string;
+    output: string;
+    exitCode: number | undefined;
+    cancelled: boolean;
+    truncated: boolean;
+    meta?: OutputMeta;
+    timestamp: number;
+    /** If true, this message is excluded from LLM context (!! prefix) */
+    excludeFromContext?: boolean;
+}
+/**
+ * Message type for user-initiated Python executions via the $ command.
+ * Shares the same kernel session as eval's Python backend.
+ */
+export interface PythonExecutionMessage {
+    role: "pythonExecution";
+    code: string;
+    output: string;
+    exitCode: number | undefined;
+    cancelled: boolean;
+    truncated: boolean;
+    meta?: OutputMeta;
+    timestamp: number;
+    /** If true, this message is excluded from LLM context ($$ prefix) */
+    excludeFromContext?: boolean;
+}
+/**
+ * Message type for extension-injected messages via sendMessage().
+ */
+export interface CustomMessage<T = unknown> {
+    role: "custom";
+    customType: string;
+    content: string | (TextContent | ImageContent)[];
+    display: boolean;
+    details?: T;
+    /** Who initiated this message for billing/attribution semantics. */
+    attribution?: MessageAttribution;
+    timestamp: number;
+}
+/**
+ * Legacy hook message type (pre-extensions). Kept for session migration.
+ */
+export interface HookMessage<T = unknown> {
+    role: "hookMessage";
+    customType: string;
+    content: string | (TextContent | ImageContent)[];
+    display: boolean;
+    details?: T;
+    /** Who initiated this message for billing/attribution semantics. */
+    attribution?: MessageAttribution;
+    timestamp: number;
+}
+/**
+ * Message type for auto-read file mentions via @filepath syntax.
+ */
+export interface FileMentionMessage {
+    role: "fileMention";
+    files: Array<{
+        path: string;
+        content: string;
+        lineCount?: number;
+        /** File size in bytes, if known. */
+        byteSize?: number;
+        /** Why the file contents were omitted from auto-read. */
+        skippedReason?: "tooLarge";
+        image?: ImageContent;
+    }>;
+    timestamp: number;
+}
+declare module "@prometheus-ai/agent-core" {
+    interface CustomAgentMessages {
+        bashExecution: BashExecutionMessage;
+        pythonExecution: PythonExecutionMessage;
+        custom: CustomMessage;
+        hookMessage: HookMessage;
+        branchSummary: BranchSummaryMessage;
+        compactionSummary: CompactionSummaryMessage;
+        fileMention: FileMentionMessage;
+    }
+}
+/**
+ * Convert a BashExecutionMessage to user message text for LLM context.
+ */
+export declare function bashExecutionToText(msg: BashExecutionMessage): string;
+/**
+ * Convert a PythonExecutionMessage to user message text for LLM context.
+ */
+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.
+ *
+ * This is used by:
+ * - Agent's transormToLlm option (for prompt calls and queued messages)
+ * - Compaction's generateSummary (for summarization)
+ * - Custom extensions and tools
+ */
+export declare function convertToLlm(messages: AgentMessage[]): Message[];

package/dist/types/session/redis-session-storage.d.ts

@@ -0,0 +1,51 @@
+import { IndexedSessionStorage } from "./indexed-session-storage";
+/**
+ * Minimal subset of the `bun:redis` `RedisClient` surface used by
+ * {@link RedisSessionStorage}. Keeping the contract narrow (and accepting any
+ * client that conforms) lets callers swap in test doubles or shared clients
+ * without dragging the entire Bun typings into this module.
+ */
+export interface RedisSessionStorageClient {
+    get(key: string): Promise<string | null>;
+    getrange(key: string, start: number, end: number): Promise<string>;
+    strlen(key: string): Promise<number>;
+    set(key: string, value: string): Promise<unknown>;
+    append(key: string, value: string): Promise<number>;
+    del(...keys: string[]): Promise<number>;
+    rename(src: string, dst: string): Promise<unknown>;
+    scan(cursor: string, ...args: string[]): Promise<[string, string[]]>;
+    hset(key: string, field: string, value: string): Promise<unknown>;
+    hgetall(key: string): Promise<Record<string, string>>;
+    hdel(key: string, ...fields: string[]): Promise<unknown>;
+}
+export interface RedisSessionStorageOptions {
+    /** A connected `bun:redis` RedisClient (or any compatible adapter). */
+    client: RedisSessionStorageClient;
+    /**
+     * Key prefix applied to every Redis key this storage owns. Default `prometheus:sessions:`.
+     * Trailing colon is preserved verbatim — set to a project-scoped prefix to share
+     * one Redis instance between multiple agents.
+     */
+    prefix?: string;
+    /**
+     * Maximum number of keys returned per SCAN batch when warming the metadata index.
+     * Default 500.
+     */
+    scanCount?: number;
+}
+/**
+ * Redis-backed implementation of {@link SessionStorage}. Each session JSONL
+ * file maps to a Redis STRING key, with per-key metadata (mtime) tracked in a
+ * single sibling HASH. This process keeps only a metadata index (`size`,
+ * `mtimeMs`) in memory so synchronous `existsSync` / `statSync` /
+ * `listFilesSync` calls remain available without mirroring full content.
+ */
+export declare class RedisSessionStorage extends IndexedSessionStorage {
+    /**
+     * Warm the metadata index with every existing session key under the configured
+     * prefix and return the ready-to-use storage. Must be awaited before passing
+     * the storage into `SessionManager.create()` so synchronous lookups (session
+     * resume, recent sessions, EPERM-backup recovery) see the existing keyspace.
+     */
+    static create(options: RedisSessionStorageOptions): Promise<RedisSessionStorage>;
+}

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

@@ -0,0 +1,22 @@
+/**
+ * Plain-text / markdown session formatting (same shape as /dump clipboard export).
+ */
+import type { AgentMessage, ThinkingLevel } from "@prometheus-ai/agent-core";
+import type { Model } from "@prometheus-ai/ai";
+/** Minimal tool shape for dump output (matches AgentTool fields used by formatSessionDumpText). */
+export interface SessionDumpToolInfo {
+    name: string;
+    description: string;
+    parameters: unknown;
+}
+export interface FormatSessionDumpTextOptions {
+    messages: readonly AgentMessage[];
+    systemPrompt?: readonly string[] | null;
+    model?: Model | null;
+    thinkingLevel?: ThinkingLevel | string | null;
+    tools?: readonly SessionDumpToolInfo[];
+}
+/**
+ * Format messages and session metadata as markdown/plain text (same as AgentSession.formatSessionAsText / /dump).
+ */
+export declare function formatSessionDumpText(options: FormatSessionDumpTextOptions): string;