@huydao/karrot 0.1.6 → 0.1.8

package/dist/executors/adapters/ag-ui-post.d.ts

@@ -6,6 +6,7 @@ export type RunAgUiPostMessageOptions = {
     processTimeoutMs?: number;
     injectMessage?: boolean;
     injectRunMetadata?: boolean;
+    textEvents?: AgUiPostTextEventConfig[];
     run?: {
         url: string;
         headers?: Record<string, string>;
@@ -52,4 +53,13 @@ export type RunAgUiPostMessageOptions = {
         timeoutMs?: number;
     };
 };
+export type AgUiPostTextEventConfig = {
+    type: string;
+    name?: string;
+    role?: string;
+    textPath?: string;
+    contentPath?: string;
+    deltaPath?: string;
+    mode?: 'content' | 'delta';
+};
 export declare function runAgUiPostMessage(options: RunAgUiPostMessageOptions): Promise<MessageRunResult>;

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

@@ -56,6 +56,13 @@ function getStringAtPath(payload, pathExpression) {
     const rawValue = getValueByPath(payload, pathExpression);
     return typeof rawValue === 'string' ? rawValue.trim() : '';
 }
+function getRawStringAtPath(payload, pathExpression) {
+    if (!pathExpression) {
+        return '';
+    }
+    const rawValue = getValueByPath(payload, pathExpression);
+    return typeof rawValue === 'string' ? rawValue : '';
+}
 function getArrayAtPath(payload, pathExpression) {
     const rawValue = getValueByPath(payload, pathExpression);
     return Array.isArray(rawValue) ? rawValue : [];
@@ -258,6 +265,100 @@ function parseSseBlock(block) {
         data: dataLines.join('\n'),
     };
 }
+function normalizeEventTimestamp(value) {
+    if (typeof value === 'number' && Number.isFinite(value)) {
+        return value > 10_000_000_000 ? value : value * 1000;
+    }
+    if (typeof value === 'string' && value.trim()) {
+        const numeric = Number(value);
+        if (Number.isFinite(numeric)) {
+            return numeric > 10_000_000_000 ? numeric : numeric * 1000;
+        }
+        const parsed = Date.parse(value);
+        return Number.isFinite(parsed) ? parsed : undefined;
+    }
+    return undefined;
+}
+function roundSeconds(startTimeMs, endTimeMs) {
+    if (typeof startTimeMs !== 'number' || typeof endTimeMs !== 'number' || endTimeMs < startTimeMs) {
+        return undefined;
+    }
+    return Number(((endTimeMs - startTimeMs) / 1000).toFixed(1));
+}
+function isStandardAssistantTextEvent(event) {
+    return (event.type === 'TEXT_MESSAGE_CONTENT' ||
+        event.type === 'TEXT_MESSAGE_CHUNK');
+}
+function isToolStartEvent(event) {
+    return (event.type === 'TOOL_CALL_START' ||
+        (event.type === 'CUSTOM' && event.name === 'super-testing-agent.tool_started'));
+}
+function matchesConfiguredTextEvent(event, config) {
+    if (event.type !== config.type) {
+        return false;
+    }
+    if (config.name != null && event.name !== config.name) {
+        return false;
+    }
+    if (config.role != null && event.role !== config.role) {
+        return false;
+    }
+    return true;
+}
+function getConfiguredTextEventValue(event, textEvents) {
+    for (const config of textEvents ?? []) {
+        if (!matchesConfiguredTextEvent(event, config)) {
+            continue;
+        }
+        const content = getRawStringAtPath(event, config.contentPath);
+        if (content.trim()) {
+            return { content: content.trim() };
+        }
+        const delta = getRawStringAtPath(event, config.deltaPath);
+        if (delta) {
+            return { delta };
+        }
+        const text = getRawStringAtPath(event, config.textPath);
+        if (!text) {
+            return {};
+        }
+        return config.mode === 'content' ? { content: text.trim() } : { delta: text };
+    }
+    return {};
+}
+function isAssistantTextEvent(event, textEvents) {
+    return (isStandardAssistantTextEvent(event) ||
+        Boolean((textEvents ?? []).find((config) => matchesConfiguredTextEvent(event, config))));
+}
+function getAssistantContent(event, textEvents) {
+    const configured = getConfiguredTextEventValue(event, textEvents);
+    if (configured.content) {
+        return configured.content;
+    }
+    if (typeof event.content === 'string' && event.content.trim()) {
+        return event.content.trim();
+    }
+    if (typeof event.value?.content === 'string' && event.value.content.trim()) {
+        return event.value.content.trim();
+    }
+    if (typeof event.value?.output === 'string' && event.value.output.trim()) {
+        return event.value.output.trim();
+    }
+    return undefined;
+}
+function getAssistantDelta(event, textEvents) {
+    const configured = getConfiguredTextEventValue(event, textEvents);
+    if (configured.delta) {
+        return configured.delta;
+    }
+    if (typeof event.delta === 'string' && event.delta) {
+        return event.delta;
+    }
+    if (typeof event.value?.delta === 'string' && event.value.delta) {
+        return event.value.delta;
+    }
+    return undefined;
+}
 function createConnectCollector(options) {
     const assistantFragments = [];
     const toolCalls = [];
@@ -266,6 +367,11 @@ function createConnectCollector(options) {
     let started = false;
     let finished = false;
     let sawAnyEvent = false;
+    let runStartedAt;
+    let firstTextAt;
+    let firstToolAt;
+    let runFinishedAt;
+    const eventTime = (event) => normalizeEventTimestamp(event.timestamp) ?? Date.now();
     const consume = (sseEvent) => {
         if (!sseEvent.data) {
             return false;
@@ -286,6 +392,7 @@ function createConnectCollector(options) {
         }
         if (parsed.type === 'RUN_STARTED' && parsed.runId === options.targetRunId) {
             started = true;
+            runStartedAt = eventTime(parsed);
             return false;
         }
         if (!started) {
@@ -300,19 +407,26 @@ function createConnectCollector(options) {
             });
         }
         const isAssistantMessage = parsed.role === 'assistant' || typeof parsed.role !== 'string';
-        if ((parsed.type === 'TEXT_MESSAGE_CHUNK' || parsed.type === 'TEXT_MESSAGE_CONTENT') && isAssistantMessage) {
-            if (typeof parsed.content === 'string' && parsed.content.trim()) {
-                latestAssistantContent = parsed.content.trim();
+        if (isAssistantTextEvent(parsed, options.textEvents) && isAssistantMessage) {
+            firstTextAt ??= eventTime(parsed);
+            const content = getAssistantContent(parsed, options.textEvents);
+            const delta = getAssistantDelta(parsed, options.textEvents);
+            if (content) {
+                latestAssistantContent = content;
             }
-            else if (typeof parsed.delta === 'string' && parsed.delta) {
-                assistantFragments.push(parsed.delta);
+            else if (delta) {
+                assistantFragments.push(delta);
             }
         }
-        if (parsed.type === 'TOOL_CALL_START' && typeof parsed.toolCallName === 'string' && parsed.toolCallName.trim()) {
-            toolCalls.push(parsed.toolCallName.trim());
+        if (isToolStartEvent(parsed)) {
+            firstToolAt ??= eventTime(parsed);
+            if (typeof parsed.toolCallName === 'string' && parsed.toolCallName.trim()) {
+                toolCalls.push(parsed.toolCallName.trim());
+            }
         }
         if (parsed.type === 'RUN_FINISHED' && (!parsed.runId || parsed.runId === options.targetRunId)) {
             finished = true;
+            runFinishedAt = eventTime(parsed);
             return true;
         }
         return false;
@@ -320,12 +434,19 @@ function createConnectCollector(options) {
     return {
         consume,
         getResult() {
+            const turnCompleteSeconds = roundSeconds(runStartedAt, runFinishedAt);
             return {
                 output: latestAssistantContent?.trim() || assistantFragments.join('').trim(),
                 toolCalls: [...toolCalls],
                 threadId: resolvedThreadId,
                 finished,
                 sawAnyEvent,
+                metrics: {
+                    ttfTextSeconds: roundSeconds(runStartedAt, firstTextAt),
+                    ttfToolSeconds: roundSeconds(runStartedAt, firstToolAt),
+                    turnCompleteSeconds,
+                    totalSeconds: turnCompleteSeconds,
+                },
             };
         },
     };
@@ -337,6 +458,7 @@ async function postAndCaptureResponse(options) {
         : undefined;
     try {
         await promises_1.default.writeFile(options.outputPath, '', 'utf8');
+        const startedAtMs = Date.now();
         const response = await fetch(options.url, {
             method: 'POST',
             headers: {
@@ -369,6 +491,8 @@ async function postAndCaptureResponse(options) {
         return {
             status: response.status,
             rawContent,
+            startedAtMs,
+            finishedAtMs: Date.now(),
         };
     }
     catch (error) {
@@ -419,17 +543,19 @@ function startConnectStream(options) {
             const collector = createConnectCollector({
                 targetRunId: options.targetRunId,
                 fallbackThreadId: options.fallbackThreadId,
+                textEvents: options.textEvents,
             });
             if (!response.body) {
                 const rawContent = await response.text();
                 await promises_1.default.writeFile(options.outputPath, rawContent, 'utf8');
-                const parsed = extractResultFromSse(rawContent, options.fallbackThreadId);
+                const parsed = extractResultFromSse(rawContent, options.fallbackThreadId, {}, options.textEvents);
                 return {
                     output: parsed.output,
                     toolCalls: parsed.toolCalls,
                     threadId: parsed.threadId,
                     finished: parsed.finished,
                     sawAnyEvent: parsed.sawAnyEvent,
+                    metrics: parsed.metrics,
                 };
             }
             const reader = response.body.getReader();
@@ -495,13 +621,17 @@ function startConnectStream(options) {
         result,
     };
 }
-function extractResultFromSse(rawContent, fallbackThreadId) {
+function extractResultFromSse(rawContent, fallbackThreadId, fallbackMetrics = {}, textEvents) {
     const fragments = [];
     let latestContent;
     let resolvedThreadId = fallbackThreadId;
     const toolCalls = [];
     let finished = false;
     let sawAnyEvent = false;
+    let runStartedAt;
+    let firstTextAt;
+    let firstToolAt;
+    let runFinishedAt;
     for (const sseEvent of parseSseEvents(rawContent)) {
         if (!sseEvent.data) {
             continue;
@@ -515,19 +645,29 @@ function extractResultFromSse(rawContent, fallbackThreadId) {
             else if (typeof parsed.conversationId === 'string' && parsed.conversationId.trim()) {
                 resolvedThreadId = parsed.conversationId.trim();
             }
-            if (parsed.type === 'TEXT_MESSAGE_CONTENT') {
-                if (typeof parsed.content === 'string' && parsed.content.trim()) {
-                    latestContent = parsed.content.trim();
+            if (parsed.type === 'RUN_STARTED' && typeof runStartedAt !== 'number') {
+                runStartedAt = normalizeEventTimestamp(parsed.timestamp);
+            }
+            if (isAssistantTextEvent(parsed, textEvents)) {
+                firstTextAt ??= normalizeEventTimestamp(parsed.timestamp);
+                const content = getAssistantContent(parsed, textEvents);
+                const delta = getAssistantDelta(parsed, textEvents);
+                if (content) {
+                    latestContent = content;
                 }
-                else if (typeof parsed.delta === 'string' && parsed.delta) {
-                    fragments.push(parsed.delta);
+                else if (delta) {
+                    fragments.push(delta);
                 }
             }
-            if (parsed.type === 'TOOL_CALL_START' && typeof parsed.toolCallName === 'string' && parsed.toolCallName.trim()) {
-                toolCalls.push(parsed.toolCallName.trim());
+            if (isToolStartEvent(parsed)) {
+                firstToolAt ??= normalizeEventTimestamp(parsed.timestamp);
+                if (typeof parsed.toolCallName === 'string' && parsed.toolCallName.trim()) {
+                    toolCalls.push(parsed.toolCallName.trim());
+                }
             }
             if (parsed.type === 'RUN_FINISHED') {
                 finished = true;
+                runFinishedAt = normalizeEventTimestamp(parsed.timestamp);
             }
             if (parsed.type === 'RUN_ERROR') {
                 throw new run_result_1.MessageRunError(parsed.error?.trim() || 'Agent run failed.', {
@@ -544,12 +684,21 @@ function extractResultFromSse(rawContent, fallbackThreadId) {
             }
         }
     }
+    const effectiveStartedAt = runStartedAt ?? fallbackMetrics.startTimeMs;
+    const effectiveFinishedAt = runFinishedAt ?? fallbackMetrics.finishedTimeMs;
+    const turnCompleteSeconds = roundSeconds(effectiveStartedAt, effectiveFinishedAt);
     return {
         output: latestContent?.trim() || fragments.join('').trim(),
         toolCalls,
         threadId: resolvedThreadId,
         finished,
         sawAnyEvent,
+        metrics: {
+            ttfTextSeconds: roundSeconds(runStartedAt, firstTextAt),
+            ttfToolSeconds: roundSeconds(runStartedAt, firstToolAt),
+            turnCompleteSeconds,
+            totalSeconds: turnCompleteSeconds,
+        },
     };
 }
 async function runAgUiPostMessage(options) {
@@ -591,6 +740,7 @@ async function runAgUiPostMessage(options) {
                 targetRunId: runId,
                 fallbackThreadId: resolvedThreadId,
                 processTimeoutMs: options.connect.processTimeoutMs ?? options.processTimeoutMs,
+                textEvents: options.textEvents,
             });
             await connectStream.ready;
             const runResponse = await postAndCaptureResponse({
@@ -625,7 +775,7 @@ async function runAgUiPostMessage(options) {
                 note: `Run log: ${node_path_1.default.basename(runOutputPath)}`,
                 toolCallCount: connected.toolCalls.length,
                 toolCalls: connected.toolCalls,
-                metrics: {},
+                metrics: connected.metrics,
             };
         }
         const runResponse = await postAndCaptureResponse({
@@ -642,7 +792,10 @@ async function runAgUiPostMessage(options) {
                 output: runResponse.rawContent,
             });
         }
-        const parsed = extractResultFromSse(runResponse.rawContent, resolvedThreadId);
+        const parsed = extractResultFromSse(runResponse.rawContent, resolvedThreadId, {
+            startTimeMs: runResponse.startedAtMs,
+            finishedTimeMs: runResponse.finishedAtMs,
+        }, options.textEvents);
         if (options.observe) {
             await promises_1.default.writeFile(observePath, '', 'utf8');
             const observed = await waitForObservedCompletion({
@@ -659,7 +812,7 @@ async function runAgUiPostMessage(options) {
                 note: `Observe status: ${observed.status}. Observe log: ${node_path_1.default.basename(observePath)}`,
                 toolCallCount: parsed.toolCalls.length,
                 toolCalls: parsed.toolCalls,
-                metrics: {},
+                metrics: parsed.metrics,
             };
         }
         if (options.completionCheck) {
@@ -671,7 +824,7 @@ async function runAgUiPostMessage(options) {
                 note: `Completion status: ${completion.status}`,
                 toolCallCount: parsed.toolCalls.length,
                 toolCalls: parsed.toolCalls,
-                metrics: {},
+                metrics: parsed.metrics,
             };
         }
         if (!parsed.finished && !parsed.output) {
@@ -691,7 +844,7 @@ async function runAgUiPostMessage(options) {
             outputPath,
             toolCallCount: parsed.toolCalls.length,
             toolCalls: parsed.toolCalls,
-            metrics: {},
+            metrics: parsed.metrics,
         };
     }
     catch (error) {

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

@@ -9,8 +9,8 @@ exports.extractAppendedLog = extractAppendedLog;
 exports.runAgUiMessage = runAgUiMessage;
 const promises_1 = __importDefault(require("node:fs/promises"));
 const node_path_1 = __importDefault(require("node:path"));
+const node_crypto_1 = require("node:crypto");
 const stompjs_1 = require("@stomp/stompjs");
-const uuid_1 = require("uuid");
 const ws_1 = __importDefault(require("ws"));
 const run_result_1 = require("../run-result");
 Object.assign(globalThis, { WebSocket: ws_1.default });
@@ -169,6 +169,7 @@ function computeMetrics(state) {
     return {
         ttfToolSeconds,
         ttfTextSeconds,
+        turnCompleteSeconds: totalSeconds,
         totalSeconds,
         protocolUsedKb,
         protocolTotalKb,
@@ -179,6 +180,7 @@ 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.turnCompleteSeconds != null ? `Turn complete: ${metrics.turnCompleteSeconds.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}%)`
@@ -430,8 +432,8 @@ async function connectAndRun(options) {
 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 threadId = options.threadId ?? options.threadIdFallback ?? (0, node_crypto_1.randomUUID)();
+    const runId = (0, node_crypto_1.randomUUID)();
     const logPath = node_path_1.default.join(options.outputDirectory, `${threadId}.jsonl`);
     const previousLogContent = await readJsonl(logPath);
     const state = await connectAndRun({

package/dist/executors/execute.js

@@ -48,6 +48,7 @@ function createAgUiPostRunner(config) {
         processTimeoutMs: processTimeoutMs ?? transport.processTimeoutMs,
         injectMessage: transport.injectMessage,
         injectRunMetadata: transport.injectRunMetadata,
+        textEvents: transport.textEvents,
         run: transport.run ?? transport.request,
         connect: transport.connect,
         observe: transport.observe,

package/dist/executors/executor.js

@@ -135,7 +135,8 @@ async function runSingleScenario(scenario, context, env, outputDirectory, deadli
                 if (assertionFailureNote) {
                     result.status = 'FAIL';
                     result.note = [result.note, assertionFailureNote].filter(Boolean).join(' ') || undefined;
-                    if (!scenario.continueOnAssertionFailure) {
+                    const shouldContinueOnAssertionFailure = turn.continueOnAssertionFailure ?? scenario.continueOnAssertionFailure ?? false;
+                    if (!shouldContinueOnAssertionFailure) {
                         throw new Error(assertionFailureNote);
                     }
                 }

package/dist/executors/run-result.d.ts

@@ -1,7 +1,10 @@
 export type TimingMetrics = {
     ttfToolSeconds?: number;
     ttfTextSeconds?: number;
+    turnCompleteSeconds?: number;
     totalSeconds?: number;
+    averageTtfTextSeconds?: number;
+    averageTurnCompleteSeconds?: number;
     protocolUsedKb?: number;
     protocolTotalKb?: number;
     efficiencyPercent?: number;

package/dist/reports/report.js

@@ -26,6 +26,16 @@ function sumNumbers(values) {
     }
     return Number(definedValues.reduce((total, value) => total + value, 0).toFixed(1));
 }
+function averageNumbers(values) {
+    const definedValues = values.filter((value) => typeof value === 'number');
+    if (definedValues.length === 0) {
+        return undefined;
+    }
+    return Number((definedValues.reduce((total, value) => total + value, 0) / definedValues.length).toFixed(1));
+}
+function turnCompleteSeconds(metrics) {
+    return metrics.turnCompleteSeconds ?? metrics.totalSeconds;
+}
 function summarizeScenarioMetrics(turns) {
     const protocolUsedKb = sumNumbers(turns.map((turn) => turn.metrics.protocolUsedKb));
     const protocolTotalKb = sumNumbers(turns.map((turn) => turn.metrics.protocolTotalKb));
@@ -35,7 +45,10 @@ function summarizeScenarioMetrics(turns) {
     return {
         ttfToolSeconds: sumNumbers(turns.map((turn) => turn.metrics.ttfToolSeconds)),
         ttfTextSeconds: sumNumbers(turns.map((turn) => turn.metrics.ttfTextSeconds)),
+        turnCompleteSeconds: sumNumbers(turns.map((turn) => turnCompleteSeconds(turn.metrics))),
         totalSeconds: sumNumbers(turns.map((turn) => turn.metrics.totalSeconds)),
+        averageTtfTextSeconds: averageNumbers(turns.map((turn) => turn.metrics.ttfTextSeconds)),
+        averageTurnCompleteSeconds: averageNumbers(turns.map((turn) => turnCompleteSeconds(turn.metrics))),
         protocolUsedKb,
         protocolTotalKb,
         efficiencyPercent,
@@ -112,6 +125,8 @@ function buildScenarioRunSummary(results) {
         failedAssertions: assertions.filter((assertion) => !assertion.passed).length,
         totalToolCalls: turns.reduce((total, turn) => total + turn.toolCallCount, 0),
         totalEvaluations: evaluations.length,
+        averageTtfTextSeconds: averageNumbers(turns.map((turn) => turn.metrics.ttfTextSeconds)),
+        averageTurnCompleteSeconds: averageNumbers(turns.map((turn) => turnCompleteSeconds(turn.metrics))),
         averageScoresByDimension,
         requestedEvalDimensions,
     };
@@ -155,7 +170,10 @@ function renderMetrics(metrics) {
     return [
         `TTF Tool: ${formatSeconds(metrics.ttfToolSeconds)}`,
         `TTF Text: ${formatSeconds(metrics.ttfTextSeconds)}`,
+        `Turn Complete: ${formatSeconds(turnCompleteSeconds(metrics))}`,
         `Total: ${formatSeconds(metrics.totalSeconds)}`,
+        `Avg TTF Text: ${formatSeconds(metrics.averageTtfTextSeconds)}`,
+        `Avg Complete: ${formatSeconds(metrics.averageTurnCompleteSeconds)}`,
         `Efficiency: ${formatPercent(metrics.efficiencyPercent)}`,
     ].join(' | ');
 }
@@ -356,6 +374,8 @@ function buildScenarioRunHtml(payload) {
         '<section class="summary-grid">',
         `<article class="summary-card"><span class="label">Scenarios</span><div class="value">${payload.summary.totalScenarios}</div><div class="sub">${payload.summary.passedScenarios} pass / ${payload.summary.failedScenarios} fail / ${payload.summary.skippedScenarios} skip</div></article>`,
         `<article class="summary-card"><span class="label">Turns</span><div class="value">${payload.summary.totalTurns}</div><div class="sub">${payload.summary.totalToolCalls} tool calls total</div></article>`,
+        `<article class="summary-card"><span class="label">Avg TTF Text</span><div class="value">${formatSeconds(payload.summary.averageTtfTextSeconds)}</div><div class="sub">First assistant text per turn</div></article>`,
+        `<article class="summary-card"><span class="label">Avg Turn Complete</span><div class="value">${formatSeconds(payload.summary.averageTurnCompleteSeconds)}</div><div class="sub">Run started to run finished</div></article>`,
         `<article class="summary-card"><span class="label">Assertions</span><div class="value">${payload.summary.totalAssertions}</div><div class="sub">${payload.summary.passedAssertions} pass / ${payload.summary.failedAssertions} fail</div></article>`,
         `<article class="summary-card"><span class="label">Evaluations</span><div class="value">${payload.summary.totalEvaluations}</div><div class="sub">LLM-scored dimensions</div></article>`,
         '</section>',

package/dist/scenarios/scenario.d.ts

@@ -44,6 +44,7 @@ export type AiTurn<TContext extends BaseAiScenarioContext = BaseAiScenarioContex
     message: AiTurnMessage<TContext>;
     idleTimeoutMs?: number;
     processTimeoutMs?: number;
+    continueOnAssertionFailure?: boolean;
     assertions?: AiTurnAssertion[];
     eval?: AiTurnEvalDefinition[];
     onComplete?: (args: AiTurnCompletionArgs<TContext>) => void | Promise<void>;

package/dist/utils/config.d.ts

@@ -22,6 +22,15 @@ export type KarrotConfig = {
         type: 'ag-ui-post';
         injectMessage?: boolean;
         injectRunMetadata?: boolean;
+        textEvents?: Array<{
+            type: string;
+            name?: string;
+            role?: string;
+            textPath?: string;
+            contentPath?: string;
+            deltaPath?: string;
+            mode?: 'content' | 'delta';
+        }>;
         run?: {
             url: string;
             headers?: Record<string, string>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@huydao/karrot",
-  "version": "0.1.6",
+  "version": "0.1.8",
   "description": "Reusable AI scenario execution, assertion, evaluation, and reporting toolkit",
   "license": "ISC",
   "type": "commonjs",
@@ -126,12 +126,15 @@
   },
   "files": [
     "dist",
+    "site",
     "README.md",
     "GUIDE.md"
   ],
   "scripts": {
     "build": "rm -rf dist && tsc -p tsconfig.json && mkdir -p dist/prompts && cp prompts/*.md dist/prompts/",
-    "prepack": "npm run build"
+    "prepack": "npm run build",
+    "site:serve": "node site/serve.js",
+    "site:check": "node site/check.js"
   },
   "dependencies": {
     "@stomp/stompjs": "^7.3.0",