@iaforged/context-code 1.0.62 → 1.0.65

package/dist/src/utils/heapDumpService.js

@@ -1,202 +0,0 @@
-import { MACRO } from '../recovery/bunBundleShim.js';
-/**
- * Service for heap dump capture.
- * Used by the /heapdump command.
- */
-import { createWriteStream, writeFileSync } from 'fs';
-import { readdir, readFile, writeFile } from 'fs/promises';
-import { join } from 'path';
-import { pipeline } from 'stream/promises';
-import { getHeapSnapshot, getHeapSpaceStatistics, getHeapStatistics, } from 'v8';
-import { getSessionId } from '../bootstrap/state.js';
-import { logEvent } from '../services/analytics/index.js';
-import { logForDebugging } from './debug.js';
-import { toError } from './errors.js';
-import { getDesktopPath } from './file.js';
-import { getFsImplementation } from './fsOperations.js';
-import { logError } from './log.js';
-import { jsonStringify } from './slowOperations.js';
-/**
- * Capture memory diagnostics.
- * This helps identify if the leak is in V8 heap (captured) or native memory (not captured).
- */
-export async function captureMemoryDiagnostics(trigger, dumpNumber = 0) {
-    const usage = process.memoryUsage();
-    const heapStats = getHeapStatistics();
-    const resourceUsage = process.resourceUsage();
-    const uptimeSeconds = process.uptime();
-    // getHeapSpaceStatistics() is not available in Bun
-    let heapSpaceStats;
-    try {
-        heapSpaceStats = getHeapSpaceStatistics();
-    }
-    catch {
-        // Not available in Bun runtime
-    }
-    // Get active handles/requests count (these are internal APIs but stable)
-    const activeHandles = process._getActiveHandles().length;
-    const activeRequests = process._getActiveRequests().length;
-    // Try to count open file descriptors (Linux/macOS)
-    let openFileDescriptors;
-    try {
-        openFileDescriptors = (await readdir('/proc/self/fd')).length;
-    }
-    catch {
-        // Not on Linux - try macOS approach would require lsof, skip for now
-    }
-    // Try to read Linux smaps_rollup for detailed memory breakdown
-    let smapsRollup;
-    try {
-        smapsRollup = await readFile('/proc/self/smaps_rollup', 'utf8');
-    }
-    catch {
-        // Not on Linux or no access - this is fine
-    }
-    // Calculate native memory (RSS - heap) and growth rate
-    const nativeMemory = usage.rss - usage.heapUsed;
-    const bytesPerSecond = uptimeSeconds > 0 ? usage.rss / uptimeSeconds : 0;
-    const mbPerHour = (bytesPerSecond * 3600) / (1024 * 1024);
-    // Identify potential leaks
-    const potentialLeaks = [];
-    if (heapStats.number_of_detached_contexts > 0) {
-        potentialLeaks.push(`${heapStats.number_of_detached_contexts} detached context(s) - possible iframe/context leak`);
-    }
-    if (activeHandles > 100) {
-        potentialLeaks.push(`${activeHandles} active handles - possible timer/socket leak`);
-    }
-    if (nativeMemory > usage.heapUsed) {
-        potentialLeaks.push('Native memory > heap - leak may be in native addons (node-pty, sharp, etc.)');
-    }
-    if (mbPerHour > 100) {
-        potentialLeaks.push(`High memory growth rate: ${mbPerHour.toFixed(1)} MB/hour`);
-    }
-    if (openFileDescriptors && openFileDescriptors > 500) {
-        potentialLeaks.push(`${openFileDescriptors} open file descriptors - possible file/socket leak`);
-    }
-    return {
-        timestamp: new Date().toISOString(),
-        sessionId: getSessionId(),
-        trigger,
-        dumpNumber,
-        uptimeSeconds,
-        memoryUsage: {
-            heapUsed: usage.heapUsed,
-            heapTotal: usage.heapTotal,
-            external: usage.external,
-            arrayBuffers: usage.arrayBuffers,
-            rss: usage.rss,
-        },
-        memoryGrowthRate: {
-            bytesPerSecond,
-            mbPerHour,
-        },
-        v8HeapStats: {
-            heapSizeLimit: heapStats.heap_size_limit,
-            mallocedMemory: heapStats.malloced_memory,
-            peakMallocedMemory: heapStats.peak_malloced_memory,
-            detachedContexts: heapStats.number_of_detached_contexts,
-            nativeContexts: heapStats.number_of_native_contexts,
-        },
-        v8HeapSpaces: heapSpaceStats?.map(space => ({
-            name: space.space_name,
-            size: space.space_size,
-            used: space.space_used_size,
-            available: space.space_available_size,
-        })),
-        resourceUsage: {
-            maxRSS: resourceUsage.maxRSS * 1024, // Convert KB to bytes
-            userCPUTime: resourceUsage.userCPUTime,
-            systemCPUTime: resourceUsage.systemCPUTime,
-        },
-        activeHandles,
-        activeRequests,
-        openFileDescriptors,
-        analysis: {
-            potentialLeaks,
-            recommendation: potentialLeaks.length > 0
-                ? `WARNING: ${potentialLeaks.length} potential leak indicator(s) found. See potentialLeaks array.`
-                : 'No obvious leak indicators. Check heap snapshot for retained objects.',
-        },
-        smapsRollup,
-        platform: process.platform,
-        nodeVersion: process.version,
-        ccVersion: MACRO.VERSION,
-    };
-}
-/**
- * Core heap dump function — captures heap snapshot + diagnostics to ~/Desktop.
- *
- * Diagnostics are written BEFORE the heap snapshot is captured, because the
- * V8 heap snapshot serialization can crash for very large heaps. By writing
- * diagnostics first, we still get useful memory info even if the snapshot fails.
- */
-export async function performHeapDump(trigger = 'manual', dumpNumber = 0) {
-    try {
-        const sessionId = getSessionId();
-        // Capture diagnostics before any other async I/O —
-        // the heap dump itself allocates memory and would skew the numbers.
-        const diagnostics = await captureMemoryDiagnostics(trigger, dumpNumber);
-        const toGB = (bytes) => (bytes / 1024 / 1024 / 1024).toFixed(3);
-        logForDebugging(`[HeapDump] Memory state:
-  heapUsed: ${toGB(diagnostics.memoryUsage.heapUsed)} GB (in snapshot)
-  external: ${toGB(diagnostics.memoryUsage.external)} GB (NOT in snapshot)
-  rss: ${toGB(diagnostics.memoryUsage.rss)} GB (total process)
-  ${diagnostics.analysis.recommendation}`);
-        const dumpDir = getDesktopPath();
-        await getFsImplementation().mkdir(dumpDir);
-        const suffix = dumpNumber > 0 ? `-dump${dumpNumber}` : '';
-        const heapFilename = `${sessionId}${suffix}.heapsnapshot`;
-        const diagFilename = `${sessionId}${suffix}-diagnostics.json`;
-        const heapPath = join(dumpDir, heapFilename);
-        const diagPath = join(dumpDir, diagFilename);
-        // Write diagnostics first (cheap, unlikely to fail)
-        await writeFile(diagPath, jsonStringify(diagnostics, null, 2), {
-            mode: 0o600,
-        });
-        logForDebugging(`[HeapDump] Diagnostics written to ${diagPath}`);
-        // Write heap snapshot (this can crash for very large heaps)
-        await writeHeapSnapshot(heapPath);
-        logForDebugging(`[HeapDump] Heap dump written to ${heapPath}`);
-        logEvent('tengu_heap_dump', {
-            triggerManual: trigger === 'manual',
-            triggerAuto15GB: trigger === 'auto-1.5GB',
-            dumpNumber,
-            success: true,
-        });
-        return { success: true, heapPath, diagPath };
-    }
-    catch (err) {
-        const error = toError(err);
-        logError(error);
-        logEvent('tengu_heap_dump', {
-            triggerManual: trigger === 'manual',
-            triggerAuto15GB: trigger === 'auto-1.5GB',
-            dumpNumber,
-            success: false,
-        });
-        return { success: false, error: error.message };
-    }
-}
-/**
- * Write heap snapshot to a file.
- * Uses pipeline() which handles stream cleanup automatically on errors.
- */
-async function writeHeapSnapshot(filepath) {
-    if (typeof Bun !== 'undefined') {
-        // In Bun, heapsnapshots are currently not streaming.
-        // Use synchronous I/O despite potentially large filesize so that we avoid cloning the string for cross-thread usage.
-        //
-        /* eslint-disable custom-rules/no-sync-fs -- intentionally sync to avoid cloning large heap snapshot string for cross-thread usage */
-        // @ts-expect-error 2nd argument is in the next version of Bun
-        writeFileSync(filepath, Bun.generateHeapSnapshot('v8', 'arraybuffer'), {
-            mode: 0o600,
-        });
-        /* eslint-enable custom-rules/no-sync-fs */
-        // Force GC to try to free that heap snapshot sooner.
-        Bun.gc(true);
-        return;
-    }
-    const writeStream = createWriteStream(filepath, { mode: 0o600 });
-    const heapSnapshotStream = getHeapSnapshot();
-    await pipeline(heapSnapshotStream, writeStream);
-}

