@botbotgo/agent-harness 0.0.120 → 0.0.121

package/dist/api.d.ts

@@ -4,6 +4,7 @@ import type { InventoryAgentRecord, InventorySkillRecord } from "./runtime/harne
 import type { RequirementAssessmentOptions } from "./runtime/harness/system/skill-requirements.js";
 import type { ToolMcpServerOptions } from "./mcp.js";
 export { AgentHarnessRuntime } from "./runtime/harness.js";
+export { createUpstreamTimelineReducer } from "./upstream-events.js";
 type CreateAgentHarnessOptions = {
     /**
      * Workspace loading behavior.

package/dist/api.js

@@ -1,6 +1,7 @@
 import { AgentHarnessRuntime } from "./runtime/harness.js";
 import { loadWorkspace } from "./workspace/compile.js";
 export { AgentHarnessRuntime } from "./runtime/harness.js";
+export { createUpstreamTimelineReducer } from "./upstream-events.js";
 export async function createAgentHarness(workspaceRoot = process.cwd(), options = {}) {
     const workspace = await loadWorkspace(workspaceRoot, options.load ?? {});
     const harness = new AgentHarnessRuntime(workspace, options.adapter ?? {});

package/dist/contracts/runtime.d.ts

@@ -1,6 +1,5 @@
 import type { RunState } from "./core.js";
 import type { CompiledAgentBinding, CompiledModel, CompiledTool, ParsedAgentObject, ParsedToolObject, WorkspaceBundle } from "./workspace.js";
-import type { CompatibleStreamPart as InternalCompatibleStreamPart, NormalizedUpstreamEvent as InternalNormalizedUpstreamEvent, UpstreamRuntimeEvent as InternalUpstreamRuntimeEvent } from "../runtime/parsing/stream-event-types.js";
 export type ThreadSummary = {
     agentId: string;
     threadId: string;
@@ -10,7 +9,7 @@ export type ThreadSummary = {
     status: RunState;
 };
 export type SessionRecord = ThreadSummary;
-export type KnownHarnessEventType = "run.created" | "run.queued" | "run.dequeued" | "run.state.changed" | "run.resumed" | "approval.requested" | "approval.resolved" | "artifact.created" | "output.delta" | "reasoning.delta" | "runtime.health.changed" | "runtime.synthetic_fallback";
+export type KnownHarnessEventType = "run.created" | "run.queued" | "run.dequeued" | "run.state.changed" | "run.resumed" | "approval.requested" | "approval.resolved" | "artifact.created" | "output.delta" | "runtime.health.changed" | "runtime.synthetic_fallback";
 export type HarnessEventType = KnownHarnessEventType | (string & {});
 export type HarnessEvent = {
     eventId: string;
@@ -86,25 +85,12 @@ export type RunResult = {
     artifacts?: ArtifactRecord[];
     metadata?: Record<string, unknown>;
 };
-export type NormalizedUpstreamEvent = InternalNormalizedUpstreamEvent;
-export type CompatibleStreamPart = InternalCompatibleStreamPart;
-export type UpstreamRuntimeEvent = InternalUpstreamRuntimeEvent;
+export type UpstreamRuntimeEvent = unknown;
 export type RuntimeListeners = {
     onEvent?: (event: HarnessEvent) => void | Promise<void>;
-};
-export type FrontendStreamListeners = {
-    onChunk?: (chunk: string) => void | Promise<void>;
-    onContentBlocks?: (blocks: unknown[]) => void | Promise<void>;
     onUpstreamEvent?: (event: UpstreamRuntimeEvent) => void | Promise<void>;
-    onReasoning?: (chunk: string) => void | Promise<void>;
-    onStep?: (step: string) => void | Promise<void>;
-    onToolResult?: (item: {
-        toolName: string;
-        output: unknown;
-        isError?: boolean;
-    }) => void | Promise<void>;
 };
-export type RunListeners = RuntimeListeners & FrontendStreamListeners;
+export type RunListeners = RuntimeListeners;
 export type MessageContentPart = {
     type: "text";
     text: string;
@@ -148,38 +134,6 @@ export type HarnessStreamItem = {
 } | {
     type: "result";
     result: RunResult;
-} | {
-    type: "content";
-    threadId: string;
-    runId: string;
-    agentId: string;
-    content: string;
-} | {
-    type: "content-blocks";
-    threadId: string;
-    runId: string;
-    agentId: string;
-    contentBlocks: unknown[];
-} | {
-    type: "reasoning";
-    threadId: string;
-    runId: string;
-    agentId: string;
-    content: string;
-} | {
-    type: "step";
-    threadId: string;
-    runId: string;
-    agentId: string;
-    content: string;
-} | {
-    type: "tool-result";
-    threadId: string;
-    runId: string;
-    agentId: string;
-    toolName: string;
-    output: unknown;
-    isError?: boolean;
 };
 export type TranscriptMessage = {
     role: "user" | "assistant";

package/dist/index.d.ts

@@ -1,3 +1,4 @@
-export { AgentHarnessRuntime, cancelRun, createAgentHarness, createToolMcpServer, deleteThread, describeInventory, getApproval, getHealth, getRun, getThread, listAgentSkills, listApprovals, listRuns, listThreads, resolveApproval, run, serveToolsOverStdio, subscribe, stop, } from "./api.js";
+export { AgentHarnessRuntime, cancelRun, createAgentHarness, createUpstreamTimelineReducer, createToolMcpServer, deleteThread, describeInventory, getApproval, getHealth, getRun, getThread, listAgentSkills, listApprovals, listRuns, listThreads, resolveApproval, run, serveToolsOverStdio, subscribe, stop, } from "./api.js";
 export type { ToolMcpServerOptions } from "./mcp.js";
 export { tool } from "./tools.js";
+export type { UpstreamTimelineProjection, UpstreamTimelineReducer } from "./upstream-events.js";

package/dist/index.js

@@ -1,2 +1,2 @@
-export { AgentHarnessRuntime, cancelRun, createAgentHarness, createToolMcpServer, deleteThread, describeInventory, getApproval, getHealth, getRun, getThread, listAgentSkills, listApprovals, listRuns, listThreads, resolveApproval, run, serveToolsOverStdio, subscribe, stop, } from "./api.js";
+export { AgentHarnessRuntime, cancelRun, createAgentHarness, createUpstreamTimelineReducer, createToolMcpServer, deleteThread, describeInventory, getApproval, getHealth, getRun, getThread, listAgentSkills, listApprovals, listRuns, listThreads, resolveApproval, run, serveToolsOverStdio, subscribe, stop, } from "./api.js";
 export { tool } from "./tools.js";

package/dist/package-version.d.ts

@@ -1 +1 @@
-export declare const AGENT_HARNESS_VERSION = "0.0.119";
+export declare const AGENT_HARNESS_VERSION = "0.0.120";

package/dist/package-version.js

@@ -1 +1 @@
-export const AGENT_HARNESS_VERSION = "0.0.119";
+export const AGENT_HARNESS_VERSION = "0.0.120";

package/dist/runtime/adapter/stream-event-projection.d.ts

@@ -6,7 +6,6 @@ export type StreamEventProjectionState = {
     emittedToolError: boolean;
     emittedToolResult: boolean;
     seenTerminalOutputs: Set<string>;
-    lastStep: string;
 };
 export declare function createStreamEventProjectionState(): StreamEventProjectionState;
 export declare function projectRuntimeStreamEvent(params: {

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

@@ -1,122 +1,19 @@
 import { sanitizeVisibleText } from "../parsing/output-parsing.js";
-import { computeIncrementalOutput, extractInterruptPayload, extractReasoningStreamOutput, extractStateStreamOutput, extractTerminalStreamOutput, extractToolResult, extractVisibleStreamOutput, normalizeTerminalOutputKey, normalizeUpstreamRuntimeEvent, } from "../parsing/stream-event-parsing.js";
+import { computeIncrementalOutput, extractInterruptPayload, extractReasoningStreamOutput, extractStateStreamOutput, extractTerminalStreamOutput, extractToolResult, extractVisibleStreamOutput, normalizeTerminalOutputKey, } from "../parsing/stream-event-parsing.js";
 import { resolveModelFacingToolName } from "./tool/tool-name-mapping.js";
-function formatStepValue(value, maxLength = 120) {
-    if (value == null)
-        return "";
-    const normalized = typeof value === "string"
-        ? parseMaybeJson(value)
-        : value;
-    const summarized = summarizeStepValue(normalized);
-    const serialized = typeof summarized === "string"
-        ? summarized
-        : (() => {
-            try {
-                return JSON.stringify(summarized);
-            }
-            catch {
-                return String(summarized);
-            }
-        })();
-    return serialized.length > maxLength ? serialized.slice(0, maxLength) + "…" : serialized;
-}
-function parseMaybeJson(value) {
-    const trimmed = value.trim();
-    if (!trimmed.startsWith("{") && !trimmed.startsWith("[")) {
-        return value;
-    }
-    try {
-        return JSON.parse(trimmed);
-    }
-    catch {
-        return value;
-    }
-}
-function summarizeStepValue(value) {
-    if (typeof value !== "object" || !value) {
-        return value;
-    }
-    const record = value;
-    if (typeof record.url === "string" && typeof record.status === "number") {
-        const warnings = Array.isArray(record.warnings) ? record.warnings.filter((item) => typeof item === "string") : [];
-        return {
-            status: record.status,
-            ok: record.ok,
-            quality: record.quality,
-            source: record.source,
-            warnings,
-        };
-    }
-    return value;
-}
-function humanizeEventName(name) {
-    return name.replace(/([a-z0-9])([A-Z])/g, "$1 $2").replace(/[._-]+/g, " ").replace(/\s+/g, " ").trim().toLowerCase();
-}
-function deriveAgentStep(event) {
-    if (typeof event !== "object" || !event)
-        return null;
-    const typed = event;
-    const name = typeof typed.name === "string" ? typed.name : "";
-    if (typed.event === "on_tool_start" || (typed.event === "on_chain_start" && typed.run_type === "tool")) {
-        const inputSummary = formatStepValue(typed.data?.input);
-        return inputSummary ? `tool ${name || "tool"}  ${inputSummary}` : `tool ${name || "tool"}`;
-    }
-    if (typed.event === "on_tool_end" || (typed.event === "on_chain_end" && typed.run_type === "tool")) {
-        const outputSummary = formatStepValue(typed.data?.output, 80);
-        return outputSummary ? `tool ${name || "tool"} done  ${outputSummary}` : `tool ${name || "tool"} done`;
-    }
-    if (typed.event === "on_tool_error" || (typed.event === "on_chain_error" && typed.run_type === "tool")) {
-        const errorSummary = formatStepValue(typed.data?.error ?? typed.data?.output, 80);
-        return errorSummary ? `tool ${name || "tool"} error  ${errorSummary}` : `tool ${name || "tool"} error`;
-    }
-    if (typed.event === "on_chat_model_start") {
-        const inputTools = typed.data?.input?.tools;
-        const tools = typed.invocation_params?.tools ?? inputTools ?? [];
-        const toolNames = tools.map((tool) => tool.name ?? tool.function?.name).filter((toolName) => typeof toolName === "string").join(", ");
-        return toolNames ? `calling model  tools: [${toolNames}]` : "calling model…";
-    }
-    if (typed.event === "on_chain_start") {
-        if (/SkillsMiddleware/i.test(name))
-            return "loading skills…";
-        if (/MemoryMiddleware/i.test(name))
-            return "loading memory…";
-        if (/patchToolCallsMiddleware/i.test(name))
-            return "normalizing tool calls…";
-        if (/HumanInTheLoopMiddleware/i.test(name))
-            return "checking approvals…";
-        if (/todoListMiddleware/i.test(name))
-            return "updating plan…";
-        if (/model_request/i.test(name))
-            return "preparing model request…";
-        if (/RunnableLambda/i.test(name) || /^__start__$/.test(name))
-            return null;
-        if (/(subagent|specialist)/i.test(name))
-            return `starting ${humanizeEventName(name)}…`;
-        if (/agent$/i.test(name))
-            return `running ${humanizeEventName(name)}…`;
-    }
-    if (typed.event === "on_chain_end") {
-        if (/(subagent|specialist)/i.test(name))
-            return `${humanizeEventName(name)} done`;
-        if (/agent$/i.test(name) && !/^__start__$/.test(name))
-            return `${humanizeEventName(name)} done`;
-    }
-    return null;
-}
 export function createStreamEventProjectionState() {
     return {
         emittedOutput: "",
         emittedToolError: false,
         emittedToolResult: false,
         seenTerminalOutputs: new Set(),
-        lastStep: "",
     };
 }
 export function projectRuntimeStreamEvent(params) {
     const { event, allowVisibleStreamDeltas, includeStateStreamOutput, toolNameMapping, primaryTools, state, } = params;
     const chunks = [{
             kind: "upstream-event",
-            event: normalizeUpstreamRuntimeEvent(event),
+            event,
         }];
     const interruptPayload = extractInterruptPayload(event);
     if (interruptPayload) {
@@ -147,11 +44,6 @@ export function projectRuntimeStreamEvent(params) {
             }
         }
     }
-    const agentStep = deriveAgentStep(event);
-    if (agentStep && agentStep !== state.lastStep) {
-        state.lastStep = agentStep;
-        chunks.push({ kind: "step", content: agentStep });
-    }
     const toolResult = extractToolResult(event);
     if (toolResult) {
         state.emittedToolResult = true;

package/dist/runtime/harness/events/listener-runtime.d.ts

@@ -1,4 +1,5 @@
-import type { HarnessStreamItem, RunListeners, RunResult } from "../../../contracts/types.js";
+import type { RunListeners, RunResult } from "../../../contracts/types.js";
+import { type InternalHarnessStreamItem } from "./streaming.js";
 export declare function createListenerDispatchRuntime(input: {
     notifyListener: <T>(listener: ((value: T) => void | Promise<void>) | undefined, value: T) => Promise<void>;
     getThread: (threadId: string) => Promise<{
@@ -14,5 +15,5 @@ export declare function createListenerDispatchRuntime(input: {
         };
     } | null>;
 }): {
-    dispatchRunListeners: (stream: AsyncGenerator<HarnessStreamItem>, listeners: RunListeners) => Promise<RunResult>;
+    dispatchRunListeners: (stream: AsyncGenerator<InternalHarnessStreamItem>, listeners: RunListeners) => Promise<RunResult>;
 };

package/dist/runtime/harness/events/streaming.d.ts

@@ -1,8 +1,29 @@
 import type { HarnessEvent, HarnessStreamItem, RunListeners, RunResult } from "../../../contracts/types.js";
-export declare function emitOutputDeltaAndCreateItem(emit: (threadId: string, runId: string, sequence: number, eventType: string, payload: Record<string, unknown>) => Promise<HarnessEvent>, threadId: string, runId: string, agentId: string, content: string): Promise<HarnessStreamItem>;
-export declare function createContentBlocksItem(threadId: string, runId: string, agentId: string, contentBlocks: unknown[]): HarnessStreamItem;
+export type InternalHarnessStreamItem = HarnessStreamItem | {
+    type: "content";
+    threadId: string;
+    runId: string;
+    agentId: string;
+    content: string;
+} | {
+    type: "content-blocks";
+    threadId: string;
+    runId: string;
+    agentId: string;
+    contentBlocks: unknown[];
+} | {
+    type: "tool-result";
+    threadId: string;
+    runId: string;
+    agentId: string;
+    toolName: string;
+    output: unknown;
+    isError?: boolean;
+};
+export declare function emitOutputDeltaAndCreateItem(emit: (threadId: string, runId: string, sequence: number, eventType: string, payload: Record<string, unknown>) => Promise<HarnessEvent>, threadId: string, runId: string, agentId: string, content: string): Promise<InternalHarnessStreamItem>;
+export declare function createContentBlocksItem(threadId: string, runId: string, agentId: string, contentBlocks: unknown[]): InternalHarnessStreamItem;
 export declare function createToolResultKey(toolName: string, output: unknown, isError?: boolean): string;
-export declare function dispatchRunListeners(stream: AsyncGenerator<HarnessStreamItem>, listeners: RunListeners, options: {
+export declare function dispatchRunListeners(stream: AsyncGenerator<InternalHarnessStreamItem>, listeners: RunListeners, options: {
     notifyListener: <T>(listener: ((value: T) => void | Promise<void>) | undefined, value: T) => Promise<void>;
     getThread: (threadId: string) => Promise<{
         currentState: RunResult["state"];

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

@@ -50,28 +50,8 @@ export async function dispatchRunListeners(stream, listeners, options) {
         }
         if (item.type === "content") {
             output += item.content;
-            await options.notifyListener(listeners.onChunk, item.content);
             continue;
         }
-        if (item.type === "content-blocks") {
-            await options.notifyListener(listeners.onContentBlocks, item.contentBlocks);
-            continue;
-        }
-        if (item.type === "reasoning") {
-            await options.notifyListener(listeners.onReasoning, item.content);
-            continue;
-        }
-        if (item.type === "step") {
-            await options.notifyListener(listeners.onStep, item.content);
-            continue;
-        }
-        if (item.type === "tool-result") {
-            await options.notifyListener(listeners.onToolResult, {
-                toolName: item.toolName,
-                output: item.output,
-                isError: item.isError,
-            });
-        }
     }
     if (!latestEvent) {
         throw new Error("run did not emit any events");

package/dist/runtime/harness/run/stream-run.d.ts

@@ -1,14 +1,12 @@
-import type { CompiledAgentBinding, HarnessEvent, HarnessStreamItem, MessageContent, RunResult, TranscriptMessage } from "../../../contracts/types.js";
+import type { CompiledAgentBinding, HarnessEvent, MessageContent, RunResult, TranscriptMessage } from "../../../contracts/types.js";
+import { type InternalHarnessStreamItem } from "../events/streaming.js";
 type RuntimeStreamChunk = string | {
     kind: "content" | "interrupt" | "reasoning" | "step" | "tool-result" | "upstream-event";
     content?: string;
     toolName?: string;
     output?: unknown;
     isError?: boolean;
-    event?: {
-        format?: string;
-        raw?: unknown;
-    } | Record<string, unknown>;
+    event?: unknown;
 };
 type StreamRunOptions = {
     binding: CompiledAgentBinding;
@@ -49,5 +47,5 @@ type StreamRunOptions = {
     clearRunRequest: (threadId: string, runId: string) => Promise<void>;
     emitSyntheticFallback: (threadId: string, runId: string, selectedAgentId: string, error: unknown) => Promise<void>;
 };
-export declare function streamHarnessRun(options: StreamRunOptions): AsyncGenerator<HarnessStreamItem>;
+export declare function streamHarnessRun(options: StreamRunOptions): AsyncGenerator<InternalHarnessStreamItem>;
 export {};

package/dist/runtime/harness/run/stream-run.js

@@ -1,5 +1,4 @@
 import { AGENT_INTERRUPT_SENTINEL_PREFIX, RuntimeOperationTimeoutError } from "../../agent-runtime-adapter.js";
-import { normalizeUpstreamRuntimeEvent } from "../../parsing/stream-event-parsing.js";
 import { renderRuntimeFailure, renderToolFailure } from "../../support/harness-support.js";
 import { createContentBlocksItem, createToolResultKey, emitOutputDeltaAndCreateItem, } from "../events/streaming.js";
 function normalizeStreamChunk(chunk) {
@@ -18,9 +17,6 @@ function normalizeStreamChunk(chunk) {
     if (chunk.kind === "reasoning") {
         return { kind: "reasoning", content: chunk.content ?? "" };
     }
-    if (chunk.kind === "step") {
-        return { kind: "step", content: chunk.content ?? "" };
-    }
     if (chunk.kind === "tool-result") {
         return {
             kind: "tool-result",
@@ -31,9 +27,6 @@ function normalizeStreamChunk(chunk) {
     }
     return { kind: "content", content: chunk.content ?? "" };
 }
-function isUpstreamRuntimeEvent(event) {
-    return event.format === "langgraph-v2" && "normalized" in event && "streamPart" in event;
-}
 export async function* streamHarnessRun(options) {
     const priorHistoryPromise = Promise.resolve(options.isNewThread ? [] : undefined).then((historyHint) => historyHint ?? options.loadPriorHistory(options.threadId, options.runId));
     yield { type: "event", event: await options.runCreatedEventPromise };
@@ -62,15 +55,12 @@ export async function* streamHarnessRun(options) {
             streamActivityObserved = true;
             const normalizedChunk = normalizeStreamChunk(rawChunk);
             if (normalizedChunk.kind === "upstream-event") {
-                const rawEvent = normalizedChunk.event;
                 yield {
                     type: "upstream-event",
                     threadId: options.threadId,
                     runId: options.runId,
                     agentId: options.selectedAgentId,
-                    event: isUpstreamRuntimeEvent(rawEvent)
-                        ? rawEvent
-                        : normalizeUpstreamRuntimeEvent(rawEvent.raw ?? rawEvent),
+                    event: normalizedChunk.event,
                 };
                 continue;
             }
@@ -100,26 +90,6 @@ export async function* streamHarnessRun(options) {
                 return;
             }
             if (normalizedChunk.kind === "reasoning") {
-                await options.emit(options.threadId, options.runId, 3, "reasoning.delta", {
-                    content: normalizedChunk.content,
-                });
-                yield {
-                    type: "reasoning",
-                    threadId: options.threadId,
-                    runId: options.runId,
-                    agentId: options.selectedAgentId,
-                    content: normalizedChunk.content,
-                };
-                continue;
-            }
-            if (normalizedChunk.kind === "step") {
-                yield {
-                    type: "step",
-                    threadId: options.threadId,
-                    runId: options.runId,
-                    agentId: options.selectedAgentId,
-                    content: normalizedChunk.content,
-                };
                 continue;
             }
             if (normalizedChunk.kind === "tool-result") {

package/dist/runtime/harness.js

@@ -38,7 +38,6 @@ export class AgentHarnessRuntime {
         "run.queued",
         "run.dequeued",
         "output.delta",
-        "reasoning.delta",
     ]);
     eventBus = new EventBus();
     persistence;
@@ -464,15 +463,10 @@ export class AgentHarnessRuntime {
         const binding = getWorkspaceBinding(this.workspace, selectedAgentId);
         if (!binding) {
             const result = await this.run(options);
-            for (const line of result.output.split("\n")) {
-                yield {
-                    type: "content",
-                    threadId: result.threadId,
-                    runId: result.runId,
-                    agentId: result.agentId ?? selectedAgentId,
-                    content: `${line}\n`,
-                };
-            }
+            yield {
+                type: "result",
+                result,
+            };
             return;
         }
         const { threadId, runId, isNewThread, runCreatedEventPromise, releaseRunSlotPromise, } = await prepareRunStart(this.createPrepareRunStartRuntime(), {
@@ -486,7 +480,7 @@ export class AgentHarnessRuntime {
                 state: "running",
             }),
         });
-        yield* streamHarnessRun({
+        const stream = streamHarnessRun({
             binding,
             input: options.input,
             invocation,
@@ -506,6 +500,11 @@ export class AgentHarnessRuntime {
             clearRunRequest: (threadId, runId) => this.persistence.clearRunRequest(threadId, runId),
             emitSyntheticFallback: (threadId, runId, selectedAgentId, error) => this.runtimeEventOperations.emitSyntheticFallback(threadId, runId, selectedAgentId, error),
         });
+        for await (const item of stream) {
+            if (item.type === "event" || item.type === "upstream-event" || item.type === "result") {
+                yield item;
+            }
+        }
     }
     async resume(options) {
         return resumeRun({

package/dist/runtime/parsing/index.d.ts

@@ -1,3 +1,2 @@
 export { extractReasoningText, extractToolFallbackContext, extractVisibleOutput, hasToolCalls, isLikelyToolArgsObject, readTextContent, sanitizeVisibleText, tryParseJson, wrapResolvedModel, } from "./output-parsing.js";
 export { extractInterruptPayload, extractReasoningStreamOutput, extractTerminalStreamOutput, extractToolResult, normalizeTerminalOutputKey, readStreamDelta, type RuntimeStreamChunk, } from "./stream-event-parsing.js";
-export type { CompatibleStreamPart, NormalizedUpstreamEvent, UpstreamRuntimeEvent, } from "./stream-event-types.js";

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

@@ -1,7 +1,6 @@
-import type { CompatibleStreamPart, UpstreamRuntimeEvent } from "./stream-event-types.js";
 export type RuntimeStreamChunk = {
     kind: "upstream-event";
-    event: UpstreamRuntimeEvent;
+    event: unknown;
 } | {
     kind: "content";
     content: string;
@@ -11,17 +10,12 @@ export type RuntimeStreamChunk = {
 } | {
     kind: "interrupt";
     content: string;
-} | {
-    kind: "step";
-    content: string;
 } | {
     kind: "tool-result";
     toolName: string;
     output: unknown;
     isError?: boolean;
 };
-export declare function normalizeUpstreamRuntimeEvent(event: unknown): UpstreamRuntimeEvent;
-export declare function extractCustomCompatibleStreamPart(event: unknown): CompatibleStreamPart | null;
 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,226 +1,4 @@
 import { extractReasoningText, extractVisibleOutput, hasToolCalls, readTextContent } from "./output-parsing.js";
-function asObject(value) {
-    return typeof value === "object" && value !== null ? value : undefined;
-}
-function extractCustomStreamData(event) {
-    const typed = asObject(event);
-    if (!typed) {
-        return null;
-    }
-    const eventName = typeof typed.event === "string" ? typed.event : "";
-    const ns = Array.isArray(typed.ns) ? typed.ns.filter((item) => typeof item === "string") : undefined;
-    const data = asObject(typed.data);
-    if (eventName === "on_custom_event") {
-        return {
-            ...(ns && ns.length > 0 ? { ns } : {}),
-            data: typed.data,
-        };
-    }
-    if (eventName === "on_chain_stream" && data && "custom" in data) {
-        return {
-            ...(ns && ns.length > 0 ? { ns } : {}),
-            data: data.custom,
-        };
-    }
-    return null;
-}
-export function normalizeUpstreamRuntimeEvent(event) {
-    const typed = asObject(event);
-    const tags = Array.isArray(typed?.tags) ? typed.tags.filter((item) => typeof item === "string") : undefined;
-    const ns = Array.isArray(typed?.ns) ? typed.ns.filter((item) => typeof item === "string") : undefined;
-    const name = typeof typed?.name === "string" ? typed.name : undefined;
-    const eventName = typeof typed?.event === "string" ? typed.event : undefined;
-    const runType = typeof typed?.run_type === "string" ? typed.run_type : undefined;
-    const data = asObject(typed?.data);
-    const metadata = asObject(typed?.metadata);
-    const normalized = normalizeUpstreamEventShape({
-        raw: event,
-        event: eventName,
-        name,
-        runType,
-        metadata,
-        tags,
-        data,
-        ns,
-    });
-    const streamPart = normalizeCompatibleStreamPart({
-        raw: event,
-        event: eventName,
-        name,
-        runType,
-        metadata,
-        tags,
-        data,
-        ns,
-        normalized,
-    });
-    return {
-        format: "langgraph-v2",
-        normalized,
-        raw: event,
-        event: eventName,
-        name,
-        runType,
-        data,
-        metadata,
-        ...(tags && tags.length > 0 ? { tags } : {}),
-        ...(ns && ns.length > 0 ? { ns } : {}),
-        streamPart,
-    };
-}
-function normalizeUpstreamEventShape(event) {
-    const nodeName = event.name;
-    const ns = event.ns;
-    const interruptPayload = extractInterruptPayload(event.raw);
-    if (interruptPayload) {
-        return {
-            kind: "interrupt",
-            interrupt: parseMaybeJson(interruptPayload),
-            ...(ns && ns.length > 0 ? { ns } : {}),
-            ...(nodeName ? { nodeName } : {}),
-        };
-    }
-    const reasoning = extractReasoningStreamOutput(event.raw);
-    if (reasoning) {
-        return {
-            kind: "reasoning-delta",
-            text: reasoning,
-            ...(ns && ns.length > 0 ? { ns } : {}),
-            ...(nodeName ? { nodeName } : {}),
-        };
-    }
-    const visibleText = extractVisibleStreamOutput(event.raw);
-    if (visibleText) {
-        return {
-            kind: "text-delta",
-            source: "model",
-            text: visibleText,
-            ...(ns && ns.length > 0 ? { ns } : {}),
-            ...(nodeName ? { nodeName } : {}),
-        };
-    }
-    const stateText = extractStateStreamOutput(event.raw);
-    if (stateText) {
-        return {
-            kind: "text-delta",
-            source: "state",
-            text: stateText,
-            ...(ns && ns.length > 0 ? { ns } : {}),
-            ...(nodeName ? { nodeName } : {}),
-        };
-    }
-    if (event.event === "on_tool_start" || (event.event === "on_chain_start" && event.runType === "tool")) {
-        return {
-            kind: "tool-start",
-            toolName: nodeName ?? "tool",
-            ...(event.data && "input" in event.data ? { input: event.data.input } : {}),
-            ...(ns && ns.length > 0 ? { ns } : {}),
-            ...(nodeName ? { nodeName } : {}),
-        };
-    }
-    const toolResult = extractToolResult(event.raw);
-    if (toolResult) {
-        return {
-            kind: "tool-end",
-            toolName: toolResult.toolName,
-            ...(toolResult.output !== undefined ? { output: toolResult.output } : {}),
-            ...(toolResult.isError !== undefined ? { isError: toolResult.isError } : {}),
-            ...(ns && ns.length > 0 ? { ns } : {}),
-            ...(nodeName ? { nodeName } : {}),
-        };
-    }
-    return {
-        kind: "run-event",
-        eventName: event.event ?? "unknown",
-        ...(event.data ? { data: event.data } : {}),
-        ...(ns && ns.length > 0 ? { ns } : {}),
-        ...(nodeName ? { nodeName } : {}),
-    };
-}
-function normalizeCompatibleStreamPart(event) {
-    const custom = extractCustomCompatibleStreamPart(event.raw);
-    if (custom) {
-        return custom;
-    }
-    const ns = event.ns ?? [];
-    const messageChunk = extractMessageCompatibleStreamPart(event);
-    if (messageChunk) {
-        return {
-            type: "messages",
-            ns,
-            data: [messageChunk, buildStreamPartMetadata(event)],
-        };
-    }
-    return {
-        type: "updates",
-        ns,
-        data: buildUpdateCompatiblePayload(event),
-    };
-}
-function buildStreamPartMetadata(event) {
-    return {
-        ...(event.metadata ?? {}),
-        ...(event.event ? { event: event.event } : {}),
-        ...(event.name ? { name: event.name } : {}),
-        ...(event.runType ? { run_type: event.runType } : {}),
-        ...(event.tags && event.tags.length > 0 ? { tags: event.tags } : {}),
-    };
-}
-function extractMessageCompatibleStreamPart(event) {
-    const typed = asObject(event.raw);
-    const data = asObject(typed?.data);
-    if (event.event === "on_chat_model_stream" && data && "chunk" in data) {
-        return data.chunk;
-    }
-    if (event.normalized.kind === "tool-end") {
-        return {
-            type: "tool",
-            name: event.normalized.toolName,
-            content: event.normalized.output,
-            ...(event.normalized.isError !== undefined ? { isError: event.normalized.isError } : {}),
-        };
-    }
-    return null;
-}
-function buildUpdateCompatiblePayload(event) {
-    const key = event.name ?? event.event ?? "event";
-    return {
-        [key]: extractUpdateNodePayload(event),
-    };
-}
-function extractUpdateNodePayload(event) {
-    const data = event.data;
-    if (event.event === "on_chain_stream" && data && "chunk" in data) {
-        return data.chunk;
-    }
-    if ((event.event === "on_tool_start" || event.event === "on_chain_start") && data && "input" in data) {
-        return { input: data.input };
-    }
-    if ((event.event === "on_tool_end" || event.event === "on_chain_end" || event.event === "on_chat_model_end") && data && "output" in data) {
-        return data.output;
-    }
-    if ((event.event === "on_tool_error" || event.event === "on_chain_error") && data) {
-        return {
-            ...(data.output !== undefined ? { output: data.output } : {}),
-            ...(data.error !== undefined ? { error: data.error } : {}),
-        };
-    }
-    if (event.normalized.kind === "interrupt") {
-        return { __interrupt__: event.normalized.interrupt };
-    }
-    return data ?? {};
-}
-export function extractCustomCompatibleStreamPart(event) {
-    const custom = extractCustomStreamData(event);
-    if (!custom) {
-        return null;
-    }
-    return {
-        type: "custom",
-        ns: custom.ns ?? [],
-        data: custom.data,
-    };
-}
 function parseMaybeJson(value) {
     const trimmed = value.trim();
     if (!trimmed.startsWith("{") && !trimmed.startsWith("[")) {

package/dist/upstream-events.d.ts

@@ -0,0 +1,20 @@
+export type UpstreamTimelineProjection = {
+    type: "thinking";
+    text: string;
+} | {
+    type: "step";
+    step: string;
+    category: "llm" | "tool" | "skill" | "memory" | "chain" | "approval";
+    status: "started" | "completed" | "failed";
+    key: string;
+} | {
+    type: "tool-result";
+    toolName: string;
+    output: unknown;
+    isError?: boolean;
+    key: string;
+};
+export type UpstreamTimelineReducer = {
+    consume: (event: unknown) => UpstreamTimelineProjection[];
+};
+export declare function createUpstreamTimelineReducer(): UpstreamTimelineReducer;

package/dist/upstream-events.js

@@ -0,0 +1,172 @@
+import { extractInterruptPayload, extractReasoningStreamOutput, extractToolResult } from "./runtime/parsing/index.js";
+function asObject(value) {
+    return typeof value === "object" && value !== null ? value : null;
+}
+function readStringArray(value) {
+    return Array.isArray(value) ? value.filter((item) => typeof item === "string") : [];
+}
+function normalizeSegment(value) {
+    return value
+        .replace(/[_-]+/g, " ")
+        .replace(/\s+/g, " ")
+        .trim();
+}
+function titleCase(value) {
+    return normalizeSegment(value)
+        .split(" ")
+        .filter(Boolean)
+        .map((part) => part.charAt(0).toUpperCase() + part.slice(1))
+        .join(" ");
+}
+function readEventContext(event) {
+    const typed = asObject(event);
+    return {
+        eventName: typeof typed?.event === 'string' ? typed.event : "",
+        name: typeof typed?.name === 'string' ? typed.name : "",
+        runType: typeof typed?.run_type === 'string' ? typed.run_type : "",
+        tags: readStringArray(typed?.tags),
+        ns: readStringArray(typed?.ns),
+    };
+}
+function containsSemanticHint(values, hint) {
+    return values.some((value) => hint.test(value));
+}
+function classifyStepCategory(context) {
+    const hints = [context.name, context.runType, ...context.tags, ...context.ns].map((value) => value.toLowerCase());
+    if (containsSemanticHint(hints, /\b(skill|skills)\b/)) {
+        return "skill";
+    }
+    if (containsSemanticHint(hints, /\b(memory|recall|store|checkpoint)\b/)) {
+        return "memory";
+    }
+    if (context.eventName.startsWith("on_tool_") || context.runType === "tool") {
+        return "tool";
+    }
+    return "chain";
+}
+function buildStepLabel(category, status, name) {
+    const displayName = titleCase(name || category);
+    if (category === "llm") {
+        return status === "started" ? `Calling LLM ${displayName}` : `Completed LLM ${displayName}`;
+    }
+    if (category === "tool") {
+        if (status === "failed") {
+            return `Tool ${displayName} failed`;
+        }
+        return status === "started" ? `Calling tool ${displayName}` : `Completed tool ${displayName}`;
+    }
+    if (category === "skill") {
+        return status === "started" ? `Calling skill ${displayName}` : `Completed skill ${displayName}`;
+    }
+    if (category === "memory") {
+        return status === "started" ? `Accessing memory ${displayName}` : `Completed memory ${displayName}`;
+    }
+    return status === "started" ? `Running ${displayName}` : `Completed ${displayName}`;
+}
+function createProjectionKey(parts) {
+    return JSON.stringify(parts);
+}
+export function createUpstreamTimelineReducer() {
+    const emittedStepKeys = new Set();
+    const emittedToolResultKeys = new Set();
+    return {
+        consume(event) {
+            const projections = [];
+            const context = readEventContext(event);
+            const reasoning = extractReasoningStreamOutput(event);
+            if (reasoning) {
+                projections.push({
+                    type: "thinking",
+                    text: reasoning,
+                });
+            }
+            const interruptPayload = extractInterruptPayload(event);
+            if (interruptPayload) {
+                const key = createProjectionKey(["approval", context.eventName || "interrupt", interruptPayload]);
+                if (!emittedStepKeys.has(key)) {
+                    emittedStepKeys.add(key);
+                    projections.push({
+                        type: "step",
+                        step: "Waiting for approval",
+                        category: "approval",
+                        status: "started",
+                        key,
+                    });
+                }
+            }
+            if (context.eventName === "on_chat_model_start") {
+                const stepName = context.name || "model";
+                const key = createProjectionKey(["llm", "started", stepName]);
+                if (!emittedStepKeys.has(key)) {
+                    emittedStepKeys.add(key);
+                    projections.push({
+                        type: "step",
+                        step: buildStepLabel("llm", "started", stepName),
+                        category: "llm",
+                        status: "started",
+                        key,
+                    });
+                }
+            }
+            if (context.eventName === "on_tool_start"
+                || (context.eventName === "on_chain_start" && context.runType === "tool")
+                || context.eventName === "on_chain_start") {
+                const category = classifyStepCategory(context);
+                if (category !== "llm") {
+                    const stepName = context.name || context.runType || "chain";
+                    const key = createProjectionKey([category, "started", stepName]);
+                    if (!emittedStepKeys.has(key)) {
+                        emittedStepKeys.add(key);
+                        projections.push({
+                            type: "step",
+                            step: buildStepLabel(category, "started", stepName),
+                            category,
+                            status: "started",
+                            key,
+                        });
+                    }
+                }
+            }
+            const toolResult = extractToolResult(event);
+            if (toolResult) {
+                const resultKey = createProjectionKey(["tool-result", toolResult.toolName, toolResult.output, toolResult.isError === true]);
+                if (!emittedToolResultKeys.has(resultKey)) {
+                    emittedToolResultKeys.add(resultKey);
+                    projections.push({
+                        type: "tool-result",
+                        toolName: toolResult.toolName,
+                        output: toolResult.output,
+                        ...(toolResult.isError !== undefined ? { isError: toolResult.isError } : {}),
+                        key: resultKey,
+                    });
+                }
+                const stepKey = createProjectionKey(["tool", toolResult.isError ? "failed" : "completed", toolResult.toolName]);
+                if (!emittedStepKeys.has(stepKey)) {
+                    emittedStepKeys.add(stepKey);
+                    projections.push({
+                        type: "step",
+                        step: buildStepLabel("tool", toolResult.isError ? "failed" : "completed", toolResult.toolName),
+                        category: "tool",
+                        status: toolResult.isError ? "failed" : "completed",
+                        key: stepKey,
+                    });
+                }
+            }
+            if (context.eventName === "on_chain_end" && context.runType !== "tool" && context.name) {
+                const category = classifyStepCategory(context);
+                const key = createProjectionKey([category, "completed", context.name]);
+                if (!emittedStepKeys.has(key)) {
+                    emittedStepKeys.add(key);
+                    projections.push({
+                        type: "step",
+                        step: buildStepLabel(category, "completed", context.name),
+                        category,
+                        status: "completed",
+                        key,
+                    });
+                }
+            }
+            return projections;
+        },
+    };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@botbotgo/agent-harness",
-  "version": "0.0.120",
+  "version": "0.0.121",
   "description": "Workspace runtime for multi-agent applications",
   "type": "module",
   "packageManager": "npm@10.9.2",

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

@@ -1,62 +0,0 @@
-export type NormalizedUpstreamEvent = {
-    kind: "text-delta";
-    source: "model" | "state";
-    text: string;
-    ns?: string[];
-    nodeName?: string;
-} | {
-    kind: "reasoning-delta";
-    text: string;
-    ns?: string[];
-    nodeName?: string;
-} | {
-    kind: "tool-start";
-    toolName: string;
-    input?: unknown;
-    ns?: string[];
-    nodeName?: string;
-} | {
-    kind: "tool-end";
-    toolName: string;
-    output?: unknown;
-    isError?: boolean;
-    ns?: string[];
-    nodeName?: string;
-} | {
-    kind: "interrupt";
-    interrupt: unknown;
-    ns?: string[];
-    nodeName?: string;
-} | {
-    kind: "run-event";
-    eventName: string;
-    data?: Record<string, unknown>;
-    ns?: string[];
-    nodeName?: string;
-};
-export type CompatibleStreamPart = {
-    type: "messages";
-    ns: string[];
-    data: [unknown, Record<string, unknown>];
-} | {
-    type: "updates";
-    ns: string[];
-    data: Record<string, unknown>;
-} | {
-    type: "custom";
-    ns: string[];
-    data: unknown;
-};
-export type UpstreamRuntimeEvent = {
-    format: "langgraph-v2";
-    normalized: NormalizedUpstreamEvent;
-    streamPart: CompatibleStreamPart;
-    raw: unknown;
-    event?: string;
-    name?: string;
-    runType?: string;
-    data?: Record<string, unknown>;
-    metadata?: Record<string, unknown>;
-    tags?: string[];
-    ns?: string[];
-};

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

@@ -1 +0,0 @@
-export {};