@undefineds.co/xpod 0.4.14 → 0.4.16

package/dist/api/background-service-supervisor.js

@@ -0,0 +1,144 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BackgroundServiceSupervisor = void 0;
+const global_logger_factory_1 = require("global-logger-factory");
+const DEFAULT_RETRY_BASE_DELAY_MS = 5_000;
+const DEFAULT_RETRY_MAX_DELAY_MS = 5 * 60_000;
+const DEFAULT_CHECK_INTERVAL_MS = 30_000;
+class BackgroundServiceSupervisor {
+    constructor(options) {
+        this.options = options;
+        this.running = false;
+        this.inFlight = false;
+        this.consecutiveFailures = 0;
+        this.restarts = 0;
+        this.logger = options.logger ?? (0, global_logger_factory_1.getLoggerFor)('BackgroundServiceSupervisor');
+        this.now = options.now ?? (() => new Date());
+        this.retryBaseDelayMs = positive(options.retryBaseDelayMs, DEFAULT_RETRY_BASE_DELAY_MS);
+        this.retryMaxDelayMs = positive(options.retryMaxDelayMs, DEFAULT_RETRY_MAX_DELAY_MS);
+        this.checkIntervalMs = positive(options.checkIntervalMs, DEFAULT_CHECK_INTERVAL_MS);
+        this.status = { name: options.name, state: 'idle', attempts: 0, restarts: 0 };
+    }
+    /** Starts supervising; repeated calls are a no-op so a restart cannot double the timers. */
+    start() {
+        if (this.running) {
+            return;
+        }
+        this.running = true;
+        this.status = { ...this.status, state: 'starting', nextRetryInMs: undefined };
+        // One cycle now, then the loop keeps its own timer.
+        void this.runOnce().then(() => this.scheduleNext());
+    }
+    async stop() {
+        this.running = false;
+        if (this.timer) {
+            clearTimeout(this.timer);
+            this.timer = undefined;
+        }
+        this.status = { ...this.status, state: 'stopped', nextRetryInMs: undefined };
+        try {
+            await this.options.stop?.();
+        }
+        catch (error) {
+            this.logger.warn(`${this.options.name}: stop failed: ${message(error)}`);
+        }
+    }
+    getStatus() {
+        return { ...this.status };
+    }
+    /** One start-or-check cycle, exposed so an operator action or a test can drive it. */
+    async runOnce() {
+        if (this.inFlight) {
+            return this.getStatus();
+        }
+        this.inFlight = true;
+        try {
+            if (this.status.state === 'running') {
+                return await this.checkAlive();
+            }
+            return await this.attempt();
+        }
+        finally {
+            this.inFlight = false;
+        }
+    }
+    nextDelayMs() {
+        if (this.consecutiveFailures === 0) {
+            return this.checkIntervalMs;
+        }
+        const exponent = Math.max(0, this.consecutiveFailures - 1);
+        return Math.min(this.retryBaseDelayMs * 2 ** exponent, this.retryMaxDelayMs);
+    }
+    async attempt() {
+        this.status = { ...this.status, attempts: this.status.attempts + 1 };
+        try {
+            await this.options.start();
+            this.consecutiveFailures = 0;
+            this.status = {
+                ...this.status,
+                state: 'running',
+                lastError: undefined,
+                startedAt: this.now().toISOString(),
+            };
+            this.logger.info(`${this.options.name}: started`);
+            return this.getStatus();
+        }
+        catch (error) {
+            this.consecutiveFailures += 1;
+            const delay = this.nextDelayMs();
+            this.status = {
+                ...this.status,
+                state: 'retrying',
+                lastError: message(error),
+                nextRetryInMs: delay,
+            };
+            this.logger.warn(`${this.options.name}: start failed (attempt ${this.status.attempts}), retrying in ${delay}ms: ${message(error)}`);
+            return this.getStatus();
+        }
+    }
+    async checkAlive() {
+        if (!this.options.isRunning) {
+            return this.getStatus();
+        }
+        let alive;
+        try {
+            alive = await this.options.isRunning();
+        }
+        catch (error) {
+            alive = false;
+            this.logger.warn(`${this.options.name}: liveness check failed: ${message(error)}`);
+        }
+        if (alive) {
+            return this.getStatus();
+        }
+        this.restarts += 1;
+        this.consecutiveFailures = 0;
+        this.status = { ...this.status, restarts: this.restarts };
+        this.logger.warn(`${this.options.name}: not running any more; restarting (restart ${this.restarts})`);
+        // Restart in this cycle rather than waiting for the next check.
+        return await this.attempt();
+    }
+    /** Schedules the next cycle from the current state; the loop owns its own timer. */
+    scheduleNext() {
+        if (!this.running) {
+            return;
+        }
+        const delay = this.status.state === 'running' && this.options.isRunning
+            ? this.checkIntervalMs
+            : this.nextDelayMs();
+        this.status = { ...this.status, nextRetryInMs: delay };
+        this.timer = setTimeout(() => {
+            this.timer = undefined;
+            void this.runOnce().then(() => this.scheduleNext());
+        }, delay);
+        this.timer.unref?.();
+    }
+}
+exports.BackgroundServiceSupervisor = BackgroundServiceSupervisor;
+function message(error) {
+    return error instanceof Error ? error.message : String(error);
+}
+function positive(value, fallback) {
+    return typeof value === 'number' && Number.isFinite(value) && value > 0 ? value : fallback;
+}
+//# sourceMappingURL=background-service-supervisor.js.map