package/dist/src/utils/heatmap.js

@@ -1,151 +0,0 @@
-import chalk from 'chalk';
-import { toDateString } from './statsCache.js';
-/**
- * Pre-calculates percentiles from activity data for use in intensity calculations
- */
-function calculatePercentiles(dailyActivity) {
-    const counts = dailyActivity
-        .map(a => a.messageCount)
-        .filter(c => c > 0)
-        .sort((a, b) => a - b);
-    if (counts.length === 0)
-        return null;
-    return {
-        p25: counts[Math.floor(counts.length * 0.25)],
-        p50: counts[Math.floor(counts.length * 0.5)],
-        p75: counts[Math.floor(counts.length * 0.75)],
-    };
-}
-/**
- * Generates a GitHub-style activity heatmap for the terminal
- */
-export function generateHeatmap(dailyActivity, options = {}) {
-    const { terminalWidth = 80, showMonthLabels = true } = options;
-    // Day labels take 4 characters ("Mon "), calculate weeks that fit
-    // Cap at 52 weeks (1 year) to match GitHub style
-    const dayLabelWidth = 4;
-    const availableWidth = terminalWidth - dayLabelWidth;
-    const width = Math.min(52, Math.max(10, availableWidth));
-    // Build activity map by date
-    const activityMap = new Map();
-    for (const activity of dailyActivity) {
-        activityMap.set(activity.date, activity);
-    }
-    // Pre-calculate percentiles once for all intensity lookups
-    const percentiles = calculatePercentiles(dailyActivity);
-    // Calculate date range - end at today, go back N weeks
-    const today = new Date();
-    today.setHours(0, 0, 0, 0);
-    // Find the Sunday of the current week (start of the week containing today)
-    const currentWeekStart = new Date(today);
-    currentWeekStart.setDate(today.getDate() - today.getDay());
-    // Go back (width - 1) weeks from the current week start
-    const startDate = new Date(currentWeekStart);
-    startDate.setDate(startDate.getDate() - (width - 1) * 7);
-    // Generate grid (7 rows for days of week, width columns for weeks)
-    // Also track which week each month starts for labels
-    const grid = Array.from({ length: 7 }, () => Array(width).fill(''));
-    const monthStarts = [];
-    let lastMonth = -1;
-    const currentDate = new Date(startDate);
-    for (let week = 0; week < width; week++) {
-        for (let day = 0; day < 7; day++) {
-            // Don't show future dates
-            if (currentDate > today) {
-                grid[day][week] = ' ';
-                currentDate.setDate(currentDate.getDate() + 1);
-                continue;
-            }
-            const dateStr = toDateString(currentDate);
-            const activity = activityMap.get(dateStr);
-            // Track month changes (on day 0 = Sunday of each week)
-            if (day === 0) {
-                const month = currentDate.getMonth();
-                if (month !== lastMonth) {
-                    monthStarts.push({ month, week });
-                    lastMonth = month;
-                }
-            }
-            // Determine intensity level based on message count
-            const intensity = getIntensity(activity?.messageCount || 0, percentiles);
-            grid[day][week] = getHeatmapChar(intensity);
-            currentDate.setDate(currentDate.getDate() + 1);
-        }
-    }
-    // Build output
-    const lines = [];
-    // Month labels - evenly spaced across the grid
-    if (showMonthLabels) {
-        const monthNames = [
-            'Jan',
-            'Feb',
-            'Mar',
-            'Apr',
-            'May',
-            'Jun',
-            'Jul',
-            'Aug',
-            'Sep',
-            'Oct',
-            'Nov',
-            'Dec',
-        ];
-        // Build label line with fixed-width month labels
-        const uniqueMonths = monthStarts.map(m => m.month);
-        const labelWidth = Math.floor(width / Math.max(uniqueMonths.length, 1));
-        const monthLabels = uniqueMonths
-            .map(month => monthNames[month].padEnd(labelWidth))
-            .join('');
-        // 4 spaces for day label column prefix
-        lines.push('    ' + monthLabels);
-    }
-    // Day labels
-    const dayLabels = ['Sun', 'Mon', 'Tue', 'Wed', 'Thu', 'Fri', 'Sat'];
-    // Grid
-    for (let day = 0; day < 7; day++) {
-        // Only show labels for Mon, Wed, Fri
-        const label = [1, 3, 5].includes(day) ? dayLabels[day].padEnd(3) : '   ';
-        const row = label + ' ' + grid[day].join('');
-        lines.push(row);
-    }
-    // Legend
-    lines.push('');
-    lines.push('    Less ' +
-        [
-            claudeOrange('░'),
-            claudeOrange('▒'),
-            claudeOrange('▓'),
-            claudeOrange('█'),
-        ].join(' ') +
-        ' More');
-    return lines.join('\n');
-}
-function getIntensity(messageCount, percentiles) {
-    if (messageCount === 0 || !percentiles)
-        return 0;
-    if (messageCount >= percentiles.p75)
-        return 4;
-    if (messageCount >= percentiles.p50)
-        return 3;
-    if (messageCount >= percentiles.p25)
-        return 2;
-    return 1;
-}
-// Claude orange color (hex #da7756)
-const claudeOrange = chalk.hex('#da7756');
-function getHeatmapChar(intensity) {
-    switch (intensity) {
-        case 0:
-            return chalk.gray('·');
-        case 1:
-            return claudeOrange('░');
-        case 2:
-            return claudeOrange('▒');
-        case 3:
-            return claudeOrange('▓');
-        case 4:
-            return claudeOrange('█');
-        default:
-            return chalk.gray('·');
-    }
-}

