@undefineds.co/xpod 0.2.0-preview.2 → 0.2.1

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

@@ -1,4 +1,6 @@
 "use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PodChatKitStore = void 0;
 /**
  * Pod-based ChatKit Store
  *
@@ -11,15 +13,13 @@
  *     #{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("drizzle-solid");
+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 model_1 = require("../../ai/schema/model");
 const tables_1 = require("../../credential/schema/tables");
 const types_2 = require("../../credential/schema/types");
 const schema = {
@@ -27,6 +27,7 @@ const schema = {
     thread: schema_1.Thread,
     message: schema_1.Message,
     provider: provider_1.Provider,
+    model: model_1.Model,
     credential: tables_1.Credential,
 };
 /**
@@ -74,7 +75,7 @@ class PodChatKitStore {
                 const db = (0, drizzle_solid_1.drizzle)({ fetch: authFetch, info: { webId: auth.webId, isLoggedIn: true } }, { schema });
                 this.logger.info(`Initializing tables for Pod (access token): ${auth.webId}`);
                 try {
-                    await db.init([schema_1.Chat, schema_1.Thread, schema_1.Message]);
+                    await db.init(schema_1.Chat, schema_1.Thread, schema_1.Message);
                     this.logger.info('Tables initialized successfully');
                 }
                 catch (initError) {
@@ -94,37 +95,30 @@ class PodChatKitStore {
             this.logger.warn('No accessToken and no valid client credentials in context, cannot access Pod');
             return null;
         }
-        // Fallback path: login with client credentials to obtain a Pod session.
+        // Fallback path: exchange client credentials for an access token directly.
         this.logger.info(`[getDb] Using client credentials path for clientId: ${auth.clientId}`);
-        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,
-                tokenType: 'DPoP',
-            });
-            if (!session.info.isLoggedIn || !session.info.webId) {
-                throw new Error('Login failed');
+            const token = await this.getClientCredentialsAccessToken(auth.clientId, auth.clientSecret);
+            const webId = auth.webId ?? this.getWebId(context);
+            if (!webId) {
+                throw new Error('Missing webId for client credentials auth');
             }
-            this.logger.info(`[getDb] Session login successful, webId: ${session.info.webId}`);
-            const authFetch = session.fetch.bind(session);
-            const db = (0, drizzle_solid_1.drizzle)({ fetch: authFetch, info: { webId: session.info.webId, isLoggedIn: true } }, { schema });
-            // 初始化表（创建容器、资源）
-            this.logger.info(`Initializing tables for Pod: ${session.info.webId}`);
+            this.logger.info(`[getDb] Client credentials token acquired, webId: ${webId}`);
+            const db = (0, drizzle_solid_1.drizzle)({ fetch: this.createAccessTokenFetch(token.accessToken, token.tokenType), info: { webId, isLoggedIn: true } }, { schema });
+            const authFetch = this.createAccessTokenFetch(token.accessToken, token.tokenType);
+            this.logger.info(`Initializing tables for Pod: ${webId}`);
             try {
-                await db.init([schema_1.Chat, schema_1.Thread, schema_1.Message]);
+                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 = authFetch;
-            context._cachedWebId = session.info.webId;
-            context._cachedSession = session;
+            context._cachedWebId = webId;
+            context._cachedAccessToken = token.accessToken;
+            context._cachedTokenType = token.tokenType;
             return db;
         }
         catch (error) {
@@ -132,6 +126,30 @@ class PodChatKitStore {
             return null;
         }
     }
+    async getClientCredentialsAccessToken(clientId, clientSecret) {
+        const response = await fetch(this.tokenEndpoint, {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/x-www-form-urlencoded',
+            },
+            body: new URLSearchParams({
+                grant_type: 'client_credentials',
+                client_id: clientId,
+                client_secret: clientSecret,
+            }),
+        });
+        if (!response.ok) {
+            throw new Error(`Client credentials token request failed: ${response.status} ${await response.text().catch(() => '')}`);
+        }
+        const token = await response.json();
+        if (!token.access_token) {
+            throw new Error(`Client credentials token response missing access_token: ${JSON.stringify(token)}`);
+        }
+        return {
+            accessToken: token.access_token,
+            tokenType: token.token_type?.toUpperCase() === 'DPOP' ? 'DPoP' : 'Bearer',
+        };
+    }
     createAccessTokenFetch(accessToken, tokenType) {
         const scheme = tokenType ?? 'Bearer';
         return async (input, init) => {
@@ -155,6 +173,42 @@ class PodChatKitStore {
         }
         return undefined;
     }
+    derivePodBaseUrl(webId) {
+        if (!webId) {
+            return undefined;
+        }
+        try {
+            const url = new URL(webId);
+            url.hash = '';
+            url.search = '';
+            const normalizedPath = url.pathname.replace(/\/+$/, '');
+            if (!normalizedPath.endsWith('/profile/card')) {
+                return undefined;
+            }
+            const podPath = normalizedPath.slice(0, -'/profile/card'.length) || '/';
+            if (podPath === '/') {
+                return url.origin;
+            }
+            url.pathname = podPath;
+            return url.toString().replace(/\/$/, '');
+        }
+        catch {
+            const withoutHash = webId.split('#')[0]?.replace(/\/+$/, '');
+            if (!withoutHash?.endsWith('/profile/card')) {
+                return undefined;
+            }
+            const podBase = withoutHash.slice(0, -'/profile/card'.length) || '/';
+            if (podBase === '/') {
+                try {
+                    return new URL(webId).origin;
+                }
+                catch {
+                    return undefined;
+                }
+            }
+            return podBase.endsWith('/') ? podBase.slice(0, -1) : podBase;
+        }
+    }
     /**
      * 将 ThreadStatus 对象转为字符串
      */
