@output.ai/core 0.4.7 → 0.4.9-dev.pr326-21ac1cf

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@output.ai/core",
-  "version": "0.4.7",
+  "version": "0.4.9-dev.pr326-21ac1cf",
   "description": "The core module of the output framework",
   "type": "module",
   "exports": {

package/src/interface/workflow.js

@@ -3,7 +3,7 @@ import { proxyActivities, inWorkflowContext, executeChild, workflowInfo, uuid4,
 import { validateWorkflow } from './validations/static.js';
 import { validateWithSchema } from './validations/runtime.js';
 import { SHARED_STEP_PREFIX, ACTIVITY_GET_TRACE_DESTINATIONS, METADATA_ACCESS_SYMBOL } from '#consts';
-import { deepMerge, mergeActivityOptions, setMetadata } from '#utils';
+import { deepMerge, mergeActivityOptions, setMetadata, toUrlSafeBase64 } from '#utils';
 import { FatalError, ValidationError } from '#errors';
 
 /**
@@ -121,7 +121,7 @@ export function workflow( { name, description, inputSchema, outputSchema, fn, op
         startWorkflow: async ( childName, input, extra = {} ) =>
           executeChild( childName, {
             args: input ? [ input ] : [],
-            workflowId: `${workflowId}-${childName}-${uuid4()}`,
+            workflowId: `${workflowId}-${toUrlSafeBase64( uuid4() )}`,
             parentClosePolicy: ParentClosePolicy[extra?.detached ? 'ABANDON' : 'TERMINATE'],
             memo: {
               executionContext,

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

@@ -6,7 +6,8 @@ const envVarSchema = z.object( {
   OUTPUT_AWS_SECRET_ACCESS_KEY: z.string(),
   OUTPUT_TRACE_REMOTE_S3_BUCKET: z.string(),
   OUTPUT_REDIS_URL: z.string(),
-  OUTPUT_REDIS_TRACE_TTL: z.coerce.number().int().positive().default( 60 * 60 * 24 * 7 ) // 7 days
+  OUTPUT_REDIS_TRACE_TTL: z.coerce.number().int().positive().default( 60 * 60 * 24 * 7 ), // 7 days
+  OUTPUT_TRACE_UPLOAD_DELAY_MS: z.coerce.number().int().nonnegative().default( 10_000 ) // 10s
 } );
 
 const env = {};
@@ -19,6 +20,7 @@ export const loadEnv = () => {
   env.remoteS3Bucket = parsedFields.OUTPUT_TRACE_REMOTE_S3_BUCKET;
   env.redisUrl = parsedFields.OUTPUT_REDIS_URL;
   env.redisIncompleteWorkflowsTTL = parsedFields.OUTPUT_REDIS_TRACE_TTL;
+  env.traceUploadDelayMs = parsedFields.OUTPUT_TRACE_UPLOAD_DELAY_MS;
 };
 
 export const getVars = () => {

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

@@ -83,6 +83,12 @@ export const exec = async ( { entry, executionContext } ) => {
     return;
   }
 
+  // Wait for straggler entries from other workers to land in Redis before uploading
+  const delayMs = getVars().traceUploadDelayMs;
+  if ( delayMs > 0 ) {
+    await new Promise( resolve => setTimeout( resolve, delayMs ) );
+  }
+
   const content = buildTraceTree( await getEntries( cacheKey ) );
   // if the trace tree is incomplete it will return null, in this case we can safely discard
   if ( !content ) {

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

@@ -1,4 +1,4 @@
-import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
 
 const loadEnvMock = vi.fn();
 const getVarsMock = vi.fn( () => ( {
@@ -29,8 +29,13 @@ vi.mock( '../../tools/build_trace_tree.js', () => ( { default: buildTraceTreeMoc
 
 describe( 'tracing/processors/s3', () => {
   beforeEach( () => {
+    vi.useFakeTimers();
     vi.clearAllMocks();
-    getVarsMock.mockReturnValue( { remoteS3Bucket: 'bkt', redisIncompleteWorkflowsTTL: 3600 } );
+    getVarsMock.mockReturnValue( { remoteS3Bucket: 'bkt', redisIncompleteWorkflowsTTL: 3600, traceUploadDelayMs: 10_000 } );
+  } );
+
+  afterEach( () => {
+    vi.useRealTimers();
   } );
 
   it( 'init(): loads config and ensures redis client is created', async () => {
@@ -57,8 +62,10 @@ describe( 'tracing/processors/s3', () => {
 
     await exec( { ...ctx, entry: { name: 'A', phase: 'start', timestamp: startTime, parentId: 'root' } } );
     await exec( { ...ctx, entry: { name: 'A', phase: 'tick', timestamp: startTime + 1, parentId: 'root' } } );
-    // Root end: no parentId and not start
-    await exec( { ...ctx, entry: { name: 'A', phase: 'end', timestamp: startTime + 2 } } );
+    // Root end: no parentId and not start — triggers the 10s delay before upload
+    const endPromise = exec( { ...ctx, entry: { name: 'A', phase: 'end', timestamp: startTime + 2 } } );
+    await vi.advanceTimersByTimeAsync( 10_000 );
+    await endPromise;
 
     // Accumulation happened 3 times
     expect( redisMulti.zAdd ).toHaveBeenCalledTimes( 3 );
@@ -78,7 +85,7 @@ describe( 'tracing/processors/s3', () => {
   } );
 
   it( 'getDestination(): returns S3 URL using bucket and key from getVars', async () => {
-    getVarsMock.mockReturnValue( { remoteS3Bucket: 'my-bucket', redisIncompleteWorkflowsTTL: 3600 } );
+    getVarsMock.mockReturnValue( { remoteS3Bucket: 'my-bucket', redisIncompleteWorkflowsTTL: 3600, traceUploadDelayMs: 10_000 } );
     const { getDestination } = await import( './index.js' );
     const startTime = Date.parse( '2020-01-02T03:04:05.678Z' );
     const url = getDestination( { workflowId: 'id1', workflowName: 'WF', startTime } );
@@ -111,7 +118,9 @@ describe( 'tracing/processors/s3', () => {
     zRangeMock.mockResolvedValue( [ JSON.stringify( { id: 'wf', phase: 'end', timestamp: startTime } ) ] );
     buildTraceTreeMock.mockReturnValueOnce( null );
 
-    await exec( { ...ctx, entry: { id: 'wf', phase: 'end', timestamp: startTime } } );
+    const endPromise = exec( { ...ctx, entry: { id: 'wf', phase: 'end', timestamp: startTime } } );
+    await vi.advanceTimersByTimeAsync( 10_000 );
+    await endPromise;
 
     expect( buildTraceTreeMock ).toHaveBeenCalledTimes( 1 );
     expect( uploadMock ).not.toHaveBeenCalled();

package/src/utils/index.d.ts

@@ -116,3 +116,12 @@ export function shuffleArray( arr: array ): array;
  * @returns A new merged object.
  */
 export function deepMerge( a: object, b: object ): object;
+
+/**
+ * Shortens a UUID to a url-safe base64-like string (custom 64-char alphabet).
+ * Temporal-friendly: no Buffer or crypto; safe to use inside workflows.
+ *
+ * @param uuid - Standard UUID (e.g. `xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx`).
+ * @returns Short string using A–Z, a–z, 0–9, `_`, `-` (typically 21–22 chars).
+ */
+export function toUrlSafeBase64( uuid: string ): string;

package/src/utils/utils.js

@@ -195,3 +195,20 @@ export const deepMerge = ( a, b ) => {
     Object.assign( obj, { [k]: isPlainObject( v ) && isPlainObject( a[k] ) ? deepMerge( a[k], v ) : v } )
   , clone( a ) );
 };
+
+/**
+ * Shortens a UUID by re-encoding it to base62.
+ *
+ * This is a Temporal friendly, without crypto or Buffer.
+ * @param {string} uuid
+ * @returns {string}
+ */
+export const toUrlSafeBase64 = uuid => {
+  const alphabet = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789_-';
+  const alphabetLen = alphabet.length;
+  const base = BigInt( alphabetLen );
+  const hex = uuid.replace( /-/g, '' );
+
+  const toDigits = n => n <= 0n ? [] : toDigits( n / base ).concat( alphabet[Number( n % base )] );
+  return toDigits( BigInt( '0x' + hex ) ).join( '' );
+};

package/src/utils/utils.spec.js

@@ -1,6 +1,14 @@
 import { describe, it, expect } from 'vitest';
 import { Readable } from 'node:stream';
-import { clone, mergeActivityOptions, serializeBodyAndInferContentType, serializeFetchResponse, deepMerge, isPlainObject } from './utils.js';
+import {
+  clone,
+  mergeActivityOptions,
+  serializeBodyAndInferContentType,
+  serializeFetchResponse,
+  deepMerge,
+  isPlainObject,
+  toUrlSafeBase64
+} from './utils.js';
 
 describe( 'clone', () => {
   it( 'produces a deep copy without shared references', () => {
@@ -411,3 +419,43 @@ describe( 'isPlainObject', () => {
     expect( isPlainObject( zum ) ).toBe( false );
   } );
 } );
+
+describe( 'toUrlSafeBase64', () => {
+  const urlSafeAlphabet = /^[A-Za-z0-9_-]+$/;
+
+  it( 'returns a string for a valid UUID', () => {
+    const uuid = '550e8400-e29b-41d4-a716-446655440000';
+    expect( typeof toUrlSafeBase64( uuid ) ).toBe( 'string' );
+    expect( toUrlSafeBase64( uuid ).length ).toBeGreaterThan( 0 );
+  } );
+
+  it( 'output length is 21 or 22 for a standard UUID', () => {
+    const uuid = '550e8400-e29b-41d4-a716-446655440000';
+    const out = toUrlSafeBase64( uuid );
+    expect( out.length ).toBeGreaterThanOrEqual( 21 );
+    expect( out.length ).toBeLessThanOrEqual( 22 );
+  } );
+
+  it( 'output contains only url-safe alphabet characters', () => {
+    const uuid = '550e8400-e29b-41d4-a716-446655440000';
+    const out = toUrlSafeBase64( uuid );
+    expect( out ).toMatch( urlSafeAlphabet );
+  } );
+
+  it( 'is deterministic for the same UUID', () => {
+    const uuid = '6ba7b810-9dad-11d1-80b4-00c04fd430c8';
+    expect( toUrlSafeBase64( uuid ) ).toBe( toUrlSafeBase64( uuid ) );
+  } );
+
+  it( 'different UUIDs produce different strings', () => {
+    const a = toUrlSafeBase64( '550e8400-e29b-41d4-a716-446655440000' );
+    const b = toUrlSafeBase64( '6ba7b810-9dad-11d1-80b4-00c04fd430c8' );
+    expect( a ).not.toBe( b );
+  } );
+
+  it( 'strips hyphens and encodes hex (same as 32-char hex)', () => {
+    const withHyphens = '550e8400-e29b-41d4-a716-446655440000';
+    const hexOnly = '550e8400e29b41d4a716446655440000';
+    expect( toUrlSafeBase64( withHyphens ) ).toBe( toUrlSafeBase64( hexOnly ) );
+  } );
+} );