flowseeker 0.1.7

package/dist/agent/commandRunner.js

@@ -0,0 +1,166 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runAgentCommandProposal = runAgentCommandProposal;
+exports.summarizeAgentCommandRun = summarizeAgentCommandRun;
+exports.formatAgentCommandRunMarkdown = formatAgentCommandRunMarkdown;
+const cp = __importStar(require("child_process"));
+const path = __importStar(require("path"));
+const vscode = __importStar(require("vscode"));
+const approvalPolicy_1 = require("./approvalPolicy");
+const logger_1 = require("../utils/logger");
+async function runAgentCommandProposal(proposal) {
+    const command = proposal.command.trim();
+    if (!command) {
+        await vscode.window.showWarningMessage("FlowSeeker command proposal is empty.");
+        return undefined;
+    }
+    const folders = vscode.workspace.workspaceFolders;
+    if (!folders?.[0]) {
+        await vscode.window.showWarningMessage("Open a workspace folder before running FlowSeeker agent commands.");
+        return undefined;
+    }
+    const classification = (0, approvalPolicy_1.classifyCommand)(command);
+    const approved = await confirmCommandIfNeeded(command, classification);
+    if (!approved) {
+        return undefined;
+    }
+    const cwd = resolveCommandCwd(folders[0].uri.fsPath, proposal.cwd);
+    (0, logger_1.logInfo)(`FlowSeeker agent command started: ${command}`);
+    const started = Date.now();
+    const result = await execCommand(command, cwd);
+    const run = {
+        proposal,
+        classification,
+        cwd,
+        ...result,
+        durationMs: Date.now() - started
+    };
+    await showCommandResult(run);
+    return run;
+}
+function summarizeAgentCommandRun(run) {
+    const status = run.exitCode === 0 ? "passed" : run.timedOut ? "timed out" : run.exitCode === null ? "errored" : "failed";
+    return `Command ${status}: \`${run.proposal.command}\` (${run.durationMs}ms).`;
+}
+function formatAgentCommandRunMarkdown(run) {
+    const lines = [
+        `# FlowSeeker Agent Command`,
+        "",
+        `Command: \`${run.proposal.command}\``,
+        `Working directory: \`${run.cwd}\``,
+        `Status: ${run.exitCode === 0 ? "PASS" : run.timedOut ? "TIMEOUT" : run.exitCode === null ? "ERROR" : "FAIL"}`,
+        `Exit code: ${run.exitCode ?? "n/a"}`,
+        `Duration: ${run.durationMs}ms`,
+        `Safety: ${run.classification.reason}`,
+        ""
+    ];
+    if (run.proposal.rationale) {
+        lines.push("## Rationale", "", run.proposal.rationale, "");
+    }
+    if (run.stdout) {
+        lines.push("## Stdout", "", "```", truncate(run.stdout, 12000), "```", "");
+    }
+    if (run.stderr) {
+        lines.push("## Stderr", "", "```", truncate(run.stderr, 6000), "```", "");
+    }
+    if (!run.stdout && !run.stderr) {
+        lines.push("No output was produced.", "");
+    }
+    return lines.join("\n");
+}
+async function confirmCommandIfNeeded(command, classification) {
+    if (classification.destructive) {
+        const action = await vscode.window.showWarningMessage(`FlowSeeker classified this command as destructive: ${command}`, { modal: true, detail: classification.reason }, "Run Anyway", "Cancel");
+        return action === "Run Anyway";
+    }
+    const kind = classification.safe ? "safe_command" : "all_command";
+    if ((0, approvalPolicy_1.canAutoApprove)(kind)) {
+        return true;
+    }
+    const action = await vscode.window.showInformationMessage(`Run FlowSeeker agent command?\n${command}`, { modal: true, detail: classification.reason }, "Run", "Cancel");
+    return action === "Run";
+}
+function execCommand(command, cwd) {
+    return new Promise((resolve) => {
+        const child = cp.exec(command, {
+            cwd,
+            timeout: 120000,
+            windowsHide: true,
+            env: { ...process.env, FORCE_COLOR: "0", CI: "true" },
+            maxBuffer: 1024 * 1024
+        }, (error, stdout, stderr) => {
+            const execError = error;
+            resolve({
+                exitCode: execError?.code ?? 0,
+                stdout: stdout.trim(),
+                stderr: stderr.trim(),
+                timedOut: Boolean(execError?.killed)
+            });
+        });
+        child.on("error", (error) => {
+            resolve({
+                exitCode: null,
+                stdout: "",
+                stderr: error.message,
+                timedOut: false
+            });
+        });
+    });
+}
+function resolveCommandCwd(workspaceRoot, requestedCwd) {
+    if (!requestedCwd?.trim()) {
+        return workspaceRoot;
+    }
+    const candidate = path.isAbsolute(requestedCwd)
+        ? path.normalize(requestedCwd)
+        : path.normalize(path.join(workspaceRoot, requestedCwd));
+    const relative = path.relative(workspaceRoot, candidate);
+    if (relative.startsWith("..") || path.isAbsolute(relative)) {
+        throw new Error(`Refusing to run command outside the workspace: ${requestedCwd}`);
+    }
+    return candidate;
+}
+async function showCommandResult(run) {
+    const document = await vscode.workspace.openTextDocument({
+        content: formatAgentCommandRunMarkdown(run),
+        language: "markdown"
+    });
+    await vscode.window.showTextDocument(document, { preview: true, viewColumn: vscode.ViewColumn.Beside });
+}
+function truncate(value, maxLength) {
+    return value.length > maxLength ? `${value.slice(0, maxLength)}\n... (truncated)` : value;
+}
+//# sourceMappingURL=commandRunner.js.map