@@ -193,9 +247,7 @@ class PodChatKitStore {
         }
         const webId = this.getWebId(context);
         // 检查是否存在
-        const existing = await db.query.chat.findFirst({
-            where: (0, drizzle_solid_1.eq)(schema_1.Chat.id, chatId),
-        });
+        const existing = await db.findByLocator(schema_1.Chat, { id: chatId });
         if (!existing) {
             // 创建 Chat 容器
             const now = new Date().toISOString();
@@ -214,8 +266,8 @@ class PodChatKitStore {
      * 将 ThreadRecord 转为 ThreadMetadata
      * 包含 metadata.chat_id 暴露 Chat 容器 ID
      */
-    threadRecordToMetadata(record) {
-        const chatId = this.extractChatId(record.chatId);
+    threadRecordToMetadata(record, chatUriMap) {
+        const chatId = this.resolveChatIdFromUri(record.chatId, chatUriMap, PodChatKitStore.DEFAULT_CHAT_ID);
         let extra;
         if (record.metadata) {
             try {
@@ -264,46 +316,104 @@ class PodChatKitStore {
         }
     }
     /**
-     * 从 Thread 获取 chatId（提取纯 ID）
+     * 获取或构建 chatUri → bare chatId 的映射缓存。
+     * drizzle-solid 的 uri() 字段返回完整 URI，通过 Chat 的 @id 比对来还原 bare 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];
+    async getChatUriMap(context) {
+        if (context._chatUriMap) {
+            return context._chatUriMap;
+        }
+        const db = await this.getDb(context);
+        const map = new Map();
+        if (db) {
+            try {
+                const chats = await db.select().from(schema_1.Chat);
+                for (const c of chats) {
+                    const uri = c['@id'];
+                    if (uri)
+                        map.set(uri, c.id);
+                }
+            }
+            catch {
+                // ignore
             }
         }
-        return chatIdOrUri;
+        context._chatUriMap = map;
+        return map;
     }
     /**
-     * 获取 Thread 的 chatId
-     * 先从缓存获取，如果没有再查询数据库
+     * 从 chatId URI 还原 bare chatId。
+     * 优先通过 @id 映射，fallback 处理裸 ID。
      */
-    async getThreadChatId(threadId, context) {
-        // 先检查缓存
-        const cached = this.getCachedThreadChatId(context, threadId);
-        if (cached) {
-            return cached;
+    resolveChatIdFromUri(chatIdUri, chatUriMap, fallback) {
+        if (!chatIdUri)
+            return fallback;
+        const bare = chatUriMap.get(chatIdUri);
+        if (bare)
+            return bare;
+        // Bare ID passed directly (not a URI)
+        return chatIdUri.includes('/') ? fallback : chatIdUri;
+    }
+    isAbsoluteHttpIri(value) {
+        try {
+            const url = new URL(value);
+            return url.protocol === 'http:' || url.protocol === 'https:';
         }
-        const db = await this.getDb(context);
-        if (!db) {
-            throw new Error('Cannot access Pod: invalid credentials');
+        catch {
+            return false;
         }
-        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;
+    }
+    parseThreadIri(threadIri) {
+        try {
+            const url = new URL(threadIri);
+            const match = url.pathname.match(/\/\.data\/chat\/([^/]+)\/index\.ttl$/);
+            const threadId = url.hash.startsWith('#') ? decodeURIComponent(url.hash.slice(1)) : '';
+            if (!match || !threadId) {
+                return null;
+            }
+            return {
+                threadId,
+                chatId: decodeURIComponent(match[1]),
+                threadUri: url.toString(),
+            };
+        }
+        catch {
+            return null;
         }
-        const chatId = this.extractChatId(thread.chatId);
-        // 缓存结果
-        this.cacheThreadChatId(context, threadId, chatId);
-        return chatId;
+    }
+    normalizeThreadCacheKey(thread) {
+        return (0, types_1.getThreadIdFromRef)(thread);
+    }
+    async buildThreadUri(threadId, chatId, context) {
+        await this.getDb(context);
+        const podBaseUrl = this.getCachedPodBaseUrl(context)
+            ?? this.derivePodBaseUrl(this.getWebId(context));
+        if (!podBaseUrl) {
+            throw new Error('Cannot resolve Pod base URL for thread locator');
+        }
+        return `${podBaseUrl}/.data/chat/${chatId}/index.ttl#${threadId}`;
+    }
+    async resolveThreadRef(thread, context) {
+        const threadIdOrIri = thread.thread_id;
+        if (this.isAbsoluteHttpIri(threadIdOrIri)) {
+            const parsed = this.parseThreadIri(threadIdOrIri);
+            if (!parsed) {
+                throw new Error(`Invalid thread IRI: ${threadIdOrIri}`);
+            }
+            this.cacheThreadChatId(context, parsed.threadId, parsed.chatId);
+            return parsed;
+        }
+        if (!('chat_id' in thread) || !thread.chat_id) {
+            throw new Error(`chat_id is required when thread_id "${threadIdOrIri}" is not a full thread IRI`);
+        }
+        const chatId = thread.chat_id;
+        const threadUri = await this.buildThreadUri(threadIdOrIri, chatId, context);
+        this.cacheThreadChatId(context, threadIdOrIri, chatId);
+        return {
+            threadId: threadIdOrIri,
+            chatId,
+            threadUri,
+        };
     }
     /**
      * 缓存 Thread -> chatId 映射
@@ -314,13 +424,6 @@ class PodChatKitStore {
         }
         context._threadChatIdCache.set(threadId, chatId);
     }
-    /**
-     * 从缓存获取 Thread 的 chatId
-     */
-    getCachedThreadChatId(context, threadId) {
-        const cache = context._threadChatIdCache;
-        return cache?.get(threadId);
-    }
     /**
      * 缓存完整的 Thread metadata
      */
@@ -337,6 +440,82 @@ class PodChatKitStore {
         const cache = context._threadMetadataCache;
         return cache?.get(threadId);
     }
+    getCachedFetch(context) {
+        return context._cachedFetch;
+    }
+    getCachedPodBaseUrl(context) {
+        const cachedWebId = context._cachedWebId;
+        return this.derivePodBaseUrl(cachedWebId);
+    }
+    extractFragmentId(subjectUri) {
+        const hashIndex = subjectUri.lastIndexOf('#');
+        if (hashIndex >= 0 && hashIndex < subjectUri.length - 1) {
+            return subjectUri.slice(hashIndex + 1);
+        }
+        const slashIndex = subjectUri.lastIndexOf('/');
+        return slashIndex >= 0 && slashIndex < subjectUri.length - 1 ? subjectUri.slice(slashIndex + 1) : subjectUri;
+    }
+    parseSparqlBindingValue(binding, key) {
+        return binding?.[key]?.value ?? null;
+    }
+    async selectMessagesForThread(thread, context) {
+        await this.getDb(context);
+        const cachedFetch = this.getCachedFetch(context);
+        const podBaseUrl = this.getCachedPodBaseUrl(context);
+        if (!cachedFetch || !podBaseUrl) {
+            return [];
+        }
+        const resolvedThread = await this.resolveThreadRef(thread, context);
+        const endpoint = `${podBaseUrl}/.data/chat/-/sparql`;
+        const query = `
+      PREFIX meeting: <http://www.w3.org/ns/pim/meeting#>
+      PREFIX sioc: <http://rdfs.org/sioc/ns#>
+      PREFIX foaf: <http://xmlns.com/foaf/0.1/>
+      PREFIX udfs: <https://undefineds.co/ns#>
+      SELECT ?msg ?maker ?role ?content ?status ?createdAt ?toolName ?toolCallId ?metadata
+      WHERE {
+        ?msg a meeting:Message ;
+             sioc:has_container <${resolvedThread.threadUri}> .
+        OPTIONAL { ?msg foaf:maker ?maker . }
+        OPTIONAL { ?msg udfs:role ?role . }
+        OPTIONAL { ?msg sioc:content ?content . }
+        OPTIONAL { ?msg udfs:status ?status . }
+        OPTIONAL { ?msg udfs:createdAt ?createdAt . }
+        OPTIONAL { ?msg udfs:toolName ?toolName . }
+        OPTIONAL { ?msg udfs:toolCallId ?toolCallId . }
+        OPTIONAL { ?msg udfs:metadata ?metadata . }
+      }
+      ORDER BY ?createdAt
+    `.trim();
+        const response = await cachedFetch(endpoint, {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/sparql-query',
+                Accept: 'application/sparql-results+json',
+            },
+            body: query,
+        });
+        if (!response.ok) {
+            const text = await response.text().catch(() => '');
+            throw new Error(`Failed to query thread messages: ${response.status} ${response.statusText} - ${text}`);
+        }
+        const json = await response.json();
+        const bindings = json.results?.bindings ?? [];
+        return bindings.map((binding) => ({
+            id: this.extractFragmentId(this.parseSparqlBindingValue(binding, 'msg') ?? ''),
+            chat: null,
+            thread: resolvedThread.threadUri,
+            maker: this.parseSparqlBindingValue(binding, 'maker'),
+            role: this.parseSparqlBindingValue(binding, 'role'),
+            content: this.parseSparqlBindingValue(binding, 'content'),
+            status: this.parseSparqlBindingValue(binding, 'status'),
+            createdAt: this.parseSparqlBindingValue(binding, 'createdAt'),
+            toolName: this.parseSparqlBindingValue(binding, 'toolName'),
+            toolCallId: this.parseSparqlBindingValue(binding, 'toolCallId'),
+            metadata: this.parseSparqlBindingValue(binding, 'metadata'),
+            subjectUri: this.parseSparqlBindingValue(binding, 'msg'),
+        }));
+    }
     // =========================================================================
     // ID Generation
     // =========================================================================
@@ -349,9 +528,10 @@ class PodChatKitStore {
     // =========================================================================
     // Thread Operations (ChatKit thread = our Thread)
     // =========================================================================
-    async loadThread(threadId, context) {
+    async loadThread(thread, context) {
+        const cacheKey = this.normalizeThreadCacheKey(thread);
         // 先从缓存获取
-        const cached = this.getCachedThreadMetadata(context, threadId);
+        const cached = this.getCachedThreadMetadata(context, cacheKey);
         if (cached) {
             return cached;
         }
@@ -359,15 +539,16 @@ class PodChatKitStore {
         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 resolvedThread = await this.resolveThreadRef(thread, context);
+        const threadRecord = await db.findByIri(schema_1.Thread, resolvedThread.threadUri);
+        if (!threadRecord) {
+            throw new Error(`Thread not found: ${resolvedThread.threadId}`);
         }
-        const metadata = this.threadRecordToMetadata(thread);
+        const chatUriMap = await this.getChatUriMap(context);
+        const metadata = this.threadRecordToMetadata(threadRecord, chatUriMap);
         // 缓存结果
         this.cacheThreadMetadata(context, metadata);
+        this.cacheThreadChatId(context, metadata.id, resolvedThread.chatId);
         return metadata;
     }
     async saveThread(thread, context) {
@@ -378,6 +559,7 @@ class PodChatKitStore {
         const now = new Date().toISOString();
         // 从 metadata 获取 chat_id
         const chatId = this.getChatIdFromMetadata(thread.metadata);
+        thread.metadata = { ...(thread.metadata ?? {}), chat_id: chatId };
         // Persist all metadata except chat_id (which is derived from storage location).
         const metadataToPersist = { ...(thread.metadata ?? {}) };
         delete metadataToPersist.chat_id;
@@ -386,18 +568,20 @@ class PodChatKitStore {
         await this.ensureChat(chatId, context);
         // 缓存 Thread -> chatId 映射，避免后续查询
         this.cacheThreadChatId(context, thread.id, chatId);
+        const threadUri = await this.buildThreadUri(thread.id, chatId, context);
         // 检查 Thread 是否存在
-        const existing = await db.query.thread.findFirst({
-            where: (0, drizzle_solid_1.eq)(schema_1.Thread.id, thread.id),
-        });
+        const existing = await db.findByIri(schema_1.Thread, threadUri);
         if (existing) {
             // Update
-            await db.update(schema_1.Thread).set({
+            await db.updateByLocator(schema_1.Thread, {
+                id: thread.id,
+                chatId,
+            }, {
                 title: thread.title || null,
                 status: this.statusToString(thread.status),
                 metadata: metadataJson,
                 updatedAt: now,
-            }).where((0, drizzle_solid_1.eq)(schema_1.Thread.id, thread.id));
+            });
         }
         else {
             // Insert
@@ -441,8 +625,9 @@ class PodChatKitStore {
             }
             const slice = threads.slice(startIndex, startIndex + limit);
             const hasMore = startIndex + limit < threads.length;
+            const chatUriMap = await this.getChatUriMap(context);
             return {
-                data: slice.map((t) => this.threadRecordToMetadata(t)),
+                data: slice.map((t) => this.threadRecordToMetadata(t, chatUriMap)),
                 has_more: hasMore,
                 after: slice.length > 0 ? slice[slice.length - 1].id : undefined,
             };
@@ -452,31 +637,15 @@ class PodChatKitStore {
             return { data: [], has_more: false };
         }
     }
-    async deleteThread(threadId, context) {
+    async deleteThread(thread, context) {
+        const resolvedThread = await this.resolveThreadRef(thread, 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));
+            await db.delete(schema_1.Message).where((0, drizzle_solid_1.eq)(schema_1.Message.thread, resolvedThread.threadUri));
         }
         catch (err) {
             if (!err.message?.includes('404') && !err.message?.includes('Could not retrieve') && !err.message?.includes('Parse error')) {
@@ -486,13 +655,10 @@ class PodChatKitStore {
         }
         // 删除 Thread
         try {
-            if (chatId) {
-                await db.delete(schema_1.Thread).where((0, drizzle_solid_1.and)((0, drizzle_solid_1.eq)(schema_1.Thread.id, threadId), (0, drizzle_solid_1.eq)(schema_1.Thread.chatId, chatId)));
-            }
-            else {
-                // 如果没有 chatId，尝试只用 id 删除（可能失败）
-                await db.delete(schema_1.Thread).where((0, drizzle_solid_1.eq)(schema_1.Thread.id, threadId));
-            }
+            await db.deleteByLocator(schema_1.Thread, {
+                id: resolvedThread.threadId,
+                chatId: resolvedThread.chatId,
+            });
         }
         catch (err) {
             if (!err.message?.includes('404') && !err.message?.includes('Could not retrieve') && !err.message?.includes('Parse error')) {
@@ -503,20 +669,16 @@ class PodChatKitStore {
         // 清除缓存
         const metadataCache = context._threadMetadataCache;
         const chatIdCache = context._threadChatIdCache;
-        metadataCache?.delete(threadId);
-        chatIdCache?.delete(threadId);
+        metadataCache?.delete(resolvedThread.threadId);
+        chatIdCache?.delete(resolvedThread.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 };
-        }
+    async loadThreadItems(thread, after, limit, order, context) {
         try {
-            // 按 threadId 查询 Message
-            const messages = await db.select().from(schema_1.Message).where((0, drizzle_solid_1.eq)(schema_1.Message.threadId, threadId));
+            const resolvedThread = await this.resolveThreadRef(thread, context);
+            const messages = await this.selectMessagesForThread(thread, context);
             // 排序
             messages.sort((a, b) => {
                 const aTime = a.createdAt ? new Date(a.createdAt).getTime() : 0;
@@ -534,7 +696,7 @@ class PodChatKitStore {
             const slice = messages.slice(startIndex, startIndex + limit);
             const hasMore = startIndex + limit < messages.length;
             return {
-                data: slice.map((m) => this.messageRecordToItem(m, threadId)),
+                data: slice.map((m) => this.messageRecordToItem(m, resolvedThread.threadId)),
                 has_more: hasMore,
                 after: slice.length > 0 ? slice[slice.length - 1].id : undefined,
             };
@@ -544,13 +706,12 @@ class PodChatKitStore {
             return { data: [], has_more: false };
         }
     }
-    async addThreadItem(threadId, item, context) {
+    async addThreadItem(thread, 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 resolvedThread = await this.resolveThreadRef(thread, context);
         const webId = this.getWebId(context);
         let content = '';
         let role = schema_1.MessageRole.USER;
@@ -579,8 +740,8 @@ class PodChatKitStore {
         }
         const messageRecord = {
             id: item.id,
-            chatId, // 用于路径构建
-            threadId, // 关联到 Thread
+            chat: resolvedThread.chatId, // bare ID，用于路径构建
+            thread: resolvedThread.threadUri, // 完整 URI，用于 RDF 引用
             maker: role === schema_1.MessageRole.USER ? webId : null,
             role,
             content,
@@ -591,13 +752,12 @@ class PodChatKitStore {
         // Track this ID to avoid cache timing issues in saveItem
         this.recentlyCreatedIds.add(messageRecord.id);
     }
-    async saveItem(threadId, item, context) {
+    async saveItem(thread, 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 resolvedThread = await this.resolveThreadRef(thread, context);
         // 准备更新数据
         let content = '';
         let status = null;
@@ -622,22 +782,23 @@ class PodChatKitStore {
         const wasRecentlyCreated = this.recentlyCreatedIds.has(item.id);
         if (wasRecentlyCreated) {
             this.recentlyCreatedIds.delete(item.id);
-            await this.directPatchMessage(context, chatId, item.id, content, status, createdAt);
+            await this.directPatchMessage(context, resolvedThread.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 existingItems = (await this.selectMessagesForThread(thread, context))
+            .filter((message) => 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);
+            await this.directPatchMessage(context, resolvedThread.chatId, item.id, content, status, existingCreatedAt);
         }
         else {
             // Create new record
-            await this.addThreadItem(threadId, item, context);
+            await this.addThreadItem(thread, item, context);
         }
     }
     /**
@@ -653,13 +814,15 @@ class PodChatKitStore {
         }
         // 构建资源 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 podBaseUrl = this.derivePodBaseUrl(cachedWebId);
+        if (!podBaseUrl) {
+            throw new Error(`Cannot resolve Pod base URL from cached WebID: ${cachedWebId}`);
+        }
+        const messageDate = createdAt ? new Date(createdAt) : new Date();
+        const yyyy = String(messageDate.getUTCFullYear());
+        const MM = String(messageDate.getUTCMonth() + 1).padStart(2, '0');
+        const dd = String(messageDate.getUTCDate()).padStart(2, '0');
+        const resourceUrl = `${podBaseUrl}/.data/chat/${chatId}/${yyyy}/${MM}/${dd}/messages.ttl`;
         const subjectUri = `${resourceUrl}#${messageId}`;
         // 构建 SPARQL UPDATE：删除旧值，插入新值
         const deletePatterns = [];
@@ -706,23 +869,47 @@ WHERE { ${deletePatterns.join(' ')} }
             throw new Error(`Direct PATCH failed: ${response.status} ${response.statusText} - ${text}`);
         }
     }
-    async loadItem(threadId, itemId, context) {
+    async directDeleteMessage(context, subjectUri) {
+        if (!subjectUri) {
+            throw new Error('Cannot delete message without subject URI');
+        }
+        const cachedFetch = context._cachedFetch;
+        if (!cachedFetch) {
+            throw new Error('No cached session for direct DELETE - call getDb first');
+        }
+        const hashIndex = subjectUri.lastIndexOf('#');
+        const resourceUrl = hashIndex >= 0 ? subjectUri.slice(0, hashIndex) : subjectUri;
+        const sparql = `DELETE WHERE { <${subjectUri}> ?p ?o . }`;
+        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 message delete failed: ${response.status} ${response.statusText} - ${text}`);
+        }
+    }
+    async loadItem(thread, 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)));
+        const resolvedThread = await this.resolveThreadRef(thread, context);
+        const messages = (await this.selectMessagesForThread(thread, context))
+            .filter((message) => message.id === itemId);
         if (messages.length === 0) {
             throw new Error(`Item not found: ${itemId}`);
         }
-        return this.messageRecordToItem(messages[0], threadId);
+        return this.messageRecordToItem(messages[0], resolvedThread.threadId);
     }
-    async deleteThreadItem(threadId, itemId, context) {
-        const db = await this.getDb(context);
-        if (!db) {
-            throw new Error('Cannot access Pod: invalid credentials');
+    async deleteThreadItem(thread, itemId, context) {
+        const target = (await this.selectMessagesForThread(thread, context))
+            .find((message) => message.id === itemId);
+        if (!target) {
+            return;
         }
-        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)));
+        await this.directDeleteMessage(context, target.subjectUri);
     }
     // =========================================================================
     // Attachment Operations (存 Pod 文件)
@@ -740,6 +927,16 @@ WHERE { ${deletePatterns.join(' ')} }
      * 从 Pod 获取 AI 配置（Provider + Credential）
      * 复用已缓存的 Session，避免重复登录
      */
+    extractProviderId(provider) {
+        if (!provider) {
+            return '';
+        }
+        const hashIndex = provider.lastIndexOf('#');
+        if (hashIndex >= 0 && hashIndex < provider.length - 1) {
+            return provider.slice(hashIndex + 1);
+        }
+        return provider;
+    }
     async getAiConfig(context) {
         const db = await this.getDb(context);
         if (!db) {
@@ -753,27 +950,38 @@ WHERE { ${deletePatterns.join(' ')} }
             if (credentials.length === 0) {
                 return undefined;
             }
+            // Build provider @id → record map for URI matching
+            const allProviders = await db.select().from(provider_1.Provider);
+            const providerByUri = new Map();
+            for (const p of allProviders) {
+                const uri = p['@id'];
+                if (uri)
+                    providerByUri.set(uri, p);
+                // Also index by bare id for fallback
+                providerByUri.set(p.id, p);
+            }
             // 遍历凭据，找到有效的 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];
+                // Match provider by full URI first, then fallback to bare fragment id.
+                const provider = providerByUri.get(cred.provider)
+                    ?? providerByUri.get(this.extractProviderId(cred.provider));
                 if (!provider)
                     continue;
-                const baseUrl = cred.baseUrl || provider.baseUrl;
+                const baseUrl = provider.baseUrl;
                 if (!baseUrl)
                     continue;
+                const defaultModelRef = provider.defaultModel ?? provider.hasModel;
+                const defaultModel = defaultModelRef
+                    ? (await db.findByIri(model_1.Model, defaultModelRef))?.id ?? undefined
+                    : undefined;
                 this.logger.debug(`Using credential ${cred.id} with provider ${provider.id}`);
                 return {
                     providerId: provider.id,
                     baseUrl,
-                    proxyUrl: cred.proxyUrl || provider.proxyUrl || undefined,
+                    proxyUrl: provider.proxyUrl || undefined,
+                    defaultModel,
                     apiKey: cred.apiKey,
                     credentialId: cred.id,
                 };
@@ -802,17 +1010,12 @@ WHERE { ${deletePatterns.join(' ')} }
             }
             // 如果需要递增 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];
+                const currentCred = await db.findByLocator(tables_1.Credential, { id: credentialId });
                 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));
+            await db.updateByLocator(tables_1.Credential, { id: credentialId }, updateData);
             this.logger.info(`Credential ${credentialId} status updated to ${status}`);
         }
         catch (error) {
@@ -828,30 +1031,17 @@ WHERE { ${deletePatterns.join(' ')} }
             return;
         }
         try {
-            await db.update(tables_1.Credential)
-                .set({
+            await db.updateByLocator(tables_1.Credential, { id: credentialId }, {
                 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 */