package/dist/src/utils/highlightMatch.js

@@ -1,28 +0,0 @@
-import { jsx as _jsx, Fragment as _Fragment } from "react/jsx-runtime";
-import { Text } from '../ink.js';
-/**
- * Inverse-highlight every occurrence of `query` in `text` (case-insensitive).
- * Used by search dialogs to show where the query matched in result rows
- * and preview panes.
- */
-export function highlightMatch(text, query) {
-    if (!query)
-        return text;
-    const queryLower = query.toLowerCase();
-    const textLower = text.toLowerCase();
-    const parts = [];
-    let offset = 0;
-    let idx = textLower.indexOf(queryLower, offset);
-    if (idx === -1)
-        return text;
-    while (idx !== -1) {
-        if (idx > offset)
-            parts.push(text.slice(offset, idx));
-        parts.push(_jsx(Text, { inverse: true, children: text.slice(idx, idx + query.length) }, idx));
-        offset = idx + query.length;
-        idx = textLower.indexOf(queryLower, offset);
-    }
-    if (offset < text.length)
-        parts.push(text.slice(offset));
-    return _jsx(_Fragment, { children: parts });
-}

package/dist/src/utils/hooks/AsyncHookRegistry.js

@@ -1,187 +0,0 @@
-import { logForDebugging } from '../debug.js';
-import { invalidateSessionEnvCache } from '../sessionEnvironment.js';
-import { jsonParse, jsonStringify } from '../slowOperations.js';
-import { emitHookResponse, startHookProgressInterval } from './hookEvents.js';
-// Global registry state
-const pendingHooks = new Map();
-export function registerPendingAsyncHook({ processId, hookId, asyncResponse, hookName, hookEvent, command, shellCommand, toolName, pluginId, }) {
-    const timeout = asyncResponse.asyncTimeout || 15000; // Default 15s
-    logForDebugging(`Hooks: Registering async hook ${processId} (${hookName}) with timeout ${timeout}ms`);
-    const stopProgressInterval = startHookProgressInterval({
-        hookId,
-        hookName,
-        hookEvent,
-        getOutput: async () => {
-            const taskOutput = pendingHooks.get(processId)?.shellCommand?.taskOutput;
-            if (!taskOutput) {
-                return { stdout: '', stderr: '', output: '' };
-            }
-            const stdout = await taskOutput.getStdout();
-            const stderr = taskOutput.getStderr();
-            return { stdout, stderr, output: stdout + stderr };
-        },
-    });
-    pendingHooks.set(processId, {
-        processId,
-        hookId,
-        hookName,
-        hookEvent,
-        toolName,
-        pluginId,
-        command,
-        startTime: Date.now(),
-        timeout,
-        responseAttachmentSent: false,
-        shellCommand,
-        stopProgressInterval,
-    });
-}
-export function getPendingAsyncHooks() {
-    return Array.from(pendingHooks.values()).filter(hook => !hook.responseAttachmentSent);
-}
-async function finalizeHook(hook, exitCode, outcome) {
-    hook.stopProgressInterval();
-    const taskOutput = hook.shellCommand?.taskOutput;
-    const stdout = taskOutput ? await taskOutput.getStdout() : '';
-    const stderr = taskOutput?.getStderr() ?? '';
-    hook.shellCommand?.cleanup();
-    emitHookResponse({
-        hookId: hook.hookId,
-        hookName: hook.hookName,
-        hookEvent: hook.hookEvent,
-        output: stdout + stderr,
-        stdout,
-        stderr,
-        exitCode,
-        outcome,
-    });
-}
-export async function checkForAsyncHookResponses() {
-    const responses = [];
-    const pendingCount = pendingHooks.size;
-    logForDebugging(`Hooks: Found ${pendingCount} total hooks in registry`);
-    // Snapshot hooks before processing — we'll mutate the map after.
-    const hooks = Array.from(pendingHooks.values());
-    const settled = await Promise.allSettled(hooks.map(async (hook) => {
-        const stdout = (await hook.shellCommand?.taskOutput.getStdout()) ?? '';
-        const stderr = hook.shellCommand?.taskOutput.getStderr() ?? '';
-        logForDebugging(`Hooks: Checking hook ${hook.processId} (${hook.hookName}) - attachmentSent: ${hook.responseAttachmentSent}, stdout length: ${stdout.length}`);
-        if (!hook.shellCommand) {
-            logForDebugging(`Hooks: Hook ${hook.processId} has no shell command, removing from registry`);
-            hook.stopProgressInterval();
-            return { type: 'remove', processId: hook.processId };
-        }
-        logForDebugging(`Hooks: Hook shell status ${hook.shellCommand.status}`);
-        if (hook.shellCommand.status === 'killed') {
-            logForDebugging(`Hooks: Hook ${hook.processId} is ${hook.shellCommand.status}, removing from registry`);
-            hook.stopProgressInterval();
-            hook.shellCommand.cleanup();
-            return { type: 'remove', processId: hook.processId };
-        }
-        if (hook.shellCommand.status !== 'completed') {
-            return { type: 'skip' };
-        }
-        if (hook.responseAttachmentSent || !stdout.trim()) {
-            logForDebugging(`Hooks: Skipping hook ${hook.processId} - already delivered/sent or no stdout`);
-            hook.stopProgressInterval();
-            return { type: 'remove', processId: hook.processId };
-        }
-        const lines = stdout.split('\n');
-        logForDebugging(`Hooks: Processing ${lines.length} lines of stdout for ${hook.processId}`);
-        const execResult = await hook.shellCommand.result;
-        const exitCode = execResult.code;
-        let response = {};
-        for (const line of lines) {
-            if (line.trim().startsWith('{')) {
-                logForDebugging(`Hooks: Found JSON line: ${line.trim().substring(0, 100)}...`);
-                try {
-                    const parsed = jsonParse(line.trim());
-                    if (!('async' in parsed)) {
-                        logForDebugging(`Hooks: Found sync response from ${hook.processId}: ${jsonStringify(parsed)}`);
-                        response = parsed;
-                        break;
-                    }
-                }
-                catch {
-                    logForDebugging(`Hooks: Failed to parse JSON from ${hook.processId}: ${line.trim()}`);
-                }
-            }
-        }
-        hook.responseAttachmentSent = true;
-        await finalizeHook(hook, exitCode, exitCode === 0 ? 'success' : 'error');
-        return {
-            type: 'response',
-            processId: hook.processId,
-            isSessionStart: hook.hookEvent === 'SessionStart',
-            payload: {
-                processId: hook.processId,
-                response,
-                hookName: hook.hookName,
-                hookEvent: hook.hookEvent,
-                toolName: hook.toolName,
-                pluginId: hook.pluginId,
-                stdout,
-                stderr,
-                exitCode,
-            },
-        };
-    }));
-    // allSettled — isolate failures so one throwing callback doesn't orphan
-    // already-applied side effects (responseAttachmentSent, finalizeHook) from others.
-    let sessionStartCompleted = false;
-    for (const s of settled) {
-        if (s.status !== 'fulfilled') {
-            logForDebugging(`Hooks: checkForAsyncHookResponses callback rejected: ${s.reason}`, { level: 'error' });
-            continue;
-        }
-        const r = s.value;
-        if (r.type === 'remove') {
-            pendingHooks.delete(r.processId);
-        }
-        else if (r.type === 'response') {
-            responses.push(r.payload);
-            pendingHooks.delete(r.processId);
-            if (r.isSessionStart)
-                sessionStartCompleted = true;
-        }
-    }
-    if (sessionStartCompleted) {
-        logForDebugging(`Invalidating session env cache after SessionStart hook completed`);
-        invalidateSessionEnvCache();
-    }
-    logForDebugging(`Hooks: checkForNewResponses returning ${responses.length} responses`);
-    return responses;
-}
-export function removeDeliveredAsyncHooks(processIds) {
-    for (const processId of processIds) {
-        const hook = pendingHooks.get(processId);
-        if (hook && hook.responseAttachmentSent) {
-            logForDebugging(`Hooks: Removing delivered hook ${processId}`);
-            hook.stopProgressInterval();
-            pendingHooks.delete(processId);
-        }
-    }
-}
-export async function finalizePendingAsyncHooks() {
-    const hooks = Array.from(pendingHooks.values());
-    await Promise.all(hooks.map(async (hook) => {
-        if (hook.shellCommand?.status === 'completed') {
-            const result = await hook.shellCommand.result;
-            await finalizeHook(hook, result.code, result.code === 0 ? 'success' : 'error');
-        }
-        else {
-            if (hook.shellCommand && hook.shellCommand.status !== 'killed') {
-                hook.shellCommand.kill();
-            }
-            await finalizeHook(hook, 1, 'cancelled');
-        }
-    }));
-    pendingHooks.clear();
-}
-// Test utility function to clear all hooks
-export function clearAllAsyncHooks() {
-    for (const hook of pendingHooks.values()) {
-        hook.stopProgressInterval();
-    }
-    pendingHooks.clear();
-}

