@huydao/karrot 0.1.7 → 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 : [];
@@ -278,15 +285,80 @@ function roundSeconds(startTimeMs, endTimeMs) {
     }
     return Number(((endTimeMs - startTimeMs) / 1000).toFixed(1));
 }
-function isAssistantTextEvent(event) {
+function isStandardAssistantTextEvent(event) {
     return (event.type === 'TEXT_MESSAGE_CONTENT' ||
-        event.type === 'TEXT_MESSAGE_CHUNK' ||
-        (event.type === 'CUSTOM' && event.name === 'super-testing-agent.model_stream_chunk'));
+        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 = [];
@@ -335,13 +407,15 @@ function createConnectCollector(options) {
             });
         }
         const isAssistantMessage = parsed.role === 'assistant' || typeof parsed.role !== 'string';
-        if (isAssistantTextEvent(parsed) && isAssistantMessage) {
+        if (isAssistantTextEvent(parsed, options.textEvents) && isAssistantMessage) {
             firstTextAt ??= eventTime(parsed);
-            if (typeof parsed.content === 'string' && parsed.content.trim()) {
-                latestAssistantContent = parsed.content.trim();
+            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 (isToolStartEvent(parsed)) {
@@ -469,11 +543,12 @@ 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,
@@ -546,7 +621,7 @@ function startConnectStream(options) {
         result,
     };
 }
-function extractResultFromSse(rawContent, fallbackThreadId, fallbackMetrics = {}) {
+function extractResultFromSse(rawContent, fallbackThreadId, fallbackMetrics = {}, textEvents) {
     const fragments = [];
     let latestContent;
     let resolvedThreadId = fallbackThreadId;
@@ -573,13 +648,15 @@ function extractResultFromSse(rawContent, fallbackThreadId, fallbackMetrics = {}
             if (parsed.type === 'RUN_STARTED' && typeof runStartedAt !== 'number') {
                 runStartedAt = normalizeEventTimestamp(parsed.timestamp);
             }
-            if (isAssistantTextEvent(parsed)) {
+            if (isAssistantTextEvent(parsed, textEvents)) {
                 firstTextAt ??= normalizeEventTimestamp(parsed.timestamp);
-                if (typeof parsed.content === 'string' && parsed.content.trim()) {
-                    latestContent = parsed.content.trim();
+                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 (isToolStartEvent(parsed)) {
@@ -663,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({
@@ -717,7 +795,7 @@ async function runAgUiPostMessage(options) {
         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({

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/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.7",
+  "version": "0.1.8",
   "description": "Reusable AI scenario execution, assertion, evaluation, and reporting toolkit",
   "license": "ISC",
   "type": "commonjs",