package/dist/api/chatkit/pod-store.d.ts

@@ -3,12 +3,14 @@ import type { ThreadMetadata, ThreadRef, ThreadItem, Attachment, Page, StoreItem
 import { type RunListOptions, type RunRecordData, type RunStepRecordData, type RunStore } from '../runs/store';
 import { type TaskListOptions, type TaskRecordData, type TaskStore } from '../tasks/store';
 import { type TaskAuthBindingRepository } from '../tasks/TaskAuthBinding';
+import { type PodAccessFetchProvider } from '../ai-gateway/pod/OwnerPodAccess';
 import { type AiCredentialSecretDecoder } from '../../ai/service/AiCredentialSecret';
 import { CredentialStatus } from '../../credential/schema/types';
 import { type ServerGroupReconcilerService } from '../reconciler';
 import { type ReaderAiConfig } from '../../document/ReaderAiConfig';
 export interface PodChatKitStoreOptions {
-    tokenEndpoint: string;
+    /** Reaches a Pod as its owner over the Pod's standard interface. */
+    podAccess?: PodAccessFetchProvider;
     serverGroupReconcilerService?: ServerGroupReconcilerService;
     /**
      * Reads a Pod credential secret (AI Connections envelope, `plaintext-v1`
@@ -30,7 +32,7 @@ export interface PodChatKitStoreOptions {
  */
 export declare class PodChatKitStore implements ChatKitStore<StoreContext>, RunStore<StoreContext>, TaskStore<StoreContext>, TaskAuthBindingRepository<StoreContext> {
     private readonly logger;
-    private readonly tokenEndpoint;
+    private readonly podAccess?;
     private readonly serverGroupReconcilerService?;
     private readonly credentialSecretDecoder;
     private readonly deployment?;
@@ -45,10 +47,12 @@ export declare class PodChatKitStore implements ChatKitStore<StoreContext>, RunS
     }): Promise<StoreContext>;
     /**
      * 获取认证后的 drizzle 实例 (缓存到 context 中)
+     *
+     * The Pod holds the only copy of this data, so a caller without a usable Pod credential is
+     * told why instead of being handed an empty result: a chat screen that answers "no threads"
+     * for a Pod it could not open reports a state the user cannot act on.
      */
     private getDb;
-    private getClientCredentialsAccessToken;
-    private createAccessTokenFetch;
     /**
      * 从 context 获取 webId
      */

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

@@ -22,6 +22,8 @@ const store_1 = require("../runs/store");
 const schema_3 = require("../tasks/schema");
 const store_2 = require("../tasks/store");
 const TaskAuthBinding_1 = require("../tasks/TaskAuthBinding");
+const CallerPodAccess_1 = require("../ai-gateway/auth/CallerPodAccess");
+const OwnerPodAccess_1 = require("../ai-gateway/pod/OwnerPodAccess");
 const AuthContext_1 = require("../auth/AuthContext");
 const provider_1 = require("../../ai/schema/provider");
 const model_1 = require("../../ai/schema/model");
@@ -60,7 +62,7 @@ class PodChatKitStore {
         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;
+        this.podAccess = options.podAccess;
         this.credentialSecretDecoder = options.credentialSecretDecoder ?? AiCredentialSecret_1.defaultAiCredentialSecretDecoder;
         this.deployment = options.deployment;
         this.serverGroupReconcilerService = options.serverGroupReconcilerService;
@@ -84,6 +86,10 @@ class PodChatKitStore {
     // =========================================================================
     /**
      * 获取认证后的 drizzle 实例 (缓存到 context 中)
+     *
+     * The Pod holds the only copy of this data, so a caller without a usable Pod credential is
+     * told why instead of being handed an empty result: a chat screen that answers "no threads"
+     * for a Pod it could not open reports a state the user cannot act on.
      */
     async getDb(context) {
         // Check if we already have a cached db in context
@@ -92,110 +98,39 @@ class PodChatKitStore {
             return context._cachedDb;
         }
         const auth = context.auth;
-        if (!auth || !(0, AuthContext_1.isSolidAuth)(auth)) {
+        if (!auth || !(0, AuthContext_1.isSolidAuth)(auth) || !auth.webId) {
             this.logger.warn('No valid solid auth in context, cannot access Pod');
-            return null;
+            throw new Error(CallerPodAccess_1.CALLER_POD_ACCESS_UNAVAILABLE);
         }
-        // Preferred path: directly use caller's Solid access token.
-        if (auth.accessToken && auth.webId) {
-            try {
-                if (auth.tokenType === 'DPoP') {
-                    this.logger.warn('Using DPoP access token without proof key; Pod access may fail if issuer enforces DPoP proof');
-                }
-                this.logger.info(`[getDb] Using access token path for webId: ${auth.webId}`);
-                const authFetch = this.createAccessTokenFetch(auth.accessToken, auth.tokenType);
-                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, schema_2.Run, schema_2.RunStep, schema_3.Task, config_1.AIConfig, tables_1.Credential);
-                    this.logger.info('Tables initialized successfully');
-                }
-                catch (initError) {
-                    this.logger.error(`Failed to init tables: ${initError}`);
-                }
-                context._cachedDb = db;
-                context._cachedFetch = authFetch;
-                context._cachedWebId = auth.webId;
-                this.ensurePodBaseUrlCache(context, db, auth.webId);
-                return db;
-            }
-            catch (error) {
-                this.logger.error(`Failed to get Pod db with access token: ${error}`);
-                return null;
-            }
-        }
-        if (!auth.clientId || !auth.clientSecret) {
-            this.logger.warn('No accessToken and no valid client credentials in context, cannot access Pod');
-            return null;
-        }
-        // Fallback path: exchange client credentials for an access token directly.
-        this.logger.info(`[getDb] Using client credentials path for clientId: ${auth.clientId}`);
+        // One credential path for every caller: the owner's own Pod key, exchanged for a
+        // token this process can prove, or the caller's reusable token.
+        let podFetch;
         try {
-            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] 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, schema_2.Run, schema_2.RunStep, schema_3.Task, config_1.AIConfig, tables_1.Credential);
-                this.logger.info('Tables initialized successfully');
-            }
-            catch (initError) {
-                this.logger.error(`Failed to init tables: ${initError}`);
-            }
-            context._cachedDb = db;
-            context._cachedFetch = authFetch;
-            context._cachedWebId = webId;
-            this.ensurePodBaseUrlCache(context, db, webId);
-            context._cachedAccessToken = token.accessToken;
-            context._cachedTokenType = token.tokenType;
-            return db;
+            podFetch = await this.podAccess?.getPodFetch(auth.webId, { auth });
         }
         catch (error) {
-            this.logger.error(`Failed to get Pod db: ${error}`);
-            return null;
+            this.logger.error(`Failed to obtain Pod access for ${auth.webId}: ${error}`);
+            throw error;
         }
