@huydao/karrot 0.1.1 → 0.1.4

package/dist/executors/adapters/ag-ui.js

@@ -9,29 +9,57 @@ exports.extractAppendedLog = extractAppendedLog;
 exports.runAgUiMessage = runAgUiMessage;
 const promises_1 = __importDefault(require("node:fs/promises"));
 const node_path_1 = __importDefault(require("node:path"));
-const node_child_process_1 = require("node:child_process");
+const stompjs_1 = require("@stomp/stompjs");
+const uuid_1 = require("uuid");
+const ws_1 = __importDefault(require("ws"));
 const run_result_1 = require("../run-result");
-function getAgUiBinaryPath() {
-    const packageJsonPath = require.resolve('ag-ui-wss/package.json');
-    const packageDirectory = node_path_1.default.dirname(packageJsonPath);
-    const packageJson = JSON.parse(require('node:fs').readFileSync(packageJsonPath, 'utf8'));
-    const binaryRelativePath = packageJson.bin?.['ag-ui-wss'];
-    if (!binaryRelativePath) {
-        throw new Error(`Unable to resolve ag-ui-wss binary from ${packageJsonPath}.`);
-    }
-    return node_path_1.default.join(packageDirectory, binaryRelativePath);
+Object.assign(globalThis, { WebSocket: ws_1.default });
+function getEnv(name, env) {
+    const value = env[name];
+    return value && value.trim() ? value.trim() : undefined;
 }
-function parseThreadId(output) {
-    return output.match(/Thread:\s*([^\s]+)/)?.[1];
+function parseHeaderMap(raw) {
+    if (!raw?.trim()) {
+        return {};
+    }
+    const result = {};
+    for (const pair of raw.split(',')) {
+        const separatorIndex = pair.indexOf(':');
+        if (separatorIndex <= 0) {
+            continue;
+        }
+        const key = pair.slice(0, separatorIndex).trim();
+        const value = pair.slice(separatorIndex + 1).trim();
+        if (key && value) {
+            result[key] = value;
+        }
+    }
+    return result;
 }
-function extractStdoutAssistantText(output) {
-    const normalized = output.replace(/\r/g, '');
-    if (!normalized.trim()) {
-        return undefined;
+function parseAgUiEnv(env) {
+    const agentUrl = getEnv('AGENT_URL', env);
+    const wsUrl = getEnv('WS_URL', env);
+    const wsTopic = getEnv('WS_TOPIC', env);
+    if (!agentUrl) {
+        throw new Error('Missing AGENT_URL for AG-UI transport.');
     }
-    const withoutAnsi = normalized.replace(/\u001B\[[0-9;]*m/g, '');
-    const trimmed = withoutAnsi.trim();
-    return trimmed || undefined;
+    if (!wsUrl) {
+        throw new Error('Missing WS_URL for AG-UI transport.');
+    }
+    if (!wsTopic) {
+        throw new Error('Missing WS_TOPIC for AG-UI transport.');
+    }
+    const idleTimeoutRaw = Number(getEnv('IDLE_TIMEOUT', env) ?? 120_000);
+    return {
+        agentUrl,
+        agentId: getEnv('AGENT_ID', env) ?? 'orchestratorAgent',
+        wsUrl,
+        wsTopic,
+        idleTimeoutMs: Number.isFinite(idleTimeoutRaw) && idleTimeoutRaw > 0 ? idleTimeoutRaw : 120_000,
+        agentHeaders: parseHeaderMap(getEnv('AGENT_HEADERS', env)),
+        wsStompHeaders: parseHeaderMap(getEnv('WS_STOMP_HEADERS', env)),
+        wsHeaders: parseHeaderMap(getEnv('WS_HEADERS', env)),
+    };
 }
 function parseExecutionTestResultId(output) {
     const urlMatch = output.match(/\/test-results\/(\d+)/);
@@ -41,50 +69,6 @@ function parseExecutionTestResultId(output) {
     const plainMatch = output.match(/test result(?: ID)?\s+(\d{3,})/i);
     return plainMatch?.[1];
 }
-function parseTimingMetrics(output) {
-    const matches = [
-        ...output.matchAll(/(?:(?:TTF-Tool:\s*([\d.]+)s)\s*\|\s*)?TTF-Text:\s*([\d.]+)s\s*\|\s*Total:\s*([\d.]+)s\s*\|\s*Protocol efficiency:\s*([\d.]+)KB\/([\d.]+)KB\s*\((\d+)%\)/g),
-    ];
-    const match = matches.at(-1);
-    if (!match) {
-        return {};
-    }
-    return {
-        ttfToolSeconds: match[1] ? Number(match[1]) : undefined,
-        ttfTextSeconds: Number(match[2]),
-        totalSeconds: Number(match[3]),
-        protocolUsedKb: Number(match[4]),
-        protocolTotalKb: Number(match[5]),
-        efficiencyPercent: Number(match[6]),
-    };
-}
-function parseRunError(logContent) {
-    const lines = logContent
-        .split('\n')
-        .map((line) => line.trim())
-        .filter(Boolean);
-    for (let index = lines.length - 1; index >= 0; index -= 1) {
-        try {
-            const event = JSON.parse(lines[index]);
-            if (event.type === 'RUN_ERROR' && typeof event.error === 'string' && event.error.trim()) {
-                return event.error.trim();
-            }
-        }
-        catch {
-            // Ignore malformed lines in the JSONL stream.
-        }
-    }
-    return undefined;
-}
-function parseConsoleError(output) {
-    const matches = [...output.matchAll(/^Error:\s*(.+)$/gm)]
-        .map((match) => match[1].trim())
-        .filter((message) => message && message !== 'Agent run failed');
-    return matches.at(0);
-}
-function countToolCalls(logContent) {
-    return [...logContent.matchAll(/"type":"TOOL_CALL_START"/g)].length;
-}
 function extractToolCallNames(logContent) {
     const toolCalls = [];
     const lines = logContent
@@ -117,50 +101,49 @@ function extractAppendedLog(previousLogContent, latestLogContent) {
     }
     return latestLogContent;
 }
-function extractAssistantText(logContent) {
-    const fragmentsByMessage = new Map();
-    const orderedMessageIds = [];
-    let latestFullContent;
-    const lines = logContent
-        .split('\n')
-        .map((line) => line.trim())
-        .filter(Boolean);
-    for (const line of lines) {
-        try {
-            const event = JSON.parse(line);
-            if (!String(event.type).startsWith('TEXT_MESSAGE_')) {
-                continue;
-            }
-            const messageId = typeof event.messageId === 'string' && event.messageId.trim()
-                ? event.messageId.trim()
-                : '__default__';
-            if (!fragmentsByMessage.has(messageId)) {
-                fragmentsByMessage.set(messageId, []);
-                orderedMessageIds.push(messageId);
-            }
-            if (typeof event.content === 'string' && event.content.trim()) {
-                latestFullContent = event.content.trim();
-            }
-            if (typeof event.text === 'string' && event.text.trim()) {
-                latestFullContent = event.text.trim();
-            }
-            if (typeof event.delta === 'string' && event.delta.length > 0) {
-                fragmentsByMessage.get(messageId)?.push(event.delta);
-            }
-        }
-        catch {
-            // Ignore malformed JSONL lines.
-        }
+function getMessageId(event) {
+    return typeof event.messageId === 'string' && event.messageId.trim()
+        ? event.messageId.trim()
+        : '__default__';
+}
+function recordAssistantText(state, event) {
+    const messageId = getMessageId(event);
+    if (!state.fragmentsByMessage.has(messageId)) {
+        state.fragmentsByMessage.set(messageId, []);
+        state.orderedMessageIds.push(messageId);
+    }
+    if (typeof event.content === 'string' && event.content.trim()) {
+        state.latestFullContent = event.content.trim();
+    }
+    if (typeof event.text === 'string' && event.text.trim()) {
+        state.latestFullContent = event.text.trim();
     }
-    if (latestFullContent) {
-        return latestFullContent;
+    const fragment = typeof event.delta === 'string' && event.delta.length > 0
+        ? event.delta
+        : typeof event.content === 'string' && event.content.length > 0
+            ? event.content
+            : typeof event.text === 'string' && event.text.length > 0
+                ? event.text
+                : undefined;
+    if (fragment) {
+        state.fragmentsByMessage.get(messageId)?.push(fragment);
     }
-    const lastMessageId = orderedMessageIds.at(-1);
+}
+function getAssistantOutput(state) {
+    if (state.latestFullContent?.trim()) {
+        return state.latestFullContent.trim();
+    }
+    const lastMessageId = state.orderedMessageIds.at(-1);
     if (!lastMessageId) {
-        return undefined;
+        return '';
     }
-    const joined = fragmentsByMessage.get(lastMessageId)?.join('').trim();
-    return joined || undefined;
+    return state.fragmentsByMessage.get(lastMessageId)?.join('').trim() ?? '';
+}
+function countToolCalls(logContent) {
+    return [...logContent.matchAll(/"type":"TOOL_CALL_START"/g)].length;
+}
+async function appendEvent(logFilePath, event) {
+    await promises_1.default.appendFile(logFilePath, `${JSON.stringify(event)}\n`, 'utf8');
 }
 async function readJsonl(pathname) {
     try {
@@ -170,104 +153,314 @@ async function readJsonl(pathname) {
         return '';
     }
 }
-async function runAgUiMessage(options) {
-    await promises_1.default.mkdir(options.outputDirectory, { recursive: true });
-    const expectedThreadId = options.threadId;
-    const existingLogPath = expectedThreadId
-        ? node_path_1.default.join(options.outputDirectory, `${expectedThreadId}.jsonl`)
+function computeMetrics(state) {
+    const totalSeconds = Number(((Date.now() - state.startTimeMs) / 1000).toFixed(1));
+    const ttfTextSeconds = typeof state.firstTextTimeMs === 'number'
+        ? Number(((state.firstTextTimeMs - state.startTimeMs) / 1000).toFixed(1))
         : undefined;
-    const previousLogContent = existingLogPath ? await readJsonl(existingLogPath) : '';
-    const child = (0, node_child_process_1.spawn)(getAgUiBinaryPath(), expectedThreadId ? ['--thread', expectedThreadId, options.message] : [options.message], {
-        cwd: options.outputDirectory,
-        env: options.env,
-        stdio: ['ignore', 'pipe', 'pipe'],
-    });
-    let stdoutOutput = '';
-    let stderrOutput = '';
-    child.stdout.on('data', (chunk) => {
-        const text = chunk.toString();
-        stdoutOutput += text;
-        process.stdout.write(text);
-    });
-    child.stderr.on('data', (chunk) => {
-        const text = chunk.toString();
-        stderrOutput += text;
-        process.stderr.write(text);
+    const ttfToolSeconds = typeof state.firstToolTimeMs === 'number'
+        ? Number(((state.firstToolTimeMs - state.startTimeMs) / 1000).toFixed(1))
+        : undefined;
+    const protocolUsedKb = Number((state.protocolUsedBytes / 1024).toFixed(1));
+    const protocolTotalKb = Number((state.protocolTotalBytes / 1024).toFixed(1));
+    const efficiencyPercent = state.protocolTotalBytes > 0
+        ? Math.round((state.protocolUsedBytes / state.protocolTotalBytes) * 100)
+        : undefined;
+    return {
+        ttfToolSeconds,
+        ttfTextSeconds,
+        totalSeconds,
+        protocolUsedKb,
+        protocolTotalKb,
+        efficiencyPercent,
+    };
+}
+function writeMetricsToStdout(metrics) {
+    const parts = [
+        metrics.ttfToolSeconds != null ? `TTF-Tool: ${metrics.ttfToolSeconds.toFixed(1)}s` : undefined,
+        metrics.ttfTextSeconds != null ? `TTF-Text: ${metrics.ttfTextSeconds.toFixed(1)}s` : undefined,
+        metrics.totalSeconds != null ? `Total: ${metrics.totalSeconds.toFixed(1)}s` : undefined,
+        metrics.protocolUsedKb != null && metrics.protocolTotalKb != null && metrics.efficiencyPercent != null
+            ? `Protocol efficiency: ${metrics.protocolUsedKb.toFixed(1)}KB/${metrics.protocolTotalKb.toFixed(1)}KB (${metrics.efficiencyPercent}%)`
+            : undefined,
+    ].filter(Boolean);
+    if (parts.length > 0) {
+        process.stdout.write(`${parts.join('  |  ')}\n`);
+    }
+}
+function getEventIdentity(event) {
+    if (!event || typeof event !== 'object') {
+        return JSON.stringify(event);
+    }
+    const typedEvent = event;
+    return typedEvent.eventId ?? typedEvent.id ?? JSON.stringify(event);
+}
+async function connectAndRun(options) {
+    const state = {
+        seenEventIds: new Set(),
+        fragmentsByMessage: new Map(),
+        orderedMessageIds: [],
+        renderedContentByMessage: new Map(),
+        toolCalls: [],
+        protocolTotalBytes: 0,
+        protocolUsedBytes: 0,
+        startTimeMs: Date.now(),
+        runFinished: false,
+    };
+    await appendEvent(options.logFilePath, {
+        type: 'USER_MESSAGE',
+        timestamp: Date.now(),
+        content: options.message,
     });
-    const exitCode = await new Promise((resolve, reject) => {
-        let timedOut = false;
-        const timeoutId = typeof options.processTimeoutMs === 'number'
-            ? setTimeout(() => {
-                timedOut = true;
-                child.kill('SIGTERM');
-                setTimeout(() => child.kill('SIGKILL'), 5_000).unref();
-                reject(new run_result_1.MessageRunError(`ag-ui-wss exceeded ${options.processTimeoutMs}ms and was terminated.`, {
-                    threadId: parseThreadId(`${stderrOutput}\n${stdoutOutput}`) ?? expectedThreadId ?? options.threadIdFallback,
-                    output: extractStdoutAssistantText(stdoutOutput) ?? '',
-                }));
-            }, options.processTimeoutMs)
-            : undefined;
-        child.on('error', reject);
-        child.on('close', (code) => {
-            if (timeoutId) {
-                clearTimeout(timeoutId);
+    process.stderr.write(`Thread: ${options.threadId}\n`);
+    process.stderr.write('Connecting...\n');
+    return await new Promise((resolve, reject) => {
+        let settled = false;
+        let idleTimer;
+        let processTimer;
+        let responseDrainPromise;
+        let activeRunId;
+        const client = new stompjs_1.Client({
+            webSocketFactory: () => new ws_1.default(options.config.wsUrl, Object.keys(options.config.wsHeaders).length > 0
+                ? { headers: options.config.wsHeaders }
+                : undefined),
+            connectHeaders: options.config.wsStompHeaders,
+            reconnectDelay: 0,
+            debug: () => { },
+        });
+        const cleanup = async () => {
+            if (idleTimer) {
+                clearTimeout(idleTimer);
+            }
+            if (processTimer) {
+                clearTimeout(processTimer);
             }
-            if (timedOut) {
+            if (responseDrainPromise) {
+                await responseDrainPromise.catch(() => { });
+            }
+            if (client.active) {
+                await client.deactivate();
+            }
+        };
+        const finish = async (callback) => {
+            if (settled) {
                 return;
             }
-            resolve(code ?? 1);
-        });
+            settled = true;
+            await cleanup();
+            callback();
+        };
+        const onIdleTimeout = async () => {
+            const assistantOutput = getAssistantOutput(state);
+            if (assistantOutput.trim()) {
+                await finish(() => resolve(state));
+                return;
+            }
+            await finish(() => reject(new run_result_1.MessageRunError(`No events for ${Math.round(options.config.idleTimeoutMs / 1000)}s, idle timeout.`, {
+                threadId: options.threadId,
+                outputPath: options.logFilePath,
+                output: assistantOutput,
+                metrics: computeMetrics(state),
+                toolCallCount: state.toolCalls.length,
+                toolCalls: [...state.toolCalls],
+            })));
+        };
+        const resetIdleTimer = () => {
+            if (idleTimer) {
+                clearTimeout(idleTimer);
+            }
+            idleTimer = setTimeout(() => {
+                void onIdleTimeout();
+            }, options.config.idleTimeoutMs);
+        };
+        if (typeof options.processTimeoutMs === 'number') {
+            processTimer = setTimeout(() => {
+                void finish(() => reject(new run_result_1.MessageRunError(`AG-UI run exceeded ${options.processTimeoutMs}ms and was terminated.`, {
+                    threadId: options.threadId,
+                    outputPath: options.logFilePath,
+                    output: getAssistantOutput(state),
+                    metrics: computeMetrics(state),
+                    toolCallCount: state.toolCalls.length,
+                    toolCalls: [...state.toolCalls],
+                })));
+            }, options.processTimeoutMs);
+        }
+        client.onConnect = () => {
+            client.subscribe(options.config.wsTopic, (message) => {
+                resetIdleTimer();
+                state.protocolTotalBytes += Buffer.byteLength(message.body, 'utf8');
+                state.lastEventTimeMs = Date.now();
+                const payload = JSON.parse(message.body);
+                const additionalData = payload.additionalData;
+                if (!additionalData || (additionalData.conversationId && additionalData.conversationId !== options.threadId)) {
+                    return;
+                }
+                const events = Array.isArray(additionalData.events) ? additionalData.events : [];
+                for (const rawEvent of events) {
+                    const identity = getEventIdentity(rawEvent);
+                    if (state.seenEventIds.has(identity)) {
+                        continue;
+                    }
+                    state.seenEventIds.add(identity);
+                    state.protocolUsedBytes += Buffer.byteLength(JSON.stringify(rawEvent), 'utf8');
+                    void appendEvent(options.logFilePath, rawEvent);
+                    if (!rawEvent || typeof rawEvent !== 'object') {
+                        continue;
+                    }
+                    const event = rawEvent;
+                    const eventRunId = typeof event.runId === 'string' ? event.runId : undefined;
+                    if (!activeRunId) {
+                        if (eventRunId === options.runId) {
+                            activeRunId = eventRunId;
+                        }
+                        else if (event.type === 'RUN_STARTED' && eventRunId) {
+                            activeRunId = eventRunId;
+                        }
+                    }
+                    if (activeRunId && eventRunId && eventRunId !== activeRunId) {
+                        continue;
+                    }
+                    if (!activeRunId && eventRunId && eventRunId !== options.runId && event.type !== 'RUN_STARTED') {
+                        continue;
+                    }
+                    switch (event.type) {
+                        case 'TEXT_MESSAGE_CONTENT': {
+                            if (typeof state.firstTextTimeMs !== 'number') {
+                                state.firstTextTimeMs = Date.now();
+                            }
+                            const messageId = getMessageId(event);
+                            const renderedContent = typeof event.content === 'string' && event.content.length > 0
+                                ? event.content
+                                : typeof event.text === 'string' && event.text.length > 0
+                                    ? event.text
+                                    : typeof event.delta === 'string' && event.delta.length > 0
+                                        ? event.delta
+                                        : undefined;
+                            recordAssistantText(state, event);
+                            if (renderedContent) {
+                                const previousRenderedContent = state.renderedContentByMessage.get(messageId) ?? '';
+                                const appendedContent = extractAppendedLog(previousRenderedContent, renderedContent);
+                                state.renderedContentByMessage.set(messageId, renderedContent);
+                                if (appendedContent) {
+                                    process.stdout.write(appendedContent);
+                                }
+                            }
+                            break;
+                        }
+                        case 'TOOL_CALL_START':
+                            if (typeof state.firstToolTimeMs !== 'number') {
+                                state.firstToolTimeMs = Date.now();
+                            }
+                            if (typeof event.toolCallName === 'string' && event.toolCallName.trim()) {
+                                state.toolCalls.push(event.toolCallName.trim());
+                            }
+                            break;
+                        case 'RUN_ERROR':
+                            state.runError = typeof event.error === 'string' ? event.error.trim() : 'Agent run failed.';
+                            void finish(() => reject(new run_result_1.MessageRunError(state.runError ?? 'Agent run failed.', {
+                                threadId: options.threadId,
+                                outputPath: options.logFilePath,
+                                output: getAssistantOutput(state),
+                                metrics: computeMetrics(state),
+                                toolCallCount: state.toolCalls.length,
+                                toolCalls: [...state.toolCalls],
+                            })));
+                            return;
+                        case 'RUN_FINISHED':
+                            state.runFinished = true;
+                            process.stdout.write('\n');
+                            void finish(() => resolve(state));
+                            return;
+                        default:
+                            break;
+                    }
+                }
+            }, options.config.wsStompHeaders);
+            process.stderr.write('Sending...\n');
+            responseDrainPromise = (async () => {
+                const response = await fetch(`${options.config.agentUrl}/${options.config.agentId}/run`, {
+                    method: 'POST',
+                    headers: {
+                        'Content-Type': 'application/json',
+                        Accept: 'text/event-stream',
+                        ...options.config.agentHeaders,
+                    },
+                    body: JSON.stringify({
+                        threadId: options.threadId,
+                        runId: options.runId,
+                        messages: [{ id: Date.now().toString(), role: 'user', content: options.message }],
+                        tools: [],
+                        context: [],
+                        forwardedProps: {},
+                        state: {},
+                    }),
+                });
+                if (!response.ok) {
+                    const errorText = await response.text();
+                    throw new Error(`HTTP ${response.status}: ${errorText}`);
+                }
+                await response.text().catch(() => '');
+            })();
+            responseDrainPromise.catch((error) => {
+                void finish(() => reject(new run_result_1.MessageRunError(error instanceof Error ? error.message : String(error), {
+                    threadId: options.threadId,
+                    outputPath: options.logFilePath,
+                    output: getAssistantOutput(state),
+                    metrics: computeMetrics(state),
+                    toolCallCount: state.toolCalls.length,
+                    toolCalls: [...state.toolCalls],
+                })));
+            });
+        };
+        client.onStompError = (frame) => {
+            void finish(() => reject(new Error(`STOMP error: ${frame.headers.message ?? 'unknown'}`)));
+        };
+        client.onWebSocketError = (event) => {
+            const detail = event instanceof Error
+                ? event.message
+                : typeof event === 'object' && event !== null && 'message' in event
+                    ? String(event.message)
+                    : JSON.stringify(event);
+            void finish(() => reject(new Error(`WebSocket error: ${detail}`)));
+        };
+        resetIdleTimer();
+        client.activate();
     });
-    const combinedConsoleOutput = `${stderrOutput}\n${stdoutOutput}`;
-    const threadId = parseThreadId(combinedConsoleOutput) ?? expectedThreadId ?? options.threadIdFallback;
-    if (!threadId) {
-        throw new Error('Unable to parse the thread ID from ag-ui-wss output.');
-    }
+}
+async function runAgUiMessage(options) {
+    await promises_1.default.mkdir(options.outputDirectory, { recursive: true });
+    const config = parseAgUiEnv(options.env);
+    const threadId = options.threadId ?? options.threadIdFallback ?? (0, uuid_1.v7)();
+    const runId = (0, uuid_1.v7)();
     const logPath = node_path_1.default.join(options.outputDirectory, `${threadId}.jsonl`);
+    const previousLogContent = await readJsonl(logPath);
+    const state = await connectAndRun({
+        config,
+        logFilePath: logPath,
+        message: options.message,
+        threadId,
+        runId,
+        processTimeoutMs: options.processTimeoutMs,
+    });
+    const metrics = computeMetrics(state);
+    writeMetricsToStdout(metrics);
     const logContent = await readJsonl(logPath);
     const runLogContent = extractAppendedLog(previousLogContent, logContent);
-    const assistantOutput = extractAssistantText(runLogContent)
-        ?? extractAssistantText(logContent)
-        ?? extractStdoutAssistantText(stdoutOutput)
-        ?? '';
-    const metrics = parseTimingMetrics(combinedConsoleOutput);
+    const assistantOutput = getAssistantOutput(state);
     const toolCallCount = countToolCalls(runLogContent);
     const toolCalls = extractToolCallNames(runLogContent);
-    const hasAssistantTextEvent = /"type":"TEXT_MESSAGE_CONTENT"/.test(runLogContent)
-        || /"type":"TEXT_MESSAGE_CONTENT"/.test(logContent);
-    const missingAssistantTextNote = !assistantOutput.trim() && !hasAssistantTextEvent
-        ? 'Run finished without any assistant text content.'
-        : undefined;
-    if (exitCode !== 0) {
-        const hasRunError = runLogContent.includes('"type":"RUN_ERROR"');
-        const hasAssistantText = hasAssistantTextEvent || Boolean(extractStdoutAssistantText(stdoutOutput));
-        if (!hasRunError &&
-            hasAssistantText &&
-            combinedConsoleOutput.includes('idle timeout')) {
-            return {
-                output: assistantOutput,
-                threadId,
-                outputPath: logPath,
-                note: 'Assistant text received but the run did not emit RUN_FINISHED before idle timeout.',
-                toolCallCount,
-                toolCalls,
-                metrics,
-            };
-        }
-        throw new run_result_1.MessageRunError(parseRunError(runLogContent) ?? parseConsoleError(combinedConsoleOutput) ?? `ag-ui-wss exited with code ${exitCode}.`, {
-            threadId,
-            outputPath: logPath,
-            output: assistantOutput,
-            metrics,
-            toolCallCount,
-            toolCalls,
-        });
-    }
+    const note = !assistantOutput.trim()
+        ? state.runFinished
+            ? 'Run finished without any assistant text content.'
+            : 'Assistant text received but the run did not emit RUN_FINISHED before idle timeout.'
+        : !state.runFinished
+            ? 'Assistant text received but the run did not emit RUN_FINISHED before idle timeout.'
+            : undefined;
     return {
         output: assistantOutput,
         threadId,
         outputPath: logPath,
-        note: missingAssistantTextNote,
+        note,
         toolCallCount,
         toolCalls,
         metrics,

package/dist/executors/execute.js

@@ -67,8 +67,8 @@ function normalizeConfig(config) {
     if (!isAgUiWssConfig(config) && !isAgUiPostConfig(config)) {
         throw new Error(`Unsupported transport type "${config.transport.type}".`);
     }
-    if (!config.context.projectId || typeof config.context.projectId !== 'string') {
-        throw new Error('karrot config requires context.projectId.');
+    if (config.context != null && (typeof config.context !== 'object' || Array.isArray(config.context))) {
+        throw new Error('karrot config context must be an object when provided.');
     }
     return config;
 }
@@ -92,9 +92,10 @@ async function execute(configOrPath, options) {
         scenarioFile: scenarioSelection.file,
         defaultRelativePath: scenarioSelection.file,
     });
+    const baseContext = resolvedConfig.context ?? {};
     const context = {
-        ...scenarioModule.buildScenarioContext(resolvedConfig.context.projectId),
-        ...resolvedConfig.context,
+        ...scenarioModule.buildScenarioContext(baseContext),
+        ...baseContext,
     };
     const selectedScenarios = scenarioModule.scenarioSet.select(scenarioSelection.ids);
     if (selectedScenarios.length === 0) {