package/dist/agent/flowCommandRunner.js

@@ -0,0 +1,124 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runFlowCommand = runFlowCommand;
+exports.commandToMode = commandToMode;
+const agentPrompts_1 = require("../gateway/agentPrompts");
+const runPipeline_1 = require("../pipeline/runPipeline");
+const logger_1 = require("../utils/logger");
+const contextExpansion_1 = require("../gateway/contextExpansion");
+async function runFlowCommand(command, task, gateway, resultProvider, planStore, editStore, callbacks, token, approvedPlan) {
+    const mode = command === "auto" ? "auto" : "guide";
+    try {
+        (0, logger_1.logInfo)(`FlowSeeker ${command} started: ${task}`);
+        callbacks.onProgress("Finding relevant files...");
+        const result = await (0, runPipeline_1.runFlowSeeker)(task, {
+            token,
+            progress: { report: (msg) => callbacks.onProgress(msg.message ?? String(msg)) }
+        });
+        resultProvider.setResult(result);
+        callbacks.onRetrievalComplete(result);
+        const connection = await gateway.getConnection();
+        // If there's an approved plan, generate edits from it
+        if (approvedPlan && connection.connected) {
+            const providerLabel = connection.providerLabel ?? connection.provider ?? "AI provider";
+            callbacks.onProviderAsking(providerLabel, connection.model);
+            const answer = await gateway.askWithInstruction(result, "auto", (0, agentPrompts_1.createApprovedEditInstruction)(approvedPlan), { stage: "approved_edits", approvedPlan });
+            if (answer.edits?.length) {
+                const editId = editStore.store(answer.edits);
+                callbacks.onComplete({
+                    mode: "auto",
+                    result,
+                    answer,
+                    editProposalId: editId
+                });
+                return {
+                    mode: "auto",
+                    result,
+                    answer,
+                    editProposalId: editId
+                };
+            }
+            callbacks.onComplete({
+                mode: "auto",
+                result,
+                answer,
+                error: "The AI provider did not return structured edits.",
+                needsMoreContext: (0, contextExpansion_1.isMissingContextRequest)(answer.message)
+            });
+            return {
+                mode: "auto",
+                result,
+                answer,
+                error: "The AI provider did not return structured edits.",
+                needsMoreContext: (0, contextExpansion_1.isMissingContextRequest)(answer.message)
+            };
+        }
+        if (!connection.connected) {
+            callbacks.onComplete({
+                mode,
+                result,
+                error: "No AI provider connected. Configure one or use Copy Agent Prompt."
+            });
+            return { mode, result, error: "No AI provider connected." };
+        }
+        const providerLabel = connection.providerLabel ?? connection.provider ?? "AI provider";
+        callbacks.onProviderAsking(providerLabel, connection.model);
+        const answer = await gateway.ask(result, mode);
+        if (mode === "auto" && (0, contextExpansion_1.isReviewablePlan)(answer.message)) {
+            const planId = planStore.store(result, answer.message);
+            callbacks.onComplete({
+                mode,
+                result,
+                answer,
+                planText: answer.message,
+                planProposalId: planId,
+                isApprovablePlan: true
+            });
+            return {
+                mode,
+                result,
+                answer,
+                planText: answer.message,
+                planProposalId: planId,
+                isApprovablePlan: true
+            };
+        }
+        if (answer.edits?.length) {
+            const editId = editStore.store(answer.edits);
+            callbacks.onComplete({
+                mode,
+                result,
+                answer,
+                editProposalId: editId
+            });
+            return {
+                mode,
+                result,
+                answer,
+                editProposalId: editId
+            };
+        }
+        callbacks.onComplete({
+            mode,
+            result,
+            answer,
+            needsMoreContext: (0, contextExpansion_1.isMissingContextRequest)(answer.message)
+        });
+        return {
+            mode,
+            result,
+            answer,
+            needsMoreContext: (0, contextExpansion_1.isMissingContextRequest)(answer.message)
+        };
+    }
+    catch (error) {
+        (0, logger_1.logError)(`FlowSeeker ${command} failed.`, error);
+        const message = error instanceof Error ? error.message : String(error);
+        callbacks.onComplete({ mode, result: undefined, error: message });
+        return { mode, result: undefined, error: message };
+    }
+}
+function commandToMode(command) {
+    return command === "auto" ? "auto" : "guide";
+}
+//# sourceMappingURL=flowCommandRunner.js.map

