@auxot/worker-cli 0.1.0 → 0.1.3

package/dist/llama-binary.js

@@ -1,287 +0,0 @@
-/**
- * llama.cpp Binary Downloader
- *
- * Downloads and manages llama.cpp server binary from GitHub releases.
- *
- * Features:
- * - Downloads fixed version for compatibility
- * - Platform-specific binaries with GPU acceleration
- * - Extracts binaries from archives
- * - Caches binary in ~/.auxot/llama-server/{platform}-{arch}/
- * - Works offline after first download
- *
- * GPU Support:
- * - macOS: Metal GPU acceleration (built into binaries)
- * - Linux: Vulkan GPU acceleration
- * - Windows: CUDA GPU acceleration (NVIDIA GPUs)
- */
-import { existsSync, chmodSync, statSync } from 'node:fs';
-import { mkdir, unlink } from 'node:fs/promises';
-import { join } from 'node:path';
-import { homedir } from 'os';
-import { platform, arch } from 'os';
-import { createWriteStream } from 'node:fs';
-import { exec } from 'child_process';
-import { promisify } from 'util';
-import { detectGpuBackend } from './gpu-detection.js';
-const execAsync = promisify(exec);
-// Pin llama.cpp version for compatibility
-// Update this when we want to upgrade to a new version
-const LLAMA_CPP_VERSION = 'b7716'; // Latest stable as of implementation (confirmed via GitHub API)
-const LLAMA_CPP_REPO = 'ggml-org/llama.cpp'; // Repository is ggml-org, not ggerganov
-/**
- * Get platform-specific archive name based on detected GPU hardware
- *
- * GPU variants:
- * - macOS: Metal GPU acceleration (built into standard binaries)
- * - Linux: Vulkan GPU acceleration (AMD/NVIDIA) or CPU fallback
- * - Windows: CUDA 12.4 GPU acceleration (NVIDIA) or CPU fallback
- */
-async function getArchiveName() {
-    const os = platform();
-    const architecture = arch();
-    const gpuDetection = await detectGpuBackend();
-    // Log warning if CPU fallback is used
-    if (gpuDetection.warning) {
-        console.warn(`  ⚠ ${gpuDetection.warning}`);
-    }
-    // Map Node.js platform/arch to llama.cpp archive names
-    if (os === 'darwin') {
-        // macOS: Metal GPU acceleration is built into the binaries
-        if (architecture === 'arm64') {
-            return { archiveName: `llama-${LLAMA_CPP_VERSION}-bin-macos-arm64.tar.gz`, warning: gpuDetection.warning };
-        }
-        else {
-            return { archiveName: `llama-${LLAMA_CPP_VERSION}-bin-macos-x64.tar.gz`, warning: gpuDetection.warning };
-        }
-    }
-    else if (os === 'linux') {
-        if (architecture === 'arm64' || architecture === 'aarch64') {
-            throw new Error(`Linux ARM64 binaries not available - please use x64 or build from source`);
-        }
-        else if (architecture === 's390x') {
-            // s390x only has CPU variant
-            return { archiveName: `llama-${LLAMA_CPP_VERSION}-bin-ubuntu-s390x.tar.gz`, warning: gpuDetection.warning };
-        }
-        else {
-            // Linux: Use Vulkan for GPU acceleration, CPU as fallback
-            if (gpuDetection.backend === 'cpu') {
-                return { archiveName: `llama-${LLAMA_CPP_VERSION}-bin-ubuntu-x64.tar.gz`, warning: gpuDetection.warning };
-            }
-            else {
-                return { archiveName: `llama-${LLAMA_CPP_VERSION}-bin-ubuntu-vulkan-x64.tar.gz`, warning: gpuDetection.warning };
-            }
-        }
-    }
-    else if (os === 'win32') {
-        if (architecture === 'arm64') {
-            // Windows ARM64 only has CPU variant
-            return { archiveName: `llama-${LLAMA_CPP_VERSION}-bin-win-cpu-arm64.zip`, warning: gpuDetection.warning };
-        }
-        else {
-            // Windows: Use CUDA for GPU acceleration (NVIDIA), CPU as fallback
-            if (gpuDetection.backend === 'cpu') {
-                return { archiveName: `llama-${LLAMA_CPP_VERSION}-bin-win-cpu-x64.zip`, warning: gpuDetection.warning };
-            }
-            else {
-                return { archiveName: `llama-${LLAMA_CPP_VERSION}-bin-win-cuda-12.4-x64.zip`, warning: gpuDetection.warning };
-            }
-        }
-    }
-    throw new Error(`Unsupported platform: ${os} ${architecture}`);
-}
-/**
- * Get cache directory for llama.cpp binary
- */
-function getCacheDir() {
-    const os = platform();
-    const architecture = arch();
-    const cacheDir = process.env.AUXOT_LLAMA_CACHE_DIR || join(homedir(), '.auxot', 'llama-server');
-    return join(cacheDir, `${os}-${architecture}`);
-}
-/**
- * Get cached binary path
- * Binary is extracted to: {cacheDir}/llama-{VERSION}/llama-server
- */
-function getBinaryPath() {
-    const cacheDir = getCacheDir();
-    return join(cacheDir, `llama-${LLAMA_CPP_VERSION}`, 'llama-server');
-}
-/**
- * Download and extract llama.cpp binary from GitHub releases
- */
-export async function downloadLlamaBinary(onProgress) {
-    const { archiveName, warning } = await getArchiveName();
-    const binaryPath = getBinaryPath();
-    const cacheDir = getCacheDir();
-    const archivePath = join(cacheDir, archiveName);
-    // Log warning if CPU fallback is used
-    if (warning) {
-        console.warn(`  ⚠ ${warning}`);
-    }
-    // Check if binary already exists
-    if (existsSync(binaryPath)) {
-        const stats = statSync(binaryPath);
-        if (stats.size > 0) {
-            console.log(`  ✓ llama.cpp binary already cached (${formatBytes(stats.size)})`);
-            return binaryPath;
-        }
-    }
-    // Create cache directory if it doesn't exist
-    if (!existsSync(cacheDir)) {
-        await mkdir(cacheDir, { recursive: true });
-    }
-    // Build GitHub release download URL
-    // Format: https://github.com/{repo}/releases/download/{tag}/{asset}
-    const downloadUrl = `https://github.com/${LLAMA_CPP_REPO}/releases/download/${LLAMA_CPP_VERSION}/${archiveName}`;
-    console.log(`  Downloading llama.cpp binary...`);
-    console.log(`  Version: ${LLAMA_CPP_VERSION}`);
-    console.log(`  Platform: ${platform()}-${arch()}`);
-    console.log(`  Archive: ${archiveName}`);
-    // Download archive
-    const response = await fetch(downloadUrl);
-    if (!response.ok) {
-        if (response.status === 404) {
-            throw new Error(`Archive not found for platform ${platform()}-${arch()}. Available binaries may not exist for this platform.`);
-        }
-        throw new Error(`Download failed: ${response.status} ${response.statusText}`);
-    }
-    const contentLength = response.headers.get('content-length');
-    const totalSize = contentLength ? parseInt(contentLength, 10) : 0;
-    // Stream response to file
-    const reader = response.body?.getReader();
-    if (!reader) {
-        throw new Error('Response body is not readable');
-    }
-    const fileStream = createWriteStream(archivePath);
-    let downloadedBytes = 0;
-    try {
-        // Download archive
-        while (true) {
-            const { done, value } = await reader.read();
-            if (done) {
-                break;
-            }
-            fileStream.write(value);
-            downloadedBytes += value.length;
-            // Report progress
-            if (onProgress) {
-                onProgress(downloadedBytes, totalSize);
-            }
-            else if (totalSize > 0) {
-                // Simple progress log every 1MB
-                if (downloadedBytes % (1024 * 1024) < value.length) {
-                    const percent = ((downloadedBytes / totalSize) * 100).toFixed(1);
-                    process.stdout.write(`\r  Progress: ${percent}% (${formatBytes(downloadedBytes)} / ${formatBytes(totalSize)})`);
-                }
-            }
-        }
-        fileStream.end();
-        // Wait for file stream to finish
-        await new Promise((resolve, reject) => {
-            fileStream.on('finish', resolve);
-            fileStream.on('error', reject);
-        });
-        if (totalSize > 0 && downloadedBytes !== totalSize) {
-            throw new Error(`Download incomplete: ${downloadedBytes} bytes downloaded, expected ${totalSize}`);
-        }
-        if (onProgress) {
-            process.stdout.write('\r');
-        }
-        else {
-            process.stdout.write('\r');
-        }
-        console.log(`  ✓ Archive downloaded (${formatBytes(downloadedBytes)})`);
-        console.log(`  Extracting archive...`);
-        // Extract archive
-        const os = platform();
-        const extractDir = cacheDir;
-        try {
-            if (archiveName.endsWith('.tar.gz')) {
-                // Extract tar.gz (macOS/Linux)
-                await execAsync(`tar -xzf "${archivePath}" -C "${extractDir}"`, {
-                    maxBuffer: 10 * 1024 * 1024, // 10MB buffer
-                });
-            }
-            else if (archiveName.endsWith('.zip')) {
-                // Extract zip (Windows)
-                // Use PowerShell Expand-Archive on Windows, or unzip on Unix-like systems (Git Bash, WSL)
-                if (os === 'win32') {
-                    // PowerShell Expand-Archive (native Windows)
-                    await execAsync(`powershell -Command "Expand-Archive -Path '${archivePath}' -DestinationPath '${extractDir}' -Force"`, {
-                        maxBuffer: 10 * 1024 * 1024, // 10MB buffer
-                    });
-                }
-                else {
-                    // Use unzip (available on Unix-like systems, Git Bash, WSL)
-                    await execAsync(`unzip -q "${archivePath}" -d "${extractDir}"`, {
-                        maxBuffer: 10 * 1024 * 1024, // 10MB buffer
-                    });
-                }
-            }
-            else {
-                throw new Error(`Unsupported archive format: ${archiveName}`);
-            }
-            // Clean up archive
-            await unlink(archivePath);
-            // Verify binary exists
-            if (!existsSync(binaryPath)) {
-                throw new Error(`Binary not found after extraction: ${binaryPath}`);
-            }
-            // Make binary executable (Unix-like systems)
-            if (os !== 'win32') {
-                chmodSync(binaryPath, 0o755);
-            }
-            console.log(`  ✓ Extraction complete`);
-            console.log(`  ✓ Binary cached at: ${binaryPath}`);
-            return binaryPath;
-        }
-        catch (extractError) {
-            // Clean up archive on error
-            if (existsSync(archivePath)) {
-                await unlink(archivePath).catch(() => { });
-            }
-            throw new Error(`Extraction failed: ${extractError instanceof Error ? extractError.message : String(extractError)}`);
-        }
-    }
-    catch (error) {
-        fileStream.destroy();
-        // Clean up partial download
-        if (existsSync(archivePath)) {
-            await unlink(archivePath).catch(() => { });
-        }
-        throw error;
-    }
-}
-/**
- * Get llama.cpp binary path, downloading if necessary
- */
-export async function ensureLlamaBinary(onProgress) {
-    const binaryPath = getBinaryPath();
-    // Check if binary exists and is valid
-    if (existsSync(binaryPath)) {
-        const stats = statSync(binaryPath);
-        if (stats.size > 0) {
-            return binaryPath;
-        }
-    }
-    // Download and extract binary
-    return await downloadLlamaBinary(onProgress);
-}
-/**
- * Get binary path without downloading (for checking if binary exists)
- */
-export function getLlamaBinaryPath() {
-    return getBinaryPath();
-}
-/**
- * Format bytes to human-readable string
- */
-function formatBytes(bytes) {
-    if (bytes === 0)
-        return '0 B';
-    const k = 1024;
-    const sizes = ['B', 'KB', 'MB', 'GB'];
-    const i = Math.floor(Math.log(bytes) / Math.log(k));
-    return `${(bytes / Math.pow(k, i)).toFixed(1)} ${sizes[i]}`;
-}

