@botbotgo/agent-harness 0.0.315 → 0.0.317

package/dist/package-version.d.ts

@@ -1 +1 @@
-export declare const AGENT_HARNESS_VERSION = "0.0.314";
+export declare const AGENT_HARNESS_VERSION = "0.0.316";

package/dist/package-version.js

@@ -1 +1 @@
-export const AGENT_HARNESS_VERSION = "0.0.314";
+export const AGENT_HARNESS_VERSION = "0.0.316";

package/dist/projections/request-events.js

@@ -1,3 +1,7 @@
+const MAX_SNAPSHOT_OUTPUT_CHARS = 4_096;
+const MAX_DATA_EVENT_INLINE_CHARS = 12_000;
+const DATA_EVENT_PREVIEW_CHARS = 2_000;
+const TRUNCATION_SENTINEL = "\n...[truncated]";
 function createEmptyPlanSummary() {
     return {
         total: 0,
@@ -58,6 +62,53 @@ function buildPlanItems(snapshot, planItems) {
 function buildStepEventKey(input) {
     return `${input.kind}:${input.id}`;
 }
+function truncateText(value, maxChars) {
+    if (value.length <= maxChars) {
+        return value;
+    }
+    const sliceLength = Math.max(0, maxChars - TRUNCATION_SENTINEL.length);
+    return `${value.slice(0, sliceLength)}${TRUNCATION_SENTINEL}`;
+}
+function appendSnapshotOutput(current, delta) {
+    if (!delta || current.length >= MAX_SNAPSHOT_OUTPUT_CHARS || current.endsWith(TRUNCATION_SENTINEL)) {
+        return current;
+    }
+    const remaining = MAX_SNAPSHOT_OUTPUT_CHARS - current.length;
+    if (delta.length <= remaining) {
+        return current + delta;
+    }
+    return `${current}${truncateText(delta, remaining)}`;
+}
+function summarizeLargeDataEventOutput(output) {
+    if (typeof output === "string") {
+        if (output.length <= MAX_DATA_EVENT_INLINE_CHARS) {
+            return output;
+        }
+        return {
+            truncated: true,
+            originalSizeChars: output.length,
+            preview: truncateText(output, DATA_EVENT_PREVIEW_CHARS),
+        };
+    }
+    if (typeof output === "number" || typeof output === "boolean" || output === null || output === undefined) {
+        return output;
+    }
+    let serialized;
+    try {
+        serialized = JSON.stringify(output, null, 2);
+    }
+    catch {
+        serialized = String(output);
+    }
+    if (serialized.length <= MAX_DATA_EVENT_INLINE_CHARS) {
+        return output;
+    }
+    return {
+        truncated: true,
+        originalSizeChars: serialized.length,
+        preview: truncateText(serialized, DATA_EVENT_PREVIEW_CHARS),
+    };
+}
 function applyPlanState(snapshot, planState) {
     if (!shouldReplacePlanItems(snapshot.plan.items, planState.items)) {
         return {
@@ -263,7 +314,7 @@ export function applyRequestStreamItemToSnapshot(snapshot, item) {
                 requestId: item.requestId,
                 updatedAt: now,
                 agentId: item.agentId,
-                output: snapshot.output + item.content,
+                output: appendSnapshotOutput(snapshot.output, item.content),
             };
         case "commentary":
             return {
@@ -327,7 +378,7 @@ export function applyRequestStreamItemToSnapshot(snapshot, item) {
                 updatedAt: now,
                 state: item.result.state,
                 agentId: item.result.agentId ?? snapshot.agentId,
-                output: item.result.output || snapshot.output,
+                output: item.result.output ? truncateText(item.result.output, MAX_SNAPSHOT_OUTPUT_CHARS) : snapshot.output,
                 ...(item.result.contentBlocks ? { contentBlocks: item.result.contentBlocks } : {}),
                 ...(item.result.structuredResponse !== undefined ? { structuredResponse: item.result.structuredResponse } : {}),
                 ...(item.result.interruptContent !== undefined ? { interruptContent: item.result.interruptContent } : {}),
@@ -376,7 +427,7 @@ export function toRequestDataEvent(item) {
                 requestId: item.requestId,
                 agentId: item.agentId,
                 toolName: item.toolName,
-                output: item.output,
+                output: summarizeLargeDataEventOutput(item.output),
                 ...(item.isError !== undefined ? { isError: item.isError } : {}),
             };
         case "upstream-event":

package/dist/projections/upstream-events.js

@@ -74,7 +74,12 @@ function buildStepLabel(category, status, name) {
     return status === "started" ? `Running ${displayName}` : `Completed ${displayName}`;
 }
 function createProjectionKey(parts) {
-    return JSON.stringify(parts);
+    return JSON.stringify(parts, (_key, value) => {
+        if (typeof value === "string" && value.length > 512) {
+            return `${value.slice(0, 497)}...[${value.length} chars]`;
+        }
+        return value;
+    });
 }
 export function createUpstreamTimelineReducer() {
     const emittedStepKeys = new Set();

package/dist/runtime/adapter/stream-event-projection.js

@@ -1,5 +1,5 @@
 import { sanitizeVisibleText } from "../parsing/output-parsing.js";
-import { computeIncrementalOutput, extractInterruptPayload, extractReasoningStreamOutput, extractStateStreamOutput, extractTerminalStreamOutput, extractToolResult, extractVisibleStreamOutput, normalizeTerminalOutputKey, } from "../parsing/stream-event-parsing.js";
+import { computeIncrementalOutput, extractInterruptPayload, extractReasoningStreamOutput, sanitizeRetainedUpstreamEvent, extractStateStreamOutput, extractTerminalStreamOutput, extractToolResult, extractVisibleStreamOutput, normalizeTerminalOutputKey, } from "../parsing/stream-event-parsing.js";
 import { resolveModelFacingToolName } from "./tool/tool-name-mapping.js";
 export function createStreamEventProjectionState() {
     return {
@@ -13,7 +13,7 @@ export function projectRuntimeStreamEvent(params) {
     const { event, allowVisibleStreamDeltas, includeStateStreamOutput, toolNameMapping, primaryTools, state, } = params;
     const chunks = [{
             kind: "upstream-event",
-            event,
+            event: sanitizeRetainedUpstreamEvent(event),
         }];
     const interruptPayload = extractInterruptPayload(event);
     if (interruptPayload) {

package/dist/runtime/harness/events/streaming.js

@@ -29,7 +29,10 @@ export function createToolResultKey(toolName, output, isError) {
     catch {
         serializedOutput = String(output);
     }
-    return JSON.stringify([toolName, serializedOutput, isError === true]);
+    const preview = serializedOutput.length > 512
+        ? `${serializedOutput.slice(0, 497)}...[${serializedOutput.length} chars]`
+        : serializedOutput;
+    return JSON.stringify([toolName, preview, isError === true]);
 }
 export async function dispatchRequestListeners(stream, listeners, options) {
     const notifyIfPresent = async (listener, value) => {

package/dist/runtime/parsing/stream-event-parsing.d.ts

@@ -23,6 +23,8 @@ export type RuntimeStreamChunk = {
     kind: "profile";
     step: RequestExecutionStep;
 };
+export declare function sanitizeStreamPayload(value: unknown): unknown;
+export declare function sanitizeRetainedUpstreamEvent(event: unknown): unknown;
 export declare function extractTerminalStreamOutput(event: unknown): string;
 export declare function extractReasoningStreamOutput(event: unknown): string;
 export declare function extractVisibleStreamOutput(event: unknown): string;

package/dist/runtime/parsing/stream-event-parsing.js

@@ -1,5 +1,150 @@
 import { isLowSignalTodoContent } from "../adapter/runtime-adapter-support.js";
 import { extractReasoningText, extractVisibleOutput, hasToolCalls, readTextContent } from "./output-parsing.js";
+const MAX_STREAM_INLINE_TEXT_CHARS = 12_000;
+const STREAM_PREVIEW_TEXT_CHARS = 2_000;
+const MAX_STREAM_OBJECT_KEYS = 64;
+const MAX_STREAM_ARRAY_ITEMS = 64;
+const MAX_STREAM_SANITIZE_DEPTH = 6;
+const LARGE_CONTEXT_KEYS = new Set([
+    "input",
+    "inputs",
+    "messages",
+    "history",
+    "context",
+    "attachments",
+    "files",
+    "conversation",
+    "transcript",
+]);
+function truncatePreview(value, maxChars) {
+    if (value.length <= maxChars) {
+        return value;
+    }
+    return `${value.slice(0, Math.max(0, maxChars - 15))}\n...[truncated]`;
+}
+function summarizeLargeText(value) {
+    if (value.length <= MAX_STREAM_INLINE_TEXT_CHARS) {
+        return value;
+    }
+    return {
+        truncated: true,
+        originalSizeChars: value.length,
+        preview: truncatePreview(value, STREAM_PREVIEW_TEXT_CHARS),
+    };
+}
+function sanitizeStreamPayloadValue(value, depth) {
+    if (typeof value === "string") {
+        return summarizeLargeText(value);
+    }
+    if (value === null
+        || value === undefined
+        || typeof value === "number"
+        || typeof value === "boolean") {
+        return value;
+    }
+    if (depth >= MAX_STREAM_SANITIZE_DEPTH) {
+        let serialized = "";
+        try {
+            serialized = JSON.stringify(value);
+        }
+        catch {
+            serialized = String(value);
+        }
+        return {
+            truncated: true,
+            reason: "max-depth",
+            originalSizeChars: serialized.length,
+            preview: truncatePreview(serialized, STREAM_PREVIEW_TEXT_CHARS),
+        };
+    }
+    if (Array.isArray(value)) {
+        const limited = value
+            .slice(0, MAX_STREAM_ARRAY_ITEMS)
+            .map((entry) => sanitizeStreamPayloadValue(entry, depth + 1));
+        return value.length > MAX_STREAM_ARRAY_ITEMS
+            ? {
+                items: limited,
+                truncated: true,
+                originalLength: value.length,
+            }
+            : limited;
+    }
+    if (typeof value === "object") {
+        const entries = Object.entries(value);
+        const limitedEntries = entries.slice(0, MAX_STREAM_OBJECT_KEYS);
+        const sanitized = Object.fromEntries(limitedEntries.map(([key, entry]) => [key, sanitizeStreamPayloadValue(entry, depth + 1)]));
+        if (entries.length > MAX_STREAM_OBJECT_KEYS) {
+            sanitized.__truncatedKeys = {
+                truncated: true,
+                originalKeyCount: entries.length,
+            };
+        }
+        return sanitized;
+    }
+    return String(value);
+}
+export function sanitizeStreamPayload(value) {
+    return sanitizeStreamPayloadValue(value, 0);
+}
+function summarizeOpaquePayload(value) {
+    if (value === null || value === undefined) {
+        return value;
+    }
+    if (typeof value === "string") {
+        return {
+            truncated: true,
+            reason: "omitted-large-context",
+            originalSizeChars: value.length,
+            preview: truncatePreview(value, STREAM_PREVIEW_TEXT_CHARS),
+        };
+    }
+    let serialized = "";
+    try {
+        serialized = JSON.stringify(value);
+    }
+    catch {
+        serialized = String(value);
+    }
+    return {
+        truncated: true,
+        reason: "omitted-large-context",
+        originalSizeChars: serialized.length,
+        preview: truncatePreview(serialized, STREAM_PREVIEW_TEXT_CHARS),
+    };
+}
+function sanitizeRetainedEventDataField(key, value) {
+    if (LARGE_CONTEXT_KEYS.has(key)) {
+        if (key === "input" && typeof value === "object" && value && !Array.isArray(value)) {
+            const typed = value;
+            const taskSubagentType = typeof typed.subagent_type === "string"
+                ? typed.subagent_type
+                : typeof typed.subagentType === "string"
+                    ? typed.subagentType
+                    : undefined;
+            if (taskSubagentType) {
+                return { subagent_type: taskSubagentType };
+            }
+        }
+        return summarizeOpaquePayload(value);
+    }
+    return sanitizeStreamPayload(value);
+}
+export function sanitizeRetainedUpstreamEvent(event) {
+    if (typeof event !== "object" || !event || Array.isArray(event)) {
+        return sanitizeStreamPayload(event);
+    }
+    const typed = event;
+    const retained = {};
+    for (const [key, value] of Object.entries(typed)) {
+        if (key === "data" && typeof value === "object" && value && !Array.isArray(value)) {
+            const data = value;
+            retained.data = Object.fromEntries(Object.entries(data).map(([dataKey, dataValue]) => [dataKey, sanitizeRetainedEventDataField(dataKey, dataValue)]));
+            continue;
+        }
+        retained[key] = sanitizeStreamPayload(value);
+    }
+    return retained;
+}
 function parseMaybeJson(value) {
     const trimmed = value.trim();
     if (!trimmed.startsWith("{") && !trimmed.startsWith("[")) {
@@ -146,7 +291,7 @@ export function extractToolResult(event) {
     }
     return {
         toolName,
-        output: normalizedOutput,
+        output: sanitizeStreamPayload(normalizedOutput),
         isError: isToolError || isErrorLikeToolOutput(normalizedOutput),
     };
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@botbotgo/agent-harness",
-  "version": "0.0.315",
+  "version": "0.0.317",
   "description": "Workspace runtime for multi-agent applications",
   "license": "MIT",
   "type": "module",