package/dist/agent/mcpToolRunner.js

@@ -0,0 +1,167 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runMcpToolProposal = runMcpToolProposal;
+exports.summarizeMcpToolRun = summarizeMcpToolRun;
+exports.availableToolNames = availableToolNames;
+const vscode = __importStar(require("vscode"));
+const approvalPolicy_1 = require("./approvalPolicy");
+const capabilities_1 = require("../runtime/capabilities");
+const logger_1 = require("../utils/logger");
+async function runMcpToolProposal(proposal) {
+    const toolName = proposal.tool.trim();
+    if (!toolName) {
+        await vscode.window.showWarningMessage("FlowSeeker MCP tool proposal is empty.");
+        return undefined;
+    }
+    const candidate = vscode;
+    const capabilities = (0, capabilities_1.getHostCapabilities)();
+    if (!capabilities.hasLanguageModelTools || typeof candidate.lm?.invokeTool !== "function") {
+        await vscode.window.showWarningMessage("This editor host does not expose the VS Code Language Model tool API to FlowSeeker.");
+        return undefined;
+    }
+    const tool = findTool(toolName, candidate.lm?.tools ?? []);
+    if (!tool) {
+        await vscode.window.showWarningMessage(`MCP/tool '${toolName}' is not available in this editor. Check FlowSeeker MCP config or host compatibility.`);
+        return undefined;
+    }
+    const approved = await confirmToolIfNeeded(tool.name, proposal);
+    if (!approved) {
+        return undefined;
+    }
+    (0, logger_1.logInfo)(`FlowSeeker MCP/tool invocation started: ${tool.name}`);
+    const started = Date.now();
+    try {
+        const result = await candidate.lm.invokeTool(tool.name, {
+            input: proposal.input ?? {},
+            toolInvocationToken: undefined
+        }, undefined);
+        const run = {
+            proposal,
+            toolName: tool.name,
+            durationMs: Date.now() - started,
+            resultText: toolResultToText(result)
+        };
+        await showToolResult(run);
+        return run;
+    }
+    catch (error) {
+        (0, logger_1.logError)(`FlowSeeker MCP/tool invocation failed: ${tool.name}`, error);
+        throw error;
+    }
+}
+function summarizeMcpToolRun(run) {
+    return `MCP/tool completed: \`${run.toolName}\` (${run.durationMs}ms).`;
+}
+function availableToolNames() {
+    const candidate = vscode;
+    return [...(candidate.lm?.tools ?? [])].map((tool) => tool.name).sort((left, right) => left.localeCompare(right));
+}
+function findTool(name, tools) {
+    const normalized = name.toLowerCase();
+    return tools.find((tool) => tool.name.toLowerCase() === normalized)
+        ?? tools.find((tool) => tool.name.toLowerCase().endsWith(`.${normalized}`))
+        ?? tools.find((tool) => tool.name.toLowerCase().endsWith(`_${normalized}`));
+}
+async function confirmToolIfNeeded(toolName, proposal) {
+    if ((0, approvalPolicy_1.canAutoApprove)("mcp_tool")) {
+        return true;
+    }
+    const action = await vscode.window.showInformationMessage(`Invoke FlowSeeker MCP/tool?\n${toolName}`, {
+        modal: true,
+        detail: proposal.rationale ?? "FlowSeeker will invoke this tool through VS Code's Language Model tool API."
+    }, "Invoke", "Cancel");
+    return action === "Invoke";
+}
+async function showToolResult(run) {
+    const document = await vscode.workspace.openTextDocument({
+        content: formatMcpToolRunMarkdown(run),
+        language: "markdown"
+    });
+    await vscode.window.showTextDocument(document, { preview: true, viewColumn: vscode.ViewColumn.Beside });
+}
+function formatMcpToolRunMarkdown(run) {
+    return [
+        "# FlowSeeker MCP Tool",
+        "",
+        `Tool: \`${run.toolName}\``,
+        `Duration: ${run.durationMs}ms`,
+        "",
+        run.proposal.rationale ? "## Rationale" : "",
+        run.proposal.rationale ?? "",
+        run.proposal.rationale ? "" : "",
+        "## Input",
+        "",
+        "```json",
+        JSON.stringify(run.proposal.input ?? {}, null, 2),
+        "```",
+        "",
+        "## Result",
+        "",
+        "```",
+        truncate(run.resultText || "(empty result)", 16000),
+        "```",
+        ""
+    ].filter((line, index, lines) => line !== "" || lines[index - 1] !== "").join("\n");
+}
+function toolResultToText(result) {
+    return result.content.map(partToText).filter(Boolean).join("\n\n");
+}
+function partToText(part) {
+    if (typeof part === "string") {
+        return part;
+    }
+    if (part && typeof part === "object") {
+        const value = part.value;
+        if (typeof value === "string") {
+            return value;
+        }
+        const data = part.data;
+        if (data instanceof Uint8Array) {
+            return `[${part.mimeType ?? "data"}: ${data.byteLength} bytes]`;
+        }
+        try {
+            return JSON.stringify(part, null, 2);
+        }
+        catch {
+            return String(part);
+        }
+    }
+    return String(part ?? "");
+}
+function truncate(value, maxLength) {
+    return value.length > maxLength ? `${value.slice(0, maxLength)}\n... (truncated)` : value;
+}
+//# sourceMappingURL=mcpToolRunner.js.map