package/dist/llama-process.js

@@ -1,203 +0,0 @@
-/**
- * llama.cpp Process Management
- *
- * Spawns and manages llama.cpp server process with parameters from GPU key policy.
- *
- * Handles:
- * - Process lifecycle (start, stop, restart)
- * - Crash detection and restart
- * - stdout/stderr capture for debugging
- * - Graceful shutdown
- */
-import { spawn } from 'child_process';
-import { ensureLlamaBinary } from './llama-binary.js';
-/**
- * Spawn llama.cpp server process with policy parameters
- */
-export async function spawnLlamaCpp(options) {
-    // Ensure llama.cpp binary is downloaded
-    const binaryPath = options.binaryPath || await ensureLlamaBinary();
-    const { modelPath, contextSize, parallelism, port = 9002, host = '127.0.0.1', gpuLayers, } = options;
-    // Store original options for restart
-    const originalOptions = {
-        binaryPath,
-        modelPath,
-        contextSize,
-        parallelism,
-        port,
-        host,
-        gpuLayers,
-    };
-    // Build command arguments
-    const args = [
-        '--model', modelPath,
-        '--ctx-size', contextSize.toString(),
-        '--parallel', parallelism.toString(),
-        '--port', port.toString(),
-        '--host', host,
-        '--batch-size', '512',
-        '--threads', '12',
-        '--jinja', // Enable Jinja templating for tool calling
-    ];
-    // Add GPU layers if specified
-    if (gpuLayers !== undefined) {
-        args.push('--n-gpu-layers', gpuLayers.toString());
-    }
-    console.log(`[llama.cpp] Spawning process: ${binaryPath} ${args.join(' ')}`);
-    // Spawn process
-    const childProcess = spawn(binaryPath, args, {
-        stdio: ['ignore', 'pipe', 'pipe'], // stdin: ignore, stdout/stderr: pipe
-        env: process.env,
-    });
-    let isRunning = true;
-    const crashCallbacks = [];
-    // Capture stdout for debugging (with buffering for better formatting)
-    let stdoutBuffer = '';
-    childProcess.stdout?.on('data', (data) => {
-        stdoutBuffer += data.toString();
-        // Process complete lines
-        const lines = stdoutBuffer.split('\n');
-        stdoutBuffer = lines.pop() || ''; // Keep incomplete line in buffer
-        for (const line of lines) {
-            const trimmed = line.trim();
-            if (trimmed) {
-                console.log(`[llama.cpp stdout] ${trimmed}`);
-            }
-        }
-    });
-    // Capture stderr for debugging (with buffering for better formatting)
-    let stderrBuffer = '';
-    childProcess.stderr?.on('data', (data) => {
-        stderrBuffer += data.toString();
-        // Process complete lines
-        const lines = stderrBuffer.split('\n');
-        stderrBuffer = lines.pop() || ''; // Keep incomplete line in buffer
-        for (const line of lines) {
-            const trimmed = line.trim();
-            if (trimmed) {
-                console.error(`[llama.cpp stderr] ${trimmed}`);
-            }
-        }
-    });
-    // Handle process exit
-    childProcess.on('exit', (code, signal) => {
-        isRunning = false;
-        // Flush any remaining buffered output
-        if (stdoutBuffer.trim()) {
-            console.log(`[llama.cpp stdout] ${stdoutBuffer.trim()}`);
-            stdoutBuffer = '';
-        }
-        if (stderrBuffer.trim()) {
-            console.error(`[llama.cpp stderr] ${stderrBuffer.trim()}`);
-            stderrBuffer = '';
-        }
-        if (code !== null) {
-            console.log(`[llama.cpp] Process exited with code ${code}`);
-            // Notify crash callbacks (non-zero exit is a crash)
-            if (code !== 0) {
-                for (const callback of crashCallbacks) {
-                    callback(code, signal);
-                }
-            }
-        }
-        else if (signal) {
-            console.log(`[llama.cpp] Process killed with signal ${signal}`);
-            // Notify crash callbacks (killed by signal is a crash unless it's SIGTERM/SIGINT)
-            if (signal !== 'SIGTERM' && signal !== 'SIGINT') {
-                for (const callback of crashCallbacks) {
-                    callback(null, signal);
-                }
-            }
-        }
-    });
-    // Handle process errors
-    childProcess.on('error', (error) => {
-        console.error(`[llama.cpp] Process error:`, error);
-        isRunning = false;
-        // Notify crash callbacks
-        for (const callback of crashCallbacks) {
-            callback(null, null);
-        }
-    });
-    return {
-        process: childProcess,
-        get isRunning() {
-            return isRunning && childProcess.exitCode === null;
-        },
-        async stop() {
-            if (!isRunning) {
-                return;
-            }
-            console.log('[llama.cpp] Stopping process...');
-            isRunning = false;
-            // Try graceful shutdown first (SIGTERM)
-            childProcess.kill('SIGTERM');
-            // Wait up to 5 seconds for graceful shutdown
-            await new Promise((resolve) => {
-                const timeout = setTimeout(() => {
-                    // Force kill if still running
-                    if (childProcess.exitCode === null) {
-                        console.warn('[llama.cpp] Process did not exit gracefully, force killing...');
-                        childProcess.kill('SIGKILL');
-                    }
-                    resolve();
-                }, 5000);
-                childProcess.once('exit', () => {
-                    clearTimeout(timeout);
-                    resolve();
-                });
-            });
-        },
-        async restart() {
-            console.log('[llama.cpp] Restarting process...');
-            // Stop current process
-            const stopPromise = (async () => {
-                if (childProcess && isRunning) {
-                    childProcess.kill('SIGTERM');
-                    // Wait for graceful shutdown
-                    await new Promise((resolve) => {
-                        const timeout = setTimeout(() => {
-                            if (childProcess && isRunning) {
-                                console.warn('[llama.cpp] Process did not exit gracefully, force killing...');
-                                childProcess.kill('SIGKILL');
-                            }
-                            resolve();
-                        }, 5000);
-                        childProcess.once('exit', () => {
-                            clearTimeout(timeout);
-                            resolve();
-                        });
-                    });
-                }
-            })();
-            await stopPromise;
-            isRunning = false;
-            // Create a new process with the same options
-            return await spawnLlamaCpp(originalOptions);
-        },
-        onCrash(callback) {
-            crashCallbacks.push(callback);
-        },
-    };
-}
-/**
- * Wait for llama.cpp server to be ready (health check)
- */
-export async function waitForLlamaReady(url, timeoutMs = 30000) {
-    const startTime = Date.now();
-    const checkInterval = 500; // Check every 500ms
-    while (Date.now() - startTime < timeoutMs) {
-        try {
-            const response = await fetch(`${url}/v1/models`);
-            if (response.ok) {
-                console.log('[llama.cpp] Server is ready');
-                return;
-            }
-        }
-        catch (error) {
-            // Server not ready yet, continue waiting
-        }
-        await new Promise((resolve) => setTimeout(resolve, checkInterval));
-    }
-    throw new Error(`llama.cpp server did not become ready within ${timeoutMs}ms`);
-}

