@undefineds.co/xpod 0.1.0-local.202602081751

package/dist/api/chatkit/pod-store.js

@@ -0,0 +1,794 @@
+"use strict";
+/**
+ * Pod-based ChatKit Store
+ *
+ * 将 ChatKit 数据存储到 Solid Pod。
+ *
+ * 存储结构:
+ * /.data/chat/{chatId}/
+ *   index.ttl
+ *     #this                           # Chat (meeting:LongChat)
+ *     #{threadId}                     # Thread (sioc:Thread)
+ *   {yyyy}/{MM}/{dd}/messages.ttl     # Messages (meeting:Message)
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PodChatKitStore = void 0;
+const solid_client_authn_node_1 = require("@inrupt/solid-client-authn-node");
+const drizzle_solid_1 = require("@undefineds.co/drizzle-solid");
+const global_logger_factory_1 = require("global-logger-factory");
+const types_1 = require("./types");
+const schema_1 = require("./schema");
+const AuthContext_1 = require("../auth/AuthContext");
+const provider_1 = require("../../ai/schema/provider");
+const tables_1 = require("../../credential/schema/tables");
+const types_2 = require("../../credential/schema/types");
+const schema = {
+    chat: schema_1.Chat,
+    thread: schema_1.Thread,
+    message: schema_1.Message,
+    provider: provider_1.Provider,
+    credential: tables_1.Credential,
+};
+/**
+ * Pod-based ChatKit Store implementation
+ *
+ * 数据模型映射：
+ * - ChatKit thread = Thread (sioc:Thread)
+ * - ChatKit thread item = Message (meeting:Message)
+ * - Chat (meeting:LongChat) 是容器/Agent，通过 metadata.chat_id 暴露
+ *
+ * 每个 Thread 属于一个 Chat 容器。默认使用 'default' Chat。
+ */
+class PodChatKitStore {
+    constructor(options) {
+        this.logger = (0, global_logger_factory_1.getLoggerFor)(this);
+        // Track recently created message IDs to avoid SELECT cache timing issues
+        this.recentlyCreatedIds = new Set();
+        this.tokenEndpoint = options.tokenEndpoint;
+    }
+    // =========================================================================
+    // Private Helpers
+    // =========================================================================
+    /**
+     * 获取认证后的 drizzle 实例 (缓存到 context 中)
+     */
+    async getDb(context) {
+        // Check if we already have a cached db in context
+        if (context._cachedDb) {
+            return context._cachedDb;
+        }
+        const auth = context.auth;
+        if (!auth || !(0, AuthContext_1.isSolidAuth)(auth) || !auth.clientId || !auth.clientSecret) {
+            this.logger.warn('No valid client credentials in context, cannot access Pod');
+            return null;
+        }
+        const session = new solid_client_authn_node_1.Session();
+        try {
+            await session.login({
+                oidcIssuer: new URL(this.tokenEndpoint).origin,
+                clientId: auth.clientId,
+                clientSecret: auth.clientSecret,
+            });
+            if (!session.info.isLoggedIn || !session.info.webId) {
+                throw new Error('Login failed');
+            }
+            const db = (0, drizzle_solid_1.drizzle)({ fetch: session.fetch, info: { webId: session.info.webId, isLoggedIn: true } }, { schema });
+            // 初始化表（创建容器、资源）
+            this.logger.info(`Initializing tables for Pod: ${session.info.webId}`);
+            try {
+                await db.init([schema_1.Chat, schema_1.Thread, schema_1.Message]);
+                this.logger.info('Tables initialized successfully');
+            }
+            catch (initError) {
+                this.logger.error(`Failed to init tables: ${initError}`);
+                // 继续执行，可能容器已存在
+            }
+            // Cache both db and session.fetch in context for reuse
+            context._cachedDb = db;
+            context._cachedFetch = session.fetch;
+            context._cachedWebId = session.info.webId;
+            return db;
+        }
+        catch (error) {
+            this.logger.error(`Failed to get Pod db: ${error}`);
+            return null;
+        }
+    }
+    /**
+     * 从 context 获取 webId
+     */
+    getWebId(context) {
+        const auth = context.auth;
+        if (auth && (0, AuthContext_1.isSolidAuth)(auth)) {
+            return auth.webId;
+        }
+        return undefined;
+    }
+    /**
+     * 将 ThreadStatus 对象转为字符串
+     */
+    statusToString(status) {
+        return status.type;
+    }
+    /**
+     * 将字符串转为 ThreadStatus 对象
+     */
+    stringToStatus(status) {
+        switch (status) {
+            case 'locked':
+                return { type: 'locked' };
+            case 'closed':
+                return { type: 'closed' };
+            default:
+                return { type: 'active' };
+        }
+    }
+    /**
+     * 从 ThreadMetadata.metadata 中获取 chat_id，如果没有则返回默认值
+     */
+    getChatIdFromMetadata(metadata) {
+        if (metadata && typeof metadata.chat_id === 'string') {
+            return metadata.chat_id;
+        }
+        return PodChatKitStore.DEFAULT_CHAT_ID;
+    }
+    /**
+     * 确保 Chat 容器存在，如果不存在则创建
+     */
+    async ensureChat(chatId, context) {
+        const db = await this.getDb(context);
+        if (!db) {
+            throw new Error('Cannot access Pod: invalid credentials');
+        }
+        const webId = this.getWebId(context);
+        // 检查是否存在
+        const existing = await db.query.chat.findFirst({
+            where: (0, drizzle_solid_1.eq)(schema_1.Chat.id, chatId),
+        });
+        if (!existing) {
+            // 创建 Chat 容器
+            const now = new Date().toISOString();
+            await db.insert(schema_1.Chat).values({
+                id: chatId,
+                title: chatId === PodChatKitStore.DEFAULT_CHAT_ID ? 'Default Chat' : chatId,
+                author: webId || null,
+                status: 'active',
+                createdAt: now,
+                updatedAt: now,
+            });
+            this.logger.info(`Created Chat container: ${chatId}`);
+        }
+    }
+    /**
+     * 将 ThreadRecord 转为 ThreadMetadata
+     * 包含 metadata.chat_id 暴露 Chat 容器 ID
+     */
+    threadRecordToMetadata(record) {
+        const chatId = this.extractChatId(record.chatId);
+        return {
+            id: record.id,
+            title: record.title || undefined,
+            status: this.stringToStatus(record.status),
+            created_at: record.createdAt ? Math.floor(new Date(record.createdAt).getTime() / 1000) : (0, types_1.nowTimestamp)(),
+            updated_at: record.updatedAt ? Math.floor(new Date(record.updatedAt).getTime() / 1000) : (0, types_1.nowTimestamp)(),
+            metadata: {
+                chat_id: chatId,
+            },
+        };
+    }
+    /**
+     * 将 MessageRecord 转为 ThreadItem
+     * thread_id 返回 Message 所属的 Thread ID
+     */
+    messageRecordToItem(record, threadId) {
+        const createdAt = record.createdAt ? Math.floor(new Date(record.createdAt).getTime() / 1000) : (0, types_1.nowTimestamp)();
+        if (record.role === schema_1.MessageRole.USER) {
+            return {
+                id: record.id,
+                thread_id: threadId,
+                type: 'user_message',
+                content: [{ type: 'input_text', text: record.content || '' }],
+                created_at: createdAt,
+            };
+        }
+        else {
+            return {
+                id: record.id,
+                thread_id: threadId,
+                type: 'assistant_message',
+                content: [{ type: 'output_text', text: record.content || '' }],
+                status: record.status || 'completed',
+                created_at: createdAt,
+            };
+        }
+    }
+    /**
+     * 从 Thread 获取 chatId（提取纯 ID）
+     */
+    extractChatId(chatIdOrUri) {
+        if (!chatIdOrUri)
+            return PodChatKitStore.DEFAULT_CHAT_ID;
+        if (chatIdOrUri.includes('#')) {
+            // 从 URI 中提取，如 http://.../.data/chat/default/index.ttl#this -> default
+            const match = chatIdOrUri.match(/\.data\/chat\/([^/]+)\/index\.ttl#this/);
+            if (match) {
+                return match[1];
+            }
+        }
+        return chatIdOrUri;
+    }
+    /**
+     * 获取 Thread 的 chatId
+     * 先从缓存获取，如果没有再查询数据库
+     */
+    async getThreadChatId(threadId, context) {
+        // 先检查缓存
+        const cached = this.getCachedThreadChatId(context, threadId);
+        if (cached) {
+            return cached;
+        }
+        const db = await this.getDb(context);
+        if (!db) {
+            throw new Error('Cannot access Pod: invalid credentials');
+        }
+        const thread = await db.query.thread.findFirst({
+            where: (0, drizzle_solid_1.eq)(schema_1.Thread.id, threadId),
+        });
+        if (!thread) {
+            // 如果找不到 Thread，返回默认 chatId
+            this.logger.warn(`Thread not found in DB, using default chatId: ${threadId}`);
+            return PodChatKitStore.DEFAULT_CHAT_ID;
+        }
+        const chatId = this.extractChatId(thread.chatId);
+        // 缓存结果
+        this.cacheThreadChatId(context, threadId, chatId);
+        return chatId;
+    }
+    /**
+     * 缓存 Thread -> chatId 映射
+     */
+    cacheThreadChatId(context, threadId, chatId) {
+        if (!context._threadChatIdCache) {
+            context._threadChatIdCache = new Map();
+        }
+        context._threadChatIdCache.set(threadId, chatId);
+    }
+    /**
+     * 从缓存获取 Thread 的 chatId
+     */
+    getCachedThreadChatId(context, threadId) {
+        const cache = context._threadChatIdCache;
+        return cache?.get(threadId);
+    }
+    /**
+     * 缓存完整的 Thread metadata
+     */
+    cacheThreadMetadata(context, thread) {
+        if (!context._threadMetadataCache) {
+            context._threadMetadataCache = new Map();
+        }
+        context._threadMetadataCache.set(thread.id, thread);
+    }
+    /**
+     * 从缓存获取 Thread metadata
+     */
+    getCachedThreadMetadata(context, threadId) {
+        const cache = context._threadMetadataCache;
+        return cache?.get(threadId);
+    }
+    // =========================================================================
+    // ID Generation
+    // =========================================================================
+    generateThreadId(_context) {
+        return (0, types_1.generateId)('thread');
+    }
+    generateItemId(itemType, _thread, _context) {
+        return (0, types_1.generateId)(itemType.replace('_', '-'));
+    }
+    // =========================================================================
+    // Thread Operations (ChatKit thread = our Thread)
+    // =========================================================================
+    async loadThread(threadId, context) {
+        // 先从缓存获取
+        const cached = this.getCachedThreadMetadata(context, threadId);
+        if (cached) {
+            return cached;
+        }
+        const db = await this.getDb(context);
+        if (!db) {
+            throw new Error('Cannot access Pod: invalid credentials');
+        }
+        const thread = await db.query.thread.findFirst({
+            where: (0, drizzle_solid_1.eq)(schema_1.Thread.id, threadId),
+        });
+        if (!thread) {
+            throw new Error(`Thread not found: ${threadId}`);
+        }
+        const metadata = this.threadRecordToMetadata(thread);
+        // 缓存结果
+        this.cacheThreadMetadata(context, metadata);
+        return metadata;
+    }
+    async saveThread(thread, context) {
+        const db = await this.getDb(context);
+        if (!db) {
+            throw new Error('Cannot access Pod: invalid credentials');
+        }
+        const now = new Date().toISOString();
+        // 从 metadata 获取 chat_id
+        const chatId = this.getChatIdFromMetadata(thread.metadata);
+        // 确保 Chat 容器存在
+        await this.ensureChat(chatId, context);
+        // 缓存 Thread -> chatId 映射，避免后续查询
+        this.cacheThreadChatId(context, thread.id, chatId);
+        // 检查 Thread 是否存在
+        const existing = await db.query.thread.findFirst({
+            where: (0, drizzle_solid_1.eq)(schema_1.Thread.id, thread.id),
+        });
+        if (existing) {
+            // Update
+            await db.update(schema_1.Thread).set({
+                title: thread.title || null,
+                status: this.statusToString(thread.status),
+                updatedAt: now,
+            }).where((0, drizzle_solid_1.eq)(schema_1.Thread.id, thread.id));
+        }
+        else {
+            // Insert
+            await db.insert(schema_1.Thread).values({
+                id: thread.id,
+                chatId, // 关联到 Chat 容器
+                title: thread.title || null,
+                status: this.statusToString(thread.status),
+                createdAt: new Date(thread.created_at * 1000).toISOString(),
+                updatedAt: now,
+            });
+        }
+        // 缓存完整的 Thread metadata，确保 metadata.chat_id 包含正确的值
+        const threadMetadata = {
+            ...thread,
+            metadata: { ...thread.metadata, chat_id: chatId },
+        };
+        this.cacheThreadMetadata(context, threadMetadata);
+    }
+    async loadThreads(limit, after, order, context) {
+        const db = await this.getDb(context);
+        if (!db) {
+            return { data: [], has_more: false };
+        }
+        try {
+            const threads = await db.select().from(schema_1.Thread);
+            // 排序
+            threads.sort((a, b) => {
+                const aTime = a.createdAt ? new Date(a.createdAt).getTime() : 0;
+                const bTime = b.createdAt ? new Date(b.createdAt).getTime() : 0;
+                return order === 'desc' ? bTime - aTime : aTime - bTime;
+            });
+            // 分页
+            let startIndex = 0;
+            if (after) {
+                const afterIndex = threads.findIndex((t) => t.id === after);
+                if (afterIndex !== -1) {
+                    startIndex = afterIndex + 1;
+                }
+            }
+            const slice = threads.slice(startIndex, startIndex + limit);
+            const hasMore = startIndex + limit < threads.length;
+            return {
+                data: slice.map((t) => this.threadRecordToMetadata(t)),
+                has_more: hasMore,
+                after: slice.length > 0 ? slice[slice.length - 1].id : undefined,
+            };
+        }
+        catch (error) {
+            this.logger.error(`Failed to load threads: ${error}`);
+            return { data: [], has_more: false };
+        }
+    }
+    async deleteThread(threadId, context) {
+        const db = await this.getDb(context);
+        if (!db) {
+            throw new Error('Cannot access Pod: invalid credentials');
+        }
+        // 尝试从缓存获取 chatId
+        let chatId = this.getCachedThreadChatId(context, threadId);
+        // 如果缓存没有，尝试从数据库查询
+        if (!chatId) {
+            try {
+                const thread = await db.query.thread.findFirst({
+                    where: (0, drizzle_solid_1.eq)(schema_1.Thread.id, threadId),
+                });
+                if (thread) {
+                    chatId = this.extractChatId(thread.chatId);
+                }
+            }
+            catch (err) {
+                // 忽略查询错误，继续尝试删除
+                this.logger.debug(`Ignoring thread query error during delete: ${err.message}`);
+            }
+        }
+        // 删除关联到此 Thread 的消息
+        try {
+            await db.delete(schema_1.Message).where((0, drizzle_solid_1.eq)(schema_1.Message.threadId, threadId));
+        }
+        catch (err) {
+            if (!err.message?.includes('404') && !err.message?.includes('Could not retrieve') && !err.message?.includes('Parse error')) {
+                throw err;
+            }
+            this.logger.debug(`Ignoring delete message error: ${err.message}`);
+        }
+        // 删除 Thread
+        try {
+            await db.delete(schema_1.Thread).where((0, drizzle_solid_1.eq)(schema_1.Thread.id, threadId));
+        }
+        catch (err) {
+            if (!err.message?.includes('404') && !err.message?.includes('Could not retrieve') && !err.message?.includes('Parse error')) {
+                throw err;
+            }
+            this.logger.debug(`Ignoring delete thread error: ${err.message}`);
+        }
+        // 清除缓存
+        const metadataCache = context._threadMetadataCache;
+        const chatIdCache = context._threadChatIdCache;
+        metadataCache?.delete(threadId);
+        chatIdCache?.delete(threadId);
+    }
+    // =========================================================================
+    // Thread Item Operations (ChatKit items = our Messages)
+    // =========================================================================
+    async loadThreadItems(threadId, after, limit, order, context) {
+        const db = await this.getDb(context);
+        if (!db) {
+            return { data: [], has_more: false };
+        }
+        try {
+            // 按 threadId 查询 Message
+            const messages = await db.select().from(schema_1.Message).where((0, drizzle_solid_1.eq)(schema_1.Message.threadId, threadId));
+            // 排序
+            messages.sort((a, b) => {
+                const aTime = a.createdAt ? new Date(a.createdAt).getTime() : 0;
+                const bTime = b.createdAt ? new Date(b.createdAt).getTime() : 0;
+                return order === 'desc' ? bTime - aTime : aTime - bTime;
+            });
+            // 分页
+            let startIndex = 0;
+            if (after) {
+                const afterIndex = messages.findIndex((m) => m.id === after);
+                if (afterIndex !== -1) {
+                    startIndex = afterIndex + 1;
+                }
+            }
+            const slice = messages.slice(startIndex, startIndex + limit);
+            const hasMore = startIndex + limit < messages.length;
+            return {
+                data: slice.map((m) => this.messageRecordToItem(m, threadId)),
+                has_more: hasMore,
+                after: slice.length > 0 ? slice[slice.length - 1].id : undefined,
+            };
+        }
+        catch (error) {
+            this.logger.error(`Failed to load thread items: ${error}`);
+            return { data: [], has_more: false };
+        }
+    }
+    async addThreadItem(threadId, item, context) {
+        const db = await this.getDb(context);
+        if (!db) {
+            throw new Error('Cannot access Pod: invalid credentials');
+        }
+        // 从 Thread 获取 chatId
+        const chatId = await this.getThreadChatId(threadId, context);
+        const webId = this.getWebId(context);
+        let content = '';
+        let role = schema_1.MessageRole.USER;
+        let status = null;
+        if (item.type === 'user_message') {
+            const userItem = item;
+            content = userItem.content
+                .filter((c) => c.type === 'input_text')
+                .map((c) => c.text)
+                .join('\n');
+            role = schema_1.MessageRole.USER;
+        }
+        else if (item.type === 'assistant_message') {
+            const assistantItem = item;
+            content = assistantItem.content
+                .filter((c) => c.type === 'output_text')
+                .map((c) => c.text)
+                .join('\n');
+            role = schema_1.MessageRole.ASSISTANT;
+            status = assistantItem.status || schema_1.MessageStatus.COMPLETED;
+        }
+        else {
+            // 其他类型暂时存储为 JSON
+            content = JSON.stringify(item);
+            role = schema_1.MessageRole.SYSTEM;
+        }
+        const messageRecord = {
+            id: item.id,
+            chatId, // 用于路径构建
+            threadId, // 关联到 Thread
+            maker: role === schema_1.MessageRole.USER ? webId : null,
+            role,
+            content,
+            status,
+            createdAt: new Date(item.created_at * 1000).toISOString(),
+        };
+        await db.insert(schema_1.Message).values(messageRecord);
+        // Track this ID to avoid cache timing issues in saveItem
+        this.recentlyCreatedIds.add(messageRecord.id);
+    }
+    async saveItem(threadId, item, context) {
+        const db = await this.getDb(context);
+        if (!db) {
+            throw new Error('Cannot access Pod: invalid credentials');
+        }
+        // 从 Thread 获取 chatId（用于构建资源路径）
+        const chatId = await this.getThreadChatId(threadId, context);
+        // 准备更新数据
+        let content = '';
+        let status = null;
+        if (item.type === 'user_message') {
+            const userItem = item;
+            content = userItem.content
+                .filter((c) => c.type === 'input_text')
+                .map((c) => c.text)
+                .join('\n');
+        }
+        else if (item.type === 'assistant_message') {
+            const assistantItem = item;
+            content = assistantItem.content
+                .filter((c) => c.type === 'output_text')
+                .map((c) => c.text)
+                .join('\n');
+            status = assistantItem.status || schema_1.MessageStatus.COMPLETED;
+        }
+        // 获取 createdAt 用于计算资源路径（与 drizzle-solid 模板填充保持一致）
+        const createdAt = item.created_at ? new Date(item.created_at * 1000).toISOString() : undefined;
+        // 如果是最近创建的消息，使用直接 PATCH 更新（避免 drizzle-solid UPDATE 的 bug）
+        const wasRecentlyCreated = this.recentlyCreatedIds.has(item.id);
+        if (wasRecentlyCreated) {
+            this.recentlyCreatedIds.delete(item.id);
+            await this.directPatchMessage(context, chatId, item.id, content, status, createdAt);
+            return;
+        }
+        // 对于非最近创建的消息，使用普通流程
+        const existingItems = await db.select().from(schema_1.Message).where((0, drizzle_solid_1.eq)(schema_1.Message.id, item.id));
+        const existing = existingItems.length > 0 ? existingItems[0] : null;
+        if (existing) {
+            // 使用直接 PATCH 更新
+            const existingCreatedAt = existing.createdAt
+                ? (existing.createdAt instanceof Date ? existing.createdAt.toISOString() : String(existing.createdAt))
+                : undefined;
+            await this.directPatchMessage(context, chatId, item.id, content, status, existingCreatedAt);
+        }
+        else {
+            // Create new record
+            await this.addThreadItem(threadId, item, context);
+        }
+    }
+    /**
+     * 直接使用 SPARQL UPDATE PATCH 更新消息内容
+     * 避免 drizzle-solid UPDATE 的 bug
+     */
+    async directPatchMessage(context, chatId, messageId, content, status, createdAt) {
+        // 使用缓存的 fetch 和 webId（由 getDb 时创建的 session）
+        const cachedFetch = context._cachedFetch;
+        const cachedWebId = context._cachedWebId;
+        if (!cachedFetch || !cachedWebId) {
+            throw new Error('No cached session for direct PATCH - call getDb first');
+        }
+        // 构建资源 URL 和 subject URI
+        // Template: {chatId}/{yyyy}/{MM}/{dd}/messages.ttl#{id}
+        // 使用 createdAt 时间来计算日期，与 drizzle-solid 的模板填充逻辑保持一致
+        const dateForPath = createdAt ? new Date(createdAt) : new Date();
+        const yyyy = dateForPath.getUTCFullYear();
+        const mm = String(dateForPath.getUTCMonth() + 1).padStart(2, '0');
+        const dd = String(dateForPath.getUTCDate()).padStart(2, '0');
+        const podBaseUrl = cachedWebId.replace('/profile/card#me', '');
+        const resourceUrl = `${podBaseUrl}/.data/chat/${chatId}/${yyyy}/${mm}/${dd}/messages.ttl`;
+        const subjectUri = `${resourceUrl}#${messageId}`;
+        // 构建 SPARQL UPDATE：删除旧值，插入新值
+        const deletePatterns = [];
+        const insertTriples = [];
+        // 转义特殊字符
+        const escapeForSparql = (value) => {
+            const hasQuotes = value.includes('"');
+            const hasNewlines = value.includes('\n') || value.includes('\r');
+            if (hasQuotes || hasNewlines) {
+                // 使用三引号
+                let escaped = value;
+                escaped = escaped.replace(/"""/g, '"\\"\\""');
+                if (escaped.endsWith('"')) {
+                    const match = escaped.match(/"*$/);
+                    const trailingQuotes = match ? match[0].length : 0;
+                    if (trailingQuotes > 0) {
+                        escaped = escaped.slice(0, -trailingQuotes) + '\\"'.repeat(trailingQuotes);
+                    }
+                }
+                return `"""${escaped}"""`;
+            }
+            return `"${value.replace(/\\/g, '\\\\').replace(/"/g, '\\"')}"`;
+        };
+        // Content 更新
+        deletePatterns.push(`<${subjectUri}> <http://rdfs.org/sioc/ns#content> ?oldContent .`);
+        insertTriples.push(`<${subjectUri}> <http://rdfs.org/sioc/ns#content> ${escapeForSparql(content)} .`);
+        // Status 更新
+        if (status) {
+            deletePatterns.push(`<${subjectUri}> <https://undefineds.co/ns#status> ?oldStatus .`);
+            insertTriples.push(`<${subjectUri}> <https://undefineds.co/ns#status> "${status}" .`);
+        }
+        const sparql = `
+DELETE { ${deletePatterns.join(' ')} }
+INSERT { ${insertTriples.join(' ')} }
+WHERE { ${deletePatterns.join(' ')} }
+    `.trim();
+        const response = await cachedFetch(resourceUrl, {
+            method: 'PATCH',
+            headers: { 'Content-Type': 'application/sparql-update' },
+            body: sparql,
+        });
+        if (!response.ok) {
+            const text = await response.text().catch(() => '');
+            throw new Error(`Direct PATCH failed: ${response.status} ${response.statusText} - ${text}`);
+        }
+    }
+    async loadItem(threadId, itemId, context) {
+        const db = await this.getDb(context);
+        if (!db) {
+            throw new Error('Cannot access Pod: invalid credentials');
+        }
+        const messages = await db.select().from(schema_1.Message).where((0, drizzle_solid_1.and)((0, drizzle_solid_1.eq)(schema_1.Message.id, itemId), (0, drizzle_solid_1.eq)(schema_1.Message.threadId, threadId)));
+        if (messages.length === 0) {
+            throw new Error(`Item not found: ${itemId}`);
+        }
+        return this.messageRecordToItem(messages[0], threadId);
+    }
+    async deleteThreadItem(threadId, itemId, context) {
+        const db = await this.getDb(context);
+        if (!db) {
+            throw new Error('Cannot access Pod: invalid credentials');
+        }
+        await db.delete(schema_1.Message).where((0, drizzle_solid_1.and)((0, drizzle_solid_1.eq)(schema_1.Message.id, itemId), (0, drizzle_solid_1.eq)(schema_1.Message.threadId, threadId)));
+    }
+    // =========================================================================
+    // Attachment Operations (存 Pod 文件)
+    // =========================================================================
+    async saveAttachment(attachment, _context) {
+        this.logger.info(`Attachment saved: ${attachment.id} (${attachment.name})`);
+    }
+    async loadAttachment(attachmentId, _context) {
+        throw new Error(`Attachment not found: ${attachmentId}`);
+    }
+    async deleteAttachment(attachmentId, _context) {
+        this.logger.info(`Attachment deleted: ${attachmentId}`);
+    }
+    /**
+     * 从 Pod 获取 AI 配置（Provider + Credential）
+     * 复用已缓存的 Session，避免重复登录
+     */
+    async getAiConfig(context) {
+        const db = await this.getDb(context);
+        if (!db) {
+            return undefined;
+        }
+        try {
+            // 查询活跃的 AI 凭据
+            const credentials = await db.select()
+                .from(tables_1.Credential)
+                .where((0, drizzle_solid_1.and)((0, drizzle_solid_1.eq)(tables_1.Credential.service, types_2.ServiceType.AI), (0, drizzle_solid_1.eq)(tables_1.Credential.status, types_2.CredentialStatus.ACTIVE)));
+            if (credentials.length === 0) {
+                return undefined;
+            }
+            // 遍历凭据，找到有效的 Provider
+            for (const cred of credentials) {
+                if (!cred.provider)
+                    continue;
+                // 从 URI 提取 provider ID
+                const providerId = this.extractProviderId(cred.provider);
+                // 查询 Provider
+                const providers = await db.select()
+                    .from(provider_1.Provider)
+                    .where((0, drizzle_solid_1.eq)(provider_1.Provider.id, providerId));
+                const provider = providers[0];
+                if (!provider)
+                    continue;
+                const baseUrl = cred.baseUrl || provider.baseUrl;
+                if (!baseUrl)
+                    continue;
+                this.logger.debug(`Using credential ${cred.id} with provider ${provider.id}`);
+                return {
+                    providerId: provider.id,
+                    baseUrl,
+                    proxyUrl: cred.proxyUrl || provider.proxyUrl || undefined,
+                    apiKey: cred.apiKey,
+                    credentialId: cred.id,
+                };
+            }
+            return undefined;
+        }
+        catch (error) {
+            this.logger.warn(`Failed to read AI config from Pod: ${error}`);
+            return undefined;
+        }
+    }
+    /**
+     * 更新凭据状态（如 429 限流）
+     * 复用已缓存的 Session
+     */
+    async updateCredentialStatus(context, credentialId, status, options) {
+        const db = await this.getDb(context);
+        if (!db) {
+            this.logger.debug('Cannot update credential status: no db available');
+            return;
+        }
+        try {
+            const updateData = { status };
+            if (options?.rateLimitResetAt) {
+                updateData.rateLimitResetAt = options.rateLimitResetAt;
+            }
+            // 如果需要递增 failCount，先查询当前值
+            if (options?.incrementFailCount) {
+                const credentials = await db.select()
+                    .from(tables_1.Credential)
+                    .where((0, drizzle_solid_1.eq)(tables_1.Credential.id, credentialId));
+                const currentCred = credentials[0];
+                if (currentCred) {
+                    updateData.failCount = (currentCred.failCount ?? 0) + 1;
+                }
+            }
+            await db.update(tables_1.Credential)
+                .set(updateData)
+                .where((0, drizzle_solid_1.eq)(tables_1.Credential.id, credentialId));
+            this.logger.info(`Credential ${credentialId} status updated to ${status}`);
+        }
+        catch (error) {
+            this.logger.error(`Failed to update credential ${credentialId}: ${error}`);
+        }
+    }
+    /**
+     * 记录凭据使用成功（重置 failCount，更新 lastUsedAt）
+     */
+    async recordCredentialSuccess(context, credentialId) {
+        const db = await this.getDb(context);
+        if (!db) {
+            return;
+        }
+        try {
+            await db.update(tables_1.Credential)
+                .set({
+                lastUsedAt: new Date(),
+                failCount: 0,
+                status: types_2.CredentialStatus.ACTIVE,
+                rateLimitResetAt: undefined,
+            })
+                .where((0, drizzle_solid_1.eq)(tables_1.Credential.id, credentialId));
+        }
+        catch (error) {
+            this.logger.debug(`Failed to record credential success: ${error}`);
+        }
+    }
+    /**
+     * 从 provider URI 提取 ID
+     * e.g., "http://localhost:3000/test/settings/ai/providers.ttl#google" -> "google"
+     */
+    extractProviderId(providerUri) {
+        const hash = providerUri.lastIndexOf('#');
+        if (hash >= 0) {
+            return providerUri.slice(hash + 1);
+        }
+        return providerUri;
+    }
+}
+exports.PodChatKitStore = PodChatKitStore;
+/** 默认 Chat 容器 ID */
+PodChatKitStore.DEFAULT_CHAT_ID = 'default';
+// =========================================================================
+// AI Config Operations (复用 Session 缓存)
+// =========================================================================
+/**
+ * AI 配置结果
+ */
+PodChatKitStore.AiConfigResult = class {
+};
+//# sourceMappingURL=pod-store.js.map