package/dist/src/utils/hooks/apiQueryHookHelper.js

@@ -1,77 +0,0 @@
-import { randomUUID } from 'crypto';
-import { queryModelWithoutStreaming } from '../../services/api/claude.js';
-import { createAbortController } from '../../utils/abortController.js';
-import { logError } from '../../utils/log.js';
-import { toError } from '../errors.js';
-import { extractTextContent } from '../messages.js';
-import { asSystemPrompt } from '../systemPromptType.js';
-export function createApiQueryHook(config) {
-    return async (context) => {
-        try {
-            const shouldRun = await config.shouldRun(context);
-            if (!shouldRun) {
-                return;
-            }
-            const uuid = randomUUID();
-            // Build messages using the config's buildMessages function
-            const messages = config.buildMessages(context);
-            context.queryMessageCount = messages.length;
-            // Use config's system prompt if provided, otherwise use context's
-            const systemPrompt = config.systemPrompt
-                ? asSystemPrompt([config.systemPrompt])
-                : context.systemPrompt;
-            // Use config's tools preference (defaults to true = use context tools)
-            const useTools = config.useTools ?? true;
-            const tools = useTools ? context.toolUseContext.options.tools : [];
-            // Get model (lazy loaded)
-            const model = config.getModel(context);
-            // Make API call
-            const response = await queryModelWithoutStreaming({
-                messages,
-                systemPrompt,
-                thinkingConfig: { type: 'disabled' },
-                tools,
-                signal: createAbortController().signal,
-                options: {
-                    getToolPermissionContext: async () => {
-                        const appState = context.toolUseContext.getAppState();
-                        return appState.toolPermissionContext;
-                    },
-                    model,
-                    toolChoice: undefined,
-                    isNonInteractiveSession: context.toolUseContext.options.isNonInteractiveSession,
-                    hasAppendSystemPrompt: !!context.toolUseContext.options.appendSystemPrompt,
-                    temperatureOverride: 0,
-                    agents: context.toolUseContext.options.agentDefinitions.activeAgents,
-                    querySource: config.name,
-                    mcpTools: [],
-                    agentId: context.toolUseContext.agentId,
-                },
-            });
-            // Parse response
-            const content = extractTextContent(response.message.content).trim();
-            try {
-                const result = config.parseResponse(content, context);
-                config.logResult({
-                    type: 'success',
-                    queryName: config.name,
-                    result,
-                    messageId: response.message.id,
-                    model,
-                    uuid,
-                }, context);
-            }
-            catch (error) {
-                config.logResult({
-                    type: 'error',
-                    queryName: config.name,
-                    error: error,
-                    uuid,
-                }, context);
-            }
-        }
-        catch (error) {
-            logError(toError(error));
-        }
-    };
-}