flowseeker 0.1.7

package/dist/gateway/aiProviders.js

@@ -0,0 +1,901 @@
+"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.AI_PROVIDER_DEFINITIONS = void 0;
+exports.getProviderDefinition = getProviderDefinition;
+exports.isAiProviderId = isAiProviderId;
+exports.providerSecretKey = providerSecretKey;
+exports.invokeDirectProviderStream = invokeDirectProviderStream;
+exports.invokeDirectProvider = invokeDirectProvider;
+exports.invokeCustomOpenAICompatibleProvider = invokeCustomOpenAICompatibleProvider;
+exports.invokeCustomOpenAICompatibleProviderStream = invokeCustomOpenAICompatibleProviderStream;
+const child_process_1 = require("child_process");
+const fs = __importStar(require("fs/promises"));
+const os = __importStar(require("os"));
+const path = __importStar(require("path"));
+exports.AI_PROVIDER_DEFINITIONS = [
+    {
+        id: "openai",
+        label: "OpenAI",
+        protocol: "openai-responses",
+        authMethod: "api_key",
+        defaultBaseUrl: "https://api.openai.com/v1",
+        defaultModel: "gpt-5.2",
+        requiresApiKey: true,
+        apiKeyLabel: "OpenAI API key",
+        apiKeyHint: "sk-proj-...",
+        supportsModelList: true
+    },
+    {
+        id: "anthropic",
+        label: "Anthropic",
+        protocol: "anthropic-messages",
+        authMethod: "api_key",
+        defaultBaseUrl: "https://api.anthropic.com/v1",
+        defaultModel: "claude-sonnet-4-5",
+        requiresApiKey: true,
+        apiKeyLabel: "Anthropic API key",
+        apiKeyHint: "sk-ant-...",
+        supportsModelList: true
+    },
+    {
+        id: "gemini",
+        label: "Google Gemini",
+        protocol: "gemini-generate-content",
+        authMethod: "api_key",
+        defaultBaseUrl: "https://generativelanguage.googleapis.com/v1beta",
+        defaultModel: "gemini-3.5-flash",
+        requiresApiKey: true,
+        apiKeyLabel: "Gemini API key",
+        apiKeyHint: "AIza...",
+        supportsModelList: true
+    },
+    {
+        id: "ollama",
+        label: "Ollama",
+        protocol: "ollama-chat",
+        authMethod: "api_key",
+        defaultBaseUrl: "http://localhost:11434",
+        defaultModel: "llama3.2",
+        requiresApiKey: false,
+        apiKeyLabel: "No API key required",
+        supportsModelList: true
+    },
+    {
+        id: "openrouter",
+        label: "OpenRouter",
+        protocol: "openai-compatible-chat",
+        authMethod: "api_key",
+        defaultBaseUrl: "https://openrouter.ai/api/v1",
+        defaultModel: "openai/gpt-5.2",
+        requiresApiKey: true,
+        apiKeyLabel: "OpenRouter API key",
+        apiKeyHint: "sk-or-v1-...",
+        supportsModelList: true
+    },
+    {
+        id: "mistral",
+        label: "Mistral",
+        protocol: "openai-compatible-chat",
+        authMethod: "api_key",
+        defaultBaseUrl: "https://api.mistral.ai/v1",
+        defaultModel: "mistral-large-latest",
+        requiresApiKey: true,
+        apiKeyLabel: "Mistral API key",
+        apiKeyHint: "Mistral key",
+        supportsModelList: true
+    },
+    {
+        id: "groq",
+        label: "Groq",
+        protocol: "openai-compatible-chat",
+        authMethod: "api_key",
+        defaultBaseUrl: "https://api.groq.com/openai/v1",
+        defaultModel: "llama-3.3-70b-versatile",
+        requiresApiKey: true,
+        apiKeyLabel: "Groq API key",
+        apiKeyHint: "gsk_...",
+        supportsModelList: true
+    },
+    {
+        id: "xai",
+        label: "xAI",
+        protocol: "openai-compatible-chat",
+        authMethod: "api_key",
+        defaultBaseUrl: "https://api.x.ai/v1",
+        defaultModel: "grok-4",
+        requiresApiKey: true,
+        apiKeyLabel: "xAI API key",
+        apiKeyHint: "xai-...",
+        supportsModelList: true
+    },
+    {
+        id: "deepseek",
+        label: "DeepSeek",
+        protocol: "openai-compatible-chat",
+        authMethod: "api_key",
+        defaultBaseUrl: "https://api.deepseek.com",
+        defaultModel: "deepseek-chat",
+        requiresApiKey: true,
+        apiKeyLabel: "DeepSeek API key",
+        apiKeyHint: "sk-...",
+        supportsModelList: true
+    },
+    {
+        id: "codexCli",
+        label: "Codex CLI",
+        protocol: "local-agent-cli",
+        authMethod: "local_cli",
+        defaultBaseUrl: "codex",
+        defaultModel: "default",
+        requiresApiKey: false,
+        apiKeyLabel: "No API key required",
+        supportsModelList: false
+    },
+    {
+        id: "claudeCode",
+        label: "Claude Code",
+        protocol: "local-agent-cli",
+        authMethod: "local_cli",
+        defaultBaseUrl: "claude",
+        defaultModel: "default",
+        requiresApiKey: false,
+        apiKeyLabel: "No API key required",
+        supportsModelList: false
+    },
+    {
+        id: "customGateway",
+        label: "Custom OpenAI-Compatible",
+        protocol: "custom-gateway",
+        authMethod: "api_key",
+        defaultBaseUrl: "",
+        defaultModel: "",
+        requiresApiKey: true,
+        apiKeyLabel: "API key / token",
+        supportsModelList: false
+    },
+    {
+        id: "customAnthropic",
+        label: "Custom Anthropic-Compatible",
+        protocol: "anthropic-messages",
+        authMethod: "api_key",
+        defaultBaseUrl: "",
+        defaultModel: "claude-sonnet-4-5",
+        requiresApiKey: true,
+        apiKeyLabel: "API key / token",
+        supportsModelList: false
+    },
+    {
+        id: "githubModels",
+        label: "GitHub Models",
+        protocol: "openai-compatible-chat",
+        authMethod: "oauth",
+        defaultBaseUrl: "https://models.inference.ai.azure.com",
+        defaultModel: "gpt-4o",
+        requiresApiKey: false,
+        apiKeyLabel: "GitHub token",
+        supportsModelList: true,
+        oauthConfig: {
+            authorizeUrl: "",
+            tokenUrl: "",
+            modelsUrl: "https://models.inference.ai.azure.com/models",
+            clientId: "",
+            scopes: ["read:user"]
+        }
+    }
+];
+function getProviderDefinition(provider) {
+    return exports.AI_PROVIDER_DEFINITIONS.find((definition) => definition.id === provider) ?? exports.AI_PROVIDER_DEFINITIONS[0];
+}
+function isAiProviderId(value) {
+    return typeof value === "string" && exports.AI_PROVIDER_DEFINITIONS.some((definition) => definition.id === value);
+}
+function providerSecretKey(provider) {
+    return provider === "customGateway" ? "flowseeker.aiGateway.token" : `flowseeker.aiProvider.${provider}.apiKey`;
+}
+async function invokeDirectProviderStream(request) {
+    const definition = getProviderDefinition(request.provider);
+    if (definition.protocol === "custom-gateway") {
+        throw new Error("Custom Gateway is handled by the gateway adapter.");
+    }
+    if (definition.requiresApiKey && !request.apiKey?.trim()) {
+        throw new Error(`${definition.label} API key is required.`);
+    }
+    if (!request.model.trim()) {
+        throw new Error(`${definition.label} model is required.`);
+    }
+    if (!request.baseUrl.trim()) {
+        throw new Error(`${definition.label} base URL is required.`);
+    }
+    switch (definition.protocol) {
+        case "openai-responses":
+            return invokeOpenAIResponsesStream(definition, request);
+        case "anthropic-messages":
+            return invokeAnthropicMessagesStream(definition, request);
+        case "ollama-chat":
+            return invokeOllamaChatStream(definition, request);
+        case "openai-compatible-chat":
+            return invokeOpenAICompatibleChatStream(definition, request);
+        case "local-agent-cli":
+            return invokeLocalAgentCliStream(definition, request);
+        case "gemini-generate-content": {
+            const response = await invokeGeminiGenerateContent(definition, request);
+            streamTextFallback(response.text, request.onToken);
+            return response;
+        }
+    }
+}
+async function invokeDirectProvider(request) {
+    const definition = getProviderDefinition(request.provider);
+    if (definition.protocol === "custom-gateway") {
+        throw new Error("Custom Gateway is handled by the gateway adapter.");
+    }
+    if (definition.requiresApiKey && !request.apiKey?.trim()) {
+        throw new Error(`${definition.label} API key is required.`);
+    }
+    if (!request.model.trim()) {
+        throw new Error(`${definition.label} model is required.`);
+    }
+    if (!request.baseUrl.trim()) {
+        throw new Error(`${definition.label} base URL is required.`);
+    }
+    switch (definition.protocol) {
+        case "openai-responses":
+            return invokeOpenAIResponses(definition, request);
+        case "anthropic-messages":
+            return invokeAnthropicMessages(definition, request);
+        case "gemini-generate-content":
+            return invokeGeminiGenerateContent(definition, request);
+        case "ollama-chat":
+            return invokeOllamaChat(definition, request);
+        case "openai-compatible-chat":
+            return invokeOpenAICompatibleChat(definition, request);
+        case "local-agent-cli":
+            return invokeLocalAgentCli(definition, request);
+    }
+}
+async function invokeCustomOpenAICompatibleProvider(request) {
+    if (!request.apiKey?.trim()) {
+        throw new Error("Custom OpenAI-compatible API key/token is required.");
+    }
+    if (!request.model.trim() || request.model === "configured-by-gateway") {
+        throw new Error("Custom OpenAI-compatible endpoint requires a model. Example: deepseek-v4-pro[1m].");
+    }
+    if (!request.baseUrl.trim()) {
+        throw new Error("Custom OpenAI-compatible base URL is required. It usually ends with /v1.");
+    }
+    const definition = {
+        id: "customGateway",
+        label: "Custom OpenAI-Compatible",
+        protocol: "openai-compatible-chat",
+        authMethod: "api_key",
+        defaultBaseUrl: "",
+        defaultModel: request.model,
+        requiresApiKey: true,
+        apiKeyLabel: "API key / token",
+        supportsModelList: false
+    };
+    const body = {
+        model: request.model,
+        stream: false,
+        messages: [{ role: "user", content: request.prompt }]
+    };
+    if (request.jsonMode) {
+        body.response_format = { type: "json_object" };
+    }
+    const { body: json, responseHeaders } = await postJson(definition, customChatCompletionsUrl(request.baseUrl), bearerHeaders(request.apiKey), body, request.apiKey);
+    return { text: textFromChatCompletion(json), responseHeaders };
+}
+async function invokeCustomOpenAICompatibleProviderStream(request) {
+    if (!request.apiKey?.trim()) {
+        throw new Error("Custom OpenAI-compatible API key/token is required.");
+    }
+    if (!request.model.trim() || request.model === "configured-by-gateway") {
+        throw new Error("Custom OpenAI-compatible endpoint requires a model. Example: deepseek-v4-pro[1m].");
+    }
+    if (!request.baseUrl.trim()) {
+        throw new Error("Custom OpenAI-compatible base URL is required. It usually ends with /v1.");
+    }
+    const definition = {
+        id: "customGateway",
+        label: "Custom OpenAI-Compatible",
+        protocol: "openai-compatible-chat",
+        authMethod: "api_key",
+        defaultBaseUrl: "",
+        defaultModel: request.model,
+        requiresApiKey: true,
+        apiKeyLabel: "API key / token",
+        supportsModelList: false
+    };
+    return streamOpenAIChatCompletion(definition, customChatCompletionsUrl(request.baseUrl), bearerHeaders(request.apiKey), {
+        model: request.model,
+        stream: true,
+        messages: [{ role: "user", content: request.prompt }]
+    }, request);
+}
+async function invokeOpenAIResponses(definition, request) {
+    const { body: json, responseHeaders } = await postJson(definition, joinUrl(request.baseUrl, "/responses"), bearerHeaders(request.apiKey), {
+        model: request.model,
+        input: request.prompt,
+        max_output_tokens: 4096
+    }, request.apiKey);
+    return { text: textFromOpenAIResponse(json), responseHeaders };
+}
+async function invokeAnthropicMessages(definition, request) {
+    const { body: json, responseHeaders } = await postJson(definition, joinUrl(request.baseUrl, "/messages"), {
+        "content-type": "application/json",
+        "x-api-key": request.apiKey ?? "",
+        "anthropic-version": "2023-06-01"
+    }, {
+        model: request.model,
+        max_tokens: 4096,
+        messages: [{ role: "user", content: request.prompt }]
+    }, request.apiKey);
+    return { text: textFromAnthropicMessage(json), responseHeaders };
+}
+async function invokeGeminiGenerateContent(definition, request) {
+    const cleanModel = request.model.replace(/^models\//, "");
+    const url = `${joinUrl(request.baseUrl, `/models/${encodeURIComponent(cleanModel)}:generateContent`)}?key=${encodeURIComponent(request.apiKey ?? "")}`;
+    const { body: json, responseHeaders } = await postJson(definition, url, { "content-type": "application/json" }, {
+        contents: [
+            {
+                role: "user",
+                parts: [{ text: request.prompt }]
+            }
+        ]
+    }, request.apiKey);
+    return { text: textFromGeminiResponse(json), responseHeaders };
+}
+async function invokeOllamaChat(definition, request) {
+    const { body: json, responseHeaders } = await postJson(definition, joinUrl(request.baseUrl, "/api/chat"), { "content-type": "application/json" }, {
+        model: request.model,
+        stream: false,
+        messages: [{ role: "user", content: request.prompt }]
+    }, request.apiKey);
+    return { text: textFromOllamaResponse(json), responseHeaders };
+}
+async function invokeOpenAICompatibleChat(definition, request) {
+    const body = {
+        model: request.model,
+        stream: false,
+        messages: [{ role: "user", content: request.prompt }]
+    };
+    if (request.jsonMode) {
+        body.response_format = { type: "json_object" };
+    }
+    const { body: json, responseHeaders } = await postJson(definition, joinUrl(request.baseUrl, "/chat/completions"), bearerHeaders(request.apiKey), body, request.apiKey);
+    return { text: textFromChatCompletion(json), responseHeaders };
+}
+async function invokeLocalAgentCli(definition, request) {
+    const command = request.baseUrl.trim();
+    if (!command) {
+        throw new Error(`${definition.label} command is required. Example: ${definition.id === "claudeCode" ? "claude" : "codex"}`);
+    }
+    const promptFile = await writePromptFile(request.prompt);
+    try {
+        const prompt = `Read the complete FlowSeeker solve packet from this file and answer using only the relevant context unless more repo inspection is necessary:\n${promptFile}`;
+        const args = localAgentArgs(definition, request.model, prompt);
+        const text = await runLocalCommand(definition, command, args, request.cwd);
+        return { text, responseHeaders: {} };
+    }
+    finally {
+        void fs.rm(path.dirname(promptFile), { recursive: true, force: true }).catch(() => undefined);
+    }
+}
+function localAgentArgs(definition, model, prompt) {
+    const cleanModel = model.trim();
+    const hasModel = Boolean(cleanModel && cleanModel !== "default");
+    if (definition.id === "claudeCode") {
+        const args = ["-p"];
+        if (hasModel) {
+            args.push("--model", cleanModel);
+        }
+        args.push(prompt);
+        return args;
+    }
+    const args = ["exec"];
+    if (hasModel) {
+        args.push("--model", cleanModel);
+    }
+    args.push(prompt);
+    return args;
+}
+async function writePromptFile(prompt) {
+    const dir = await fs.mkdtemp(path.join(os.tmpdir(), "flowseeker-agent-"));
+    const file = path.join(dir, "solve-packet.md");
+    await fs.writeFile(file, prompt, "utf8");
+    return file;
+}
+function runLocalCommand(definition, command, args, cwd) {
+    return new Promise((resolve, reject) => {
+        const child = (0, child_process_1.spawn)(command, args, {
+            cwd,
+            shell: false,
+            windowsHide: true,
+            env: process.env
+        });
+        let stdout = "";
+        let stderr = "";
+        const timeout = setTimeout(() => {
+            child.kill();
+            reject(new Error(`${definition.label} timed out after 10 minutes.`));
+        }, 600000);
+        child.stdout.on("data", (chunk) => {
+            stdout += chunk.toString("utf8");
+            if (stdout.length > 2000000) {
+                stdout = stdout.slice(-2000000);
+            }
+        });
+        child.stderr.on("data", (chunk) => {
+            stderr += chunk.toString("utf8");
+            if (stderr.length > 500000) {
+                stderr = stderr.slice(-500000);
+            }
+        });
+        child.on("error", (error) => {
+            clearTimeout(timeout);
+            reject(new Error(`${definition.label} command failed to start: ${error.message}. Set the CLI command/path in the Command field and make sure you are logged in.`));
+        });
+        child.on("close", (code) => {
+            clearTimeout(timeout);
+            const cleanStdout = stdout.trim();
+            const cleanStderr = stderr.trim();
+            if (code !== 0) {
+                reject(new Error(`${definition.label} exited with code ${code ?? "unknown"}: ${errorBodySummary(cleanStderr || cleanStdout)}`));
+                return;
+            }
+            resolve(cleanStdout || cleanStderr || `${definition.label} returned an empty response.`);
+        });
+    });
+}
+async function invokeOpenAIResponsesStream(definition, request) {
+    return streamSseText(definition, joinUrl(request.baseUrl, "/responses"), bearerHeaders(request.apiKey), {
+        model: request.model,
+        input: request.prompt,
+        max_output_tokens: 4096,
+        stream: true
+    }, request, (json) => {
+        if (!isObject(json))
+            return "";
+        if (json.type === "response.output_text.delta") {
+            return firstString(json.delta) ?? "";
+        }
+        if (json.type === "response.completed" && isObject(json.response)) {
+            return "";
+        }
+        return "";
+    });
+}
+async function invokeAnthropicMessagesStream(definition, request) {
+    return streamSseText(definition, joinUrl(request.baseUrl, "/messages"), {
+        "content-type": "application/json",
+        "x-api-key": request.apiKey ?? "",
+        "anthropic-version": "2023-06-01"
+    }, {
+        model: request.model,
+        max_tokens: 4096,
+        stream: true,
+        messages: [{ role: "user", content: request.prompt }]
+    }, request, (json) => {
+        if (!isObject(json))
+            return "";
+        if (json.type === "content_block_delta" && isObject(json.delta)) {
+            return firstString(json.delta.text) ?? "";
+        }
+        return "";
+    });
+}
+async function invokeOpenAICompatibleChatStream(definition, request) {
+    const body = {
+        model: request.model,
+        stream: true,
+        messages: [{ role: "user", content: request.prompt }]
+    };
+    if (request.jsonMode) {
+        body.response_format = { type: "json_object" };
+    }
+    return streamOpenAIChatCompletion(definition, joinUrl(request.baseUrl, "/chat/completions"), bearerHeaders(request.apiKey), body, request);
+}
+async function invokeOllamaChatStream(definition, request) {
+    const response = await fetch(joinUrl(request.baseUrl, "/api/chat"), {
+        method: "POST",
+        headers: { "content-type": "application/json" },
+        body: JSON.stringify({
+            model: request.model,
+            stream: true,
+            messages: [{ role: "user", content: request.prompt }]
+        }),
+        signal: request.signal
+    });
+    const responseHeaders = collectHeaders(response);
+    if (!response.ok) {
+        throw new Error(`${definition.label} returned ${response.status}: ${sanitizeProviderError(errorBodySummary(await response.text()), request.apiKey)}`);
+    }
+    let fullText = "";
+    await readResponseLines(response, (line) => {
+        if (!line.trim())
+            return;
+        try {
+            const json = JSON.parse(line);
+            const chunk = isObject(json) && isObject(json.message) ? firstString(json.message.content) : undefined;
+            if (chunk) {
+                fullText += chunk;
+                request.onToken(chunk);
+            }
+        }
+        catch {
+            // Ignore malformed partial lines.
+        }
+    });
+    return { text: fullText.trim() || "(empty response)", responseHeaders };
+}
+async function invokeLocalAgentCliStream(definition, request) {
+    const command = request.baseUrl.trim();
+    if (!command) {
+        throw new Error(`${definition.label} command is required. Example: ${definition.id === "claudeCode" ? "claude" : "codex"}`);
+    }
+    const promptFile = await writePromptFile(request.prompt);
+    try {
+        const prompt = `Read the complete FlowSeeker solve packet from this file and answer using only the relevant context unless more repo inspection is necessary:\n${promptFile}`;
+        const args = localAgentArgs(definition, request.model, prompt);
+        const text = await runLocalCommandStream(definition, command, args, request.cwd, request.onToken, request.signal);
+        return { text, responseHeaders: {} };
+    }
+    finally {
+        void fs.rm(path.dirname(promptFile), { recursive: true, force: true }).catch(() => undefined);
+    }
+}
+async function streamOpenAIChatCompletion(definition, url, headers, body, request) {
+    return streamSseText(definition, url, headers, body, request, (json) => {
+        if (!isObject(json))
+            return "";
+        const choices = Array.isArray(json.choices) ? json.choices : [];
+        for (const choice of choices) {
+            if (isObject(choice) && isObject(choice.delta)) {
+                const chunk = firstString(choice.delta.content);
+                if (chunk)
+                    return chunk;
+            }
+        }
+        return "";
+    });
+}
+async function streamSseText(definition, url, headers, body, request, extract) {
+    const response = await fetch(url, {
+        method: "POST",
+        headers,
+        body: JSON.stringify(body),
+        signal: request.signal
+    });
+    const responseHeaders = collectHeaders(response);
+    if (!response.ok) {
+        throw new Error(`${definition.label} returned ${response.status}: ${sanitizeProviderError(errorBodySummary(await response.text()), request.apiKey)}`);
+    }
+    let fullText = "";
+    await readResponseLines(response, (line) => {
+        const trimmed = line.trim();
+        if (!trimmed.startsWith("data:"))
+            return;
+        const data = trimmed.slice(5).trim();
+        if (!data || data === "[DONE]")
+            return;
+        try {
+            const json = JSON.parse(data);
+            const chunk = extract(json);
+            if (chunk) {
+                fullText += chunk;
+                request.onToken(chunk);
+            }
+        }
+        catch {
+            // Ignore malformed stream events.
+        }
+    });
+    return { text: fullText.trim() || "(empty response)", responseHeaders };
+}
+async function readResponseLines(response, onLine) {
+    const reader = response.body?.getReader();
+    if (!reader)
+        return;
+    const decoder = new TextDecoder();
+    let buffer = "";
+    while (true) {
+        const { value, done } = await reader.read();
+        if (done)
+            break;
+        buffer += decoder.decode(value, { stream: true });
+        let index = buffer.indexOf("\n");
+        while (index >= 0) {
+            const line = buffer.slice(0, index);
+            buffer = buffer.slice(index + 1);
+            onLine(line);
+            index = buffer.indexOf("\n");
+        }
+    }
+    buffer += decoder.decode();
+    if (buffer.trim())
+        onLine(buffer);
+}
+function streamTextFallback(text, onToken) {
+    const chunks = text.match(/\S+\s*/g) ?? [];
+    for (const chunk of chunks) {
+        onToken(chunk);
+    }
+}
+function collectHeaders(response) {
+    const responseHeaders = {};
+    response.headers.forEach((value, key) => { responseHeaders[key.toLowerCase()] = value; });
+    return responseHeaders;
+}
+function runLocalCommandStream(definition, command, args, cwd, onToken, signal) {
+    return new Promise((resolve, reject) => {
+        const child = (0, child_process_1.spawn)(command, args, {
+            cwd,
+            shell: false,
+            windowsHide: true,
+            env: process.env
+        });
+        let stdout = "";
+        let stderr = "";
+        const timeout = setTimeout(() => {
+            child.kill();
+            reject(new Error(`${definition.label} timed out after 10 minutes.`));
+        }, 600000);
+        const abort = () => {
+            child.kill();
+            reject(new Error("cancelled"));
+        };
+        signal?.addEventListener("abort", abort, { once: true });
+        child.stdout.on("data", (chunk) => {
+            const text = chunk.toString("utf8");
+            stdout += text;
+            onToken(text);
+            if (stdout.length > 2000000)
+                stdout = stdout.slice(-2000000);
+        });
+        child.stderr.on("data", (chunk) => {
+            stderr += chunk.toString("utf8");
+            if (stderr.length > 500000)
+                stderr = stderr.slice(-500000);
+        });
+        child.on("error", (error) => {
+            clearTimeout(timeout);
+            signal?.removeEventListener("abort", abort);
+            reject(new Error(`${definition.label} command failed to start: ${error.message}. Set the CLI command/path in the Command field and make sure you are logged in.`));
+        });
+        child.on("close", (code) => {
+            clearTimeout(timeout);
+            signal?.removeEventListener("abort", abort);
+            const cleanStdout = stdout.trim();
+            const cleanStderr = stderr.trim();
+            if (signal?.aborted) {
+                reject(new Error("cancelled"));
+                return;
+            }
+            if (code !== 0) {
+                reject(new Error(`${definition.label} exited with code ${code ?? "unknown"}: ${errorBodySummary(cleanStderr || cleanStdout)}`));
+                return;
+            }
+            resolve(cleanStdout || cleanStderr || `${definition.label} returned an empty response.`);
+        });
+    });
+}
+async function postJson(definition, url, headers, body, apiKey) {
+    let response;
+    try {
+        response = await fetch(url, {
+            method: "POST",
+            headers,
+            body: JSON.stringify(body)
+        });
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        throw new Error(`${definition.label} request failed: ${sanitizeProviderError(message, apiKey)}`);
+    }
+    const responseHeaders = {};
+    response.headers.forEach((value, key) => { responseHeaders[key.toLowerCase()] = value; });
+    const text = await response.text();
+    if (!response.ok) {
+        throw new Error(`${definition.label} returned ${response.status}: ${sanitizeProviderError(errorBodySummary(text), apiKey)}`);
+    }
+    try {
+        return { body: JSON.parse(text), responseHeaders };
+    }
+    catch {
+        throw new Error(`${definition.label} returned a non-JSON response. ${nonJsonResponseHint(text)}`);
+    }
+}
+function bearerHeaders(apiKey) {
+    return {
+        "content-type": "application/json",
+        authorization: `Bearer ${apiKey ?? ""}`
+    };
+}
+function joinUrl(baseUrl, path) {
+    const cleanBase = baseUrl.trim().replace(/\/+$/, "");
+    const cleanPath = path.replace(/^\/+/, "");
+    return `${cleanBase}/${cleanPath}`;
+}
+function customChatCompletionsUrl(baseUrl) {
+    const cleanBase = baseUrl.trim().replace(/\/+$/, "");
+    if (/\/chat\/completions$/i.test(cleanBase)) {
+        return cleanBase;
+    }
+    if (/\/(?:v\d+|api\/v\d+|openai\/v\d+)$/i.test(cleanBase)) {
+        return joinUrl(cleanBase, "/chat/completions");
+    }
+    return joinUrl(cleanBase, "/v1/chat/completions");
+}
+function nonJsonResponseHint(text) {
+    const trimmed = text.trim();
+    if (/^<!doctype html/i.test(trimmed) || /^<html[\s>]/i.test(trimmed)) {
+        return "The endpoint returned an HTML page, not an API response. Use the API base URL, usually ending in /v1, not the dashboard/home page URL.";
+    }
+    return `First response bytes: ${trimmed.slice(0, 160) || "empty response body"}`;
+}
+function textFromOpenAIResponse(value) {
+    if (!isObject(value)) {
+        return "";
+    }
+    const outputText = firstString(value.output_text, value.text);
+    if (outputText) {
+        return outputText;
+    }
+    const output = Array.isArray(value.output) ? value.output : [];
+    const parts = [];
+    for (const item of output) {
+        if (!isObject(item)) {
+            continue;
+        }
+        const content = Array.isArray(item.content) ? item.content : [];
+        for (const part of content) {
+            if (isObject(part)) {
+                const text = firstString(part.text, part.output_text, part.content);
+                if (text) {
+                    parts.push(text);
+                }
+            }
+        }
+    }
+    return parts.join("\n").trim() || JSON.stringify(value, null, 2);
+}
+function textFromAnthropicMessage(value) {
+    if (!isObject(value)) {
+        return "";
+    }
+    const content = Array.isArray(value.content) ? value.content : [];
+    const parts = content
+        .map((part) => (isObject(part) ? firstString(part.text, part.content) : undefined))
+        .filter((part) => Boolean(part));
+    return parts.join("\n").trim() || JSON.stringify(value, null, 2);
+}
+function textFromGeminiResponse(value) {
+    if (!isObject(value)) {
+        return "";
+    }
+    const candidates = Array.isArray(value.candidates) ? value.candidates : [];
+    const parts = [];
+    for (const candidate of candidates) {
+        if (!isObject(candidate) || !isObject(candidate.content)) {
+            continue;
+        }
+        const candidateParts = Array.isArray(candidate.content.parts) ? candidate.content.parts : [];
+        for (const part of candidateParts) {
+            if (isObject(part)) {
+                const text = firstString(part.text);
+                if (text) {
+                    parts.push(text);
+                }
+            }
+        }
+    }
+    return parts.join("\n").trim() || JSON.stringify(value, null, 2);
+}
+function textFromOllamaResponse(value) {
+    if (!isObject(value)) {
+        return "";
+    }
+    if (isObject(value.message)) {
+        const content = firstString(value.message.content);
+        if (content) {
+            return content;
+        }
+    }
+    return firstString(value.response, value.text) ?? JSON.stringify(value, null, 2);
+}
+function textFromChatCompletion(value) {
+    if (!isObject(value)) {
+        return "";
+    }
+    const choices = Array.isArray(value.choices) ? value.choices : [];
+    for (const choice of choices) {
+        if (!isObject(choice) || !isObject(choice.message)) {
+            continue;
+        }
+        const content = choice.message.content;
+        if (typeof content === "string" && content.trim()) {
+            return content;
+        }
+        if (Array.isArray(content)) {
+            const parts = content
+                .map((part) => (isObject(part) ? firstString(part.text, part.content) : undefined))
+                .filter((part) => Boolean(part));
+            if (parts.length > 0) {
+                return parts.join("\n").trim();
+            }
+        }
+    }
+    return JSON.stringify(value, null, 2);
+}
+function errorBodySummary(text) {
+    const trimmed = text.trim();
+    if (!trimmed) {
+        return "empty response body";
+    }
+    try {
+        const json = JSON.parse(trimmed);
+        if (isObject(json)) {
+            const direct = firstString(json.message, json.error, json.detail);
+            if (direct) {
+                return direct;
+            }
+            if (isObject(json.error)) {
+                const nested = firstString(json.error.message, json.error.type, json.error.code);
+                if (nested) {
+                    return nested;
+                }
+            }
+        }
+    }
+    catch {
+        // Fall back to raw text below.
+    }
+    return trimmed.slice(0, 500);
+}
+function sanitizeProviderError(value, apiKey) {
+    if (!apiKey) {
+        return value;
+    }
+    const escaped = apiKey.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+    return value.replace(new RegExp(escaped, "g"), "[redacted]");
+}
+function firstString(...values) {
+    return values.find((value) => typeof value === "string" && value.trim().length > 0);
+}
+function isObject(value) {
+    return typeof value === "object" && value !== null;
+}
+//# sourceMappingURL=aiProviders.js.map