@wingman-ai/gateway 0.1.0

package/dist/cli/core/sessionManager.cjs

@@ -0,0 +1,535 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    resolveMessageRole: ()=>resolveMessageRole,
+    SessionManager: ()=>SessionManager,
+    extractImageUrl: ()=>extractImageUrl,
+    extractAttachments: ()=>extractAttachments,
+    extractImageAttachments: ()=>extractImageAttachments,
+    extractMessagesFromState: ()=>extractMessagesFromState
+});
+const langgraph_checkpoint_sqlite_namespaceObject = require("@langchain/langgraph-checkpoint-sqlite");
+const external_deepagents_namespaceObject = require("deepagents");
+const external_uuid_namespaceObject = require("uuid");
+function _define_property(obj, key, value) {
+    if (key in obj) Object.defineProperty(obj, key, {
+        value: value,
+        enumerable: true,
+        configurable: true,
+        writable: true
+    });
+    else obj[key] = value;
+    return obj;
+}
+const isBunRuntime = void 0 !== globalThis.Bun;
+class SessionManager {
+    async initialize() {
+        if (!isBunRuntime) throw new Error("SessionManager requires Bun runtime (bun:sqlite not available)");
+        const { BunSqliteAdapter } = await import("./database/bunSqliteAdapter.cjs");
+        const adapter = new BunSqliteAdapter(this.dbPath);
+        this.checkpointer = new langgraph_checkpoint_sqlite_namespaceObject.SqliteSaver(adapter);
+        await this.checkpointer.setup();
+        this.db = adapter.db;
+        this.db.run(`
+      CREATE TABLE IF NOT EXISTS sessions (
+        id TEXT PRIMARY KEY,
+        name TEXT NOT NULL,
+        agent_name TEXT NOT NULL,
+        created_at INTEGER NOT NULL,
+        updated_at INTEGER NOT NULL,
+        status TEXT NOT NULL DEFAULT 'active',
+        message_count INTEGER DEFAULT 0,
+        last_message_preview TEXT,
+        metadata TEXT
+      );
+
+      CREATE INDEX IF NOT EXISTS idx_sessions_updated ON sessions(updated_at DESC);
+      CREATE INDEX IF NOT EXISTS idx_sessions_agent ON sessions(agent_name);
+    `);
+    }
+    createSession(agentName, name) {
+        if (!this.db) throw new Error("SessionManager not initialized");
+        const id = (0, external_uuid_namespaceObject.v4)();
+        const now = Date.now();
+        const sessionName = name || `Session ${new Date().toLocaleString()}`;
+        const stmt = this.db.prepare(`
+      INSERT INTO sessions (id, name, agent_name, created_at, updated_at, status, message_count)
+      VALUES (?, ?, ?, ?, ?, 'active', 0)
+    `);
+        stmt.run(id, sessionName, agentName, now, now);
+        return {
+            id,
+            name: sessionName,
+            agentName,
+            createdAt: new Date(now),
+            updatedAt: new Date(now),
+            status: "active",
+            messageCount: 0
+        };
+    }
+    getOrCreateSession(sessionId, agentName, name) {
+        if (!this.db) throw new Error("SessionManager not initialized");
+        const existing = this.getSession(sessionId);
+        if (existing) return existing;
+        const now = Date.now();
+        const sessionName = name || `Session ${new Date().toLocaleString()}`;
+        const stmt = this.db.prepare(`
+      INSERT INTO sessions (id, name, agent_name, created_at, updated_at, status, message_count)
+      VALUES (?, ?, ?, ?, ?, 'active', 0)
+    `);
+        stmt.run(sessionId, sessionName, agentName, now, now);
+        return {
+            id: sessionId,
+            name: sessionName,
+            agentName,
+            createdAt: new Date(now),
+            updatedAt: new Date(now),
+            status: "active",
+            messageCount: 0
+        };
+    }
+    getSession(sessionId) {
+        if (!this.db) throw new Error("SessionManager not initialized");
+        const stmt = this.db.prepare(`
+      SELECT * FROM sessions WHERE id = ?
+    `);
+        const row = stmt.get(sessionId);
+        if (!row) return null;
+        return this.rowToSession(row);
+    }
+    getLastSession() {
+        if (!this.db) throw new Error("SessionManager not initialized");
+        const stmt = this.db.prepare(`
+      SELECT * FROM sessions
+      WHERE status = 'active'
+      ORDER BY updated_at DESC
+      LIMIT 1
+    `);
+        const row = stmt.get();
+        if (!row) return null;
+        return this.rowToSession(row);
+    }
+    listSessions(options = {}) {
+        if (!this.db) throw new Error("SessionManager not initialized");
+        const { status = "active", limit = 10, offset = 0, agentName } = options;
+        let query = `
+      SELECT * FROM sessions
+      WHERE status = ?
+    `;
+        const params = [
+            status
+        ];
+        if (agentName) {
+            query += " AND agent_name = ?";
+            params.push(agentName);
+        }
+        query += " ORDER BY updated_at DESC LIMIT ? OFFSET ?";
+        params.push(limit, offset);
+        const stmt = this.db.prepare(query);
+        const rows = stmt.all(...params);
+        return rows.map(this.rowToSession);
+    }
+    updateSession(sessionId, updates) {
+        if (!this.db) throw new Error("SessionManager not initialized");
+        const fields = [];
+        const values = [];
+        if (void 0 !== updates.name) {
+            fields.push("name = ?");
+            values.push(updates.name);
+        }
+        if (void 0 !== updates.status) {
+            fields.push("status = ?");
+            values.push(updates.status);
+        }
+        if (void 0 !== updates.messageCount) {
+            fields.push("message_count = ?");
+            values.push(updates.messageCount);
+        }
+        if (void 0 !== updates.lastMessagePreview) {
+            fields.push("last_message_preview = ?");
+            values.push(updates.lastMessagePreview);
+        }
+        fields.push("updated_at = ?");
+        values.push(Date.now());
+        values.push(sessionId);
+        const stmt = this.db.prepare(`
+      UPDATE sessions
+      SET ${fields.join(", ")}
+      WHERE id = ?
+    `);
+        stmt.run(...values);
+    }
+    updateSessionMetadata(sessionId, metadata) {
+        if (!this.db) throw new Error("SessionManager not initialized");
+        const existing = this.getSession(sessionId);
+        const nextMetadata = {
+            ...existing?.metadata || {},
+            ...metadata
+        };
+        const stmt = this.db.prepare(`
+      UPDATE sessions
+      SET metadata = ?, updated_at = ?
+      WHERE id = ?
+    `);
+        stmt.run(JSON.stringify(nextMetadata), Date.now(), sessionId);
+    }
+    archiveSession(sessionId) {
+        this.updateSession(sessionId, {
+            status: "archived"
+        });
+    }
+    deleteSession(sessionId) {
+        if (!this.db || !this.checkpointer) throw new Error("SessionManager not initialized");
+        const sessionStmt = this.db.prepare("DELETE FROM sessions WHERE id = ?");
+        sessionStmt.run(sessionId);
+        const checkpointStmt = this.db.prepare("DELETE FROM checkpoints WHERE thread_id = ?");
+        checkpointStmt.run(sessionId);
+        const writesStmt = this.db.prepare("DELETE FROM writes WHERE thread_id = ?");
+        writesStmt.run(sessionId);
+    }
+    clearSessionMessages(sessionId) {
+        if (!this.db || !this.checkpointer) throw new Error("SessionManager not initialized");
+        const checkpointStmt = this.db.prepare("DELETE FROM checkpoints WHERE thread_id = ?");
+        checkpointStmt.run(sessionId);
+        const writesStmt = this.db.prepare("DELETE FROM writes WHERE thread_id = ?");
+        writesStmt.run(sessionId);
+        const sessionStmt = this.db.prepare(`
+      UPDATE sessions
+      SET message_count = 0, last_message_preview = NULL, updated_at = ?
+      WHERE id = ?
+    `);
+        sessionStmt.run(Date.now(), sessionId);
+    }
+    getCheckpointer() {
+        if (!this.checkpointer) throw new Error("SessionManager not initialized");
+        return this.checkpointer;
+    }
+    async listMessages(sessionId) {
+        if (!this.checkpointer) throw new Error("SessionManager not initialized");
+        const stateMessages = await this.loadMessagesFromState(sessionId);
+        if (null !== stateMessages) return stateMessages;
+        const rawCheckpoints = this.loadRecentCheckpoints(sessionId, 25);
+        const fallbackTuple = 0 === rawCheckpoints.length ? await this.checkpointer.getTuple({
+            configurable: {
+                thread_id: sessionId
+            }
+        }) : null;
+        const checkpoints = [
+            ...rawCheckpoints,
+            ...fallbackTuple?.checkpoint ? [
+                fallbackTuple.checkpoint
+            ] : []
+        ];
+        if (0 === checkpoints.length) return [];
+        let bestScore = -1;
+        let bestMessages = [];
+        for (const checkpoint of checkpoints){
+            const channelValues = checkpoint?.channel_values || checkpoint?.channelValues || checkpoint?.state?.channel_values || checkpoint?.state?.channelValues || {};
+            const candidates = [];
+            if (Array.isArray(channelValues?.messages)) candidates.push(channelValues.messages);
+            for (const value of Object.values(channelValues))if (Array.isArray(value)) candidates.push(value);
+            const relevantCandidates = candidates.filter((arr)=>arr.some(isMessageLike));
+            if (0 === relevantCandidates.length) continue;
+            const baseTime = parseTimestamp(checkpoint?.ts);
+            const scored = relevantCandidates.map((candidate)=>scoreMessages(candidate, baseTime));
+            scored.sort((a, b)=>b.score - a.score);
+            if (scored[0] && scored[0].score > bestScore) {
+                bestScore = scored[0].score;
+                bestMessages = scored[0].messages;
+            }
+        }
+        if (0 === bestMessages.length) return [];
+        return filterEmptyAssistantMessages(bestMessages);
+    }
+    rowToSession(row) {
+        return {
+            id: row.id,
+            name: row.name,
+            agentName: row.agent_name,
+            createdAt: new Date(row.created_at),
+            updatedAt: new Date(row.updated_at),
+            status: row.status,
+            messageCount: row.message_count,
+            lastMessagePreview: row.last_message_preview,
+            metadata: row.metadata ? JSON.parse(row.metadata) : void 0
+        };
+    }
+    close() {
+        if (this.db) this.db.close();
+    }
+    loadRecentCheckpoints(sessionId, limit) {
+        if (!this.db) return [];
+        const stmt = this.db.prepare(`
+      SELECT checkpoint
+      FROM checkpoints
+      WHERE thread_id = ?
+      ORDER BY rowid DESC
+      LIMIT ?
+    `);
+        const rows = stmt.all(sessionId, limit);
+        const checkpoints = [];
+        for (const row of rows){
+            if (!row?.checkpoint) continue;
+            const raw = row.checkpoint;
+            let text = null;
+            if ("string" == typeof raw) text = raw;
+            else if (raw instanceof Uint8Array) text = new TextDecoder().decode(raw);
+            if (text) try {
+                checkpoints.push(JSON.parse(text));
+            } catch  {
+                continue;
+            }
+        }
+        return checkpoints;
+    }
+    getStateReaderAgent() {
+        if (!this.checkpointer) throw new Error("SessionManager not initialized");
+        if (!this.stateReaderAgent) this.stateReaderAgent = (0, external_deepagents_namespaceObject.createDeepAgent)({
+            checkpointer: this.checkpointer
+        });
+        return this.stateReaderAgent;
+    }
+    async loadMessagesFromState(sessionId) {
+        if (!this.checkpointer) return null;
+        try {
+            const agent = this.getStateReaderAgent();
+            if ("function" != typeof agent.getState) return null;
+            const state = await agent.getState({
+                configurable: {
+                    thread_id: sessionId
+                }
+            });
+            return extractMessagesFromState(state);
+        } catch  {
+            return null;
+        }
+    }
+    constructor(dbPath){
+        _define_property(this, "checkpointer", null);
+        _define_property(this, "stateReaderAgent", null);
+        _define_property(this, "db", null);
+        _define_property(this, "dbPath", void 0);
+        this.dbPath = dbPath;
+    }
+}
+function isMessageLike(entry) {
+    if (!entry || "object" != typeof entry) return false;
+    return "string" == typeof entry.role || "string" == typeof entry.type || "string" == typeof entry?.kwargs?.role || "string" == typeof entry?.additional_kwargs?.role;
+}
+function toSessionMessage(entry, index, baseTime) {
+    if (!entry || "object" != typeof entry) return null;
+    if (entry?.additional_kwargs?.ui_hidden || entry?.additional_kwargs?.uiHidden) return null;
+    if (entry?.metadata?.ui_hidden || entry?.metadata?.uiHidden) return null;
+    const role = resolveMessageRole(entry);
+    if ("user" !== role && "assistant" !== role) return null;
+    const blocks = extractContentBlocks(entry);
+    const content = "string" == typeof entry.content ? entry.content : "string" == typeof entry?.kwargs?.content ? entry.kwargs.content : "string" == typeof entry?.additional_kwargs?.content ? entry.additional_kwargs.content : "string" == typeof entry?.data?.content ? entry.data.content : blocks.length > 0 ? blocks.filter((block)=>block && "text" === block.type && block.text).map((block)=>block.text).join("") : "";
+    if ("user" === role && isUiHiddenContent(content)) return null;
+    const attachments = extractAttachments(blocks);
+    return {
+        id: `msg-${index}`,
+        role,
+        content,
+        attachments: attachments.length > 0 ? attachments : void 0,
+        createdAt: baseTime + index
+    };
+}
+function extractMessagesFromState(state) {
+    if (!state || "object" != typeof state) return null;
+    const values = state?.values ?? state?.value ?? state?.state ?? {};
+    const candidates = [
+        values?.messages,
+        values?.channel_values?.messages,
+        values?.channelValues?.messages,
+        state?.channel_values?.messages,
+        state?.channelValues?.messages
+    ];
+    const messages = candidates.find((candidate)=>Array.isArray(candidate));
+    if (!messages) return null;
+    const baseTime = parseTimestamp(state?.createdAt ?? values?.createdAt ?? state?.metadata?.createdAt ?? state?.metadata?.created_at ?? state?.ts);
+    const mapped = messages.map((message, index)=>toSessionMessage(message, index, baseTime)).filter(Boolean);
+    return filterEmptyAssistantMessages(mapped);
+}
+function extractContentBlocks(entry) {
+    if (!entry || "object" != typeof entry) return [];
+    const candidates = [
+        entry?.content,
+        entry?.kwargs?.content,
+        entry?.additional_kwargs?.content,
+        entry?.data?.content
+    ];
+    for (const candidate of candidates)if (Array.isArray(candidate)) return candidate;
+    return [];
+}
+function extractAttachments(blocks) {
+    const attachments = [];
+    for (const block of blocks){
+        if (!block || "object" != typeof block) continue;
+        const imageUrl = extractImageUrl(block);
+        if (imageUrl) {
+            attachments.push({
+                kind: "image",
+                dataUrl: imageUrl
+            });
+            continue;
+        }
+        const audioUrl = extractAudioUrl(block);
+        if (audioUrl) attachments.push({
+            kind: "audio",
+            dataUrl: audioUrl
+        });
+    }
+    return attachments;
+}
+function extractImageAttachments(blocks) {
+    return extractAttachments(blocks).filter((attachment)=>"image" === attachment.kind);
+}
+function extractImageUrl(block) {
+    if ("image_url" === block.type) {
+        if ("string" == typeof block.image_url) return block.image_url;
+        if ("string" == typeof block.image_url?.url) return block.image_url.url;
+    }
+    if ("input_image" === block.type) {
+        if ("string" == typeof block.image_url) return block.image_url;
+        if ("string" == typeof block.image_url?.url) return block.image_url.url;
+        if ("string" == typeof block.url) return block.url;
+    }
+    if ("image" === block.type && block.source) {
+        const mediaType = block.source.media_type || block.source.mediaType;
+        const data = block.source.data;
+        if (mediaType && data) return `data:${mediaType};base64,${data}`;
+    }
+    return null;
+}
+function extractAudioUrl(block) {
+    if ("audio_url" === block.type) {
+        if ("string" == typeof block.audio_url) return block.audio_url;
+        if ("string" == typeof block.audio_url?.url) return block.audio_url.url;
+    }
+    if ("input_audio" === block.type) {
+        const input = block.input_audio || block.audio;
+        const data = "string" == typeof input?.data ? input.data : null;
+        const format = "string" == typeof input?.format ? input.format : void 0;
+        if (data) {
+            const mimeType = format ? resolveAudioMimeType(format) : "audio/wav";
+            return `data:${mimeType};base64,${data}`;
+        }
+    }
+    if ("audio" === block.type && block.source) {
+        const mediaType = block.source.media_type || block.source.mediaType;
+        const data = block.source.data;
+        if (mediaType && data) return `data:${mediaType};base64,${data}`;
+    }
+    if ("audio" === block.type) {
+        const sourceType = block.source_type || block.sourceType;
+        const data = block.data;
+        if ("base64" === sourceType && "string" == typeof data) {
+            const rawFormat = block.mime_type || block.media_type || block.mediaType || block.format;
+            const mimeType = "string" == typeof rawFormat ? rawFormat.includes("/") ? rawFormat : resolveAudioMimeType(rawFormat) : "audio/wav";
+            return `data:${mimeType};base64,${data}`;
+        }
+        if ("url" === sourceType && "string" == typeof block.url) return block.url;
+    }
+    return null;
+}
+function resolveAudioMimeType(format) {
+    const normalized = format.toLowerCase();
+    switch(normalized){
+        case "mp3":
+        case "mpeg":
+            return "audio/mpeg";
+        case "wav":
+            return "audio/wav";
+        case "m4a":
+        case "mp4":
+            return "audio/mp4";
+        case "ogg":
+            return "audio/ogg";
+        case "webm":
+            return "audio/webm";
+        default:
+            return `audio/${normalized}`;
+    }
+}
+function mapMessageType(type) {
+    if (!type) return null;
+    if ("human" === type || "user" === type) return "user";
+    if ("ai" === type || "assistant" === type) return "assistant";
+    return null;
+}
+function mapMessageTypeFromId(id) {
+    if (!Array.isArray(id) || 0 === id.length) return null;
+    const last = String(id[id.length - 1] || "").toLowerCase();
+    if (last.includes("human") || last.includes("user")) return "user";
+    if (last.includes("ai") || last.includes("assistant")) return "assistant";
+    return null;
+}
+function resolveMessageRole(entry) {
+    return entry?.role || entry?.kwargs?.role || entry?.additional_kwargs?.role || mapMessageType(entry?.type) || mapMessageTypeFromId(entry?.id ?? entry?.lc_id ?? entry?.kwargs?.id);
+}
+function parseTimestamp(value) {
+    if ("number" == typeof value && Number.isFinite(value)) return value;
+    if ("string" == typeof value) {
+        const parsed = Date.parse(value);
+        if (!Number.isNaN(parsed)) return parsed;
+    }
+    return Date.now();
+}
+function isUiHiddenContent(content) {
+    if (!content) return false;
+    return content.includes("Current Date Time (UTC):") || content.startsWith("# User's Machine Information");
+}
+function scoreMessages(candidate, baseTime) {
+    const messages = candidate.map((message, index)=>toSessionMessage(message, index, baseTime)).filter(Boolean);
+    const contentful = messages.filter((msg)=>msg.content.trim().length > 0 || (msg.attachments?.length ?? 0) > 0).length;
+    const assistantContentful = messages.filter((msg)=>"assistant" === msg.role && msg.content.trim().length > 0).length;
+    const score = 3 * assistantContentful + 2 * contentful + messages.length;
+    return {
+        score,
+        messages
+    };
+}
+function filterEmptyAssistantMessages(messages) {
+    const filtered = messages.filter((message)=>"assistant" !== message.role || message.content.trim().length > 0 || (message.attachments?.length ?? 0) > 0);
+    return filtered.length > 0 ? filtered : messages;
+}
+exports.SessionManager = __webpack_exports__.SessionManager;
+exports.extractAttachments = __webpack_exports__.extractAttachments;
+exports.extractImageAttachments = __webpack_exports__.extractImageAttachments;
+exports.extractImageUrl = __webpack_exports__.extractImageUrl;
+exports.extractMessagesFromState = __webpack_exports__.extractMessagesFromState;
+exports.resolveMessageRole = __webpack_exports__.resolveMessageRole;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "SessionManager",
+    "extractAttachments",
+    "extractImageAttachments",
+    "extractImageUrl",
+    "extractMessagesFromState",
+    "resolveMessageRole"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cli/core/sessionManager.d.ts

