STREAM_FLUSH_INTERVAL_MS should be configurable per-world

[jcourson-bg]

WorkflowServerWritableStream buffers writes for 10ms before flushing (STREAM_FLUSH_INTERVAL_MS in packages/core/src/serialization.ts). This makes sense for world-vercel where each flush is an HTTP PUT, but for backends like Redis where XADD is sub-millisecond, the buffer just adds latency for no benefit (chunky ai outputs).

The constant is hardcoded and there's no env var or runtime option to change it. Every world pays the same 10ms delay regardless of how cheap its writes are.

I want to use a hybrid world (Postgres for storage/queue, Redis for streams):

import { createWorld as createPostgresWorld } from '@workflow/world-postgres';
import { createStreamer as createRedisStreamer } from '@workflow-worlds/redis';
import type { World } from '@workflow/world';

export function createHybridWorld(config: {
  postgresUrl: string;
  redisUrl: string;
}): World {
  const pgWorld = createPostgresWorld({
    connectionString: config.postgresUrl,
  });
  
  // Redis streamer from the community package
  const { streamer: redisStreamer, close: closeRedis } = await createRedisStreamer({
    redis: new Redis(config.redisUrl),
  });

  return {
    // Storage, queue, everything else from Postgres
    ...pgWorld,
    // Override just the stream methods with Redis
    ...redisStreamer,
    async start() {
      await pgWorld.start();
    },
    async close() {
      await closeRedis();
      await pgWorld.close?.();
    },
  };
}

But the 10ms buffering lives in core's WorkflowServerWritableStream, not in the world - so even with a fast Redis streamer, every write still sits in the buffer before writeToStream is ever called. There's no way for a world to opt out of it.

[VaguelySerious]

(AI) Reproduction: The issue is confirmed by reading the code — STREAM_FLUSH_INTERVAL_MS is hardcoded as a module-level constant (10ms) in packages/core/src/serialization.ts and used directly in WorkflowServerWritableStream's scheduleFlush. There is no way for a world implementation to override it.

Related issues: No duplicates or related issues found.

Fix: #1533 adds an optional streamFlushIntervalMs property to the Streamer interface in @workflow/world. WorkflowServerWritableStream reads this from the active world, falling back to the existing 10ms default. world-local and world-postgres expose it as a config option. world-vercel always uses the default (10ms) since its HTTP-based writes benefit from batching.

Usage:

import { createWorld } from '@workflow/world-postgres';

const world = createWorld({
  connectionString: process.env.DATABASE_URL,
  streamFlushIntervalMs: 0, // immediate flush for low-latency backends
});

To see if this fix solves your issue, could you try to install the pre-release in your package.json? Just replace the workflow dep like so:

{
  "dependencies": {
    "workflow": "https://workflow-docs-pfooddbi6.vercel.sh/workflow.tgz",
    "@workflow/ai": "https://workflow-docs-pfooddbi6.vercel.sh/workflow-ai.tgz"
  }
}