package/dist/llama.js

@@ -1,207 +0,0 @@
-/**
- * llama.cpp Integration
- *
- * Simple dumb router: forwards OpenAI-format jobs to llama.cpp and streams back tokens.
- * NO prompt templates or business logic - server controls all prompts.
- */
-import { createParser } from 'eventsource-parser';
-import { logClientToLlama, logLlamaToClient } from './debug.js';
-/**
- * Process job by forwarding to llama.cpp
- *
- * Dumb router - receives OpenAI format, forwards to llama.cpp, streams back tokens.
- *
- * If job.max_tokens is not provided, uses capabilities.max_tokens_default to override
- * llama.cpp's OpenAI API layer default (which is 2048, too restrictive).
- *
- * Supports cancellation via AbortSignal.
- */
-export async function processJob(job, llamaUrl, capabilities, abortSignal, onToken) {
-    const startTime = Date.now();
-    // Prepare request to llama.cpp (OpenAI compatible format)
-    const request = {
-        model: 'default',
-        messages: job.messages,
-        temperature: job.temperature ?? 0.7,
-        stream: true,
-    };
-    // Include tools if provided (for function calling)
-    if (job.tools && job.tools.length > 0) {
-        request.tools = job.tools;
-    }
-    // Handle max_tokens:
-    // - If job specifies max_tokens, use it (explicit limit)
-    // - Otherwise, use capabilities.max_tokens_default from /props (server's default, often -1 for unlimited)
-    // - This overrides llama.cpp's OpenAI API compat layer default of 2048
-    if (job.max_tokens !== undefined) {
-        request.max_tokens = job.max_tokens;
-    }
-    else if (capabilities.max_tokens_default !== undefined) {
-        request.max_tokens = capabilities.max_tokens_default;
-    }
-    // Debug log request to llama.cpp (level 2)
-    logClientToLlama(request);
-    const requestBody = JSON.stringify(request);
-    const response = await fetch(`${llamaUrl}/v1/chat/completions`, {
-        method: 'POST',
-        headers: {
-            'Content-Type': 'application/json',
-        },
-        body: requestBody,
-        signal: abortSignal, // Pass abort signal for cancellation
-    });
-    if (!response.ok) {
-        // Try to get error details from response body
-        let errorDetails = '';
-        try {
-            const errorBody = await response.text();
-            errorDetails = errorBody ? ` - ${errorBody.substring(0, 500)}` : '';
-        }
-        catch {
-            // Ignore if we can't read error body
-        }
-        console.error(`[llama.cpp] Request failed:`, {
-            status: response.status,
-            statusText: response.statusText,
-            request: JSON.stringify(request, null, 2),
-            errorBody: errorDetails,
-        });
-        throw new Error(`llama.cpp request failed: ${response.status} ${response.statusText}${errorDetails}`);
-    }
-    if (!response.body) {
-        throw new Error('No response body from llama.cpp');
-    }
-    // Process stream
-    let fullResponse = '';
-    let timings = undefined;
-    const reader = response.body.getReader();
-    const decoder = new TextDecoder();
-    // Track tool calls as they stream in
-    const toolCallsMap = new Map();
-    // Create SSE parser
-    const parser = createParser((event) => {
-        // Skip reconnection interval messages
-        if (event.type === 'reconnect-interval')
-            return;
-        // Check for [DONE] signal
-        if (event.data === '[DONE]')
-            return;
-        try {
-            const chunk = JSON.parse(event.data);
-            // Capture timings from the final chunk
-            if (chunk.timings) {
-                timings = chunk.timings;
-            }
-            // Extract content
-            const content = chunk.choices[0]?.delta?.content;
-            if (content) {
-                fullResponse += content;
-                onToken(content);
-            }
-            // Extract tool_calls (streamed incrementally)
-            const toolCalls = chunk.choices[0]?.delta?.tool_calls;
-            if (toolCalls) {
-                for (const tc of toolCalls) {
-                    const index = tc.index ?? 0;
-                    // Get or create tool call entry
-                    if (!toolCallsMap.has(index)) {
-                        toolCallsMap.set(index, {
-                            id: tc.id,
-                            type: 'function',
-                            function: {
-                                name: tc.function?.name,
-                                arguments: tc.function?.arguments || '',
-                            },
-                        });
-                    }
-                    else {
-                        // Append to existing tool call (arguments stream incrementally)
-                        const existing = toolCallsMap.get(index);
-                        if (tc.id)
-                            existing.id = tc.id;
-                        if (tc.function?.name)
-                            existing.function.name = tc.function.name;
-                        if (tc.function?.arguments) {
-                            existing.function.arguments = (existing.function.arguments || '') + tc.function.arguments;
-                        }
-                    }
-                }
-            }
-        }
-        catch (error) {
-            console.error('[SSE Parser] Error parsing chunk:', error);
-        }
-    });
-    try {
-        while (true) {
-            // Check for abort before reading next chunk
-            if (abortSignal.aborted) {
-                break; // Exit gracefully with partial response
-            }
-            const { done, value } = await reader.read();
-            if (done)
-                break;
-            // Decode and feed to SSE parser
-            const text = decoder.decode(value, { stream: true });
-            // Debug log raw SSE chunk (level 2)
-            logLlamaToClient(text);
-            parser.feed(text);
-        }
-    }
-    catch (error) {
-        // If aborted, return partial response gracefully
-        if (error instanceof Error && error.name === 'AbortError') {
-            console.log(`[Job ${job.job_id}] Cancelled - returning partial response`);
-            // Don't throw - return what we have so far
-        }
-        else {
-            throw error; // Re-throw non-abort errors
-        }
-    }
-    finally {
-        reader.releaseLock();
-    }
-    // Use real timing data from llama.cpp if available
-    let durationMs;
-    let inputTokens;
-    let outputTokens;
-    if (timings) {
-        // TypeScript has narrowing issues with optional types in closures, so we explicitly type
-        const t = timings;
-        durationMs = Math.round(t.prompt_ms + t.predicted_ms);
-        inputTokens = t.prompt_n;
-        outputTokens = t.predicted_n;
-        console.log(`[Job ${job.job_id}] Completed in ${durationMs}ms (${inputTokens} prompt, ${outputTokens} predicted)`);
-    }
-    else {
-        // Fallback to estimates if no timing data
-        console.warn(`[Job ${job.job_id}] No timing data from llama.cpp`);
-        durationMs = Date.now() - startTime;
-        inputTokens = Math.ceil(JSON.stringify(job.messages).length / 4);
-        outputTokens = Math.ceil(fullResponse.length / 4);
-    }
-    // Convert tool calls map to array (if any)
-    const finalToolCalls = toolCallsMap.size > 0
-        ? Array.from(toolCallsMap.values())
-            .filter(tc => tc.id && tc.function.name) // Only include complete tool calls
-            .map(tc => ({
-            id: tc.id,
-            type: 'function',
-            function: {
-                name: tc.function.name,
-                arguments: tc.function.arguments || '{}',
-            },
-        }))
-        : undefined;
-    // Log tool calls if present
-    if (finalToolCalls && finalToolCalls.length > 0) {
-        console.log(`[Job ${job.job_id}] Detected ${finalToolCalls.length} tool call(s):`, finalToolCalls.map(tc => tc.function.name).join(', '));
-    }
-    return {
-        fullResponse,
-        durationMs,
-        inputTokens,
-        outputTokens,
-        tool_calls: finalToolCalls,
-    };
-}