@@ -0,0 +1,111 @@
+import { SqliteSaver } from "@langchain/langgraph-checkpoint-sqlite";
+export interface Session {
+    id: string;
+    name: string;
+    agentName: string;
+    createdAt: Date;
+    updatedAt: Date;
+    status: "active" | "archived" | "deleted";
+    messageCount: number;
+    lastMessagePreview?: string;
+    metadata?: Record<string, any>;
+}
+export interface ListSessionsOptions {
+    status?: "active" | "archived" | "deleted";
+    limit?: number;
+    offset?: number;
+    agentName?: string;
+}
+export interface SessionMessage {
+    id: string;
+    role: "user" | "assistant";
+    content: string;
+    attachments?: SessionAttachment[];
+    createdAt: number;
+}
+export interface SessionAttachment {
+    kind: "image" | "audio";
+    dataUrl: string;
+    name?: string;
+    mimeType?: string;
+    size?: number;
+}
+/**
+ * SessionManager handles session metadata and provides unified access to
+ * both the custom sessions table and LangGraph's SqliteSaver checkpointer.
+ */
+export declare class SessionManager {
+    private checkpointer;
+    private stateReaderAgent;
+    private db;
+    private dbPath;
+    constructor(dbPath: string);
+    /**
+     * Initialize the SessionManager with SqliteSaver and create custom tables
+     */
+    initialize(): Promise<void>;
+    /**
+     * Create a new session
+     */
+    createSession(agentName: string, name?: string): Session;
+    /**
+     * Get or create a session with a fixed ID
+     */
+    getOrCreateSession(sessionId: string, agentName: string, name?: string): Session;
+    /**
+     * Get a session by ID
+     */
+    getSession(sessionId: string): Session | null;
+    /**
+     * Get the most recently updated session
+     */
+    getLastSession(): Session | null;
+    /**
+     * List sessions with optional filtering
+     */
+    listSessions(options?: ListSessionsOptions): Session[];
+    /**
+     * Update a session's metadata
+     */
+    updateSession(sessionId: string, updates: Partial<Pick<Session, "name" | "status" | "messageCount" | "lastMessagePreview">>): void;
+    /**
+     * Merge and update session metadata
+     */
+    updateSessionMetadata(sessionId: string, metadata: Record<string, any>): void;
+    /**
+     * Archive a session (soft delete)
+     */
+    archiveSession(sessionId: string): void;
+    /**
+     * Delete a session (hard delete from database)
+     */
+    deleteSession(sessionId: string): void;
+    /**
+     * Clear session messages while preserving the session record
+     */
+    clearSessionMessages(sessionId: string): void;
+    /**
+     * Get the checkpointer for use with DeepAgents
+     */
+    getCheckpointer(): SqliteSaver;
+    /**
+     * List messages for a session by reading the latest checkpoint.
+     */
+    listMessages(sessionId: string): Promise<SessionMessage[]>;
+    /**
+     * Convert database row to Session object
+     */
+    private rowToSession;
+    /**
+     * Close the database connection
+     */
+    close(): void;
+    private loadRecentCheckpoints;
+    private getStateReaderAgent;
+    private loadMessagesFromState;
+}
+export declare function extractMessagesFromState(state: any): SessionMessage[] | null;
+export declare function extractAttachments(blocks: any[]): SessionAttachment[];
+export declare function extractImageAttachments(blocks: any[]): SessionAttachment[];
+export declare function extractImageUrl(block: any): string | null;
+export declare function resolveMessageRole(entry: any): "user" | "assistant" | null;