@outputai/core 0.4.1-dev.56c13a8.0 → 0.4.1-dev.7b85c96.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@outputai/core",
-  "version": "0.4.1-dev.56c13a8.0",
+  "version": "0.4.1-dev.7b85c96.0",
   "description": "The core module of the output framework",
   "type": "module",
   "exports": {
@@ -19,9 +19,6 @@
     "./sdk_utils": {
       "types": "./src/utils/index.d.ts",
       "import": "./src/utils/index.js"
-    },
-    "./sdk_tracing_tools": {
-      "import": "./src/tracing/tools/index.js"
     }
   },
   "files": [
@@ -36,6 +33,7 @@
   },
   "dependencies": {
     "@aws-sdk/client-s3": "3.1038.0",
+    "@aws-sdk/lib-storage": "3.1038.0",
     "@babel/generator": "7.29.1",
     "@babel/parser": "7.29.2",
     "@babel/traverse": "7.29.0",
@@ -45,6 +43,7 @@
     "@temporalio/common": "1.17.0",
     "@temporalio/worker": "1.17.0",
     "@temporalio/workflow": "1.17.0",
+    "json-stream-stringify": "3.1.6",
     "redis": "5.12.1",
     "stacktrace-parser": "0.1.11",
     "undici": "8.1.0",

package/src/activity_integration/events.d.ts

@@ -1,5 +1,10 @@
 /**
- * Emits a custom event
+ * Emits a custom event on the in-process message bus.
+ *
+ * The framework automatically attaches `workflowId`, `runId`, and `activityId`
+ * (pulled from `executionContext`) onto every emitted payload, so consumer
+ * subscribers registered via `on(...)` always receive those identifiers
+ * alongside whatever custom fields the emitter supplies.
  *
  * @param eventName - The name of the event to emit
  * @param payload - An optional payload to send to the event

package/src/activity_integration/events.js

@@ -5,6 +5,6 @@ export const emitEvent = ( eventName, payload ) => {
   const ctx = Storage.load();
 
   const { executionContext, parentId: activityId } = ctx ?? {};
-  const { workflowId } = executionContext ?? {};
-  messageBus.emit( `external:${eventName}`, { workflowId, activityId, ...payload ?? {} } );
+  const { workflowId, runId } = executionContext ?? {};
+  messageBus.emit( `external:${eventName}`, { ...payload ?? {}, workflowId, runId, activityId } );
 };

package/src/activity_integration/events.spec.js

@@ -0,0 +1,87 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+
+const loadMock = vi.hoisted( () => vi.fn() );
+const emitMock = vi.hoisted( () => vi.fn() );
+
+vi.mock( '#async_storage', () => ( {
+  Storage: { load: loadMock }
+} ) );
+
+vi.mock( '#bus', () => ( {
+  messageBus: { emit: emitMock }
+} ) );
+
+import { emitEvent } from './events.js';
+
+describe( 'emitEvent', () => {
+  beforeEach( () => {
+    vi.clearAllMocks();
+  } );
+
+  it( 'forwards workflowId, runId, and activityId from executionContext', () => {
+    loadMock.mockReturnValue( {
+      executionContext: { workflowId: 'wf-1', runId: 'run-1' },
+      parentId: 'act-1'
+    } );
+
+    emitEvent( 'cost:llm:request', { modelId: 'gpt-4o' } );
+
+    expect( emitMock ).toHaveBeenCalledWith( 'external:cost:llm:request', {
+      workflowId: 'wf-1',
+      runId: 'run-1',
+      activityId: 'act-1',
+      modelId: 'gpt-4o'
+    } );
+  } );
+
+  it( 'handles missing executionContext gracefully', () => {
+    loadMock.mockReturnValue( undefined );
+
+    emitEvent( 'foo:bar', { x: 1 } );
+
+    expect( emitMock ).toHaveBeenCalledWith( 'external:foo:bar', {
+      workflowId: undefined,
+      runId: undefined,
+      activityId: undefined,
+      x: 1
+    } );
+  } );
+
+  it( 'handles missing payload', () => {
+    loadMock.mockReturnValue( {
+      executionContext: { workflowId: 'wf-2', runId: 'run-2' },
+      parentId: 'act-2'
+    } );
+
+    emitEvent( 'lifecycle:start' );
+
+    expect( emitMock ).toHaveBeenCalledWith( 'external:lifecycle:start', {
+      workflowId: 'wf-2',
+      runId: 'run-2',
+      activityId: 'act-2'
+    } );
+  } );
+
+  it( 'does not let payload override workflowId / runId / activityId', () => {
+    loadMock.mockReturnValue( {
+      executionContext: { workflowId: 'wf-3', runId: 'run-3' },
+      parentId: 'act-3'
+    } );
+
+    emitEvent( 'cost:http:request', {
+      workflowId: 'should-be-overridden',
+      runId: 'should-be-overridden',
+      activityId: 'should-be-overridden',
+      url: 'https://example.com'
+    } );
+
+    // Context fields are spread after the payload, so caller-supplied
+    // workflowId / runId / activityId cannot escape the executionContext.
+    expect( emitMock ).toHaveBeenCalledWith( 'external:cost:http:request', {
+      workflowId: 'wf-3',
+      runId: 'run-3',
+      activityId: 'act-3',
+      url: 'https://example.com'
+    } );
+  } );
+} );

package/src/activity_integration/tracing.d.ts

@@ -42,5 +42,4 @@ export declare function addEventAttribute( args: { eventId: string; name: string
  */
 export declare const Attribute: {
   COST: 'cost';
-  TOKEN_USAGE: 'token_usage';
 };

package/src/activity_integration/tracing.js

@@ -49,6 +49,5 @@ export const addEventAttribute = ( { eventId, name, value } ) =>
  * Known attributes
  */
 export const Attribute = {
-  COST: 'cost',
-  TOKEN_USAGE: 'token_usage'
+  COST: 'cost'
 };

package/src/hooks/index.d.ts

@@ -16,8 +16,10 @@ export interface ErrorHookPayload {
  * Payload passed to the onWorkflowStart handler when a workflow run begins.
  */
 export interface WorkflowStartHookPayload {
-  /** Identifier of the workflow run. */
+  /** Workflow id (stable across retries / continue-as-new). */
   id: string;
+  /** Temporal run id for the current execution attempt. */
+  runId: string;
   /** Name of the workflow. */
   name: string;
 }
@@ -26,8 +28,10 @@ export interface WorkflowStartHookPayload {
  * Payload passed to the onWorkflowEnd handler when a workflow run completes successfully.
  */
 export interface WorkflowEndHookPayload {
-  /** Identifier of the workflow run. */
+  /** Workflow id (stable across retries / continue-as-new). */
   id: string;
+  /** Temporal run id for the current execution attempt. */
+  runId: string;
   /** Name of the workflow. */
   name: string;
   /** Duration of the workflow run in milliseconds. */
@@ -38,8 +42,10 @@ export interface WorkflowEndHookPayload {
  * Payload passed to the onWorkflowError handler when a workflow run fails.
  */
 export interface WorkflowErrorHookPayload {
-  /** Identifier of the workflow run. */
+  /** Workflow id (stable across retries / continue-as-new). */
   id: string;
+  /** Temporal run id for the current execution attempt. */
+  runId: string;
   /** Name of the workflow. */
   name: string;
   /** Elapsed time before failure in milliseconds. */
@@ -90,6 +96,37 @@ export declare function onWorkflowEnd( handler: ( payload: WorkflowEndHookPayloa
  */
 export declare function onWorkflowError( handler: ( payload: WorkflowErrorHookPayload ) => void ): void;
 
+/**
+ * Payload broadcast on the `http:request` event for every HTTP call issued
+ * through `@outputai/http`'s `fetch`. Fires for success, non-2xx, and network
+ * failure paths — `cost:http:request` continues to fire only when the consumer
+ * has attached a cost via `addRequestCost`.
+ *
+ * The framework auto-attaches `workflowId`, `runId`, and `activityId` onto the
+ * payload before broadcast, so consumers receive those identifiers in addition
+ * to the fields listed here.
+ */
+export interface HttpRequestHookPayload {
+  /** Workflow id (stable across retries / continue-as-new). */
+  workflowId: string;
+  /** Temporal run id for the current execution attempt. */
+  runId: string;
+  /** Activity / step id, when emitted from inside a step. */
+  activityId?: string;
+  /** UUID generated per request inside `@outputai/http`. */
+  requestId: string;
+  /** HTTP method (uppercase). */
+  method: string;
+  /** Absolute request URL. */
+  url: string;
+  /** HTTP status code; undefined on network failure. */
+  status?: number;
+  /** Elapsed time from request issuance to response (or failure), in milliseconds. */
+  durationMs: number;
+  /** Outcome bucket: `success` (2xx-3xx), `http_error` (>=400), `network_error` (DNS / timeout / abort). */
+  outcome: 'success' | 'http_error' | 'network_error';
+}
+
 /**
  * Register a handler to be invoked when a given event happens
  *

package/src/hooks/index.js

@@ -34,16 +34,16 @@ export const onBeforeWorkerStart = handler => messageBus.on( BusEventType.WORKER
   safeInvoke( handler, undefined, 'onBeforeWorkerStart' ) );
 
 /** Listen to workflow start events, excludes catalog workflow */
-export const onWorkflowStart = handler => messageBus.on( BusEventType.WORKFLOW_START, ( { id, name } ) =>
-  WORKFLOW_CATALOG !== name ? safeInvoke( handler, { id, name }, 'onWorkflowStart' ) : null );
+export const onWorkflowStart = handler => messageBus.on( BusEventType.WORKFLOW_START, ( { id, runId, name } ) =>
+  WORKFLOW_CATALOG !== name ? safeInvoke( handler, { id, runId, name }, 'onWorkflowStart' ) : null );
 
 /** Listen to workflow end events, excludes catalog workflow */
-export const onWorkflowEnd = handler => messageBus.on( BusEventType.WORKFLOW_END, ( { id, name, duration } ) =>
-  WORKFLOW_CATALOG !== name ? safeInvoke( handler, { id, name, duration }, 'onWorkflowEnd' ) : null );
+export const onWorkflowEnd = handler => messageBus.on( BusEventType.WORKFLOW_END, ( { id, runId, name, duration } ) =>
+  WORKFLOW_CATALOG !== name ? safeInvoke( handler, { id, runId, name, duration }, 'onWorkflowEnd' ) : null );
 
 /** Listen to workflow error events, excludes catalog workflow */
-export const onWorkflowError = handler => messageBus.on( BusEventType.WORKFLOW_ERROR, ( { id, name, duration, error } ) =>
-  WORKFLOW_CATALOG !== name ? safeInvoke( handler, { id, name, duration, error }, 'onWorkflowError' ) : null );
+export const onWorkflowError = handler => messageBus.on( BusEventType.WORKFLOW_ERROR, ( { id, runId, name, duration, error } ) =>
+  WORKFLOW_CATALOG !== name ? safeInvoke( handler, { id, runId, name, duration, error }, 'onWorkflowError' ) : null );
 
 /** Generic listener for events emitted elsewhere (outside core) */
 export const on = ( eventName, handler ) => messageBus.on( `external:${eventName}`, payload =>

package/src/interface/workflow.d.ts

@@ -63,7 +63,18 @@ export type WorkflowContext<
      *
      * @see {@link https://docs.temporal.io/workflow-execution/workflowid-runid#workflow-id}
      */
-    workflowId: string
+    workflowId: string,
+
+    /**
+     * Internal Temporal run id for the current execution attempt.
+     *
+     * A single `workflowId` can map to multiple `runId`s when a workflow is
+     * retried, reset, or continued-as-new. The current run can be pinned in
+     * downstream `/workflow/{id}/runs/{rid}/...` API calls.
+     *
+     * @see {@link https://docs.temporal.io/workflow-execution/workflowid-runid#run-id}
+     */
+    runId: string
   }
 };
 

package/src/interface/workflow.js

@@ -39,15 +39,20 @@ export function workflow( { name, description, inputSchema, outputSchema, fn, op
     // this returns a plain function, for example, in unit tests
     if ( !inWorkflowContext() ) {
       validateWithSchema( inputSchema, input, `Workflow ${name} input` );
-      const context = Context.build( { workflowId: 'test-workflow', continueAsNew: async () => {}, isContinueAsNewSuggested: () => false } );
+      const context = Context.build( {
+        workflowId: 'test-workflow',
+        runId: 'test-run',
+        continueAsNew: async () => {},
+        isContinueAsNewSuggested: () => false
+      } );
       const output = await fn( input, deepMerge( context, extra.context ) );
       validateWithSchema( outputSchema, output, `Workflow ${name} output` );
       return output;
     }
 
-    const { workflowId, memo, startTime } = workflowInfo();
+    const { workflowId, runId, memo, startTime } = workflowInfo();
 
-    const context = Context.build( { workflowId, continueAsNew, isContinueAsNewSuggested: () => workflowInfo().continueAsNewSuggested } );
+    const context = Context.build( { workflowId, runId, continueAsNew, isContinueAsNewSuggested: () => workflowInfo().continueAsNewSuggested } );
 
     // Root workflows will not have the execution context yet, since it is set here.
     const isRoot = !memo.executionContext;
@@ -57,6 +62,7 @@ export function workflow( { name, description, inputSchema, outputSchema, fn, op
        It will be used to as context for tracing (connecting events) */
     const executionContext = memo.executionContext ?? {
       workflowId,
+      runId,
       workflowName: name,
       disableTrace,
       startTime: startTime.getTime()

package/src/interface/workflow_context.js

@@ -7,11 +7,12 @@ export class Context {
    * Builds a new context instance
    * @param {object} options - Arguments to build a new context instance
    * @param {string} workflowId
+   * @param {string} runId
    * @param {function} continueAsNew
    * @param {function} isContinueAsNewSuggested
    * @returns {object} context
    */
-  static build( { workflowId, continueAsNew, isContinueAsNewSuggested } ) {
+  static build( { workflowId, runId, continueAsNew, isContinueAsNewSuggested } ) {
     return {
       /**
        * Control namespace: This object adds functions to interact with Temporal flow mechanisms
@@ -24,7 +25,8 @@ export class Context {
        * Info namespace: abstracts workflowInfo()
        */
       info: {
-        workflowId
+        workflowId,
+        runId
       }
     };
   }

package/src/tracing/processors/local/index.js

@@ -1,9 +1,11 @@
-import { appendFileSync, mkdirSync, readdirSync, readFileSync, rmSync, writeFileSync } from 'node:fs';
+import { appendFileSync, mkdirSync, readdirSync, readFileSync, rmSync, createWriteStream } from 'node:fs';
 import { dirname, join } from 'node:path';
 import { fileURLToPath } from 'url';
 import buildTraceTree from '../../tools/build_trace_tree.js';
-import { safeFormatJSON } from '../../tools/utils.js';
 import { EOL } from 'node:os';
+import { JsonStreamStringify } from 'json-stream-stringify';
+
+import { pipeline } from 'stream/promises';
 
 const __dirname = dirname( fileURLToPath( import.meta.url ) );
 
@@ -109,7 +111,7 @@ export const init = () => {
  * @param {object} args.executionContext - Execution info: workflowId, workflowName, startTime
  * @returns {void}
  */
-export const exec = ( { entry, executionContext } ) => {
+export const exec = async ( { entry, executionContext } ) => {
   const { workflowId, workflowName, startTime } = executionContext;
   const tempFilePath = createTempFilePath( executionContext );
   addEntry( entry, tempFilePath );
@@ -126,7 +128,11 @@ export const exec = ( { entry, executionContext } ) => {
   const path = join( dir, buildTraceFilename( { startTime, workflowId } ) );
 
   mkdirSync( dir, { recursive: true } );
-  writeFileSync( path, safeFormatJSON( content ) + EOL, 'utf-8' );
+
+  await pipeline(
+    new JsonStreamStringify( content ),
+    createWriteStream( path )
+  );
 };
 
 /**

package/src/tracing/processors/local/index.spec.js

@@ -1,5 +1,4 @@
 import { describe, it, expect, vi, beforeEach } from 'vitest';
-import { EOL } from 'node:os';
 
 // In-memory fs mock store
 const store = { files: new Map() };
@@ -12,6 +11,7 @@ const appendFileSyncMock = vi.fn( ( path, data ) => {
 const readFileSyncMock = vi.fn( path => store.files.get( path ) ?? '' );
 const readdirSyncMock = vi.fn( () => [] );
 const rmSyncMock = vi.fn();
+const createWriteStreamMock = vi.fn( path => ( { path } ) );
 
 vi.mock( 'node:fs', () => ( {
   mkdirSync: mkdirSyncMock,
@@ -19,9 +19,36 @@ vi.mock( 'node:fs', () => ( {
   appendFileSync: appendFileSyncMock,
   readFileSync: readFileSyncMock,
   readdirSync: readdirSyncMock,
-  rmSync: rmSyncMock
+  rmSync: rmSyncMock,
+  createWriteStream: createWriteStreamMock
 } ) );
 
+const pipelineMock = vi.fn( async ( source, destination ) => {
+  const chunks = [];
+  for await ( const chunk of source ) {
+    chunks.push( Buffer.isBuffer( chunk ) ? chunk : Buffer.from( chunk ) );
+  }
+  store.files.set( destination.path, Buffer.concat( chunks ).toString( 'utf8' ) );
+} );
+vi.mock( 'node:stream/promises', () => ( { pipeline: pipelineMock } ) );
+
+vi.mock( 'json-stream-stringify', async () => {
+  const { Readable } = await import( 'node:stream' );
+  return {
+    JsonStreamStringify: class extends Readable {
+      constructor( body ) {
+        super();
+        this.body = body;
+      }
+
+      _read() {
+        this.push( JSON.stringify( this.body ) );
+        this.push( null );
+      }
+    }
+  };
+} );
+
 const buildTraceTreeMock = vi.fn( entries => ( { count: entries.length } ) );
 vi.mock( '../../tools/build_trace_tree.js', () => ( { default: buildTraceTreeMock } ) );
 
@@ -58,17 +85,18 @@ describe( 'tracing/processors/local', () => {
     const workflowId = 'id1';
     const ctx = { executionContext: { workflowId, workflowName: 'WF', startTime } };
 
-    exec( { ...ctx, entry: rootStart( workflowId, startTime ) } );
-    exec( { ...ctx, entry: childTick( 'child-1', startTime + 1 ) } );
-    exec( { ...ctx, entry: rootEnd( workflowId, startTime + 2 ) } );
+    await exec( { ...ctx, entry: rootStart( workflowId, startTime ) } );
+    await exec( { ...ctx, entry: childTick( 'child-1', startTime + 1 ) } );
+    await exec( { ...ctx, entry: rootEnd( workflowId, startTime + 2 ) } );
 
     expect( buildTraceTreeMock ).toHaveBeenCalledTimes( 1 );
     expect( buildTraceTreeMock.mock.calls[0][0] ).toHaveLength( 3 );
 
-    expect( writeFileSyncMock ).toHaveBeenCalledTimes( 1 );
-    const [ writtenPath, content ] = writeFileSyncMock.mock.calls[0];
+    expect( createWriteStreamMock ).toHaveBeenCalledTimes( 1 );
+    expect( pipelineMock ).toHaveBeenCalledTimes( 1 );
+    const [ writtenPath ] = createWriteStreamMock.mock.calls[0];
     expect( writtenPath ).toMatch( /\/tmp\/project\/logs\/runs\/WF\// );
-    expect( JSON.parse( content.trim() ).count ).toBe( 3 );
+    expect( JSON.parse( store.files.get( writtenPath ) ).count ).toBe( 3 );
   } );
 
   it( 'exec(): does not build or write on non-flush entries', async () => {
@@ -79,11 +107,13 @@ describe( 'tracing/processors/local', () => {
     const workflowId = 'id1';
     const ctx = { executionContext: { workflowId, workflowName: 'WF', startTime } };
 
-    exec( { ...ctx, entry: rootStart( workflowId, startTime ) } );
-    exec( { ...ctx, entry: childTick( 'child-1', startTime + 1 ) } );
+    await exec( { ...ctx, entry: rootStart( workflowId, startTime ) } );
+    await exec( { ...ctx, entry: childTick( 'child-1', startTime + 1 ) } );
 
     expect( buildTraceTreeMock ).not.toHaveBeenCalled();
     expect( writeFileSyncMock ).not.toHaveBeenCalled();
+    expect( createWriteStreamMock ).not.toHaveBeenCalled();
+    expect( pipelineMock ).not.toHaveBeenCalled();
   } );
 
   it( 'exec(): flushes on error action before root end', async () => {
@@ -94,12 +124,13 @@ describe( 'tracing/processors/local', () => {
     const workflowId = 'id1';
     const ctx = { executionContext: { workflowId, workflowName: 'WF', startTime } };
 
-    exec( { ...ctx, entry: rootStart( workflowId, startTime ) } );
-    exec( { ...ctx, entry: { id: 'step-1', action: 'error', timestamp: startTime + 1 } } );
+    await exec( { ...ctx, entry: rootStart( workflowId, startTime ) } );
+    await exec( { ...ctx, entry: { id: 'step-1', action: 'error', timestamp: startTime + 1 } } );
 
     expect( buildTraceTreeMock ).toHaveBeenCalledTimes( 1 );
     expect( buildTraceTreeMock.mock.calls[0][0] ).toHaveLength( 2 );
-    expect( writeFileSyncMock ).toHaveBeenCalledTimes( 1 );
+    expect( createWriteStreamMock ).toHaveBeenCalledTimes( 1 );
+    expect( pipelineMock ).toHaveBeenCalledTimes( 1 );
   } );
 
   it( 'getDestination(): returns absolute path under callerDir logs', async () => {
@@ -128,11 +159,11 @@ describe( 'tracing/processors/local', () => {
     const workflowId = 'id1';
     const ctx = { executionContext: { workflowId, workflowName: 'WF', startTime } };
 
-    exec( { ...ctx, entry: rootStart( workflowId, startTime ) } );
-    exec( { ...ctx, entry: rootEnd( workflowId, startTime + 1 ) } );
+    await exec( { ...ctx, entry: rootStart( workflowId, startTime ) } );
+    await exec( { ...ctx, entry: rootEnd( workflowId, startTime + 1 ) } );
 
-    expect( writeFileSyncMock ).toHaveBeenCalledTimes( 1 );
-    const [ writtenPath ] = writeFileSyncMock.mock.calls[0];
+    expect( createWriteStreamMock ).toHaveBeenCalledTimes( 1 );
+    const [ writtenPath ] = createWriteStreamMock.mock.calls[0];
 
     expect( writtenPath ).not.toContain( '/host/path/logs' );
     expect( writtenPath ).toMatch( /\/tmp\/project\/logs\/runs\/WF\// );
@@ -164,15 +195,15 @@ describe( 'tracing/processors/local', () => {
     const workflowName = 'test-workflow';
     const ctx = { executionContext: { workflowId, workflowName, startTime } };
 
-    exec( { ...ctx, entry: rootStart( workflowId, startTime ) } );
-    exec( { ...ctx, entry: rootEnd( workflowId, startTime + 1 ) } );
+    await exec( { ...ctx, entry: rootStart( workflowId, startTime ) } );
+    await exec( { ...ctx, entry: rootEnd( workflowId, startTime + 1 ) } );
 
     const destination = getDestination( { startTime, workflowId, workflowName } );
 
-    const [ writtenPath, payload ] = writeFileSyncMock.mock.calls[0];
+    const [ writtenPath ] = createWriteStreamMock.mock.calls[0];
     expect( writtenPath ).not.toContain( '/Users/ben/project' );
     expect( writtenPath ).toMatch( /\/tmp\/project\/logs\/runs\/test-workflow\// );
-    expect( payload.endsWith( EOL ) ).toBe( true );
+    expect( JSON.parse( store.files.get( writtenPath ) ).count ).toBe( 2 );
 
     expect( destination ).toBe( '/Users/ben/project/logs/runs/test-workflow/2020-01-02-03-04-05-678Z_workflow-id-123.json' );
   } );

package/src/tracing/processors/s3/index.js

@@ -1,10 +1,9 @@
 import { upload } from './s3_client.js';
 import { getRedisClient } from './redis_client.js';
 import buildTraceTree from '../../tools/build_trace_tree.js';
-import { EOL } from 'node:os';
 import { loadEnv, getVars } from './configs.js';
 import { createChildLogger } from '#logger';
-import { safeFormatJSON } from '../../tools/utils.js';
+import { JsonStreamStringify } from 'json-stream-stringify';
 
 const log = createChildLogger( 'S3 Processor' );
 
@@ -100,9 +99,10 @@ export const exec = async ( { entry, executionContext } ) => {
     log.warn( 'Incomplete trace file discarded', { workflowId, error: 'incomplete_trace_file' } );
     return;
   }
+
   await upload( {
     key: getS3Key( { workflowId, workflowName, startTime } ),
-    content: safeFormatJSON( content ) + EOL
+    content: new JsonStreamStringify( content )
   } );
   await bustEntries( cacheKey );
 };

package/src/tracing/processors/s3/index.spec.js

@@ -27,6 +27,31 @@ vi.mock( './s3_client.js', () => ( { upload: uploadMock } ) );
 const buildTraceTreeMock = vi.fn( entries => ( { count: entries.length } ) );
 vi.mock( '../../tools/build_trace_tree.js', () => ( { default: buildTraceTreeMock } ) );
 
+vi.mock( 'json-stream-stringify', async () => {
+  const { Readable } = await import( 'node:stream' );
+  return {
+    JsonStreamStringify: class extends Readable {
+      constructor( body ) {
+        super();
+        this.body = body;
+      }
+
+      _read() {
+        this.push( JSON.stringify( this.body ) );
+        this.push( null );
+      }
+    }
+  };
+} );
+
+const streamToString = async stream => {
+  const chunks = [];
+  for await ( const chunk of stream ) {
+    chunks.push( Buffer.isBuffer( chunk ) ? chunk : Buffer.from( chunk ) );
+  }
+  return Buffer.concat( chunks ).toString( 'utf8' );
+};
+
 describe( 'tracing/processors/s3', () => {
   beforeEach( () => {
     vi.useFakeTimers();
@@ -74,7 +99,7 @@ describe( 'tracing/processors/s3', () => {
     expect( uploadMock ).toHaveBeenCalledTimes( 1 );
     const { key, content } = uploadMock.mock.calls[0][0];
     expect( key ).toMatch( /^WF\/2020\/01\/02\// );
-    expect( JSON.parse( content.trim() ).count ).toBe( 3 );
+    expect( JSON.parse( await streamToString( content ) ).count ).toBe( 3 );
     expect( delMock ).toHaveBeenCalledTimes( 1 );
     expect( delMock ).toHaveBeenCalledWith( 'traces/WF/id1' );
   } );

package/src/tracing/processors/s3/s3_client.js

@@ -1,4 +1,5 @@
-import { S3Client, PutObjectCommand } from '@aws-sdk/client-s3';
+import { S3Client } from '@aws-sdk/client-s3';
+import { Upload } from '@aws-sdk/lib-storage';
 import { getVars } from './configs.js';
 
 const state = { s3Client: null };
@@ -21,7 +22,14 @@ const getS3Client = () => {
  * Upload given file to S3
  * @param {object} args
  * @param {string} key - S3 file key
- * @param {string} content - File content
+ * @param {string|import('node:stream').Readable} content - File content
  */
 export const upload = ( { key, content } ) =>
-  getS3Client().send( new PutObjectCommand( { Bucket: getVars().remoteS3Bucket, Key: key, Body: content } ) );
+  new Upload( {
+    client: getS3Client(),
+    params: {
+      Bucket: getVars().remoteS3Bucket,
+      Key: key,
+      Body: content
+    }
+  } ).done();

package/src/tracing/processors/s3/s3_client.spec.js

@@ -9,24 +9,27 @@ vi.mock( '#utils', () => ( {
 const getVarsMock = vi.fn();
 vi.mock( './configs', () => ( { getVars: () => getVarsMock() } ) );
 
-const sendMock = vi.fn();
 const ctorState = { args: null };
 class S3ClientMock {
   constructor( args ) {
     ctorState.args = args;
-  } send = sendMock;
-}
-class PutObjectCommandMock {
-  constructor( input ) {
-    this.input = input;
   }
 }
-
 vi.mock( '@aws-sdk/client-s3', () => ( {
-  S3Client: S3ClientMock,
-  PutObjectCommand: PutObjectCommandMock
+  S3Client: S3ClientMock
 } ) );
 
+const uploadDoneMock = vi.fn();
+const uploadCtorState = { args: [] };
+class UploadMock {
+  constructor( args ) {
+    uploadCtorState.args.push( args );
+  }
+
+  done = uploadDoneMock;
+}
+vi.mock( '@aws-sdk/lib-storage', () => ( { Upload: UploadMock } ) );
+
 async function loadModule() {
   vi.resetModules();
   return import( './s3_client.js' );
@@ -35,6 +38,9 @@ async function loadModule() {
 describe( 'tracing/processors/s3/s3_client', () => {
   beforeEach( () => {
     vi.clearAllMocks();
+    ctorState.args = null;
+    uploadCtorState.args = [];
+    uploadDoneMock.mockResolvedValue( undefined );
     getVarsMock.mockReturnValue( {
       awsRegion: 'us-east-1',
       awsAccessKeyId: 'id',
@@ -48,15 +54,21 @@ describe( 'tracing/processors/s3/s3_client', () => {
 
     await upload( { key: 'wf/key.json', content: '{"a":1}' } );
 
-    expect( ctorState.args ).toEqual( { region: 'us-east-1', credentials: { secretAccessKey: 'sek', accessKeyId: 'id' } } );
-    expect( sendMock ).toHaveBeenCalledTimes( 1 );
-    const cmd = sendMock.mock.calls[0][0];
-    expect( cmd ).toBeInstanceOf( PutObjectCommandMock );
-    expect( cmd.input ).toEqual( { Bucket: 'bucket', Key: 'wf/key.json', Body: '{"a":1}' } );
+    expect( ctorState.args ).toEqual( {
+      region: 'us-east-1',
+      credentials: { secretAccessKey: 'sek', accessKeyId: 'id' }
+    } );
+    expect( uploadCtorState.args ).toHaveLength( 1 );
+    expect( uploadCtorState.args[0] ).toEqual( {
+      client: expect.any( S3ClientMock ),
+      params: { Bucket: 'bucket', Key: 'wf/key.json', Body: '{"a":1}' }
+    } );
+    expect( uploadDoneMock ).toHaveBeenCalledTimes( 1 );
 
     // subsequent upload uses cached client
     await upload( { key: 'wf/key2.json', content: '{}' } );
-    expect( sendMock ).toHaveBeenCalledTimes( 2 );
+    expect( uploadCtorState.args ).toHaveLength( 2 );
+    expect( uploadDoneMock ).toHaveBeenCalledTimes( 2 );
   } );
 } );
 

package/src/tracing/tools/utils.js

@@ -19,31 +19,3 @@ export const serializeError = error =>
     message: error.message,
     stack: error.stack
   };
-
-/**
- * Tries to stringify an object to an indented JSON string.
- * If its byte size is bigger than threshold returns a plain JSON string without formatting.
- *
- * @param {object|array} content
- * @param {*} [threshold] - The max allowed size to try to stringify with formatting (in bytes). Default is 50mb
- * @returns {string} String representation of the object
- */
-export const safeFormatJSON = ( content, threshold = 50 * 1024 * 1024 /* 50mb */ ) => {
-  const plainString = JSON.stringify( content );
-  const plainStringSize = Buffer.byteLength( plainString, 'utf8' );
-
-  if ( plainStringSize > threshold ) {
-    return plainString;
-  }
-  try {
-    return JSON.stringify( content, undefined, 2 );
-  } catch ( error ) {
-    // Only handles this specific error because other common parsing errors like:
-    // "TypeError: cyclic object value" and "RangeError: Maximum call stack size exceeded"
-    // would have been thrown on the first parsing.
-    if ( error instanceof RangeError && error.message === 'Invalid string length' ) {
-      return plainString;
-    }
-    throw error;
-  }
-};

package/src/tracing/tools/utils.spec.js

@@ -1,15 +1,5 @@
-import { describe, it, expect, vi } from 'vitest';
-import { safeFormatJSON, serializeError } from './utils.js';
-
-const isPrettyStringifyCall = args => args.length >= 3 && args[2] === 2;
-
-/** @param {number} targetBytes UTF-8 size of compact JSON.stringify( { a: "<xs>" } ) */
-const objectWithCompactByteLength = targetBytes => {
-  const sample = { a: '' };
-  const overhead = Buffer.byteLength( JSON.stringify( sample ), 'utf8' );
-  const repeat = Math.max( 0, targetBytes - overhead );
-  return { a: 'x'.repeat( repeat ) };
-};
+import { describe, it, expect } from 'vitest';
+import { serializeError } from './utils.js';
 
 describe( 'tracing/utils', () => {
   it( 'serializeError unwraps causes and keeps message/stack', () => {
@@ -21,126 +11,4 @@ describe( 'tracing/utils', () => {
     expect( out.message ).toBe( 'inner' );
     expect( typeof out.stack ).toBe( 'string' );
   } );
-
-  describe( 'safeFormatJSON', () => {
-    it( 'formats small objects with indentation when under threshold', () => {
-      const content = { a: 1, b: [ 2, 3 ] };
-      const out = safeFormatJSON( content, 10_000 );
-
-      expect( out ).toContain( '\n' );
-      expect( out ).toMatch( /^\{\n/ );
-      expect( JSON.parse( out ) ).toEqual( content );
-    } );
-
-    it( 'formats small arrays with indentation when under threshold', () => {
-      const content = [ 1, { nested: true } ];
-      const out = safeFormatJSON( content, 10_000 );
-
-      expect( out ).toContain( '\n' );
-      expect( out.trimStart() ).toMatch( /^\[/ );
-      expect( JSON.parse( out ) ).toEqual( content );
-    } );
-
-    it( 'returns compact JSON when compact UTF-8 size is strictly greater than threshold', () => {
-      const content = objectWithCompactByteLength( 40 );
-      const compact = JSON.stringify( content );
-      expect( Buffer.byteLength( compact, 'utf8' ) ).toBe( 40 );
-
-      const out = safeFormatJSON( content, 39 );
-      expect( out ).toBe( compact );
-      expect( out ).not.toContain( '\n  ' );
-      expect( JSON.parse( out ) ).toEqual( content );
-    } );
-
-    it( 'uses pretty JSON when compact UTF-8 size equals threshold', () => {
-      const content = objectWithCompactByteLength( 40 );
-      const compact = JSON.stringify( content );
-      expect( Buffer.byteLength( compact, 'utf8' ) ).toBe( 40 );
-
-      const out = safeFormatJSON( content, 40 );
-      expect( out ).not.toBe( compact );
-      expect( out ).toContain( '\n' );
-      expect( JSON.parse( out ) ).toEqual( content );
-    } );
-
-    it( 'uses UTF-8 byte length for threshold, not JavaScript string length', () => {
-      const content = { label: 'éclair' };
-      const compact = JSON.stringify( content );
-      expect( compact.length ).toBeLessThan( Buffer.byteLength( compact, 'utf8' ) );
-
-      const bytes = Buffer.byteLength( compact, 'utf8' );
-      const outCompact = safeFormatJSON( content, bytes - 1 );
-      expect( outCompact ).toBe( compact );
-
-      const outPretty = safeFormatJSON( content, bytes + 100 );
-      expect( outPretty ).toContain( '\n' );
-      expect( JSON.parse( outPretty ) ).toEqual( content );
-    } );
-
-    it( 'round-trips empty object and primitives for both branches', () => {
-      const tiny = {};
-      const pretty = safeFormatJSON( tiny, 100 );
-      expect( JSON.parse( pretty ) ).toEqual( tiny );
-
-      const forcedCompact = safeFormatJSON( tiny, 0 );
-      expect( JSON.parse( forcedCompact ) ).toEqual( tiny );
-    } );
-
-    it( 'returns compact JSON when pretty stringify throws Invalid string length', () => {
-      const content = { a: 1 };
-      const compact = JSON.stringify( content );
-      const origStringify = JSON.stringify.bind( JSON );
-
-      const spy = vi.spyOn( JSON, 'stringify' ).mockImplementation( ( ...args ) => {
-        if ( isPrettyStringifyCall( args ) ) {
-          throw new RangeError( 'Invalid string length' );
-        }
-        return origStringify( ...args );
-      } );
-
-      try {
-        const out = safeFormatJSON( content, 10_000 );
-        expect( out ).toBe( compact );
-        expect( JSON.parse( out ) ).toEqual( content );
-      } finally {
-        spy.mockRestore();
-      }
-    } );
-
-    it( 'rethrows RangeError when message is not Invalid string length', () => {
-      const content = { a: 1 };
-      const origStringify = JSON.stringify.bind( JSON );
-
-      const spy = vi.spyOn( JSON, 'stringify' ).mockImplementation( ( ...args ) => {
-        if ( isPrettyStringifyCall( args ) ) {
-          throw new RangeError( 'not the string length error' );
-        }
-        return origStringify( ...args );
-      } );
-
-      try {
-        expect( () => safeFormatJSON( content, 10_000 ) ).toThrow( RangeError );
-      } finally {
-        spy.mockRestore();
-      }
-    } );
-
-    it( 'rethrows non-RangeError from pretty stringify', () => {
-      const content = { a: 1 };
-      const origStringify = JSON.stringify.bind( JSON );
-
-      const spy = vi.spyOn( JSON, 'stringify' ).mockImplementation( ( ...args ) => {
-        if ( isPrettyStringifyCall( args ) ) {
-          throw new TypeError( 'cyclic structure' );
-        }
-        return origStringify( ...args );
-      } );
-
-      try {
-        expect( () => safeFormatJSON( content, 10_000 ) ).toThrow( TypeError );
-      } finally {
-        spy.mockRestore();
-      }
-    } );
-  } );
 } );

package/src/worker/sinks.js

@@ -11,8 +11,8 @@ export const sinks = {
   workflow: {
     start: {
       fn: ( workflowInfo, input ) => {
-        const { workflowId: id, workflowType: name, memo: { parentId, executionContext } } = workflowInfo;
-        messageBus.emit( BusEventType.WORKFLOW_START, { id, name } );
+        const { workflowId: id, runId, workflowType: name, memo: { parentId, executionContext } } = workflowInfo;
+        messageBus.emit( BusEventType.WORKFLOW_START, { id, runId, name } );
         if ( executionContext ) { // filters out internal workflows
           Tracing.addEventStart( { id, kind: ComponentType.WORKFLOW, name, details: input, parentId, executionContext } );
         }
@@ -22,8 +22,8 @@ export const sinks = {
 
     end: {
       fn: ( workflowInfo, output ) => {
-        const { workflowId: id, workflowType: name, startTime, memo: { executionContext } } = workflowInfo;
-        messageBus.emit( BusEventType.WORKFLOW_END, { id, name, duration: Date.now() - startTime.getTime() } );
+        const { workflowId: id, runId, workflowType: name, startTime, memo: { executionContext } } = workflowInfo;
+        messageBus.emit( BusEventType.WORKFLOW_END, { id, runId, name, duration: Date.now() - startTime.getTime() } );
         if ( executionContext ) { // filters out internal workflows
           Tracing.addEventEnd( { id, details: output, executionContext } );
         }
@@ -33,8 +33,8 @@ export const sinks = {
 
     error: {
       fn: ( workflowInfo, error ) => {
-        const { workflowId: id, workflowType: name, startTime, memo: { executionContext } } = workflowInfo;
-        messageBus.emit( BusEventType.WORKFLOW_ERROR, { id, name, error, duration: Date.now() - startTime.getTime() } );
+        const { workflowId: id, runId, workflowType: name, startTime, memo: { executionContext } } = workflowInfo;
+        messageBus.emit( BusEventType.WORKFLOW_ERROR, { id, runId, name, error, duration: Date.now() - startTime.getTime() } );
         if ( executionContext ) { // filters out internal workflows
           Tracing.addEventError( { id, details: error, executionContext } );
         }

package/src/tracing/tools/aggregate_trace_attributes.js

@@ -1,118 +0,0 @@
-/**
- * Aggregate `attributes.cost` and `attributes.token_usage` across an entire trace tree.
- *
- * Walks every node in the tree, sums `attributes.cost.total` grouped by the emitting
- * event name (inferred from node `kind` — see `eventNameForKind`), and sums
- * `attributes.token_usage` across LLM nodes. Falls back to `output.usage` on
- * legacy llm trace nodes that predate the `attributes.token_usage` write
- * (see overview §1.2).
- *
- * @typedef {object} TraceAttributes
- * @property {{ total: number, components: Array<{ name: string, value: number }> }} cost
- * @property {{ inputTokens: number, outputTokens: number, cachedInputTokens: number, totalTokens: number }} tokenUsage
- */
-
-const COST_EVENT_LLM = 'cost:llm:request';
-const COST_EVENT_HTTP = 'cost:http:request';
-const COST_EVENT_OTHER = 'other';
-
-/**
- * Map a trace node `kind` to the canonical cost event name that would emit it.
- * Unknown kinds bucket into `other` so future event sources still roll up cleanly.
- *
- * @param {string} kind
- * @returns {string}
- */
-const eventNameForKind = kind => {
-  if ( kind === 'llm' ) {
-    return COST_EVENT_LLM;
-  }
-  if ( kind === 'http' ) {
-    return COST_EVENT_HTTP;
-  }
-  return COST_EVENT_OTHER;
-};
-
-const isNumber = value => typeof value === 'number' && Number.isFinite( value );
-
-/**
- * Pull token usage off an llm node, preferring the new attribute over the legacy
- * `output.usage` fallback. Returns `null` when neither shape is present.
- */
-const readTokenUsage = node => {
-  const attrUsage = node.attributes?.token_usage;
-  if ( attrUsage && typeof attrUsage === 'object' ) {
-    return attrUsage;
-  }
-  const legacyUsage = node.output?.usage;
-  if ( legacyUsage && typeof legacyUsage === 'object' ) {
-    return legacyUsage;
-  }
-  return null;
-};
-
-/**
- * Recursively walk a trace tree depth-first, applying `visit` to each node.
- */
-const walk = ( node, visit ) => {
-  if ( !node ) {
-    return;
-  }
-  visit( node );
-  for ( const child of node.children ?? [] ) {
-    walk( child, visit );
-  }
-};
-
-/**
- * Build the aggregated `attributes` payload returned by `/trace-attributes`.
- * Component buckets always appear in a stable order so callers can index them
- * positionally if they want to.
- *
- * @param {object|null} root - The root NodeEntry returned by `buildTraceTree`.
- * @returns {TraceAttributes}
- */
-export default function aggregateTraceAttributes( root ) {
-  const costByEvent = new Map( [
-    [ COST_EVENT_LLM, 0 ],
-    [ COST_EVENT_HTTP, 0 ],
-    [ COST_EVENT_OTHER, 0 ]
-  ] );
-  const tokenUsage = { inputTokens: 0, outputTokens: 0, cachedInputTokens: 0, totalTokens: 0 };
-
-  walk( root, node => {
-    const cost = node.attributes?.cost;
-    if ( cost && isNumber( cost.total ) ) {
-      const eventName = eventNameForKind( node.kind );
-      costByEvent.set( eventName, ( costByEvent.get( eventName ) ?? 0 ) + cost.total );
-    }
-
-    if ( node.kind === 'llm' ) {
-      const usage = readTokenUsage( node );
-      if ( usage ) {
-        if ( isNumber( usage.inputTokens ) ) {
-          tokenUsage.inputTokens += usage.inputTokens;
-        }
-        if ( isNumber( usage.outputTokens ) ) {
-          tokenUsage.outputTokens += usage.outputTokens;
-        }
-        if ( isNumber( usage.cachedInputTokens ) ) {
-          tokenUsage.cachedInputTokens += usage.cachedInputTokens;
-        }
-        if ( isNumber( usage.totalTokens ) ) {
-          tokenUsage.totalTokens += usage.totalTokens;
-        }
-      }
-    }
-  } );
-
-  const components = Array.from( costByEvent, ( [ name, value ] ) => ( { name, value } ) );
-  const total = components.reduce( ( sum, { value } ) => sum + value, 0 );
-
-  return {
-    cost: { total, components },
-    tokenUsage
-  };
-}
-
-export { COST_EVENT_LLM, COST_EVENT_HTTP, COST_EVENT_OTHER };

package/src/tracing/tools/aggregate_trace_attributes.spec.js

@@ -1,231 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import aggregateTraceAttributes, {
-  COST_EVENT_LLM,
-  COST_EVENT_HTTP,
-  COST_EVENT_OTHER
-} from './aggregate_trace_attributes.js';
-
-const node = ( { id, kind = 'step', attributes = {}, output, children = [] } ) => ( {
-  id,
-  kind,
-  name: id,
-  startedAt: 0,
-  endedAt: 0,
-  input: undefined,
-  output,
-  attributes,
-  children
-} );
-
-describe( 'aggregate_trace_attributes', () => {
-  it( 'returns zeros for a null root', () => {
-    const result = aggregateTraceAttributes( null );
-    expect( result.cost.total ).toBe( 0 );
-    expect( result.cost.components ).toEqual( [
-      { name: COST_EVENT_LLM, value: 0 },
-      { name: COST_EVENT_HTTP, value: 0 },
-      { name: COST_EVENT_OTHER, value: 0 }
-    ] );
-    expect( result.tokenUsage ).toEqual( {
-      inputTokens: 0, outputTokens: 0, cachedInputTokens: 0, totalTokens: 0
-    } );
-  } );
-
-  it( 'returns zeros for a tree with no cost or usage attributes', () => {
-    const root = node( {
-      id: 'wf',
-      kind: 'workflow',
-      children: [ node( { id: 's1' } ), node( { id: 's2' } ) ]
-    } );
-    const result = aggregateTraceAttributes( root );
-    expect( result.cost.total ).toBe( 0 );
-    expect( result.tokenUsage.totalTokens ).toBe( 0 );
-  } );
-
-  it( 'buckets cost by node kind into llm / http / other components', () => {
-    const root = node( {
-      id: 'wf',
-      kind: 'workflow',
-      children: [
-        node( { id: 'llm-1', kind: 'llm', attributes: { cost: { total: 0.20 } } } ),
-        node( { id: 'llm-2', kind: 'llm', attributes: { cost: { total: 0.10 } } } ),
-        node( { id: 'http-1', kind: 'http', attributes: { cost: { total: 0.50 } } } ),
-        // Unknown kind falls into the catch-all bucket
-        node( { id: 'step-1', kind: 'step', attributes: { cost: { total: 0.07 } } } )
-      ]
-    } );
-    const result = aggregateTraceAttributes( root );
-
-    const byName = Object.fromEntries( result.cost.components.map( c => [ c.name, c.value ] ) );
-    expect( byName[COST_EVENT_LLM] ).toBeCloseTo( 0.30, 10 );
-    expect( byName[COST_EVENT_HTTP] ).toBeCloseTo( 0.50, 10 );
-    expect( byName[COST_EVENT_OTHER] ).toBeCloseTo( 0.07, 10 );
-    expect( result.cost.total ).toBeCloseTo( 0.87, 10 );
-  } );
-
-  it( 'total equals the sum of all components', () => {
-    const root = node( {
-      id: 'wf',
-      kind: 'workflow',
-      children: [
-        node( { id: 'llm-1', kind: 'llm', attributes: { cost: { total: 0.1234 } } } ),
-        node( { id: 'http-1', kind: 'http', attributes: { cost: { total: 0.0011 } } } )
-      ]
-    } );
-    const { cost } = aggregateTraceAttributes( root );
-    const sum = cost.components.reduce( ( s, c ) => s + c.value, 0 );
-    expect( cost.total ).toBeCloseTo( sum, 10 );
-  } );
-
-  it( 'sums token_usage across llm nodes from the attribute path', () => {
-    const root = node( {
-      id: 'wf',
-      kind: 'workflow',
-      children: [
-        node( {
-          id: 'llm-1', kind: 'llm', attributes: {
-            token_usage: { inputTokens: 100, outputTokens: 20, cachedInputTokens: 5, totalTokens: 125 }
-          }
-        } ),
-        node( {
-          id: 'llm-2', kind: 'llm', attributes: {
-            token_usage: { inputTokens: 50, outputTokens: 10, cachedInputTokens: 1, totalTokens: 61 }
-          }
-        } )
-      ]
-    } );
-    const { tokenUsage } = aggregateTraceAttributes( root );
-    expect( tokenUsage ).toEqual( {
-      inputTokens: 150,
-      outputTokens: 30,
-      cachedInputTokens: 6,
-      totalTokens: 186
-    } );
-  } );
-
-  it( 'falls back to output.usage on legacy llm nodes that lack attributes.token_usage', () => {
-    const root = node( {
-      id: 'wf',
-      kind: 'workflow',
-      children: [
-        // Legacy shape — usage lives on output.usage, no attributes.token_usage
-        node( {
-          id: 'llm-legacy',
-          kind: 'llm',
-          output: { result: '...', usage: { inputTokens: 200, outputTokens: 40, totalTokens: 240 } }
-        } )
-      ]
-    } );
-    const { tokenUsage } = aggregateTraceAttributes( root );
-    expect( tokenUsage.inputTokens ).toBe( 200 );
-    expect( tokenUsage.outputTokens ).toBe( 40 );
-    expect( tokenUsage.totalTokens ).toBe( 240 );
-    expect( tokenUsage.cachedInputTokens ).toBe( 0 );
-  } );
-
-  it( 'prefers attributes.token_usage over output.usage when both are present', () => {
-    const root = node( {
-      id: 'wf',
-      kind: 'workflow',
-      children: [
-        node( {
-          id: 'llm-1',
-          kind: 'llm',
-          attributes: { token_usage: { inputTokens: 10, outputTokens: 2, totalTokens: 12 } },
-          output: { usage: { inputTokens: 999, outputTokens: 999, totalTokens: 999 } }
-        } )
-      ]
-    } );
-    const { tokenUsage } = aggregateTraceAttributes( root );
-    expect( tokenUsage.inputTokens ).toBe( 10 );
-    expect( tokenUsage.totalTokens ).toBe( 12 );
-  } );
-
-  it( 'ignores token_usage shapes on non-llm nodes', () => {
-    const root = node( {
-      id: 'wf',
-      kind: 'workflow',
-      // attributes.token_usage on a non-llm node is intentionally ignored —
-      // only llm nodes contribute to the token-usage rollup today.
-      children: [
-        node( {
-          id: 'step-1', kind: 'step', attributes: {
-            token_usage: { inputTokens: 999, outputTokens: 999, totalTokens: 999 }
-          }
-        } )
-      ]
-    } );
-    const { tokenUsage } = aggregateTraceAttributes( root );
-    expect( tokenUsage.totalTokens ).toBe( 0 );
-  } );
-
-  it( 'aggregates a mixed tree with cost on http nodes and usage on llm nodes', () => {
-    const root = node( {
-      id: 'wf',
-      kind: 'workflow',
-      children: [
-        node( {
-          id: 'llm-1',
-          kind: 'llm',
-          attributes: {
-            cost: { total: 0.0038 },
-            token_usage: { inputTokens: 2264, outputTokens: 411, cachedInputTokens: 100, totalTokens: 2775 }
-          }
-        } ),
-        node( {
-          id: 'http-1',
-          kind: 'http',
-          attributes: { cost: { total: 0.50 } }
-        } )
-      ]
-    } );
-    const result = aggregateTraceAttributes( root );
-
-    const byName = Object.fromEntries( result.cost.components.map( c => [ c.name, c.value ] ) );
-    expect( byName[COST_EVENT_LLM] ).toBeCloseTo( 0.0038, 10 );
-    expect( byName[COST_EVENT_HTTP] ).toBeCloseTo( 0.50, 10 );
-    expect( byName[COST_EVENT_OTHER] ).toBe( 0 );
-    expect( result.cost.total ).toBeCloseTo( 0.5038, 10 );
-
-    expect( result.tokenUsage ).toEqual( {
-      inputTokens: 2264,
-      outputTokens: 411,
-      cachedInputTokens: 100,
-      totalTokens: 2775
-    } );
-  } );
-
-  it( 'recurses through nested children', () => {
-    const root = node( {
-      id: 'wf',
-      kind: 'workflow',
-      children: [
-        node( {
-          id: 's1',
-          kind: 'step',
-          children: [
-            node( {
-              id: 'llm-1', kind: 'llm', attributes: {
-                cost: { total: 0.01 },
-                token_usage: { inputTokens: 10, outputTokens: 5, totalTokens: 15 }
-              }
-            } )
-          ]
-        } )
-      ]
-    } );
-    const result = aggregateTraceAttributes( root );
-    expect( result.cost.total ).toBeCloseTo( 0.01, 10 );
-    expect( result.tokenUsage.totalTokens ).toBe( 15 );
-  } );
-
-  it( 'keeps the canonical component ordering: llm, http, other', () => {
-    const root = node( { id: 'wf', kind: 'workflow' } );
-    const { cost } = aggregateTraceAttributes( root );
-    expect( cost.components.map( c => c.name ) ).toEqual( [
-      COST_EVENT_LLM,
-      COST_EVENT_HTTP,
-      COST_EVENT_OTHER
-    ] );
-  } );
-} );

package/src/tracing/tools/index.js

@@ -1,7 +0,0 @@
-export { default as buildTraceTree } from './build_trace_tree.js';
-export {
-  default as aggregateTraceAttributes,
-  COST_EVENT_LLM,
-  COST_EVENT_HTTP,
-  COST_EVENT_OTHER
-} from './aggregate_trace_attributes.js';