package/dist/auth/githubAuth.js

@@ -0,0 +1,71 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getGitHubSession = getGitHubSession;
+exports.getSilentGitHubSession = getSilentGitHubSession;
+exports.hasGitHubSession = hasGitHubSession;
+const vscode = __importStar(require("vscode"));
+const GITHUB_AUTH_PROVIDER = "github";
+const GITHUB_MODELS_SCOPE = "read:user";
+async function getGitHubSession() {
+    const session = await vscode.authentication.getSession(GITHUB_AUTH_PROVIDER, [GITHUB_MODELS_SCOPE], {
+        createIfNone: true,
+        silent: false
+    });
+    if (!session) {
+        return null;
+    }
+    return {
+        accessToken: session.accessToken,
+        accountLabel: session.account.label
+    };
+}
+async function getSilentGitHubSession() {
+    const session = await vscode.authentication.getSession(GITHUB_AUTH_PROVIDER, [GITHUB_MODELS_SCOPE], {
+        silent: true
+    });
+    if (!session) {
+        return null;
+    }
+    return {
+        accessToken: session.accessToken,
+        accountLabel: session.account.label
+    };
+}
+async function hasGitHubSession() {
+    const session = await getSilentGitHubSession();
+    return session !== null;
+}
+//# sourceMappingURL=githubAuth.js.map

package/dist/auth/modelList.js

