forge-openclaw-plugin 0.2.20 → 0.2.21

package/dist/server/managers/platform/background-job-manager.js

@@ -1,19 +1,49 @@
 import { AbstractManager } from "../base.js";
+import { recordDiagnosticLog } from "../../repositories/diagnostic-logs.js";
 export class BackgroundJobManager extends AbstractManager {
+    maxConcurrentJobs;
     name = "BackgroundJobManager";
     queue = [];
     active = new Set();
     draining = false;
+    constructor(maxConcurrentJobs = 3) {
+        super();
+        this.maxConcurrentJobs = maxConcurrentJobs;
+    }
     start() {
         return;
     }
     enqueue(input) {
+        if (this.has(input.id)) {
+            this.recordLifecycleLog("info", "background_job_enqueue_skipped", {
+                task: input,
+                message: `Skipped duplicate background job ${input.label}.`,
+                details: {
+                    queueDepth: this.queue.length,
+                    activeCount: this.active.size
+                },
+                functionName: "enqueue"
+            });
+            return;
+        }
         this.queue.push(input);
+        this.recordLifecycleLog("info", "background_job_enqueued", {
+            task: input,
+            message: `Enqueued background job ${input.label}.`,
+            details: {
+                queueDepth: this.queue.length,
+                activeCount: this.active.size
+            },
+            functionName: "enqueue"
+        });
         this.scheduleDrain();
     }
     isActive(jobId) {
         return this.active.has(jobId);
     }
+    has(jobId) {
+        return (this.active.has(jobId) || this.queue.some((task) => task.id === jobId));
+    }
     async stop() {
         this.draining = true;
         while (this.active.size > 0) {
@@ -21,26 +51,69 @@ export class BackgroundJobManager extends AbstractManager {
         }
     }
     scheduleDrain() {
-        if (this.draining || this.queue.length === 0) {
+        if (this.draining ||
+            this.queue.length === 0 ||
+            this.active.size >= this.maxConcurrentJobs) {
             return;
         }
         queueMicrotask(() => {
-            void this.drainNext();
+            void this.drainAvailable();
         });
     }
-    async drainNext() {
-        if (this.draining || this.active.size > 0) {
+    async drainAvailable() {
+        if (this.draining) {
             return;
         }
-        const next = this.queue.shift();
-        if (!next) {
-            return;
+        while (!this.draining &&
+            this.queue.length > 0 &&
+            this.active.size < this.maxConcurrentJobs) {
+            const next = this.queue.shift();
+            if (!next) {
+                return;
+            }
+            this.active.add(next.id);
+            void this.runTask(next);
         }
-        this.active.add(next.id);
+    }
+    async runTask(next) {
+        const startedAt = Date.now();
+        this.recordLifecycleLog("info", "background_job_started", {
+            task: next,
+            message: `Started background job ${next.label}.`,
+            details: {
+                queueDepth: this.queue.length,
+                activeCount: this.active.size,
+                maxConcurrentJobs: this.maxConcurrentJobs
+            },
+            functionName: "runTask"
+        });
         try {
             await next.handler();
+            this.recordLifecycleLog("info", "background_job_completed", {
+                task: next,
+                message: `Completed background job ${next.label}.`,
+                details: {
+                    durationMs: Date.now() - startedAt,
+                    queueDepth: this.queue.length,
+                    activeCount: this.active.size,
+                    maxConcurrentJobs: this.maxConcurrentJobs
+                },
+                functionName: "runTask"
+            });
         }
         catch (error) {
+            this.recordLifecycleLog("error", "background_job_failed", {
+                task: next,
+                message: `Background job failed for ${next.label}.`,
+                details: {
+                    durationMs: Date.now() - startedAt,
+                    queueDepth: this.queue.length,
+                    activeCount: this.active.size,
+                    maxConcurrentJobs: this.maxConcurrentJobs,
+                    error
+                },
+                functionName: "runTask"
+            });
             console.error(`[${this.name}] background job failed for ${next.label}:`, error);
         }
         finally {
@@ -48,4 +121,26 @@ export class BackgroundJobManager extends AbstractManager {
             this.scheduleDrain();
         }
     }
+    recordLifecycleLog(level, eventKey, input) {
+        try {
+            recordDiagnosticLog({
+                level,
+                source: "system",
+                scope: "background_job",
+                eventKey,
+                message: input.message,
+                functionName: input.functionName,
+                entityType: "background_job",
+                entityId: input.task.id,
+                jobId: input.task.id,
+                details: {
+                    label: input.task.label,
+                    ...(input.details ?? {})
+                }
+            });
+        }
+        catch {
+            // Diagnostics should never block job execution.
+        }
+    }
 }

package/dist/server/managers/platform/llm-manager.js

@@ -1,5 +1,8 @@
 import { AbstractManager } from "../base.js";
 import { readEncryptedSecret } from "../../repositories/calendar.js";
+function emitDiagnostic(logger, input) {
+    logger?.(input);
+}
 export class LlmManager extends AbstractManager {
     secretsManager;
     name = "LlmManager";
@@ -13,18 +16,101 @@ export class LlmManager extends AbstractManager {
             this.providers.set(alias, provider);
         }
     }
-    async compileWikiIngest(profile, input) {
-        const provider = this.providers.get(profile.provider) ??
-            this.providers.get("openai-responses") ??
-            null;
+    async compileWikiIngest(profile, input, options = {}, logger) {
+        const provider = this.resolveProvider(profile.provider);
         if (!provider) {
+            emitDiagnostic(logger, {
+                level: "error",
+                message: "Wiki ingest LLM provider is not supported.",
+                details: {
+                    scope: "wiki_llm",
+                    eventKey: "llm_provider_missing",
+                    provider: profile.provider,
+                    baseUrl: profile.baseUrl,
+                    model: profile.model
+                }
+            });
             return null;
         }
         const apiKey = this.readApiKey(profile.secretId);
         if (!apiKey) {
+            emitDiagnostic(logger, {
+                level: "error",
+                message: "Wiki ingest LLM profile is missing an API key.",
+                details: {
+                    scope: "wiki_llm",
+                    eventKey: "llm_api_key_missing",
+                    provider: profile.provider,
+                    baseUrl: profile.baseUrl,
+                    model: profile.model,
+                    secretId: profile.secretId ?? null
+                }
+            });
             return null;
         }
-        return provider.compile({ apiKey, profile, input });
+        return provider.compile({
+            apiKey,
+            profile,
+            input,
+            resumeResponseId: options.resumeResponseId ?? null,
+            logger
+        });
+    }
+    async testWikiConnection(profile, explicitApiKey, logger) {
+        const provider = this.resolveProvider(profile.provider);
+        if (!provider) {
+            emitDiagnostic(logger, {
+                level: "error",
+                message: "Wiki LLM connection test requested an unsupported provider.",
+                details: {
+                    scope: "wiki_llm",
+                    eventKey: "llm_provider_missing",
+                    provider: profile.provider,
+                    baseUrl: profile.baseUrl,
+                    model: profile.model
+                }
+            });
+            throw new Error("Unsupported LLM provider.");
+        }
+        const apiKey = explicitApiKey?.trim() || this.readApiKey(profile.secretId);
+        if (!apiKey) {
+            emitDiagnostic(logger, {
+                level: "error",
+                message: "Wiki LLM connection test is missing an API key.",
+                details: {
+                    scope: "wiki_llm",
+                    eventKey: "llm_api_key_missing",
+                    provider: profile.provider,
+                    baseUrl: profile.baseUrl,
+                    model: profile.model,
+                    secretId: profile.secretId ?? null
+                }
+            });
+            throw new Error("Save an OpenAI API key first.");
+        }
+        const result = await provider.testConnection({
+            apiKey,
+            profile,
+            logger
+        });
+        return {
+            provider: profile.provider,
+            model: profile.model,
+            baseUrl: profile.baseUrl,
+            reasoningEffort: typeof profile.metadata.reasoningEffort === "string"
+                ? profile.metadata.reasoningEffort
+                : null,
+            verbosity: typeof profile.metadata.verbosity === "string"
+                ? profile.metadata.verbosity
+                : null,
+            usingStoredKey: !explicitApiKey?.trim(),
+            outputPreview: result.outputPreview
+        };
+    }
+    resolveProvider(providerName) {
+        return (this.providers.get(providerName) ??
+            this.providers.get("openai-responses") ??
+            null);
     }
     readApiKey(secretId) {
         if (!secretId) {