@theowlops/boombot 0.0.0-stage → 1.1.1

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

@@ -0,0 +1,200 @@
+/**
+ * Error thrown when the active provider cannot be turned into a working
+ * LLM client, or when a chat request fails. Messages are written for the
+ * operator: they name the remedy and never contain secret material.
+ */
+export class LlmResolutionError extends Error {
+    code;
+    status;
+    constructor(code, message, status) {
+        super(message);
+        this.name = 'LlmResolutionError';
+        this.code = code;
+        this.status = status;
+    }
+}
+export function isRecord(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+/** Fresh decode state for one Anthropic SSE stream. */
+export function newAnthropicDecodeState() {
+    return { blockIndex: -1 };
+}
+/** The `delta` object of the first (only) choice in a chat-completions chunk. */
+export function firstChoiceDelta(choices) {
+    if (!Array.isArray(choices))
+        return undefined;
+    const first = choices[0];
+    if (!isRecord(first))
+        return undefined;
+    const delta = first['delta'];
+    return isRecord(delta) ? delta : undefined;
+}
+/**
+ * Decode one parsed OpenAI-compatible chat-completions SSE payload into
+ * `LlmChunk`s. Returns an empty array when the payload carries nothing the
+ * turn loop needs (e.g. a role-only first chunk).
+ */
+export function decodeOpenAiChunk(payload) {
+    const chunks = [];
+    const usage = isRecord(payload['usage']) ? payload['usage'] : undefined;
+    const inputTokens = usage?.['prompt_tokens'];
+    const outputTokens = usage?.['completion_tokens'];
+    if (typeof inputTokens === 'number' || typeof outputTokens === 'number') {
+        chunks.push({
+            usage: {
+                ...(typeof inputTokens === 'number' ? { inputTokens } : {}),
+                ...(typeof outputTokens === 'number' ? { outputTokens } : {}),
+            },
+        });
+    }
+    const delta = firstChoiceDelta(payload['choices']);
+    if (delta === undefined)
+        return chunks;
+    const content = delta['content'];
+    if (typeof content === 'string' && content !== '') {
+        chunks.push({ delta: content });
+    }
+    // DeepSeek / OpenRouter expose chain-of-thought as `reasoning_content`.
+    // Grok / 9Router / OpenRouter expose `reasoning`, Gemini exposes `thought`.
+    const reasoning = delta['reasoning_content'] ?? delta['reasoning'] ?? delta['thought'];
+    if (typeof reasoning === 'string' && reasoning !== '') {
+        chunks.push({ reasoningDelta: reasoning });
+    }
+    const toolCalls = delta['tool_calls'];
+    if (Array.isArray(toolCalls)) {
+        for (const raw of toolCalls) {
+            if (!isRecord(raw))
+                continue;
+            const index = typeof raw['index'] === 'number' ? raw['index'] : 0;
+            const fn = isRecord(raw['function']) ? raw['function'] : undefined;
+            const id = typeof raw['id'] === 'string' ? raw['id'] : undefined;
+            const name = typeof fn?.['name'] === 'string' ? fn['name'].replace(/__dot__/g, '.') : undefined;
+            const args = typeof fn?.['arguments'] === 'string' ? fn['arguments'] : undefined;
+            if (id === undefined && name === undefined && args === undefined)
+                continue;
+            chunks.push({
+                toolCallDelta: {
+                    index,
+                    ...(id !== undefined ? { id } : {}),
+                    ...(name !== undefined ? { name } : {}),
+                    ...(args !== undefined ? { argumentsJson: args } : {}),
+                },
+            });
+        }
+    }
+    return chunks;
+}
+/**
+ * Decode one parsed Anthropic Messages SSE payload into `LlmChunk`s,
+ * advancing `state` as content blocks open.
+ *
+ * - `message_start` yields usage input tokens; `message_delta` yields
+ *   output tokens.
+ * - `content_block_start` for a `tool_use` block yields the tool call
+ *   header (id/name); `input_json_delta` yields argument fragments for the
+ *   currently open block.
+ * - `text_delta` yields text; `thinking_delta` yields `reasoningDelta`
+ *   (extended-thinking models). `signature_delta` and unknown delta types
+ *   carry nothing the turn loop needs.
+ * - `message_stop` yields `[{ done: true }]` — a stream-completion sentinel
+ *   the client turns into the end of the chunk iterable (it does not throw,
+ *   so replay tests can assert on it like any other chunk).
+ * - `error` throws `LlmResolutionError('HTTP_ERROR', ...)` — a mid-stream
+ *   provider failure is not a chunk.
+ * - `ping`, `content_block_stop` and unknown event types yield nothing.
+ */
+export function decodeAnthropicChunk(payload, state) {
+    const chunks = [];
+    const type = payload['type'];
+    if (type === 'error') {
+        const errObj = isRecord(payload['error']) ? payload['error'] : undefined;
+        const msg = typeof errObj?.['message'] === 'string' ? errObj['message'] : 'unknown error';
+        throw new LlmResolutionError('HTTP_ERROR', `Anthropic stream error: ${msg.slice(0, 300)}`);
+    }
+    if (type === 'message_start') {
+        const message = isRecord(payload['message']) ? payload['message'] : undefined;
+        const usage = isRecord(message?.['usage']) ? message['usage'] : undefined;
+        const inputTokens = usage?.['input_tokens'];
+        if (typeof inputTokens === 'number')
+            chunks.push({ usage: { inputTokens } });
+    }
+    else if (type === 'content_block_start') {
+        state.blockIndex += 1;
+        const block = isRecord(payload['content_block']) ? payload['content_block'] : undefined;
+        if (block?.['type'] === 'tool_use') {
+            const id = typeof block['id'] === 'string' ? block['id'] : undefined;
+            const name = typeof block['name'] === 'string' ? block['name'].replace(/__dot__/g, '.') : undefined;
+            chunks.push({
+                toolCallDelta: {
+                    index: state.blockIndex,
+                    ...(id !== undefined ? { id } : {}),
+                    ...(name !== undefined ? { name } : {}),
+                },
+            });
+        }
+    }
+    else if (type === 'content_block_delta') {
+        const delta = isRecord(payload['delta']) ? payload['delta'] : undefined;
+        const deltaType = delta?.['type'];
+        if (deltaType === 'text_delta') {
+            const text = delta?.['text'];
+            if (typeof text === 'string' && text !== '')
+                chunks.push({ delta: text });
+        }
+        else if (deltaType === 'input_json_delta') {
+            const partial = delta?.['partial_json'];
+            if (typeof partial === 'string' && partial !== '') {
+                chunks.push({ toolCallDelta: { index: state.blockIndex, argumentsJson: partial } });
+            }
+        }
+        else if (deltaType === 'thinking_delta') {
+            const thinking = delta?.['thinking'];
+            if (typeof thinking === 'string' && thinking !== '')
+                chunks.push({ reasoningDelta: thinking });
+        }
+    }
+    else if (type === 'message_delta') {
+        const usage = isRecord(payload['usage']) ? payload['usage'] : undefined;
+        const outputTokens = usage?.['output_tokens'];
+        if (typeof outputTokens === 'number')
+            chunks.push({ usage: { outputTokens } });
+    }
+    else if (type === 'message_stop') {
+        chunks.push({ done: true });
+    }
+    return chunks;
+}
+/**
+ * Split buffered SSE text into raw events. Follows the same line rules as
+ * the streaming `readSseEvents` in `llm-client.ts` (blank line resets the
+ * event name, `: ...` comments and `id:`/`retry:` fields are ignored, one
+ * leading space after `data:` is stripped) so golden traces replay exactly
+ * what the client would have seen.
+ */
+export function splitSseText(text) {
+    const events = [];
+    let eventName;
+    for (const rawLine of text.split('\n')) {
+        const line = rawLine.replace(/\r$/, '');
+        if (line === '') {
+            eventName = undefined;
+            continue;
+        }
+        if (line.startsWith(':'))
+            continue;
+        if (line.startsWith('event:')) {
+            eventName = line.slice('event:'.length).trim();
+            continue;
+        }
+        if (line.startsWith('data:')) {
+            // Per the SSE spec, a single leading space after the colon is stripped.
+            events.push({
+                ...(eventName !== undefined ? { event: eventName } : {}),
+                data: line.slice('data:'.length).replace(/^ /, ''),
+            });
+        }
+        // 'id:' and 'retry:' carry nothing we need.
+    }
+    return events;
+}

package/dist/gateway/services/local-fallback.js

@@ -0,0 +1,135 @@
+export function getLocalFallbackConfig() {
+    const enabled = process.env['BOOMBOT_LOCAL_FALLBACK_ENABLED'] !== 'false';
+    const baseUrl = process.env['BOOMBOT_LOCAL_FALLBACK_URL']?.trim() || 'http://127.0.0.1:11434/v1';
+    const model = process.env['BOOMBOT_LOCAL_FALLBACK_MODEL']?.trim() || 'qwen2.5-coder';
+    return { enabled, baseUrl, model, probeTimeoutMs: 1500 };
+}
+/**
+ * Health-probe local daemon to verify offline availability without blocking startup.
+ */
+export async function probeLocalFallback(baseUrl = 'http://127.0.0.1:11434/v1', timeoutMs = 1500) {
+    const startedAt = Date.now();
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), timeoutMs);
+    try {
+        const cleanUrl = baseUrl.replace(/\/+$/, '');
+        const probeUrl = `${cleanUrl}/models`;
+        const response = await fetch(probeUrl, {
+            method: 'GET',
+            signal: controller.signal,
+            headers: { Accept: 'application/json' },
+        });
+        clearTimeout(timer);
+        return {
+            available: response.ok,
+            latencyMs: Date.now() - startedAt,
+        };
+    }
+    catch (err) {
+        clearTimeout(timer);
+        return {
+            available: false,
+            error: err instanceof Error ? err.message : String(err),
+        };
+    }
+}
+/**
+ * Creates an LlmClient talking directly to the local offline OpenAI-compatible daemon.
+ */
+export function createLocalFallbackClient(baseUrl, modelName) {
+    const cleanUrl = baseUrl.replace(/\/+$/, '');
+    const endpoint = `${cleanUrl}/chat/completions`;
+    return {
+        async *complete(messages, tools, signal) {
+            const formattedMessages = messages.map((m) => ({
+                role: m.role,
+                content: m.content,
+                ...(m.toolCallId ? { tool_call_id: m.toolCallId } : {}),
+            }));
+            const body = {
+                model: modelName,
+                messages: formattedMessages,
+                stream: true,
+            };
+            if (tools.length > 0) {
+                body['tools'] = tools.map((t) => ({
+                    type: 'function',
+                    function: {
+                        name: t.name,
+                        description: t.description,
+                        parameters: t.parameters,
+                    },
+                }));
+            }
+            const response = await fetch(endpoint, {
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/json',
+                    Accept: 'text/event-stream',
+                },
+                body: JSON.stringify(body),
+                signal,
+            });
+            if (!response.ok) {
+                const errorText = await response.text().catch(() => '');
+                throw new Error(`Local offline LLM returned HTTP ${response.status}: ${errorText}`);
+            }
+            const reader = response.body?.getReader();
+            if (!reader) {
+                throw new Error('Local offline LLM response body is not readable');
+            }
+            const decoder = new TextDecoder('utf-8');
+            let buffer = '';
+            try {
+                while (true) {
+                    if (signal?.aborted)
+                        break;
+                    const { done, value } = await reader.read();
+                    if (done)
+                        break;
+                    buffer += decoder.decode(value, { stream: true });
+                    const lines = buffer.split('\n');
+                    buffer = lines.pop() ?? '';
+                    for (const line of lines) {
+                        const trimmed = line.trim();
+                        if (!trimmed || trimmed.startsWith(':'))
+                            continue;
+                        if (trimmed === 'data: [DONE]') {
+                            yield { done: true };
+                            return;
+                        }
+                        if (trimmed.startsWith('data: ')) {
+                            try {
+                                const parsed = JSON.parse(trimmed.slice(6));
+                                const choice = parsed.choices?.[0];
+                                const delta = choice?.delta;
+                                if (delta?.content) {
+                                    yield { delta: delta.content };
+                                }
+                                if (delta?.tool_calls) {
+                                    for (const tc of delta.tool_calls) {
+                                        yield {
+                                            toolCallDelta: {
+                                                id: tc.id,
+                                                index: tc.index,
+                                                name: tc.function?.name,
+                                                argumentsJson: tc.function?.arguments,
+                                            },
+                                        };
+                                    }
+                                }
+                            }
+                            catch {
+                                // Ignore malformed chunk
+                            }
+                        }
+                    }
+                }
+            }
+            finally {
+                reader.releaseLock();
+            }
+            yield { done: true };
+        },
+    };
+}