@@ -0,0 +1,127 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fetchModelList = fetchModelList;
+exports.getCachedModels = getCachedModels;
+exports.cacheModels = cacheModels;
+exports.clearCachedModels = clearCachedModels;
+const aiProviders_1 = require("../gateway/aiProviders");
+const MODELS_CACHE_TTL_MS = 10 * 60 * 1000;
+function cacheKey(providerId, baseUrl = "") {
+    return `flowseeker.models.${providerId}.${hashString(normalizeBaseUrl(baseUrl))}`;
+}
+async function fetchModelList(providerId, baseUrl, accessToken) {
+    const definition = (0, aiProviders_1.getProviderDefinition)(providerId);
+    const cleanBaseUrl = normalizeBaseUrl(baseUrl || definition.defaultBaseUrl);
+    let response;
+    if (providerId === "ollama") {
+        response = await fetch(joinUrl(cleanBaseUrl, "/api/tags"), {
+            headers: { "Content-Type": "application/json" }
+        });
+    }
+    else if (providerId === "gemini") {
+        response = await fetch(`${joinUrl(cleanBaseUrl, "/models")}?key=${encodeURIComponent(accessToken ?? "")}`, {
+            headers: { "Content-Type": "application/json" }
+        });
+    }
+    else if (providerId === "anthropic" || providerId === "customAnthropic") {
+        response = await fetch(joinUrl(cleanBaseUrl, "/models"), {
+            headers: {
+                "Content-Type": "application/json",
+                "x-api-key": accessToken ?? "",
+                "anthropic-version": "2023-06-01"
+            }
+        });
+    }
+    else {
+        response = await fetch(joinUrl(cleanBaseUrl, "/models"), {
+            headers: { Authorization: `Bearer ${accessToken ?? ""}`, "Content-Type": "application/json" }
+        });
+    }
+    if (!response.ok) {
+        throw new Error(`Failed to fetch models (${response.status})`);
+    }
+    return parseModelResponse(providerId, await response.json());
+}
+function parseModelResponse(providerId, data) {
+    // GitHub Models returns a plain array
+    if (Array.isArray(data)) {
+        return data
+            .filter(isObject)
+            .map((model) => {
+            const rawId = stringValue(model.id) ?? stringValue(model.name) ?? stringValue(model.model);
+            if (!rawId) {
+                return undefined;
+            }
+            const displayName = stringValue(model.display_name) ?? stringValue(model.displayName) ?? stringValue(model.name) ?? rawId;
+            return {
+                id: rawId,
+                name: displayName,
+                owned_by: stringValue(model.owned_by) ?? stringValue(model.ownedBy)
+            };
+        })
+            .filter((model) => Boolean(model?.id));
+    }
+    if (!isObject(data)) {
+        return [];
+    }
+    const rows = Array.isArray(data.data)
+        ? data.data
+        : Array.isArray(data.models)
+            ? data.models
+            : [];
+    return rows
+        .filter(isObject)
+        .map((model) => {
+        const rawId = stringValue(model.id) ?? stringValue(model.name) ?? stringValue(model.model);
+        if (!rawId) {
+            return undefined;
+        }
+        const id = providerId === "gemini" ? rawId.replace(/^models\//, "") : rawId;
+        const displayName = stringValue(model.display_name) ?? stringValue(model.displayName) ?? stringValue(model.name) ?? id;
+        return {
+            id,
+            name: providerId === "gemini" ? displayName.replace(/^models\//, "") : displayName,
+            owned_by: stringValue(model.owned_by) ?? stringValue(model.ownedBy)
+        };
+    })
+        .filter((model) => Boolean(model?.id));
+}
+function getCachedModels(context, providerId, baseUrl = "") {
+    const cached = context.globalState.get(cacheKey(providerId, baseUrl));
+    if (!cached || !Array.isArray(cached.models)) {
+        return null;
+    }
+    if (Date.now() - cached.fetchedAt > MODELS_CACHE_TTL_MS) {
+        return null;
+    }
+    return cached.models;
+}
+async function cacheModels(context, providerId, baseUrl, models) {
+    await context.globalState.update(cacheKey(providerId, baseUrl), {
+        models,
+        fetchedAt: Date.now()
+    });
+}
+function clearCachedModels(context, providerId, baseUrl = "") {
+    void context.globalState.update(cacheKey(providerId, baseUrl), undefined);
+}
+function joinUrl(baseUrl, path) {
+    return `${baseUrl.replace(/\/+$/, "")}/${path.replace(/^\/+/, "")}`;
+}
+function normalizeBaseUrl(value) {
+    return value.trim().replace(/\/+$/, "");
+}
+function stringValue(value) {
+    return typeof value === "string" && value.trim() ? value.trim() : undefined;
+}
+function isObject(value) {
+    return typeof value === "object" && value !== null;
+}
+function hashString(value) {
+    let hash = 5381;
+    for (let index = 0; index < value.length; index += 1) {
+        hash = ((hash << 5) + hash) ^ value.charCodeAt(index);
+    }
+    return (hash >>> 0).toString(36);
+}
+//# sourceMappingURL=modelList.js.map