@theowlops/boombot 0.0.0-stage → 1.1.0

package/dist/gateway/services/llm-client.js

@@ -0,0 +1,593 @@
+import { buildAuthHeaders, deepMergeRecords, defaultBaseUrlFor, getProviderProfile, KeyRoulette, kindDefaultProfile, PROVIDER_KINDS, resolveRequestProfile, } from '@boombot/protocol';
+import { normalizeHistoryForProvider } from './history-normalizer.js';
+import { KeyRotatingLlmClient } from './key-roulette-client.js';
+import { createLocalFallbackClient, getLocalFallbackConfig } from './local-fallback.js';
+import { toAnthropicVisionContent, toOpenAiVisionContent } from './vision-payload.js';
+import { decodeAnthropicChunk, decodeOpenAiChunk, isRecord, LlmResolutionError, newAnthropicDecodeState, } from './llm-decoder.js';
+/**
+ * Re-exported from `./llm-decoder.js`, where the class is defined so the
+ * decoders can throw it without an import cycle. Existing import sites
+ * (`import { LlmResolutionError } from '.../llm-client.js'`) keep working.
+ */
+export { LlmResolutionError } from './llm-decoder.js';
+const SETUP_HINT = 'Run `boombot setup` to configure a provider.';
+/**
+ * Apply a resolved request profile to request headers and body.
+ *
+ * - `headers`: merged over the profile's headers, auth headers stay
+ *   authoritative (a profile can add headers, never swap the credential).
+ * - Scalar params (`maxTokens`, `temperature`, `topP`) are mapped to the
+ *   kind's wire names by the caller; `extraBody` is deep-merged last so it
+ *   works as an escape hatch for provider-specific knobs.
+ */
+function applyProfileHeaders(authHeaders, profile) {
+    return { ...profile.headers, ...authHeaders };
+}
+function applyProfileBody(body, profile) {
+    return profile.extraBody === undefined ? body : deepMergeRecords(body, profile.extraBody);
+}
+function parseJsonObject(data, label) {
+    let parsed;
+    try {
+        parsed = JSON.parse(data);
+    }
+    catch {
+        throw new LlmResolutionError('PROTOCOL_ERROR', `${label} stream sent a malformed event payload.`);
+    }
+    if (!isRecord(parsed)) {
+        throw new LlmResolutionError('PROTOCOL_ERROR', `${label} stream sent a non-object event payload.`);
+    }
+    return parsed;
+}
+/**
+ * Minimal SSE reader over a fetch response body. Yields one entry per
+ * `data:` line; `event:` lines set the event name for the following data
+ * lines. Comment/heartbeat lines (`: ...`) and `id:`/`retry:` fields are
+ * ignored. A blank line resets the event name (dispatch boundary).
+ */
+async function* readSseEvents(body) {
+    const reader = body.getReader();
+    const decoder = new TextDecoder();
+    let buf = '';
+    let eventName;
+    const handleLine = function* (rawLine) {
+        const line = rawLine.replace(/\r$/, '');
+        if (line === '') {
+            eventName = undefined;
+            return;
+        }
+        if (line.startsWith(':'))
+            return;
+        if (line.startsWith('event:')) {
+            eventName = line.slice('event:'.length).trim();
+            return;
+        }
+        if (line.startsWith('data:')) {
+            // Per the SSE spec, a single leading space after the colon is stripped.
+            yield { event: eventName, data: line.slice('data:'.length).replace(/^ /, '') };
+        }
+        // 'id:' and 'retry:' carry nothing we need.
+    };
+    try {
+        for (;;) {
+            const { done, value } = await reader.read();
+            if (done)
+                break;
+            buf += decoder.decode(value, { stream: true });
+            let nl = buf.indexOf('\n');
+            while (nl !== -1) {
+                const line = buf.slice(0, nl);
+                buf = buf.slice(nl + 1);
+                yield* handleLine(line);
+                nl = buf.indexOf('\n');
+            }
+        }
+        buf += decoder.decode();
+        if (buf.length > 0) {
+            for (const line of buf.split('\n')) {
+                yield* handleLine(line);
+            }
+        }
+    }
+    catch (error) {
+        if (error instanceof Error && error.name === 'AbortError')
+            throw error;
+        if (error instanceof LlmResolutionError)
+            throw error;
+        throw new LlmResolutionError('NETWORK_ERROR', `Provider stream failed: ${error instanceof Error ? error.message : String(error)}`);
+    }
+    finally {
+        reader.releaseLock();
+    }
+}
+/** `fetch` wrapper that converts transport failures into coded errors. */
+async function postJson(url, headers, body, label, signal, accept = 'text/event-stream') {
+    let res;
+    try {
+        res = await fetch(url, {
+            method: 'POST',
+            headers: { ...headers, 'Content-Type': 'application/json', Accept: accept },
+            body: JSON.stringify(body),
+            signal,
+        });
+    }
+    catch (err) {
+        // Cancellation must propagate untouched — the turn loop relies on it.
+        if (err instanceof Error && err.name === 'AbortError')
+            throw err;
+        throw new LlmResolutionError('NETWORK_ERROR', `${label} request failed: ${err instanceof Error ? err.message : String(err)}`);
+    }
+    if (!res.ok) {
+        throw await httpError(res, label);
+    }
+    if (res.body === null) {
+        throw new LlmResolutionError('PROTOCOL_ERROR', `${label} returned an empty response body.`);
+    }
+    return res;
+}
+/**
+ * Build a coded error from a non-2xx response. The provider's error message
+ * is included (truncated); the raw body never is — some proxies reflect
+ * request data, which could contain secret material.
+ */
+async function httpError(res, label) {
+    let detail = '';
+    try {
+        const text = await res.text();
+        const parsed = JSON.parse(text);
+        if (isRecord(parsed)) {
+            const nested = isRecord(parsed['error']) ? parsed['error']['message'] : undefined;
+            const direct = parsed['message'];
+            const msg = typeof nested === 'string' ? nested : typeof direct === 'string' ? direct : '';
+            if (msg !== '')
+                detail = ` — ${msg.slice(0, 300)}`;
+        }
+    }
+    catch {
+        // Non-JSON error body: status code alone is enough.
+    }
+    return new LlmResolutionError('HTTP_ERROR', `${label} request failed with HTTP ${res.status}${detail}.`, res.status);
+}
+// ---------------------------------------------------------------------------
+// OpenAI-compatible chat completions
+// ---------------------------------------------------------------------------
+/**
+ * Anthropic / Vertex AI require tool names to match /^[a-zA-Z0-9_-]{1,128}$/.
+ * BoomBot uses dot-namespaced names like `shell.exec`, `file.read`.
+ * We encode `.` → `__dot__` on the wire and decode back after parsing.
+ */
+function sanitizeToolName(name) {
+    return name.replace(/\./g, '__dot__');
+}
+export function desanitizeToolName(name) {
+    return name.replace(/__dot__/g, '.');
+}
+function toOpenAiMessages(messages) {
+    return messages.map((m, idx) => {
+        if (m.role === 'tool') {
+            return { role: 'tool', tool_call_id: m.toolCallId ?? '', content: m.content };
+        }
+        if (m.role === 'assistant' && m.toolCalls !== undefined && m.toolCalls.length > 0) {
+            return {
+                role: 'assistant',
+                content: m.content,
+                tool_calls: m.toolCalls.map((tc) => ({
+                    id: tc.id,
+                    type: 'function',
+                    function: { name: tc.name, arguments: JSON.stringify(tc.arguments) },
+                })),
+            };
+        }
+        // Mid-conversation system messages: map to user role so proxies (Anthropic/Gemini/9Router) accept them
+        if (m.role === 'system' && idx > 0) {
+            return {
+                role: 'user',
+                content: `[System Instruction: ${m.content}]`,
+            };
+        }
+        return {
+            role: m.role,
+            content: m.images?.length ? toOpenAiVisionContent(m.content, m.images) : m.content,
+        };
+    });
+}
+function toOpenAiTools(tools) {
+    return tools.map((t) => ({
+        type: 'function',
+        function: { name: t.name, description: t.description, parameters: t.parameters },
+    }));
+}
+class OpenAiEmbeddingClient {
+    baseUrl;
+    model;
+    authHeaders;
+    constructor(baseUrl, model, authHeaders) {
+        this.baseUrl = baseUrl;
+        this.model = model;
+        this.authHeaders = authHeaders;
+    }
+    async embed(inputs) {
+        if (inputs.length === 0)
+            return [];
+        const res = await postJson(`${this.baseUrl}/embeddings`, this.authHeaders, { model: this.model, input: inputs }, 'OpenAI-compatible embeddings', AbortSignal.timeout(5_000), 'application/json');
+        const payload = await res.json();
+        if (!isRecord(payload) || !Array.isArray(payload['data'])) {
+            throw new LlmResolutionError('PROTOCOL_ERROR', 'Embedding provider returned an invalid payload.');
+        }
+        const items = payload['data']
+            .map((item) => {
+            if (!isRecord(item) || !Array.isArray(item['embedding']) || typeof item['index'] !== 'number')
+                return undefined;
+            const embedding = item['embedding'];
+            if (embedding.length === 0 || !embedding.every((value) => typeof value === 'number' && Number.isFinite(value)))
+                return undefined;
+            return { index: item['index'], embedding: embedding };
+        })
+            .filter((item) => item !== undefined)
+            .sort((a, b) => a.index - b.index);
+        if (items.length !== inputs.length
+            || items.some((item, index) => item.index !== index || item.embedding.length !== items[0]?.embedding.length)) {
+            throw new LlmResolutionError('PROTOCOL_ERROR', 'Embedding provider returned invalid vectors.');
+        }
+        return items.map((item) => item.embedding);
+    }
+}
+/** Streaming chat client for OpenAI-compatible `POST /chat/completions`. */
+class OpenAiCompatChatClient {
+    baseUrl;
+    model;
+    authHeaders;
+    requestUsage;
+    profile;
+    constructor(baseUrl, model, authHeaders, requestUsage, profile) {
+        this.baseUrl = baseUrl;
+        this.model = model;
+        this.authHeaders = authHeaders;
+        this.requestUsage = requestUsage;
+        this.profile = profile;
+    }
+    async *complete(messages, tools, signal) {
+        const profile = this.profile;
+        const requestBody = applyProfileBody({
+            model: this.model,
+            messages: toOpenAiMessages(normalizeHistoryForProvider(messages, 'openai')),
+            stream: true,
+            ...(profile.maxTokens !== undefined ? { max_tokens: profile.maxTokens } : {}),
+            ...(profile.temperature !== undefined ? { temperature: profile.temperature } : {}),
+            ...(profile.topP !== undefined ? { top_p: profile.topP } : {}),
+            ...(profile.reasoning?.effort !== undefined ? { reasoning_effort: profile.reasoning.effort } : {}),
+            ...(this.requestUsage ? { stream_options: { include_usage: true } } : {}),
+            ...(tools.length > 0 ? { tools: toOpenAiTools(tools), tool_choice: 'auto' } : {}),
+        }, profile);
+        const res = await postJson(`${this.baseUrl}/chat/completions`, applyProfileHeaders(this.authHeaders, profile), requestBody, 'OpenAI-compatible', signal);
+        const body = res.body;
+        if (body === null) {
+            throw new LlmResolutionError('PROTOCOL_ERROR', 'OpenAI-compatible returned an empty response body.');
+        }
+        for await (const ev of readSseEvents(body)) {
+            if (ev.data === '[DONE]')
+                break;
+            if (ev.data === '')
+                continue; // keepalive: no payload to parse
+            const payload = parseJsonObject(ev.data, 'OpenAI-compatible');
+            yield* decodeOpenAiChunk(payload);
+        }
+        yield { done: true };
+    }
+}
+// ---------------------------------------------------------------------------
+// Anthropic Messages API
+// ---------------------------------------------------------------------------
+function toAnthropicPayload(messages) {
+    const systems = [];
+    const out = [];
+    // Consecutive tool results merge into ONE user message with several
+    // `tool_result` blocks (Anthropic shape); a 1:1 mapping would emit a run
+    // of single-block user messages instead.
+    let pendingToolResults = [];
+    const flushToolResults = () => {
+        if (pendingToolResults.length > 0) {
+            out.push({ role: 'user', content: pendingToolResults });
+            pendingToolResults = [];
+        }
+    };
+    for (const m of messages) {
+        if (m.role === 'system') {
+            systems.push(m.content);
+            continue;
+        }
+        if (m.role === 'tool') {
+            pendingToolResults.push({
+                type: 'tool_result',
+                tool_use_id: m.toolCallId ?? '',
+                content: m.content,
+            });
+            continue;
+        }
+        flushToolResults();
+        if (m.role === 'assistant' && m.toolCalls !== undefined && m.toolCalls.length > 0) {
+            const content = [];
+            if (m.content !== '')
+                content.push({ type: 'text', text: m.content });
+            for (const tc of m.toolCalls) {
+                content.push({ type: 'tool_use', id: tc.id, name: sanitizeToolName(tc.name), input: tc.arguments });
+            }
+            out.push({ role: 'assistant', content });
+            continue;
+        }
+        out.push({
+            role: m.role,
+            content: m.images?.length ? toAnthropicVisionContent(m.content, m.images) : m.content,
+        });
+    }
+    flushToolResults();
+    return { ...(systems.length > 0 ? { system: systems.join('\n\n') } : {}), messages: out };
+}
+function toAnthropicTools(tools) {
+    return tools.map((t) => ({ name: sanitizeToolName(t.name), description: t.description, input_schema: t.parameters }));
+}
+/** Streaming chat client for Anthropic `POST /messages` (SSE). */
+class AnthropicChatClient {
+    baseUrl;
+    model;
+    authHeaders;
+    profile;
+    constructor(baseUrl, model, authHeaders, profile) {
+        this.baseUrl = baseUrl;
+        this.model = model;
+        this.authHeaders = authHeaders;
+        this.profile = profile;
+    }
+    async *complete(messages, tools, signal) {
+        const { system, messages: anthropicMessages } = toAnthropicPayload(normalizeHistoryForProvider(messages, 'anthropic'));
+        const profile = this.profile;
+        // Anthropic requires `max_tokens`; the default comes from the kind's
+        // tier-1 profile (no magic constant at the call site).
+        const maxTokens = profile.maxTokens ?? kindDefaultProfile('anthropic').maxTokens;
+        const requestBody = applyProfileBody({
+            model: this.model,
+            ...(maxTokens !== undefined ? { max_tokens: maxTokens } : {}),
+            ...(profile.temperature !== undefined ? { temperature: profile.temperature } : {}),
+            ...(profile.topP !== undefined ? { top_p: profile.topP } : {}),
+            ...(profile.reasoning?.budgetTokens !== undefined
+                ? { thinking: { type: 'enabled', budget_tokens: profile.reasoning.budgetTokens } }
+                : {}),
+            ...(system !== undefined ? { system } : {}),
+            messages: anthropicMessages,
+            stream: true,
+            ...(tools.length > 0 ? { tools: toAnthropicTools(tools) } : {}),
+        }, profile);
+        const res = await postJson(`${this.baseUrl}/messages`, applyProfileHeaders(this.authHeaders, profile), requestBody, 'Anthropic', signal);
+        const body = res.body;
+        if (body === null) {
+            throw new LlmResolutionError('PROTOCOL_ERROR', 'Anthropic returned an empty response body.');
+        }
+        // Content blocks are numbered in start order; the decode state tracks the
+        // currently open block across payloads.
+        const state = newAnthropicDecodeState();
+        let done = false;
+        for await (const ev of readSseEvents(body)) {
+            if (ev.data === '')
+                continue; // keepalive: no payload to parse
+            const payload = parseJsonObject(ev.data, 'Anthropic');
+            for (const chunk of decodeAnthropicChunk(payload, state)) {
+                if (chunk.done === true) {
+                    // `message_stop`: the decoder's stream-completion sentinel.
+                    yield chunk;
+                    done = true;
+                    break;
+                }
+                yield chunk;
+            }
+            if (done)
+                break;
+        }
+        if (!done)
+            yield { done: true };
+    }
+}
+// ---------------------------------------------------------------------------
+// Resolution: active provider -> working LlmClient
+// ---------------------------------------------------------------------------
+function isKnownKind(kind) {
+    return PROVIDER_KINDS.includes(kind);
+}
+function canFailOver(error) {
+    return error instanceof LlmResolutionError &&
+        (error.code === 'NETWORK_ERROR' ||
+            (error.code === 'HTTP_ERROR' &&
+                error.status !== undefined &&
+                (error.status === 408 || error.status === 429 || error.status >= 500)));
+}
+class FallbackLlmClient {
+    clients;
+    constructor(clients) {
+        this.clients = clients;
+    }
+    async *complete(messages, tools, signal) {
+        for (const [index, resolveClient] of this.clients.entries()) {
+            let emitted = false;
+            const metadata = [];
+            try {
+                const client = await resolveClient();
+                for await (const chunk of client.complete(messages, tools, signal)) {
+                    const hasOutput = chunk.delta !== undefined || chunk.toolCallDelta !== undefined;
+                    if (!emitted && !hasOutput && chunk.done !== true) {
+                        metadata.push(chunk);
+                        continue;
+                    }
+                    if (!emitted) {
+                        for (const pending of metadata)
+                            yield pending;
+                        metadata.length = 0;
+                    }
+                    emitted ||= hasOutput;
+                    yield chunk;
+                }
+                for (const pending of metadata)
+                    yield pending;
+                return;
+            }
+            catch (error) {
+                if (signal?.aborted === true || emitted || !canFailOver(error) || index === this.clients.length - 1) {
+                    throw error;
+                }
+            }
+        }
+    }
+}
+async function resolveProviderClient(service, provider) {
+    const kind = provider.kind;
+    if (!isKnownKind(kind)) {
+        throw new LlmResolutionError('UNSUPPORTED_KIND', `Provider '${provider.name}' has unsupported kind '${String(kind)}'. ` +
+            `Supported kinds: ${PROVIDER_KINDS.join(', ')}.`);
+    }
+    // Declarative profile: base URL, auth, wire protocol, and tier-1 defaults
+    // all come from the provider's profile, not from switch statements.
+    const providerProfile = getProviderProfile(kind);
+    if (!providerProfile) {
+        throw new LlmResolutionError('UNSUPPORTED_KIND', `Provider '${provider.name}' has no registered profile for kind '${String(kind)}'.`);
+    }
+    const rawBase = provider.baseUrl ?? defaultBaseUrlFor(kind);
+    if (rawBase === null || rawBase === '') {
+        throw new LlmResolutionError('BAD_BASE_URL', `Provider '${provider.name}' (kind '${kind}') has no base URL and kind '${kind}' defines no default. ` +
+            `Set 'baseUrl' via provider.save.`);
+    }
+    const endpoint = parseHttpBaseUrl(rawBase, `Provider '${provider.name}' base URL`);
+    const model = provider.model ?? provider.models?.[0];
+    if (model === undefined || model === '') {
+        throw new LlmResolutionError('NO_MODEL', `Provider '${provider.name}' has no default model. Set 'model' via provider.save or ${SETUP_HINT}`);
+    }
+    if (provider.hasKey === false && providerProfile.keyless !== true) {
+        throw new LlmResolutionError('NO_API_KEY', `Provider '${provider.name}' has no API key stored. ${SETUP_HINT}`);
+    }
+    let apiKeys;
+    try {
+        if (typeof service.getApiKeys === 'function') {
+            apiKeys = await service.getApiKeys(provider.id);
+        }
+        else {
+            const single = await service.getApiKey(provider.id);
+            apiKeys = single !== null && single !== undefined ? [single] : [];
+        }
+    }
+    catch {
+        throw new LlmResolutionError('KEY_DECRYPT_FAILED', `Stored API key for provider '${provider.name}' cannot be decrypted ` +
+            `(is BOOMBOT_MASTER_KEY correct?). Re-run \`boombot setup\` to store the key again.`);
+    }
+    if (apiKeys.length === 0 && providerProfile.keyless !== true) {
+        throw new LlmResolutionError('NO_API_KEY', `Provider '${provider.name}' has no API key stored. ${SETUP_HINT}`);
+    }
+    // Request profile, three tiers: kind defaults < provider.extra < model override.
+    const profile = resolveRequestProfile(kind, provider.extra, provider.modelProfiles, model);
+    const makeClient = (apiKey) => {
+        const headers = buildAuthHeaders(kind, apiKey === '' ? undefined : apiKey);
+        // The wire protocol comes from the provider profile: Anthropic Messages vs
+        // OpenAI-compatible chat completions. No kind switch.
+        return providerProfile.apiMode === 'anthropic_messages'
+            ? new AnthropicChatClient(endpoint, model, headers, profile)
+            : new OpenAiCompatChatClient(endpoint, model, headers, providerProfile.requestUsage === true, profile);
+    };
+    if (apiKeys.length <= 1) {
+        // Single key (or a keyless local endpoint): the old behavior, no rotation.
+        return makeClient(apiKeys[0] ?? '');
+    }
+    // KeyRoulette: rotate the ring on 401/429 and persist the cursor, so a
+    // rate-limited or rejected key is skipped without failing the request.
+    const roulette = new KeyRoulette({
+        keys: apiKeys,
+        cursor: provider.keyCursor ?? 0,
+        onCursorAdvanced: (cursor) => service.setKeyCursor(provider.id, cursor),
+    });
+    return new KeyRotatingLlmClient(makeClient, roulette);
+}
+/**
+ * Resolve the loop-facing LLM client for the currently active provider.
+ *
+ * This is the real implementation behind `ProviderServiceLike.resolveLlm()`
+ * (see `agent-worker/src/turns/runtime-deps.ts` and the wiring in
+ * `services/providers.ts`). It:
+ * 1. reads the active provider from the registry,
+ * 2. resolves its base URL (explicit `baseUrl`, else the kind default),
+ * 3. picks the chat model (`model`, else the first discovered model),
+ * 4. decrypts the API key ring (never logged, never echoed),
+ * 5. resolves the 3-tier request profile (kind defaults < provider.extra <
+ *    per-model override),
+ * 6. returns a streaming HTTP client for the kind's wire protocol — wrapped
+ *    in KeyRoulette rotation when the provider holds more than one key, so a
+ *    401/429 on one key retries the request with the next key.
+ *
+ * Every expected failure mode throws `LlmResolutionError` with a code and
+ * an operator-actionable message — never a bare `TypeError`, never a crash.
+ */
+export async function resolveLlmClient(service) {
+    const providers = await service.list();
+    const active = providers.find((p) => p.active);
+    if (active === undefined) {
+        throw new LlmResolutionError('NO_ACTIVE_PROVIDER', `No active LLM provider. ${SETUP_HINT}`);
+    }
+    const primary = await resolveProviderClient(service, active);
+    const fallbackIds = (process.env['BOOMBOT_PROVIDER_FALLBACKS'] ?? '')
+        .split(',')
+        .map((id) => id.trim())
+        .filter((id, index, ids) => id !== '' && id !== active.id && ids.indexOf(id) === index);
+    const localFallbackUrl = process.env['BOOMBOT_LOCAL_FALLBACK_URL']?.trim();
+    if (fallbackIds.length === 0 && !localFallbackUrl)
+        return primary;
+    const byId = new Map(providers.map((provider) => [provider.id, provider]));
+    const clientResolvers = [async () => primary];
+    for (const id of fallbackIds) {
+        const provider = byId.get(id);
+        if (provider === undefined) {
+            throw new LlmResolutionError('FALLBACK_NOT_FOUND', `Fallback provider '${id}' was not found.`);
+        }
+        clientResolvers.push(async () => resolveProviderClient(service, provider));
+    }
+    if (localFallbackUrl) {
+        const localConfig = getLocalFallbackConfig();
+        clientResolvers.push(async () => createLocalFallbackClient(localConfig.baseUrl, localConfig.model));
+    }
+    return new FallbackLlmClient(clientResolvers);
+}
+/** Resolve semantic skill matching without coupling it to the chat model. */
+export async function resolveEmbeddingClient(service) {
+    const envKey = process.env['BOOMBOT_SKILL_EMBEDDING_API_KEY']?.trim();
+    if (envKey) {
+        const endpoint = parseHttpBaseUrl(process.env['BOOMBOT_SKILL_EMBEDDING_BASE_URL']?.trim() || 'https://api.openai.com/v1', 'skill embedding endpoint');
+        const model = process.env['BOOMBOT_SKILL_EMBEDDING_MODEL']?.trim() || 'text-embedding-3-small';
+        return new OpenAiEmbeddingClient(endpoint, model, { Authorization: `Bearer ${envKey}` });
+    }
+    const providers = await service.list();
+    const active = providers.find((provider) => provider.active);
+    if (active === undefined)
+        return undefined;
+    // Anthropic's Messages API has no compatible embeddings endpoint here.
+    const activeProfile = getProviderProfile(active.kind);
+    if (activeProfile?.apiMode === 'anthropic_messages')
+        return undefined;
+    const configuredModel = process.env['BOOMBOT_SKILL_EMBEDDING_MODEL']?.trim();
+    const discoveredModel = active.models?.find((model) => /embed/iu.test(model));
+    const model = configuredModel || discoveredModel || activeProfile?.defaultEmbeddingModel;
+    if (!model)
+        return undefined;
+    const rawBase = process.env['BOOMBOT_SKILL_EMBEDDING_BASE_URL']?.trim()
+        || active.baseUrl
+        || defaultBaseUrlFor(active.kind);
+    if (!rawBase)
+        return undefined;
+    const apiKey = await service.getApiKey(active.id);
+    if (apiKey === null && activeProfile?.keyless !== true)
+        return undefined;
+    return new OpenAiEmbeddingClient(parseHttpBaseUrl(rawBase, 'skill embedding endpoint'), model, buildAuthHeaders(active.kind, apiKey ?? undefined));
+}
+function parseHttpBaseUrl(raw, label) {
+    try {
+        const url = new URL(raw.replace(/\/+$/, ''));
+        if (url.protocol !== 'http:' && url.protocol !== 'https:')
+            throw new Error('not http(s)');
+        return url.toString().replace(/\/+$/, '');
+    }
+    catch {
+        throw new LlmResolutionError('BAD_BASE_URL', `${label} must be a valid HTTP(S) URL.`);
+    }
+}