-    }
-    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(() => '')}`);
+        if (!podFetch) {
+            const reason = (0, OwnerPodAccess_1.podAccessError)(auth.webId, auth);
+            this.logger.warn(`No usable Pod credential for ${auth.webId}: ${reason}`);
+            throw new Error(reason);
         }
-        const token = await response.json();
-        if (!token.access_token) {
-            throw new Error(`Client credentials token response missing access_token: ${JSON.stringify(token)}`);
+        const db = (0, drizzle_solid_1.drizzle)({ fetch: podFetch, info: { webId: auth.webId, isLoggedIn: true } }, { schema });
+        this.logger.info(`Initializing tables for Pod: ${auth.webId}`);
+        try {
+            await db.init(schema_1.Chat, schema_1.Thread, schema_1.Message, schema_2.Run, schema_2.RunStep, schema_3.Task, config_1.AIConfig, tables_1.Credential);
+            this.logger.info('Tables initialized successfully');
         }
-        return {
-            accessToken: token.access_token,
-            tokenType: token.token_type?.toUpperCase() === 'DPOP' ? 'DPoP' : 'Bearer',
-        };
-    }
-    createAccessTokenFetch(accessToken, tokenType) {
-        const scheme = tokenType ?? 'Bearer';
-        return async (input, init) => {
-            const headers = new Headers(init?.headers);
-            if (!headers.has('Authorization')) {
-                headers.set('Authorization', `${scheme} ${accessToken}`);
-            }
-            return fetch(input, {
-                ...init,
-                headers,
-            });
-        };
+        catch (initError) {
+            this.logger.error(`Failed to init tables: ${initError}`);
+        }
+        context._cachedDb = db;
+        context._cachedFetch = podFetch;
+        context._cachedWebId = auth.webId;
+        this.ensurePodBaseUrlCache(context, db, auth.webId);
+        return db;
     }
     /**
      * 从 context 获取 webId
@@ -540,9 +475,6 @@ class PodChatKitStore {
      */
     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 chatResourceId = this.buildChatResourceId(chatId);
         const surfaceId = this.chatSurfaceIdFromResourceId(chatResourceId) ?? chatId;
@@ -991,9 +923,6 @@ class PodChatKitStore {
     }
     async selectMessagesForThread(thread, context) {
         const db = await this.getDb(context);
-        if (!db) {
-            return [];
-        }
         const resolvedThread = await this.resolveThreadRef(thread, context);
         const records = await db.select()
             .from(schema_1.Message)
@@ -1054,9 +983,6 @@ class PodChatKitStore {
             return cached;
         }
         const db = await this.getDb(context);
-        if (!db) {
-            throw new Error('Cannot access Pod: invalid credentials');
-        }
         const resolvedThread = await this.resolveThreadRef(thread, context);
         const threadRecord = await db.findByIri(schema_1.Thread, resolvedThread.thread);
         if (!threadRecord) {
@@ -1073,9 +999,6 @@ class PodChatKitStore {
     }
     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();
         const parent = this.resolveThreadParent(thread, context);
         const commandKind = parent.commandKind;
@@ -1135,9 +1058,6 @@ class PodChatKitStore {
     }
     async loadThreads(limit, after, order, context) {
         const db = await this.getDb(context);
-        if (!db) {
-            return { data: [], has_more: false };
-        }
         try {
             const threads = await models_1.threadRepository.list(db);
             const metadataById = new Map();
@@ -1180,9 +1100,6 @@ class PodChatKitStore {
     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');
-        }
         // 删除关联到此 Thread 的消息
         try {
             await db.delete(schema_1.Message).where((0, drizzle_solid_1.eq)(schema_1.Message.thread, resolvedThread.thread));
@@ -1245,9 +1162,6 @@ class PodChatKitStore {
     }
     async addThreadItem(thread, item, context) {
         const db = await this.getDb(context);
-        if (!db) {
-            throw new Error('Cannot access Pod: invalid credentials');
-        }
         const resolvedThread = await this.resolveThreadRef(thread, context);
         const itemResourceId = this.buildMessageResourceId({
             id: item.id,
@@ -1365,9 +1279,6 @@ class PodChatKitStore {
     }
     async saveItem(thread, item, context) {
         const db = await this.getDb(context);
-        if (!db) {
-            throw new Error('Cannot access Pod: invalid credentials');
-        }
         const resolvedThread = await this.resolveThreadRef(thread, context);
         // 准备更新数据
         let content = '';
@@ -1513,9 +1424,6 @@ WHERE { ${deletePatterns.join(' ')} }
     }
     async loadItem(thread, itemId, context) {
         const db = await this.getDb(context);
-        if (!db) {
-            throw new Error('Cannot access Pod: invalid credentials');
-        }
         const resolvedThread = await this.resolveThreadRef(thread, context);
         const messages = (await this.selectMessagesForThread(thread, context))
             .filter((message) => message.id === itemId);
@@ -1549,9 +1457,6 @@ WHERE { ${deletePatterns.join(' ')} }
     // =========================================================================
     async saveRun(run, context) {
         const db = await this.getDb(context);
-        if (!db) {
-            throw new Error('Cannot access Pod: invalid credentials');
-        }
         run.id = (0, store_1.buildRunResourceId)(run);
         const existing = await db.findById(schema_2.Run, run.id);
         const values = {
@@ -1584,9 +1489,6 @@ WHERE { ${deletePatterns.join(' ')} }
     }
     async loadRun(id, context) {
         const db = await this.getDb(context);
-        if (!db) {
-            throw new Error('Cannot access Pod: invalid credentials');
-        }
         const record = await db.findById(schema_2.Run, id);
         if (!record) {
             throw new Error(`Run not found: ${id}`);
@@ -1595,9 +1497,6 @@ WHERE { ${deletePatterns.join(' ')} }
     }
     async listRuns(options, context) {
         const db = await this.getDb(context);
-        if (!db) {
-            throw new Error('Cannot access Pod: invalid credentials');
-        }
         const conditions = [];
         if (options.task) {
             conditions.push((0, drizzle_solid_1.eq)(schema_2.Run.task, options.task));
@@ -1622,9 +1521,6 @@ WHERE { ${deletePatterns.join(' ')} }
     }
     async appendRunStep(event, context) {
         const db = await this.getDb(context);
-        if (!db) {
-            throw new Error('Cannot access Pod: invalid credentials');
-        }
         if (!(0, store_1.isRunResourceId)(event.runId)) {
             throw new Error(`RunStep runId must be a complete Run resource id: ${event.runId}`);
         }
@@ -1641,9 +1537,6 @@ WHERE { ${deletePatterns.join(' ')} }
     }
     async loadRunSteps(runId, context) {
         const db = await this.getDb(context);
-        if (!db) {
-            throw new Error('Cannot access Pod: invalid credentials');
-        }
         if (!(0, store_1.isRunResourceId)(runId)) {
             throw new Error(`loadRunSteps requires a base-relative Run id: ${runId}`);
         }
@@ -1684,9 +1577,6 @@ WHERE { ${deletePatterns.join(' ')} }
             return undefined;
         }
         const db = await this.getDb(context);
-        if (!db) {
-            throw new Error('Cannot access Pod: invalid credentials');
-        }
         const updatedAt = this.timestampToIso(input.now);
         const expectedLease = run.leaseOwner
             ? (0, drizzle_solid_1.eq)(schema_2.Run.leaseOwner, run.leaseOwner)
@@ -1713,9 +1603,6 @@ WHERE { ${deletePatterns.join(' ')} }
     }
     async releaseClientToolContinuation(claim, now, context) {
         const db = await this.getDb(context);
-        if (!db) {
-            throw new Error('Cannot access Pod: invalid credentials');
-        }
         const released = await db.update(schema_2.Run)
             .set({
             status: schema_2.RunStatus.WAITING_INPUT,
@@ -1745,9 +1632,6 @@ WHERE { ${deletePatterns.join(' ')} }
     // =========================================================================
     async saveTask(task, context) {
         const db = await this.getDb(context);
-        if (!db) {
-            throw new Error('Cannot access Pod: invalid credentials');
-        }
         task.id = (0, store_2.buildTaskResourceId)(task.id);
         const existing = await db.findById(schema_3.Task, task.id);
         const metadata = this.withXpodMetadata(this.withTaskAuthBindingMetadata(task.metadata, task.authBinding), {
@@ -1780,9 +1664,6 @@ WHERE { ${deletePatterns.join(' ')} }
     }
     async loadTask(taskId, context) {
         const db = await this.getDb(context);
-        if (!db) {
-            throw new Error('Cannot access Pod: invalid credentials');
-        }
         const record = await db.findById(schema_3.Task, taskId);
         if (!record) {
             throw new Error(`Task not found: ${taskId}`);
@@ -1791,9 +1672,6 @@ WHERE { ${deletePatterns.join(' ')} }
     }
     async listTasks(options, context) {
         const db = await this.getDb(context);
-        if (!db) {
-            throw new Error('Cannot access Pod: invalid credentials');
-        }
         const records = await db.select().from(schema_3.Task);
         const dueAt = options.dueAt ?? (0, types_1.nowTimestamp)();
         let tasks = records.map((record) => this.taskRecordToData(record));
@@ -1814,9 +1692,6 @@ WHERE { ${deletePatterns.join(' ')} }
     }
     async saveTaskAuthCredential(input, context) {
         const db = await this.getDb(context);
-        if (!db) {
-            throw new Error('Cannot access Pod: invalid credentials');
-        }
         const values = {
             service: TaskAuthBinding_1.TASK_AUTH_CREDENTIAL_SERVICE,
             status: types_2.CredentialStatus.ACTIVE,
@@ -1845,9 +1720,6 @@ WHERE { ${deletePatterns.join(' ')} }
     }
     async loadTaskAuthCredential(id, context) {
         const db = await this.getDb(context);
-        if (!db) {
-            throw new Error('Cannot access Pod: invalid credentials');
-        }
         const credential = await db.findById(tables_1.Credential, id);
         if (!credential || credential.service !== TaskAuthBinding_1.TASK_AUTH_CREDENTIAL_SERVICE) {
             return undefined;
@@ -2218,9 +2090,6 @@ WHERE { ${deletePatterns.join(' ')} }
     }
     async getAiConfig(context) {
         const db = await this.getDb(context);
-        if (!db) {
-            return undefined;
-        }
         this.ensurePodBaseUrlCache(context, db);
         try {
             try {
@@ -2281,9 +2150,6 @@ WHERE { ${deletePatterns.join(' ')} }
     }
     async getReaderConfig(context, preferredProviderId = 'paddleocr') {
         const db = await this.getDb(context);
-        if (!db) {
-            return undefined;
-        }
         try {
             const [providers, models, credentials] = await Promise.all([
                 db.select().from(provider_1.Provider),
@@ -2304,9 +2170,6 @@ WHERE { ${deletePatterns.join(' ')} }
     }
     async listAvailableModels(context) {
         const db = await this.getDb(context);
-        if (!db) {
-            return [];
-        }
         const config = await this.getAiConfig(context);
         if (!config) {
             return [];
@@ -2377,10 +2240,6 @@ WHERE { ${deletePatterns.join(' ')} }
      */
     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) {
@@ -2405,9 +2264,6 @@ WHERE { ${deletePatterns.join(' ')} }
      */
     async recordCredentialSuccess(context, credentialId) {
         const db = await this.getDb(context);
-        if (!db) {
-            return;
-        }
         try {
             await db.updateById(tables_1.Credential, credentialId, {
                 lastUsedAt: new Date(),