@theowlops/boombot 0.0.0-stage → 1.1.1

package/dist/gateway/services/history-normalizer.js

@@ -0,0 +1,42 @@
+/** Inserted when a tool call has no recorded result. Kept stable for tests. */
+export const CANCELLED_TOOL_RESULT = '[tool result unavailable: the call was cancelled or was not recorded]';
+export function normalizeHistoryForProvider(messages, kind) {
+    if (kind !== 'openai' && kind !== 'anthropic') {
+        throw new Error(`[history-normalizer] unknown provider kind: ${String(kind)}`);
+    }
+    const out = [];
+    // Call ids requested by the latest assistant message, still awaiting results.
+    let pending = new Map(); // id -> name
+    const flushPending = () => {
+        for (const [id, name] of pending) {
+            out.push({ role: 'tool', content: CANCELLED_TOOL_RESULT, toolCallId: id, name });
+        }
+        pending = new Map();
+    };
+    for (const message of messages) {
+        if (message.role === 'assistant' && message.toolCalls !== undefined && message.toolCalls.length > 0) {
+            // A new assistant turn: calls from the previous turn that never got
+            // results are dangling — repair before continuing.
+            flushPending();
+            out.push(message);
+            pending = new Map(message.toolCalls.map((tc) => [tc.id, tc.name]));
+            continue;
+        }
+        if (message.role === 'tool') {
+            const id = message.toolCallId ?? '';
+            if (id !== '' && pending.has(id)) {
+                pending.delete(id);
+                out.push(message);
+            }
+            // Else: orphan result — dropped (fail-safe, see module doc).
+            continue;
+        }
+        // Any other role between a call and its results breaks the pairing;
+        // repair first so the provider never sees a dangling tool_call.
+        if (pending.size > 0)
+            flushPending();
+        out.push(message);
+    }
+    flushPending();
+    return out;
+}

package/dist/gateway/services/image-pipeline.js

@@ -0,0 +1,56 @@
+import { createHash } from 'node:crypto';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import sharp from 'sharp';
+import { createWorker } from 'tesseract.js';
+const MAX_BYTES = 12 * 1024 * 1024;
+const MAX_PIXELS = 40_000_000;
+const THUMBNAIL_WIDTH = 1536;
+/** Decode, validate and resize image data in-memory; metadata is checked before pixel processing. */
+export async function prepareImage(input, options = {}) {
+    const maxBytes = options.maxBytes ?? MAX_BYTES;
+    const maxPixels = options.maxPixels ?? MAX_PIXELS;
+    if (input.byteLength === 0 || input.byteLength > maxBytes) {
+        throw new Error(`Image size must be between 1 byte and ${maxBytes} bytes.`);
+    }
+    const image = sharp(input, { limitInputPixels: maxPixels, failOn: 'error' });
+    const metadata = await image.metadata();
+    if (!metadata.width || !metadata.height || !metadata.format || !['jpeg', 'png', 'webp', 'gif', 'tiff', 'avif'].includes(metadata.format)) {
+        throw new Error('Unsupported or invalid image format.');
+    }
+    if (metadata.width * metadata.height > maxPixels) {
+        throw new Error(`Image exceeds the ${maxPixels}-pixel processing limit.`);
+    }
+    const { data, info } = await image
+        .rotate()
+        .resize({ width: options.thumbnailWidth ?? THUMBNAIL_WIDTH, withoutEnlargement: true })
+        .jpeg({ quality: 82, mozjpeg: true })
+        .toBuffer({ resolveWithObject: true });
+    return {
+        dataUrl: `data:image/jpeg;base64,${data.toString('base64')}`,
+        mimeType: 'image/jpeg',
+        width: info.width,
+        height: info.height,
+        sha256: createHash('sha256').update(input).digest('hex'),
+    };
+}
+/** Run local Tesseract OCR; the worker is scoped to this call and always terminated. */
+const warmWorkers = new Map();
+/** Reuse warm OCR workers by language to avoid 1-2s startup cost on every image. */
+export async function extractImageText(input, language = 'eng') {
+    if (!/^[a-z]{3}(\+[a-z]{3})*$/.test(language)) {
+        throw new Error('Language must be a Tesseract language code such as eng, vie, or vie+eng.');
+    }
+    let workerPromise = warmWorkers.get(language);
+    if (!workerPromise) {
+        workerPromise = createWorker(language, undefined, {
+            cachePath: join(tmpdir(), 'boombot-tesseract-cache'),
+            cacheMethod: 'readOnly',
+            gzip: true,
+        });
+        warmWorkers.set(language, workerPromise);
+    }
+    const worker = await workerPromise;
+    const { data } = await worker.recognize(Buffer.from(input));
+    return data.text.trim();
+}

package/dist/gateway/services/key-roulette-client.js

@@ -0,0 +1,43 @@
+import { KeyRoulette } from '@boombot/protocol';
+import { LlmResolutionError } from './llm-decoder.js';
+/**
+ * HTTP statuses that mean "try the next key". 401 = this key is rejected;
+ * 429 = this key is rate-limited. Everything else fails the request.
+ */
+export function isKeyRotationFailure(error) {
+    return (error instanceof LlmResolutionError &&
+        error.code === 'HTTP_ERROR' &&
+        (error.status === 401 || error.status === 429));
+}
+export class KeyRotatingLlmClient {
+    makeClient;
+    roulette;
+    constructor(makeClient, roulette) {
+        this.makeClient = makeClient;
+        this.roulette = roulette;
+    }
+    async *complete(messages, tools, signal) {
+        let lastError;
+        for (;;) {
+            const index = this.roulette.pickIndex();
+            if (index === null) {
+                if (lastError instanceof LlmResolutionError)
+                    throw lastError;
+                throw new LlmResolutionError('KEYS_EXHAUSTED', 'All API keys for this provider are cooling down after failures; try again shortly.');
+            }
+            try {
+                yield* this.makeClient(this.roulette.keyAt(index)).complete(messages, tools, signal);
+                this.roulette.recordSuccess(index);
+                return;
+            }
+            catch (error) {
+                // Cancellation and non-key failures propagate untouched.
+                if (signal?.aborted === true || !isKeyRotationFailure(error))
+                    throw error;
+                lastError = error;
+                // Bench the failed key, advance the persisted cursor, retry.
+                await this.roulette.markFailed(index);
+            }
+        }
+    }
+}