browser-debugging-daemon 1.0.0

package/subagent/OpenAIPlanner.js

@@ -0,0 +1,382 @@
+function extractTextContent(content) {
+    if (typeof content === "string") {
+        return content;
+    }
+
+    if (Array.isArray(content)) {
+        return content
+            .map((item) => {
+                if (typeof item === "string") return item;
+                if (item?.type === "text") return item.text || "";
+                return "";
+            })
+            .join("");
+    }
+
+    return "";
+}
+
+function extractJsonObject(text) {
+    const trimmed = text.trim();
+    const direct = tryParseJson(trimmed);
+    if (direct) return direct;
+
+    const start = trimmed.indexOf("{");
+    const end = trimmed.lastIndexOf("}");
+    if (start === -1 || end === -1 || end <= start) {
+        return null;
+    }
+
+    return tryParseJson(trimmed.slice(start, end + 1));
+}
+
+function tryParseJson(text) {
+    try {
+        return JSON.parse(text);
+    } catch (error) {
+        return null;
+    }
+}
+
+function sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+function parseCsvList(value) {
+    return String(value || "")
+        .split(",")
+        .map((item) => item.trim())
+        .filter(Boolean);
+}
+
+const DEFAULT_MODEL_FALLBACKS = [];
+const DEFAULT_BASE_URL = "http://localhost:8045/v1";
+const BASE_URL_ENV_KEYS = [
+    "OPENAI_BASE_URL",
+    "LLM_BASE_URL",
+    "MODEL_BASE_URL",
+    "ANTHROPIC_BASE_URL",
+];
+const MODEL_ENV_KEYS = [
+    "OPENAI_MODEL",
+    "LLM_MODEL",
+    "MODEL_NAME",
+    "ANTHROPIC_MODEL",
+    "CLAUDE_CODE_MODEL",
+];
+const API_KEY_ENV_KEYS = [
+    "OPENAI_API_KEY",
+    "LLM_API_KEY",
+    "MODEL_API_KEY",
+    "ANTHROPIC_API_KEY",
+];
+
+function firstNonEmpty(...values) {
+    for (const value of values) {
+        if (typeof value !== "string") continue;
+        const trimmed = value.trim();
+        if (trimmed) return trimmed;
+    }
+    return "";
+}
+
+function firstEnv(keys = []) {
+    for (const key of keys) {
+        const value = process.env[key];
+        if (typeof value !== "string") continue;
+        const trimmed = value.trim();
+        if (trimmed) return trimmed;
+    }
+    return "";
+}
+
+export class OpenAIPlanner {
+    constructor(options = {}) {
+        this.apiKey = firstNonEmpty(options.apiKey, firstEnv(API_KEY_ENV_KEYS), "browser-subagent-local");
+        this.baseUrl = firstNonEmpty(options.baseUrl, firstEnv(BASE_URL_ENV_KEYS), DEFAULT_BASE_URL).replace(/\/$/, "");
+        this.model = firstNonEmpty(options.model, firstEnv(MODEL_ENV_KEYS));
+        this.modelFallbacks = parseCsvList(
+            options.modelFallbacks
+            || process.env.BROWSER_PLANNER_MODEL_FALLBACKS
+            || DEFAULT_MODEL_FALLBACKS.join(",")
+        );
+        this.requestTimeoutMs = Number.parseInt(process.env.BROWSER_PLANNER_TIMEOUT_MS, 10) || 45000;
+        this.maxRetries = Number.parseInt(process.env.BROWSER_PLANNER_MAX_RETRIES, 10) || 2;
+        this.baseRetryDelayMs = Number.parseInt(process.env.BROWSER_PLANNER_RETRY_BACKOFF_MS, 10) || 700;
+        this.modelDiscoveryTtlMs = Number.parseInt(process.env.BROWSER_PLANNER_MODEL_CACHE_MS, 10) || 60000;
+        this.availableModelsCache = [];
+        this.availableModelsCacheAt = 0;
+        this.lastHealthyModel = null;
+    }
+
+    buildDecisionSystemPrompt() {
+        return [
+            "You are an autonomous browser subagent controller.",
+            "Your job is to complete the user's task by choosing exactly one next browser action at a time.",
+            "You must output valid JSON only.",
+            "Prefer the simplest action that makes forward progress.",
+            "If the task is complete, return status=completed and next_action.type=finish.",
+            "If the task is blocked or impossible, return status=failed and next_action.type=fail with a clear reason.",
+            "If you need guidance from the main agent or a human operator, return status=needs_input and next_action.type=ask_main_agent.",
+            "Be proactive about asking for guidance when you detect a login wall, permission dialog, or unexpected page/runtime error.",
+            "Never invent elements that are not present in the observed element list.",
+            "Use goto only when you know the exact URL to open.",
+            "Available action types: goto, click, type, hover, keypress, scroll, finish, fail, ask_main_agent.",
+        ].join(" ");
+    }
+
+    buildDecisionUserPrompt(input) {
+        return JSON.stringify({
+            task: input.taskInstruction,
+            current_page: input.page,
+            observed_elements: input.elements,
+            history: input.history,
+            operator_messages: input.operatorMessages || [],
+            debug_state: {
+                recentErrors: input.debugState.recentErrors,
+                recentConsole: input.debugState.recentConsole,
+                recentNetwork: input.debugState.recentNetwork,
+            },
+            required_output_schema: {
+                thinking: "string",
+                status: "continue|completed|failed|needs_input",
+                summary: "string",
+                next_action: {
+                    type: "goto|click|type|hover|keypress|scroll|finish|fail|ask_main_agent",
+                    url: "string?",
+                    id: "number?",
+                    text: "string?",
+                    key: "string?",
+                    direction: "down|up|top|bottom?",
+                    result: "string?",
+                    reason: "string?",
+                    question: "string?",
+                    details: "string?",
+                    suggested_reply: "string?",
+                },
+            },
+        }, null, 2);
+    }
+
+    buildVerificationSystemPrompt() {
+        return [
+            "You are a browser task verifier.",
+            "You evaluate whether the browser task is complete after the last action.",
+            "You must output valid JSON only.",
+            "Be conservative: only mark completed when the page state clearly satisfies the task.",
+            "If progress was made but the task is not finished, return goal_status=incomplete.",
+            "If the task appears blocked or impossible from the current state, return goal_status=blocked.",
+        ].join(" ");
+    }
+
+    buildVerificationUserPrompt(input) {
+        return JSON.stringify({
+            task: input.taskInstruction,
+            page_after_action: input.page,
+            observed_elements_after_action: input.elements,
+            last_action: input.lastAction,
+            last_action_result: input.lastActionResult,
+            history: input.history,
+            debug_state: {
+                recentErrors: input.debugState.recentErrors,
+                recentConsole: input.debugState.recentConsole,
+                recentNetwork: input.debugState.recentNetwork,
+            },
+            required_output_schema: {
+                goal_status: "incomplete|completed|blocked",
+                confidence: "low|medium|high",
+                summary: "string",
+                evidence: ["string"],
+                next_hint: "string",
+            },
+        }, null, 2);
+    }
+
+    shouldTryAnotherModel(error) {
+        const message = String(error?.message || "").toLowerCase();
+        return message.includes("all accounts failed")
+            || message.includes("unhealthy")
+            || message.includes("token error")
+            || message.includes("no such model")
+            || message.includes("not found")
+            || message.includes("model_not_found")
+            || message.includes("does not exist")
+            || message.includes("unsupported model")
+            || message.includes("unsupported value")
+            || message.includes("invalid model")
+            || message.includes("bad model");
+    }
+
+    async listAvailableModels() {
+        const now = Date.now();
+        if (
+            this.availableModelsCache.length > 0
+            && now - this.availableModelsCacheAt < this.modelDiscoveryTtlMs
+        ) {
+            return this.availableModelsCache;
+        }
+
+        const controller = new AbortController();
+        const timeoutMs = Math.max(3000, Math.min(this.requestTimeoutMs, 8000));
+        const timeoutId = setTimeout(() => controller.abort(), timeoutMs);
+        try {
+            const response = await fetch(`${this.baseUrl}/models`, {
+                method: "GET",
+                signal: controller.signal,
+                headers: {
+                    Authorization: `Bearer ${this.apiKey}`,
+                },
+            });
+            if (!response.ok) {
+                return [];
+            }
+            const data = await response.json().catch(() => ({}));
+            const models = Array.isArray(data?.data)
+                ? data.data
+                    .map((item) => (typeof item?.id === "string" ? item.id.trim() : ""))
+                    .filter(Boolean)
+                : [];
+            this.availableModelsCache = models;
+            this.availableModelsCacheAt = now;
+            return models;
+        } catch (error) {
+            return [];
+        } finally {
+            clearTimeout(timeoutId);
+        }
+    }
+
+    async buildModelCandidates() {
+        const availableModels = await this.listAvailableModels();
+        const discovered = availableModels.length > 0
+            ? [
+                this.model && availableModels.includes(this.model) ? this.model : null,
+                ...availableModels,
+            ].filter(Boolean)
+            : [];
+        const configured = [this.model, ...this.modelFallbacks].filter(Boolean);
+        const candidates = [
+            this.lastHealthyModel,
+            ...discovered,
+            ...configured,
+        ].filter(Boolean);
+
+        const unique = [];
+        const seen = new Set();
+        for (const modelName of candidates) {
+            if (!seen.has(modelName)) {
+                seen.add(modelName);
+                unique.push(modelName);
+            }
+        }
+        if (unique.length > 0) {
+            return unique;
+        }
+
+        throw new Error(
+            "Planner model is not configured and no models were discovered. Set OPENAI_MODEL (or LLM_MODEL/ANTHROPIC_MODEL), or ensure /models is reachable."
+        );
+    }
+
+    async requestJsonWithModel(systemPrompt, userPrompt, modelName) {
+        let lastError = null;
+        const attempts = Math.max(1, this.maxRetries + 1);
+
+        for (let attempt = 1; attempt <= attempts; attempt += 1) {
+            const controller = new AbortController();
+            const timeoutId = setTimeout(() => controller.abort(), this.requestTimeoutMs);
+            try {
+                const response = await fetch(`${this.baseUrl}/chat/completions`, {
+                    method: "POST",
+                    signal: controller.signal,
+                    headers: {
+                        "Content-Type": "application/json",
+                        Authorization: `Bearer ${this.apiKey}`,
+                    },
+                    body: JSON.stringify({
+                        model: modelName,
+                        temperature: 0,
+                        response_format: { type: "json_object" },
+                        messages: [
+                            { role: "system", content: systemPrompt },
+                            { role: "user", content: userPrompt },
+                        ],
+                    }),
+                });
+
+                if (!response.ok) {
+                    const errorText = await response.text().catch(() => response.statusText);
+                    const retryable = response.status >= 500 || response.status === 429;
+                    throw Object.assign(new Error(`Planner request failed (${modelName}): ${response.status} ${errorText}`), {
+                        retryable,
+                    });
+                }
+
+                const data = await response.json();
+                const message = data?.choices?.[0]?.message;
+                const text = extractTextContent(message?.content || "");
+                const parsed = extractJsonObject(text);
+
+                if (!parsed) {
+                    throw Object.assign(new Error(`Planner returned non-JSON output (${modelName}): ${text}`), {
+                        retryable: false,
+                    });
+                }
+
+                this.lastHealthyModel = modelName;
+                return parsed;
+            } catch (error) {
+                const isTimeout = error?.name === "AbortError";
+                const retryable = isTimeout || error?.retryable === true || !Object.prototype.hasOwnProperty.call(error || {}, "retryable");
+                lastError = isTimeout
+                    ? new Error(`Planner request timed out (${modelName}) after ${this.requestTimeoutMs}ms.`)
+                    : error;
+
+                if (!retryable || attempt >= attempts) {
+                    throw lastError;
+                }
+
+                const delay = this.baseRetryDelayMs * (2 ** (attempt - 1));
+                await sleep(delay);
+            } finally {
+                clearTimeout(timeoutId);
+            }
+        }
+
+        throw lastError || new Error("Planner request failed.");
+    }
+
+    async requestJson(systemPrompt, userPrompt) {
+        const candidates = await this.buildModelCandidates();
+        let lastError = null;
+
+        for (let index = 0; index < candidates.length; index += 1) {
+            const candidate = candidates[index];
+            try {
+                return await this.requestJsonWithModel(systemPrompt, userPrompt, candidate);
+            } catch (error) {
+                lastError = error;
+                const hasNext = index < candidates.length - 1;
+                if (!hasNext || !this.shouldTryAnotherModel(error)) {
+                    throw error;
+                }
+            }
+        }
+
+        throw lastError || new Error("Planner request failed: no healthy model available.");
+    }
+
+    async decide(input) {
+        return this.requestJson(
+            this.buildDecisionSystemPrompt(),
+            this.buildDecisionUserPrompt(input)
+        );
+    }
+
+    async verify(input) {
+        return this.requestJson(
+            this.buildVerificationSystemPrompt(),
+            this.buildVerificationUserPrompt(input)
+        );
+    }
+}