flowseeker 0.1.7

package/dist/gateway/aiGateway.js

@@ -0,0 +1,1255 @@
+"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.AiGatewayClient = void 0;
+exports.parseAgentResponse = parseAgentResponse;
+const vscode = __importStar(require("vscode"));
+const fileGroups_1 = require("../pipeline/fileGroups");
+const responseLanguage_1 = require("../pipeline/responseLanguage");
+const agentPrompts_1 = require("./agentPrompts");
+const aiProviders_1 = require("./aiProviders");
+const oauthHandler_1 = require("../auth/oauthHandler");
+const githubAuth_1 = require("../auth/githubAuth");
+const modelList_1 = require("../auth/modelList");
+const tokenSecretKey = "flowseeker.aiGateway.token";
+const endpointStateKey = "flowseeker.aiGateway.endpoint";
+const activeProviderStateKey = "flowseeker.ai.provider";
+const modelStateKey = "flowseeker.ai.model";
+const baseUrlStateKey = "flowseeker.ai.baseUrl";
+const providerProfilesStateKey = "flowseeker.ai.providerProfiles.v1";
+const activeProviderProfileStateKey = "flowseeker.ai.activeProviderProfileId.v1";
+const maxProviderProfiles = 24;
+class AiGatewayClient {
+    constructor(context, quotaTracker) {
+        this.context = context;
+        this.quotaTracker = quotaTracker;
+    }
+    async getConnection() {
+        const activeProfile = await this.getActiveProfile();
+        if (activeProfile) {
+            return this.getProfileConnection(activeProfile);
+        }
+        const provider = this.getActiveProvider();
+        if (provider) {
+            return this.getProviderConnection(provider);
+        }
+        const endpoint = this.context.globalState.get(endpointStateKey);
+        const token = await this.context.secrets.get(tokenSecretKey);
+        return {
+            endpoint,
+            baseUrl: endpoint,
+            connected: Boolean(endpoint && token),
+            mode: endpoint && token ? "customGateway" : undefined,
+            provider: endpoint && token ? "customGateway" : undefined,
+            providerLabel: endpoint && token ? "Custom Gateway" : undefined,
+            model: endpoint && token ? "configured-by-gateway" : undefined,
+            requiresApiKey: true
+        };
+    }
+    async listProviderProfiles() {
+        const profiles = await this.getProfiles();
+        const activeProfile = await this.getActiveProfile(profiles);
+        return {
+            activeProfileId: activeProfile?.id,
+            profiles: await Promise.all(profiles.map((profile) => this.hydrateProfile(profile)))
+        };
+    }
+    async setActiveProviderProfile(profileId) {
+        const profiles = await this.getProfiles();
+        const profile = profiles.find((item) => item.id === profileId);
+        if (!profile) {
+            throw new Error("AI provider profile was not found.");
+        }
+        await this.activateProfile(profile);
+        return this.getProfileConnection(profile);
+    }
+    async removeProviderProfile(profileId) {
+        const profiles = await this.getProfiles();
+        const activeProfile = await this.getActiveProfile(profiles);
+        const targetId = profileId ?? activeProfile?.id;
+        if (!targetId) {
+            await this.clearLegacyActiveState();
+            return;
+        }
+        const nextProfiles = profiles.filter((profile) => profile.id !== targetId);
+        await this.context.secrets.delete(profileSecretKey(targetId));
+        await this.saveProfiles(nextProfiles);
+        if (activeProfile?.id === targetId) {
+            const nextActive = nextProfiles[0];
+            if (nextActive) {
+                await this.activateProfile(nextActive);
+            }
+            else {
+                await this.context.globalState.update(activeProviderProfileStateKey, undefined);
+                await this.clearLegacyActiveState();
+            }
+        }
+    }
+    async configureProvider(input) {
+        const definition = (0, aiProviders_1.getProviderDefinition)(input.provider);
+        const cleanBaseUrl = (input.baseUrl ?? definition.defaultBaseUrl).trim();
+        const cleanModel = (input.model ?? definition.defaultModel).trim();
+        const cleanKey = input.apiKey?.trim();
+        if (input.provider === "customGateway" || input.provider === "customAnthropic") {
+            if (!cleanModel) {
+                throw new Error(`${definition.label} requires a model.`);
+            }
+        }
+        if (!cleanBaseUrl) {
+            throw new Error(`${definition.label} base URL is required.`);
+        }
+        if (!cleanModel) {
+            throw new Error(`${definition.label} model is required.`);
+        }
+        const profileId = createProviderProfileId(input.provider, cleanModel, cleanBaseUrl);
+        const existingProfileKey = await this.context.secrets.get(profileSecretKey(profileId));
+        const existingProviderKey = await this.context.secrets.get((0, aiProviders_1.providerSecretKey)(input.provider));
+        const isOAuth = definition.authMethod === "oauth";
+        if (!isOAuth && definition.requiresApiKey && !cleanKey && !existingProfileKey && !existingProviderKey) {
+            throw new Error(`${definition.label} API key is required.`);
+        }
+        const profile = {
+            id: profileId,
+            provider: input.provider,
+            model: cleanModel,
+            baseUrl: cleanBaseUrl,
+            updatedAt: new Date().toISOString()
+        };
+        await this.upsertProfile(profile);
+        const keyForProfile = cleanKey || existingProfileKey || existingProviderKey;
+        if (keyForProfile) {
+            await this.context.secrets.store(profileSecretKey(profile.id), keyForProfile);
+        }
+        if (cleanKey) {
+            await this.context.secrets.store((0, aiProviders_1.providerSecretKey)(input.provider), cleanKey);
+            if (input.provider === "customGateway") {
+                await this.context.secrets.store(tokenSecretKey, cleanKey);
+            }
+        }
+        await this.activateProfile(profile);
+    }
+    async connect(endpoint, token, model = "configured-by-gateway") {
+        const cleanEndpoint = endpoint.trim();
+        const cleanToken = token.trim();
+        if (!cleanEndpoint) {
+            throw new Error("AI Gateway endpoint is required.");
+        }
+        if (!cleanToken) {
+            throw new Error("AI Gateway token is required.");
+        }
+        await this.configureProvider({
+            provider: "customGateway",
+            baseUrl: cleanEndpoint,
+            model: model.trim() || "configured-by-gateway",
+            apiKey: cleanToken
+        });
+    }
+    async disconnect() {
+        const activeProfile = await this.getActiveProfile();
+        if (activeProfile) {
+            const definition = (0, aiProviders_1.getProviderDefinition)(activeProfile.provider);
+            if (definition.authMethod === "oauth") {
+                await (0, oauthHandler_1.clearTokens)(this.context, activeProfile.provider);
+                (0, modelList_1.clearCachedModels)(this.context, activeProfile.provider);
+            }
+            await this.removeProviderProfile(activeProfile.id);
+            return;
+        }
+        const activeProvider = this.getActiveProvider();
+        if (activeProvider) {
+            const definition = (0, aiProviders_1.getProviderDefinition)(activeProvider);
+            if (definition.authMethod === "oauth") {
+                await (0, oauthHandler_1.clearTokens)(this.context, activeProvider);
+                (0, modelList_1.clearCachedModels)(this.context, activeProvider);
+            }
+            await this.context.secrets.delete((0, aiProviders_1.providerSecretKey)(activeProvider));
+        }
+        await this.clearLegacyActiveState();
+    }
+    async ask(result, mode) {
+        const activeProvider = this.getActiveProvider();
+        if (activeProvider && activeProvider !== "customGateway") {
+            const prompt = mode === "auto" ? (0, agentPrompts_1.createPlanPrompt)(result) : (0, agentPrompts_1.createGuidancePrompt)(result);
+            const { text, responseHeaders } = await this.askDirectProvider(prompt, false, activeProvider);
+            const response = mode === "auto" ? { message: text.trim() || "The selected provider returned an empty plan." } : parseAgentResponse(text);
+            this.recordAskUsage(prompt, text, responseHeaders);
+            return response;
+        }
+        const response = await this.askWithInstruction(result, mode);
+        const prompt = (0, agentPrompts_1.createGuidancePrompt)(result);
+        this.recordAskUsage(prompt, response.message, {});
+        return response;
+    }
+    async askDirectChat(task) {
+        const provider = this.getActiveProvider();
+        if (!provider) {
+            throw new Error("No AI provider is connected. Connect one in the sidebar before using Chat mode.");
+        }
+        if (provider === "customGateway") {
+            const endpoint = this.context.globalState.get(endpointStateKey) || this.context.globalState.get(baseUrlStateKey);
+            const token = await this.context.secrets.get(tokenSecretKey);
+            const model = this.context.globalState.get(modelStateKey) || "configured-by-gateway";
+            if (!endpoint || !token) {
+                throw new Error("AI Gateway is not connected.");
+            }
+            if (!this.shouldUseCustomOpenAICompatible(model)) {
+                throw new Error("Chat mode requires a Custom OpenAI-Compatible model name for Custom Gateway profiles.");
+            }
+            const { text, responseHeaders } = await (0, aiProviders_1.invokeCustomOpenAICompatibleProvider)({
+                provider: "customGateway",
+                model,
+                baseUrl: endpoint,
+                apiKey: token,
+                prompt: task
+            });
+            this.recordGatewayUsage("customGateway", model, task, text, responseHeaders);
+            return { message: text.trim() || "(empty response)" };
+        }
+        const { text, responseHeaders } = await this.askDirectProvider(task, false, provider);
+        this.recordAskUsage(task, text, responseHeaders);
+        return { message: text.trim() || "(empty response)" };
+    }
+    async askDirectChatStream(task, onToken, signal, activeProvider) {
+        const provider = activeProvider ?? this.getActiveProvider();
+        if (!provider) {
+            throw new Error("No AI provider is connected. Connect one in the sidebar before using Chat mode.");
+        }
+        if (provider === "customGateway") {
+            const endpoint = this.context.globalState.get(endpointStateKey) || this.context.globalState.get(baseUrlStateKey);
+            const token = await this.context.secrets.get(tokenSecretKey);
+            const model = this.context.globalState.get(modelStateKey) || "configured-by-gateway";
+            if (!endpoint || !token) {
+                throw new Error("AI Gateway is not connected.");
+            }
+            if (!this.shouldUseCustomOpenAICompatible(model)) {
+                throw new Error("Chat mode requires a Custom OpenAI-Compatible model name for Custom Gateway profiles.");
+            }
+            const { text, responseHeaders } = await (0, aiProviders_1.invokeCustomOpenAICompatibleProviderStream)({
+                provider: "customGateway",
+                model,
+                baseUrl: endpoint,
+                apiKey: token,
+                prompt: task,
+                onToken,
+                signal
+            });
+            this.recordGatewayUsage("customGateway", model, task, text, responseHeaders);
+            return { message: text.trim() || "(empty response)" };
+        }
+        const { text, responseHeaders } = await this.askDirectProviderStream(task, onToken, signal, provider);
+        this.recordAskUsage(task, text, responseHeaders);
+        return { message: text.trim() || "(empty response)" };
+    }
+    async askStream(result, mode, onToken, signal) {
+        if (mode === "auto") {
+            return this.ask(result, mode);
+        }
+        const prompt = (0, agentPrompts_1.createGuidancePrompt)(result);
+        const activeProvider = this.getActiveProvider();
+        if (activeProvider && activeProvider !== "customGateway") {
+            const { text, responseHeaders } = await this.askDirectProviderStream(prompt, onToken, signal, activeProvider);
+            const response = parseAgentResponse(text);
+            this.recordAskUsage(prompt, text, responseHeaders);
+            return response;
+        }
+        const endpoint = this.context.globalState.get(endpointStateKey);
+        const token = await this.context.secrets.get(tokenSecretKey);
+        const model = this.context.globalState.get(modelStateKey) || "configured-by-gateway";
+        if (!endpoint || !token) {
+            throw new Error("AI Gateway is not connected.");
+        }
+        if (this.shouldUseCustomOpenAICompatible(model)) {
+            const { text, responseHeaders } = await (0, aiProviders_1.invokeCustomOpenAICompatibleProviderStream)({
+                provider: "customGateway",
+                model,
+                baseUrl: endpoint,
+                apiKey: token,
+                prompt,
+                onToken,
+                signal
+            });
+            this.recordGatewayUsage("customGateway", model, prompt, text, responseHeaders);
+            return parseAgentResponse(text);
+        }
+        const response = await this.askWithInstruction(result, mode);
+        onToken(response.message);
+        this.recordAskUsage(prompt, response.message, {});
+        return response;
+    }
+    async askWithInstruction(result, mode, instruction, extra) {
+        const activeProvider = this.getActiveProvider();
+        if (activeProvider && activeProvider !== "customGateway") {
+            const prompt = instruction
+                ? (0, agentPrompts_1.createPromptWithInstruction)(result, instruction)
+                : mode === "auto"
+                    ? (0, agentPrompts_1.createPlanPrompt)(result)
+                    : (0, agentPrompts_1.createGuidancePrompt)(result);
+            const jsonMode = extra?.stage === "approved_edits";
+            const { text } = await this.askDirectProvider(prompt, jsonMode, activeProvider);
+            return parseAgentResponse(text);
+        }
+        const endpoint = this.context.globalState.get(endpointStateKey);
+        const token = await this.context.secrets.get(tokenSecretKey);
+        const model = this.context.globalState.get(modelStateKey) || "configured-by-gateway";
+        if (!endpoint || !token) {
+            throw new Error("AI Gateway is not connected.");
+        }
+        if (this.shouldUseCustomOpenAICompatible(model)) {
+            const prompt = instruction
+                ? (0, agentPrompts_1.createPromptWithInstruction)(result, instruction)
+                : mode === "auto"
+                    ? (0, agentPrompts_1.createPlanPrompt)(result)
+                    : (0, agentPrompts_1.createGuidancePrompt)(result);
+            const jsonMode = extra?.stage === "approved_edits";
+            const { text, responseHeaders } = await (0, aiProviders_1.invokeCustomOpenAICompatibleProvider)({
+                provider: "customGateway",
+                model,
+                baseUrl: endpoint,
+                apiKey: token,
+                prompt,
+                jsonMode
+            });
+            this.recordGatewayUsage("customGateway", model, prompt, text, responseHeaders);
+            return parseAgentResponse(text);
+        }
+        const response = await fetch(endpoint, {
+            method: "POST",
+            headers: {
+                "content-type": "application/json",
+                authorization: `Bearer ${token}`
+            },
+            body: JSON.stringify(toGatewayPayload(result, mode, instruction, extra))
+        });
+        const responseHeaders = {};
+        response.headers.forEach((value, key) => { responseHeaders[key.toLowerCase()] = value; });
+        const text = await response.text();
+        if (!response.ok) {
+            throw new Error(`AI Gateway returned ${response.status}: ${text.slice(0, 500)}`);
+        }
+        if (looksLikeHtml(text)) {
+            throw new Error("AI Gateway returned an HTML page, not an agent response. Use the API base URL, usually ending in /v1, not the dashboard/home page URL. For AI Box/new-api, choose Custom OpenAI-Compatible and enter the model name.");
+        }
+        this.recordGatewayUsage("customGateway", model, JSON.stringify(toGatewayPayload(result, mode, instruction, extra)), text, responseHeaders);
+        return parseAgentResponse(text);
+    }
+    async testProvider(input) {
+        if (input) {
+            const definition = (0, aiProviders_1.getProviderDefinition)(input.provider);
+            const baseUrl = (input.baseUrl ?? definition.defaultBaseUrl).trim();
+            const model = (input.model ?? definition.defaultModel).trim();
+            const profileId = createProviderProfileId(input.provider, model, baseUrl);
+            const apiKey = definition.authMethod === "oauth"
+                ? (await this.getOAuthAccessToken(input.provider)) ?? undefined
+                : input.apiKey?.trim() ||
+                    (await this.context.secrets.get(profileSecretKey(profileId))) ||
+                    (await this.context.secrets.get((0, aiProviders_1.providerSecretKey)(input.provider)));
+            if (definition.protocol === "local-agent-cli") {
+                const cmd = input.apiKey?.trim() || definition.label;
+                throw new Error(`Local CLI provider "${definition.label}" cannot be tested with a text generation probe.\n\n` +
+                    `**Setup:** Make sure \`${cmd}\` is installed and logged in.\n` +
+                    `**Command field:** Set the CLI path or command in the provider configuration.\n` +
+                    `**Verification:** Run \`${cmd} --version\` or \`${cmd} --help\` in a terminal to confirm the CLI is available.`);
+            }
+            try {
+                if (input.provider === "customGateway") {
+                    const prompt = "Reply with exactly: OK";
+                    const { text, responseHeaders } = await (0, aiProviders_1.invokeCustomOpenAICompatibleProvider)({
+                        provider: "customGateway",
+                        model,
+                        baseUrl,
+                        apiKey,
+                        prompt
+                    });
+                    this.recordGatewayUsage("customGateway", model, prompt, text, responseHeaders);
+                }
+                else {
+                    const prompt = "Reply with exactly: OK";
+                    const { text, responseHeaders } = await (0, aiProviders_1.invokeDirectProvider)({
+                        provider: input.provider,
+                        model,
+                        baseUrl,
+                        apiKey,
+                        prompt,
+                        cwd: workspaceRootPath()
+                    });
+                    this.recordProviderUsage(input.provider, model, prompt, text, responseHeaders);
+                }
+            }
+            catch (error) {
+                throw new Error(classifyProviderError(error, definition.label));
+            }
+            return {
+                endpoint: baseUrl,
+                baseUrl,
+                connected: true,
+                mode: input.provider === "customGateway" ? "customGateway" : "direct",
+                provider: input.provider,
+                providerLabel: definition.label,
+                model,
+                requiresApiKey: definition.requiresApiKey
+            };
+        }
+        const connection = await this.getConnection();
+        if (!connection.connected || !connection.provider) {
+            throw new Error("No AI provider is connected.");
+        }
+        if (connection.provider === "customGateway") {
+            await this.testCustomGateway();
+            return connection;
+        }
+        await this.askDirectProvider("Reply with exactly: OK");
+        return connection;
+    }
+    async handleOAuthCallback(providerId, _code) {
+        const definition = (0, aiProviders_1.getProviderDefinition)(providerId);
+        if (definition.authMethod !== "oauth" || !definition.oauthConfig) {
+            throw new Error(`Provider ${providerId} does not support OAuth.`);
+        }
+        const hasTokens = await (0, oauthHandler_1.hasValidOAuthSession)(this.context, providerId);
+        if (!hasTokens) {
+            throw new Error("OAuth tokens were not stored. Please try signing in again.");
+        }
+        const models = await this.listModels(providerId);
+        const defaultModel = models[0]?.id || definition.defaultModel;
+        await this.configureProvider({
+            provider: providerId,
+            model: defaultModel,
+            baseUrl: definition.defaultBaseUrl,
+        });
+    }
+    async listModels(providerId) {
+        const definition = (0, aiProviders_1.getProviderDefinition)(providerId);
+        if (!definition.supportsModelList) {
+            return [];
+        }
+        const activeProfile = await this.getActiveProfile();
+        const baseUrl = activeProfile?.provider === providerId
+            ? activeProfile.baseUrl
+            : this.context.globalState.get(baseUrlStateKey) || definition.defaultBaseUrl;
+        const token = definition.authMethod === "oauth"
+            ? (await this.getOAuthAccessToken(providerId)) ?? undefined
+            : activeProfile?.provider === providerId
+                ? await this.context.secrets.get(profileSecretKey(activeProfile.id)) || await this.context.secrets.get((0, aiProviders_1.providerSecretKey)(providerId))
+                : await this.context.secrets.get((0, aiProviders_1.providerSecretKey)(providerId));
+        return this.fetchModels(providerId, baseUrl, token);
+    }
+    async listModelsForInput(input) {
+        const definition = (0, aiProviders_1.getProviderDefinition)(input.provider);
+        if (!definition.supportsModelList) {
+            return [];
+        }
+        const baseUrl = (input.baseUrl ?? definition.defaultBaseUrl).trim();
+        const profileId = createProviderProfileId(input.provider, input.model ?? definition.defaultModel, baseUrl);
+        const token = definition.authMethod === "oauth"
+            ? (await this.getOAuthAccessToken(input.provider)) ?? undefined
+            : input.apiKey?.trim() ||
+                (await this.context.secrets.get(profileSecretKey(profileId))) ||
+                (await this.context.secrets.get((0, aiProviders_1.providerSecretKey)(input.provider)));
+        return this.fetchModels(input.provider, baseUrl, token);
+    }
+    async fetchModels(providerId, baseUrl, token) {
+        const definition = (0, aiProviders_1.getProviderDefinition)(providerId);
+        if (!definition.supportsModelList) {
+            return [];
+        }
+        if (definition.requiresApiKey && !token) {
+            return [];
+        }
+        const cached = (0, modelList_1.getCachedModels)(this.context, providerId, baseUrl);
+        if (cached) {
+            return cached;
+        }
+        try {
+            const models = await (0, modelList_1.fetchModelList)(providerId, baseUrl || definition.defaultBaseUrl, token);
+            await (0, modelList_1.cacheModels)(this.context, providerId, baseUrl || definition.defaultBaseUrl, models);
+            return models;
+        }
+        catch {
+            return [];
+        }
+    }
+    async getOAuthAccessToken(providerId) {
+        const definition = (0, aiProviders_1.getProviderDefinition)(providerId);
+        if (definition.authMethod !== "oauth" || !definition.oauthConfig) {
+            return null;
+        }
+        // GitHub Models: try stored token first, then refresh via VS Code session
+        if (providerId === "githubModels") {
+            const stored = await (0, oauthHandler_1.getValidAccessToken)(this.context, {
+                providerId,
+                authorizeUrl: "",
+                tokenUrl: "",
+                clientId: "",
+                scopes: [],
+                redirectUri: "",
+            });
+            if (stored) {
+                return stored;
+            }
+            const session = await (0, githubAuth_1.getSilentGitHubSession)();
+            if (session) {
+                await this.context.secrets.store("flowseeker.oauth.githubModels.accessToken", session.accessToken);
+                return session.accessToken;
+            }
+            return null;
+        }
+        const config = {
+            providerId,
+            authorizeUrl: definition.oauthConfig.authorizeUrl,
+            tokenUrl: definition.oauthConfig.tokenUrl,
+            clientId: definition.oauthConfig.clientId,
+            scopes: definition.oauthConfig.scopes,
+            redirectUri: "",
+        };
+        return (0, oauthHandler_1.getValidAccessToken)(this.context, config);
+    }
+    async recordAskUsage(promptText, responseText, responseHeaders) {
+        if (!this.quotaTracker)
+            return;
+        const provider = this.getActiveProvider();
+        if (!provider)
+            return;
+        const connection = await this.getConnection();
+        const model = connection.model || "";
+        if (!model)
+            return;
+        const inputTokens = extractTokens(responseHeaders, "prompt_tokens", promptText.length);
+        const outputTokens = extractTokens(responseHeaders, "completion_tokens", responseText.length);
+        const providerQuota = extractProviderQuota(provider, responseHeaders);
+        this.quotaTracker.record(provider, model, inputTokens, outputTokens, providerQuota);
+    }
+    recordProviderUsage(provider, model, promptText, responseText, responseHeaders) {
+        if (!this.quotaTracker)
+            return;
+        const inputTokens = extractTokens(responseHeaders, "prompt_tokens", promptText.length);
+        const outputTokens = extractTokens(responseHeaders, "completion_tokens", responseText.length);
+        const providerQuota = extractProviderQuota(provider, responseHeaders);
+        this.quotaTracker.record(provider, model, inputTokens, outputTokens, providerQuota);
+    }
+    recordGatewayUsage(provider, model, promptText, responseText, responseHeaders) {
+        if (!this.quotaTracker)
+            return;
+        const inputTokens = Math.ceil(promptText.length / 4);
+        const outputTokens = Math.ceil(responseText.length / 4);
+        const providerQuota = extractProviderQuota(provider, responseHeaders);
+        this.quotaTracker.record(provider, model, inputTokens, outputTokens, providerQuota);
+    }
+    getActiveProvider() {
+        const configured = this.context.globalState.get(activeProviderStateKey);
+        if ((0, aiProviders_1.isAiProviderId)(configured)) {
+            return configured;
+        }
+        const config = vscode.workspace.getConfiguration("flowseeker");
+        const useDirectProvider = config.get("ai.useDirectProvider", false);
+        const configProvider = config.get("ai.provider", "");
+        return useDirectProvider && (0, aiProviders_1.isAiProviderId)(configProvider) && configProvider !== "customGateway" ? configProvider : undefined;
+    }
+    async getProviderConnection(provider) {
+        const definition = (0, aiProviders_1.getProviderDefinition)(provider);
+        const config = vscode.workspace.getConfiguration("flowseeker");
+        const baseUrl = this.context.globalState.get(baseUrlStateKey) || config.get("ai.baseUrl", "") || definition.defaultBaseUrl;
+        const model = this.context.globalState.get(modelStateKey) || config.get("ai.model", "") || definition.defaultModel;
+        const isOAuth = definition.authMethod === "oauth";
+        const oauthConnected = isOAuth ? await (0, oauthHandler_1.hasValidOAuthSession)(this.context, provider) : false;
+        const token = isOAuth ? undefined : await this.context.secrets.get((0, aiProviders_1.providerSecretKey)(provider));
+        const connected = isOAuth
+            ? oauthConnected
+            : provider === "customGateway"
+                ? Boolean(baseUrl && token)
+                : Boolean(baseUrl && model && (!definition.requiresApiKey || token));
+        return {
+            endpoint: baseUrl,
+            baseUrl,
+            connected,
+            mode: provider === "customGateway" ? "customGateway" : "direct",
+            provider,
+            providerLabel: definition.label,
+            model,
+            requiresApiKey: isOAuth ? false : definition.requiresApiKey
+        };
+    }
+    async getProfiles() {
+        const stored = this.getStoredProfiles();
+        if (stored.length > 0) {
+            return stored;
+        }
+        const legacyProfile = await this.createLegacyProfileSnapshot();
+        if (!legacyProfile) {
+            return [];
+        }
+        await this.saveProfiles([legacyProfile]);
+        await this.context.globalState.update(activeProviderProfileStateKey, legacyProfile.id);
+        return [legacyProfile];
+    }
+    getStoredProfiles() {
+        const profiles = this.context.globalState.get(providerProfilesStateKey, []);
+        return profiles
+            .filter(isStoredProfile)
+            .slice(0, maxProviderProfiles);
+    }
+    async saveProfiles(profiles) {
+        const normalized = profiles
+            .filter(isStoredProfile)
+            .sort((left, right) => Date.parse(right.updatedAt) - Date.parse(left.updatedAt))
+            .slice(0, maxProviderProfiles);
+        await this.context.globalState.update(providerProfilesStateKey, normalized);
+    }
+    async upsertProfile(profile) {
+        const profiles = await this.getProfiles();
+        const next = [profile, ...profiles.filter((item) => item.id !== profile.id)];
+        await this.saveProfiles(next);
+    }
+    async getActiveProfile(profiles) {
+        const available = profiles ?? await this.getProfiles();
+        if (available.length === 0) {
+            return undefined;
+        }
+        const activeProfileId = this.context.globalState.get(activeProviderProfileStateKey);
+        return available.find((profile) => profile.id === activeProfileId) ?? available[0];
+    }
+    async activateProfile(profile) {
+        await this.context.globalState.update(activeProviderProfileStateKey, profile.id);
+        await this.context.globalState.update(activeProviderStateKey, profile.provider);
+        await this.context.globalState.update(modelStateKey, profile.model);
+        await this.context.globalState.update(baseUrlStateKey, profile.baseUrl);
+        await this.context.globalState.update(endpointStateKey, profile.provider === "customGateway" ? profile.baseUrl : undefined);
+        const token = await this.context.secrets.get(profileSecretKey(profile.id)) ||
+            await this.context.secrets.get((0, aiProviders_1.providerSecretKey)(profile.provider));
+        if (token) {
+            await this.context.secrets.store((0, aiProviders_1.providerSecretKey)(profile.provider), token);
+            if (profile.provider === "customGateway") {
+                await this.context.secrets.store(tokenSecretKey, token);
+            }
+        }
+    }
+    async clearLegacyActiveState() {
+        await this.context.globalState.update(activeProviderStateKey, undefined);
+        await this.context.globalState.update(modelStateKey, undefined);
+        await this.context.globalState.update(baseUrlStateKey, undefined);
+        await this.context.globalState.update(endpointStateKey, undefined);
+        await this.context.secrets.delete(tokenSecretKey);
+    }
+    async hydrateProfile(profile) {
+        const connection = await this.getProfileConnection(profile);
+        return {
+            id: profile.id,
+            provider: profile.provider,
+            providerLabel: connection.providerLabel ?? (0, aiProviders_1.getProviderDefinition)(profile.provider).label,
+            model: profile.model,
+            baseUrl: profile.baseUrl,
+            requiresApiKey: connection.requiresApiKey ?? true,
+            connected: connection.connected,
+            updatedAt: profile.updatedAt
+        };
+    }
+    async getProfileConnection(profile) {
+        const definition = (0, aiProviders_1.getProviderDefinition)(profile.provider);
+        const token = await this.context.secrets.get(profileSecretKey(profile.id)) ||
+            await this.context.secrets.get((0, aiProviders_1.providerSecretKey)(profile.provider));
+        const oauthConnected = definition.authMethod === "oauth" ? await (0, oauthHandler_1.hasValidOAuthSession)(this.context, profile.provider) : false;
+        const connected = definition.authMethod === "oauth"
+            ? Boolean(profile.baseUrl && profile.model && oauthConnected)
+            : Boolean(profile.baseUrl && profile.model && (!definition.requiresApiKey || token));
+        return {
+            profileId: profile.id,
+            endpoint: profile.baseUrl,
+            baseUrl: profile.baseUrl,
+            connected,
+            mode: profile.provider === "customGateway" ? "customGateway" : "direct",
+            provider: profile.provider,
+            providerLabel: definition.label,
+            model: profile.model,
+            requiresApiKey: definition.authMethod === "oauth" ? false : definition.requiresApiKey
+        };
+    }
+    async createLegacyProfileSnapshot() {
+        const provider = this.getActiveProvider();
+        const configuredEndpoint = this.context.globalState.get(endpointStateKey);
+        const legacyProvider = provider ?? (configuredEndpoint ? "customGateway" : undefined);
+        if (!legacyProvider) {
+            return undefined;
+        }
+        const definition = (0, aiProviders_1.getProviderDefinition)(legacyProvider);
+        const baseUrl = this.context.globalState.get(baseUrlStateKey) || configuredEndpoint || definition.defaultBaseUrl;
+        const model = this.context.globalState.get(modelStateKey) || definition.defaultModel || "configured-by-gateway";
+        if (!baseUrl || !model) {
+            return undefined;
+        }
+        return {
+            id: createProviderProfileId(legacyProvider, model, baseUrl),
+            provider: legacyProvider,
+            model,
+            baseUrl,
+            updatedAt: new Date().toISOString()
+        };
+    }
+    isDirectProviderActive() {
+        const provider = this.getActiveProvider();
+        return Boolean(provider && provider !== "customGateway");
+    }
+    async askDirectProvider(prompt, jsonMode = false, activeProvider) {
+        const provider = activeProvider ?? this.getActiveProvider();
+        if (!provider || provider === "customGateway") {
+            throw new Error("No direct AI provider is connected.");
+        }
+        const definition = (0, aiProviders_1.getProviderDefinition)(provider);
+        const connection = await this.getProviderConnection(provider);
+        if (!connection.connected || !connection.model || !connection.baseUrl) {
+            throw new Error(`${connection.providerLabel ?? "AI provider"} is not connected.`);
+        }
+        const apiKey = definition.authMethod === "oauth"
+            ? await this.getOAuthAccessToken(provider) ?? undefined
+            : await this.context.secrets.get((0, aiProviders_1.providerSecretKey)(provider));
+        const { text, responseHeaders } = await (0, aiProviders_1.invokeDirectProvider)({
+            provider,
+            model: connection.model,
+            baseUrl: connection.baseUrl,
+            apiKey,
+            prompt,
+            cwd: workspaceRootPath(),
+            jsonMode
+        });
+        return { text, responseHeaders };
+    }
+    async askDirectProviderStream(prompt, onToken, signal, activeProvider) {
+        const provider = activeProvider ?? this.getActiveProvider();
+        if (!provider || provider === "customGateway") {
+            throw new Error("No direct AI provider is connected.");
+        }
+        const definition = (0, aiProviders_1.getProviderDefinition)(provider);
+        const connection = await this.getProviderConnection(provider);
+        if (!connection.connected || !connection.model || !connection.baseUrl) {
+            throw new Error(`${connection.providerLabel ?? "AI provider"} is not connected.`);
+        }
+        const apiKey = definition.authMethod === "oauth"
+            ? await this.getOAuthAccessToken(provider) ?? undefined
+            : await this.context.secrets.get((0, aiProviders_1.providerSecretKey)(provider));
+        return (0, aiProviders_1.invokeDirectProviderStream)({
+            provider,
+            model: connection.model,
+            baseUrl: connection.baseUrl,
+            apiKey,
+            prompt,
+            cwd: workspaceRootPath(),
+            onToken,
+            signal
+        });
+    }
+    async testCustomGateway() {
+        const endpoint = this.context.globalState.get(endpointStateKey) || this.context.globalState.get(baseUrlStateKey);
+        const token = await this.context.secrets.get(tokenSecretKey);
+        const model = this.context.globalState.get(modelStateKey) || "configured-by-gateway";
+        if (endpoint && token && this.shouldUseCustomOpenAICompatible(model)) {
+            await (0, aiProviders_1.invokeCustomOpenAICompatibleProvider)({
+                provider: "customGateway",
+                model,
+                baseUrl: endpoint,
+                apiKey: token,
+                prompt: "Reply with exactly: OK"
+            });
+            return;
+        }
+        await this.testCustomGatewayInput(endpoint, token);
+    }
+    async testCustomGatewayInput(endpoint, token) {
+        if (!endpoint || !token) {
+            throw new Error("AI Gateway is not connected.");
+        }
+        const response = await fetch(endpoint, {
+            method: "POST",
+            headers: {
+                "content-type": "application/json",
+                authorization: `Bearer ${token}`
+            },
+            body: JSON.stringify({
+                product: "FlowSeeker",
+                mode: "guide",
+                instruction: "Reply with OK.",
+                task: "Connection test",
+                profile: {},
+                stats: {},
+                topFiles: [],
+                contextPack: "Connection test."
+            })
+        });
+        const text = await response.text();
+        if (!response.ok) {
+            throw new Error(`AI Gateway returned ${response.status}: ${text.slice(0, 500)}`);
+        }
+        if (looksLikeHtml(text)) {
+            throw new Error("AI Gateway returned an HTML page, not an agent response. Use the API base URL, usually ending in /v1, not the dashboard/home page URL. For AI Box/new-api, choose Custom OpenAI-Compatible and enter the model name.");
+        }
+    }
+    shouldUseCustomOpenAICompatible(model) {
+        const cleanModel = model?.trim();
+        return Boolean(cleanModel && cleanModel !== "configured-by-gateway");
+    }
+}
+exports.AiGatewayClient = AiGatewayClient;
+function profileSecretKey(profileId) {
+    return `flowseeker.aiProviderProfile.${profileId}.apiKey`;
+}
+function createProviderProfileId(provider, model, baseUrl) {
+    return `${provider}-${hashString(`${provider}|${model.trim()}|${baseUrl.trim()}`)}`;
+}
+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);
+}
+function isStoredProfile(value) {
+    return Boolean(value &&
+        typeof value.id === "string" &&
+        (0, aiProviders_1.isAiProviderId)(value.provider) &&
+        typeof value.model === "string" &&
+        typeof value.baseUrl === "string" &&
+        typeof value.updatedAt === "string");
+}
+function workspaceRootPath() {
+    return vscode.workspace.workspaceFolders?.[0]?.uri.fsPath;
+}
+function classifyProviderError(error, providerLabel) {
+    const message = error instanceof Error ? error.message : String(error);
+    const statusMatch = message.match(/\b(4\d\d|5\d\d)\b/);
+    const status = statusMatch ? parseInt(statusMatch[1], 10) : 0;
+    if (status === 401 || status === 403) {
+        return [
+            `${providerLabel} rejected the connection: invalid or expired credentials (HTTP ${status}).`,
+            "",
+            "**Fix:**",
+            "- Re-enter your API key in the provider configuration.",
+            "- If using OAuth, sign in again to refresh the token.",
+            "- Verify the key is active in your provider dashboard."
+        ].join("\n");
+    }
+    if (status === 429) {
+        if (/quota|billing/i.test(message)) {
+            return [
+                `${providerLabel} quota or billing is exhausted (HTTP 429).`,
+                "",
+                "**Fix:**",
+                "- Add billing or raise the spending limit in your provider account.",
+                "- Use a different API key or project.",
+                "- Try again after the quota reset period."
+            ].join("\n");
+        }
+        return [
+            `${providerLabel} rate-limited the request (HTTP 429).`,
+            "",
+            "**Fix:**",
+            "- Wait before sending another request.",
+            "- Use a different model or API key.",
+            "- Reduce request frequency."
+        ].join("\n");
+    }
+    if (status >= 500) {
+        return [
+            `${providerLabel} returned a server error (HTTP ${status}).`,
+            "",
+            "This is a provider-side issue. Check the provider status page or try again later.",
+            `Details: ${message}`
+        ].join("\n");
+    }
+    if (/ENOTFOUND|ECONNREFUSED|ECONNRESET|ETIMEDOUT|ENOENT/i.test(message)) {
+        return [
+            `Cannot reach ${providerLabel}.`,
+            "",
+            "**Fix:**",
+            "- Verify the base URL is correct.",
+            "- Check your network connection.",
+            "- If using a local provider (Ollama, local server), make sure it is running.",
+            `Details: ${message}`
+        ].join("\n");
+    }
+    if (/not found|not installed|command not found/i.test(message)) {
+        return [
+            `${providerLabel} CLI is not available.`,
+            "",
+            "**Fix:**",
+            "- Install the CLI tool.",
+            "- Set the correct path in the Command field.",
+            "- Verify the CLI is in your system PATH.",
+            `Details: ${message}`
+        ].join("\n");
+    }
+    return `${providerLabel} connection test failed: ${message}`;
+}
+function toGatewayPayload(result, mode, instructionOverride, extra = {}) {
+    const configuredLanguage = vscode.workspace.getConfiguration("flowseeker").get("ai.outputLanguage", "auto");
+    const languageInstruction = (0, responseLanguage_1.buildResponseLanguageInstruction)(configuredLanguage, result.task);
+    const taskInstruction = instructionOverride ??
+        (mode === "auto"
+            ? (0, agentPrompts_1.createPlanInstruction)()
+            : "Use the retrieved context to guide the developer. Explain likely edit files, reasoning, risks, and focused verification steps.");
+    const topFiles = (0, fileGroups_1.aggregateEvidenceFiles)(result.units).slice(0, 20).map((group) => ({
+        path: group.relativePath,
+        role: group.role,
+        score: group.score,
+        evidenceCount: group.unitCount,
+        kinds: group.kinds,
+        ranges: group.ranges.slice(0, 5),
+        reasons: group.reasons.slice(0, 5)
+    }));
+    return {
+        product: "FlowSeeker",
+        mode,
+        instruction: `${languageInstruction}\n${taskInstruction}`,
+        task: result.task,
+        profile: result.profile,
+        stats: result.stats,
+        topFiles,
+        contextPack: result.contextPack,
+        ...extra
+    };
+}
+function parseAgentResponse(text) {
+    const jsonText = extractJsonText(text);
+    try {
+        const json = JSON.parse(jsonText);
+        const message = firstString(json.message, json.answer, json.content) ?? JSON.stringify(json, null, 2);
+        const patch = firstString(json.patch, json.diff);
+        const edits = parseEdits(json.edits ?? json);
+        const commands = parseCommands(json.commands);
+        const mcpTools = parseMcpTools(json.mcpTools);
+        return { message, patch, edits, commands, mcpTools, raw: json };
+    }
+    catch {
+        return { message: text };
+    }
+}
+function extractJsonText(text) {
+    const trimmed = text.trim();
+    // 1. Try markdown code fence with optional json tag
+    const fenced = trimmed.match(/```(?:json)?\s*([\s\S]*?)```/i);
+    if (fenced?.[1]) {
+        return fenced[1].trim();
+    }
+    // 2. Try to find a top-level JSON object anywhere in the text
+    const objectMatch = extractTopLevelJson(trimmed);
+    if (objectMatch) {
+        return objectMatch;
+    }
+    // 3. If the text looks like it starts with JSON, return as-is
+    if (/^\s*\{/.test(trimmed)) {
+        return trimmed;
+    }
+    // 4. Fallback: return raw text (parseAgentResponse will treat it as a message)
+    return trimmed;
+}
+function extractTopLevelJson(text) {
+    // Find the first { and try to extract the matching JSON object
+    const start = text.indexOf("{");
+    if (start === -1)
+        return undefined;
+    let depth = 0;
+    let inString = false;
+    let escaped = false;
+    for (let i = start; i < text.length; i++) {
+        const char = text[i];
+        if (escaped) {
+            escaped = false;
+            continue;
+        }
+        if (char === "\\" && inString) {
+            escaped = true;
+            continue;
+        }
+        if (char === '"' && !escaped) {
+            inString = !inString;
+            continue;
+        }
+        if (inString)
+            continue;
+        if (char === "{") {
+            depth++;
+        }
+        else if (char === "}") {
+            depth--;
+            if (depth === 0) {
+                const candidate = text.slice(start, i + 1);
+                // Validate it's parseable JSON
+                try {
+                    JSON.parse(candidate);
+                    return candidate;
+                }
+                catch {
+                    // Continue searching for another {
+                    const nextStart = text.indexOf("{", start + 1);
+                    if (nextStart === -1)
+                        return undefined;
+                    // Reset and try from next position (simplified: just return undefined)
+                    return undefined;
+                }
+            }
+        }
+    }
+    return undefined;
+}
+function firstString(...values) {
+    return values.find((value) => typeof value === "string" && value.trim().length > 0);
+}
+function parseEdits(value) {
+    const items = Array.isArray(value)
+        ? value
+        : isObject(value) && (firstString(value.file, value.path) || Array.isArray(value.edits))
+            ? [value]
+            : undefined;
+    if (!items) {
+        return undefined;
+    }
+    const edits = items.flatMap((item) => {
+        if (!isObject(item)) {
+            return [];
+        }
+        const file = firstString(item.file, item.path);
+        const text = firstString(item.text, item.newText, item.replacement);
+        if (!file || text === undefined) {
+            return [];
+        }
+        const range = parseRange(item.range);
+        const replaceWholeFile = item.replaceWholeFile === true || item.wholeFile === true;
+        return [{ file, text, range, replaceWholeFile }];
+    });
+    return edits.length > 0 ? edits : undefined;
+}
+function parseRange(value) {
+    if (!isObject(value)) {
+        return undefined;
+    }
+    const startLine = numberValue(value.startLine);
+    const endLine = numberValue(value.endLine);
+    if (!startLine || !endLine) {
+        return undefined;
+    }
+    return {
+        startLine,
+        startColumn: numberValue(value.startColumn) ?? numberValue(value.startCol),
+        endLine,
+        endColumn: numberValue(value.endColumn) ?? numberValue(value.endCol)
+    };
+}
+function parseCommands(value) {
+    if (!Array.isArray(value)) {
+        return undefined;
+    }
+    const commands = value.flatMap((item) => {
+        if (!isObject(item)) {
+            return [];
+        }
+        const command = firstString(item.command, item.cmd, item.script);
+        if (!command) {
+            return [];
+        }
+        return [{
+                command,
+                cwd: firstString(item.cwd, item.workingDirectory),
+                rationale: firstString(item.rationale, item.reason, item.why)
+            }];
+    });
+    return commands.length > 0 ? commands : undefined;
+}
+function parseMcpTools(value) {
+    if (!Array.isArray(value)) {
+        return undefined;
+    }
+    const tools = value.flatMap((item) => {
+        if (!isObject(item)) {
+            return [];
+        }
+        const tool = firstString(item.tool, item.name);
+        if (!tool) {
+            return [];
+        }
+        return [{
+                tool,
+                input: isObject(item.input) ? item.input : undefined,
+                rationale: firstString(item.rationale, item.reason, item.why)
+            }];
+    });
+    return tools.length > 0 ? tools : undefined;
+}
+function numberValue(value) {
+    return typeof value === "number" && Number.isFinite(value) && value >= 1 ? value : undefined;
+}
+function isObject(value) {
+    return typeof value === "object" && value !== null;
+}
+function looksLikeHtml(text) {
+    const trimmed = text.trim();
+    return /^<!doctype html/i.test(trimmed) || /^<html[\s>]/i.test(trimmed);
+}
+function extractTokens(headers, key, fallbackLength) {
+    // Try to get actual token count from response body (stored in a special header pattern)
+    // OpenAI returns usage in response body, not headers. We estimate from response length as fallback.
+    // Anthropic also returns usage in response body.
+    // The headers only contain rate limit info, not token counts per request.
+    return Math.ceil(fallbackLength / 4);
+}
+function extractProviderQuota(provider, headers) {
+    const normalized = normalizeHeaders(headers);
+    const tokenLimitKeys = provider === "anthropic" || provider === "customAnthropic"
+        ? [
+            "anthropic-ratelimit-tokens-limit",
+            "anthropic-ratelimit-input-tokens-limit",
+            "anthropic-ratelimit-output-tokens-limit",
+            "x-ratelimit-limit-tokens",
+            "x-ratelimit-limit-tokens-1m"
+        ]
+        : [
+            "x-ratelimit-limit-tokens",
+            "x-ratelimit-token-limit",
+            "x-ratelimit-limit-tokens-1m",
+            "x-ratelimit-limit-requests-tokens"
+        ];
+    const tokenRemainingKeys = provider === "anthropic" || provider === "customAnthropic"
+        ? [
+            "anthropic-ratelimit-tokens-remaining",
+            "anthropic-ratelimit-input-tokens-remaining",
+            "anthropic-ratelimit-output-tokens-remaining",
+            "x-ratelimit-remaining-tokens",
+            "x-ratelimit-remaining-tokens-1m"
+        ]
+        : [
+            "x-ratelimit-remaining-tokens",
+            "x-ratelimit-token-remaining",
+            "x-ratelimit-remaining-tokens-1m"
+        ];
+    const requestLimitKeys = provider === "anthropic" || provider === "customAnthropic"
+        ? [
+            "anthropic-ratelimit-requests-limit",
+            "x-ratelimit-limit-requests",
+            "x-ratelimit-limit"
+        ]
+        : [
+            "x-ratelimit-limit-requests",
+            "x-ratelimit-request-limit",
+            "x-ratelimit-limit",
+            "x-ratelimit-limit-requests-1m"
+        ];
+    const requestRemainingKeys = provider === "anthropic" || provider === "customAnthropic"
+        ? [
+            "anthropic-ratelimit-requests-remaining",
+            "x-ratelimit-remaining-requests",
+            "x-ratelimit-remaining"
+        ]
+        : [
+            "x-ratelimit-remaining-requests",
+            "x-ratelimit-request-remaining",
+            "x-ratelimit-remaining",
+            "x-ratelimit-remaining-requests-1m"
+        ];
+    const tokensLimit = firstHeaderNumber(normalized, tokenLimitKeys);
+    const tokensRemaining = firstHeaderNumber(normalized, tokenRemainingKeys);
+    const requestsLimit = firstHeaderNumber(normalized, requestLimitKeys);
+    const requestsRemaining = firstHeaderNumber(normalized, requestRemainingKeys);
+    const resetSeconds = firstHeaderResetSeconds(normalized, [
+        "x-ratelimit-reset-requests",
+        "x-ratelimit-reset",
+        "x-ratelimit-reset-requests-1m",
+        "anthropic-ratelimit-requests-reset",
+        "anthropic-ratelimit-tokens-reset"
+    ]);
+    if (tokensLimit !== undefined ||
+        tokensRemaining !== undefined ||
+        requestsLimit !== undefined ||
+        requestsRemaining !== undefined) {
+        return { tokensLimit, tokensRemaining, requestsLimit, requestsRemaining, resetSeconds };
+    }
+    return undefined;
+}
+function normalizeHeaders(headers) {
+    return Object.fromEntries(Object.entries(headers).map(([key, value]) => [key.toLowerCase(), value]));
+}
+function firstHeaderNumber(headers, keys) {
+    for (const key of keys) {
+        const value = headerNumber(headers[key.toLowerCase()]);
+        if (value !== undefined) {
+            return value;
+        }
+    }
+    return undefined;
+}
+function headerNumber(value) {
+    if (!value) {
+        return undefined;
+    }
+    const first = value.split(",")[0].trim();
+    const match = first.match(/-?\d+(?:\.\d+)?/);
+    if (!match) {
+        return undefined;
+    }
+    const n = Number(match[0]);
+    return Number.isFinite(n) && n >= 0 ? Math.floor(n) : undefined;
+}
+function firstHeaderResetSeconds(headers, keys) {
+    for (const key of keys) {
+        const seconds = parseResetSeconds(headers[key.toLowerCase()]);
+        if (seconds !== undefined) {
+            return seconds;
+        }
+    }
+    return undefined;
+}
+function parseResetSeconds(value) {
+    if (!value) {
+        return undefined;
+    }
+    const clean = value.split(",")[0].trim();
+    if (!clean) {
+        return undefined;
+    }
+    if (/^\d+(?:\.\d+)?$/.test(clean)) {
+        const numeric = Number(clean);
+        if (numeric > 1000000000) {
+            return Math.max(0, Math.round(numeric - Date.now() / 1000));
+        }
+        return Math.max(0, Math.round(numeric));
+    }
+    const isoMs = Date.parse(clean);
+    if (!Number.isNaN(isoMs)) {
+        return Math.max(0, Math.round((isoMs - Date.now()) / 1000));
+    }
+    const duration = clean.match(/(?:(\d+)h)?(?:(\d+)m)?(?:(\d+)s)?/i);
+    if (duration && duration[0]) {
+        const hours = Number(duration[1] ?? 0);
+        const minutes = Number(duration[2] ?? 0);
+        const seconds = Number(duration[3] ?? 0);
+        return hours * 3600 + minutes * 60 + seconds;
+    }
+    return undefined;
+}
+//# sourceMappingURL=aiGateway.js.map