@outputai/cli 0.10.1-next.37650c5.0 → 0.10.1-next.52bedcf.0

package/dist/commands/workflow/monitor.spec.js

@@ -0,0 +1,243 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { HttpError } from '#api/http_client.js';
+vi.mock('#services/workflow_history.js', () => ({ fetchWorkflowHistory: vi.fn(), fetchWorkflowHistoryUpdates: vi.fn() }));
+vi.mock('#utils/sleep.js', () => ({ sleep: vi.fn().mockResolvedValue(undefined) }));
+const span = (id, status, overrides = {}) => ({
+    id,
+    name: `Step ${id}`,
+    technicalName: `wf#step${id}`,
+    description: null,
+    status,
+    kind: 'activity',
+    attempt: 1,
+    startedAt: null,
+    scheduledAt: null,
+    completedAt: null,
+    startOffsetMs: 0,
+    endOffsetMs: 0,
+    durationMs: 1000,
+    failureMessage: null,
+    ...overrides
+});
+const history = (status, overrides = {}) => ({
+    workflow: { status },
+    runId: 'run-1',
+    events: [],
+    spans: [],
+    totalDurationMs: 0,
+    continuedAsNewRunId: null,
+    // Every result carries a cursor now (see workflow_history.ts) — `poll()` uses its
+    // presence to decide fetchWorkflowHistory vs. fetchWorkflowHistoryUpdates on the next tick.
+    cursor: { pageToken: 'token', lastEventId: 1, meta: null, runId: 'run-1', events: [] },
+    ...overrides
+});
+// `fetchWorkflowHistoryUpdates` (used from the second poll onward) wraps the same result
+// shape with a resume cursor; tests don't care about cursor contents, only that it's threaded.
+const update = (status, overrides = {}) => ({
+    result: history(status, overrides),
+    cursor: { pageToken: 'token', lastEventId: 1, meta: null, runId: 'run-1', events: [] }
+});
+describe('workflow monitor command', () => {
+    beforeEach(() => {
+        vi.clearAllMocks();
+        process.exitCode = undefined;
+    });
+    describe('command definition', () => {
+        it('exports a valid OCLIF command with a required workflowId arg', async () => {
+            const WorkflowMonitor = (await import('./monitor.js')).default;
+            expect(WorkflowMonitor).toBeDefined();
+            expect(WorkflowMonitor.args).toHaveProperty('workflowId');
+            expect(WorkflowMonitor.args.workflowId.required).toBe(true);
+        });
+        it('declares the expected flags and defaults', async () => {
+            const WorkflowMonitor = (await import('./monitor.js')).default;
+            const flags = WorkflowMonitor.flags;
+            expect(flags).toHaveProperty('run-id');
+            expect(flags).toHaveProperty('include-payloads');
+            expect(flags).toHaveProperty('interval');
+            expect(flags).toHaveProperty('color');
+            expect(flags.format.options).toEqual(['text', 'json']);
+            expect(flags.format.default).toBe('text');
+            expect(flags.interval.default).toBe(2500);
+            expect(flags.color.default).toBe(true);
+        });
+    });
+    describe('run()', () => {
+        const createCommand = async (flagOverrides = {}) => {
+            const WorkflowMonitor = (await import('./monitor.js')).default;
+            const { fetchWorkflowHistory, fetchWorkflowHistoryUpdates } = await import('#services/workflow_history.js');
+            const cmd = new WorkflowMonitor(['wf-1'], {});
+            cmd.log = vi.fn();
+            cmd.warn = vi.fn();
+            cmd.error = vi.fn((message) => {
+                throw new Error(message);
+            });
+            cmd.parse = vi.fn().mockResolvedValue({
+                args: { workflowId: 'wf-1' },
+                flags: {
+                    'run-id': undefined,
+                    format: 'text',
+                    'include-payloads': false,
+                    interval: 1,
+                    color: false,
+                    ...flagOverrides
+                }
+            });
+            return {
+                cmd,
+                fetchWorkflowHistory: vi.mocked(fetchWorkflowHistory),
+                fetchWorkflowHistoryUpdates: vi.mocked(fetchWorkflowHistoryUpdates)
+            };
+        };
+        it('prints span updates and exits cleanly when the workflow is already completed on the first poll', async () => {
+            const { cmd, fetchWorkflowHistory } = await createCommand();
+            fetchWorkflowHistory.mockResolvedValueOnce(history('completed', { spans: [span('1', 'completed')], totalDurationMs: 5000 }));
+            await cmd.run();
+            expect(fetchWorkflowHistory).toHaveBeenCalledTimes(1);
+            expect(cmd.log).toHaveBeenCalledWith(expect.stringContaining('Step 1'));
+            expect(cmd.log).toHaveBeenCalledWith(expect.stringContaining('workflow completed'));
+            expect(process.exitCode).toBeUndefined();
+        });
+        it('sets exit code 1 when the workflow ends in a failed status', async () => {
+            const { cmd, fetchWorkflowHistory } = await createCommand();
+            fetchWorkflowHistory.mockResolvedValueOnce(history('failed', {
+                spans: [span('1', 'failed', { failureMessage: 'boom' })], totalDurationMs: 1000
+            }));
+            await cmd.run();
+            expect(process.exitCode).toBe(1);
+        });
+        it('polls again while the workflow is running, then stops once it completes', async () => {
+            const { cmd, fetchWorkflowHistory, fetchWorkflowHistoryUpdates } = await createCommand();
+            fetchWorkflowHistory.mockResolvedValueOnce(history('running', { spans: [span('1', 'running')] }));
+            fetchWorkflowHistoryUpdates.mockResolvedValueOnce(update('completed', {
+                spans: [span('1', 'completed')], totalDurationMs: 2000
+            }));
+            await cmd.run();
+            expect(fetchWorkflowHistory).toHaveBeenCalledTimes(1);
+            expect(fetchWorkflowHistoryUpdates).toHaveBeenCalledTimes(1);
+            expect(cmd.log).toHaveBeenCalledWith(expect.stringContaining('running'));
+            expect(cmd.log).toHaveBeenCalledWith(expect.stringContaining('1s'));
+            expect(process.exitCode).toBeUndefined();
+        });
+        it('keeps a span label stable once printed, even when a same-named span appears on a later poll', async () => {
+            const { cmd, fetchWorkflowHistory, fetchWorkflowHistoryUpdates } = await createCommand();
+            fetchWorkflowHistory.mockResolvedValueOnce(history('running', { spans: [span('1', 'running', { name: 'Scrape Page' })] }));
+            // Span 2 shares span 1's name, only showing up on the second poll — buildSpanLabels
+            // would number both "#1"/"#2" if recomputed fresh, retroactively relabeling span 1's
+            // already-printed "running" line.
+            fetchWorkflowHistoryUpdates.mockResolvedValueOnce(update('completed', {
+                spans: [
+                    span('1', 'completed', { name: 'Scrape Page' }),
+                    span('2', 'completed', { name: 'Scrape Page' })
+                ]
+            }));
+            await cmd.run();
+            const lines = cmd.log.mock.calls.map(([line]) => line);
+            expect(lines.some((line) => line.includes('Scrape Page running'))).toBe(true);
+            // Span 1's completion line keeps its original unnumbered label...
+            expect(lines.some((line) => line.includes('Scrape Page  '))).toBe(true);
+            expect(lines.some((line) => line.includes('Scrape Page #1'))).toBe(false);
+            // ...while span 2, new this tick, is free to be numbered.
+            expect(lines.some((line) => line.includes('Scrape Page #2'))).toBe(true);
+        });
+        it('does not re-print a span whose status has not changed between polls', async () => {
+            const { cmd, fetchWorkflowHistory, fetchWorkflowHistoryUpdates } = await createCommand();
+            fetchWorkflowHistory.mockResolvedValueOnce(history('running', { spans: [span('1', 'running')] }));
+            fetchWorkflowHistoryUpdates.mockResolvedValueOnce(update('completed', {
+                spans: [span('1', 'running'), span('2', 'completed')], totalDurationMs: 1000
+            }));
+            await cmd.run();
+            const runningLines = cmd.log.mock.calls.filter(([line]) => line.includes('Step 1'));
+            expect(runningLines).toHaveLength(1); // span 1 only reported once, not again on the second poll
+        });
+        it('follows a continue-as-new chain by re-polling with the new run id', async () => {
+            const { cmd, fetchWorkflowHistory, fetchWorkflowHistoryUpdates } = await createCommand();
+            fetchWorkflowHistory
+                .mockResolvedValueOnce(history('continued_as_new', { continuedAsNewRunId: 'run-2' }))
+                // The new run's cursor was reset, so its first poll takes the same fast,
+                // non-waiting path as the very first poll of the command — not a resumed one.
+                .mockResolvedValueOnce(history('completed', { runId: 'run-2', totalDurationMs: 500 }));
+            await cmd.run();
+            expect(fetchWorkflowHistory).toHaveBeenCalledTimes(2);
+            expect(fetchWorkflowHistory).toHaveBeenNthCalledWith(2, expect.objectContaining({ runId: 'run-2' }));
+            expect(fetchWorkflowHistoryUpdates).not.toHaveBeenCalled();
+            expect(cmd.log).toHaveBeenCalledWith(expect.stringContaining('continued as new run run-2'));
+            expect(process.exitCode).toBeUndefined();
+        });
+        it('errors when the workflow continues as new but no new run id can be determined', async () => {
+            const { cmd, fetchWorkflowHistory } = await createCommand();
+            fetchWorkflowHistory.mockResolvedValueOnce(history('continued_as_new'));
+            await expect(cmd.run()).rejects.toThrow(/new run ID could not be determined/);
+        });
+        it('propagates a failure on the very first poll', async () => {
+            const { cmd, fetchWorkflowHistory } = await createCommand();
+            fetchWorkflowHistory.mockRejectedValue(new Error('network down'));
+            await expect(cmd.run()).rejects.toThrow('network down');
+            expect(fetchWorkflowHistory).toHaveBeenCalledTimes(1);
+        });
+        it('retries a transient network failure after the first successful poll instead of crashing', async () => {
+            const { cmd, fetchWorkflowHistory, fetchWorkflowHistoryUpdates } = await createCommand();
+            fetchWorkflowHistory.mockResolvedValueOnce(history('running'));
+            fetchWorkflowHistoryUpdates
+                .mockRejectedValueOnce(Object.assign(new Error('blip'), { code: 'ECONNRESET' }))
+                .mockResolvedValueOnce(update('completed', { totalDurationMs: 1000 }));
+            await cmd.run();
+            expect(fetchWorkflowHistory).toHaveBeenCalledTimes(1);
+            expect(fetchWorkflowHistoryUpdates).toHaveBeenCalledTimes(2);
+            expect(cmd.warn).toHaveBeenCalledWith(expect.stringContaining('(1/5)'));
+            expect(process.exitCode).toBeUndefined();
+        });
+        it('retries a transient 503 HttpError after the first successful poll', async () => {
+            const { cmd, fetchWorkflowHistory, fetchWorkflowHistoryUpdates } = await createCommand();
+            fetchWorkflowHistory.mockResolvedValueOnce(history('running'));
+            fetchWorkflowHistoryUpdates
+                .mockRejectedValueOnce(new HttpError('Service unavailable', { status: 503 }))
+                .mockResolvedValueOnce(update('completed', { totalDurationMs: 1000 }));
+            await cmd.run();
+            expect(fetchWorkflowHistoryUpdates).toHaveBeenCalledTimes(2);
+            expect(cmd.warn).toHaveBeenCalledWith(expect.stringContaining('(1/5)'));
+            expect(process.exitCode).toBeUndefined();
+        });
+        it('immediately rethrows a non-transient error (e.g. a stale resume cursor) without retrying', async () => {
+            const { cmd, fetchWorkflowHistory, fetchWorkflowHistoryUpdates } = await createCommand();
+            fetchWorkflowHistory.mockResolvedValueOnce(history('running'));
+            fetchWorkflowHistoryUpdates.mockRejectedValueOnce(new HttpError('Invalid page token', { status: 400 }));
+            await expect(cmd.run()).rejects.toThrow('Invalid page token');
+            expect(fetchWorkflowHistoryUpdates).toHaveBeenCalledTimes(1);
+            expect(cmd.warn).not.toHaveBeenCalled();
+        });
+        it('registers a SIGINT handler that detaches and exits 130 without affecting the workflow', async () => {
+            const { cmd, fetchWorkflowHistory } = await createCommand();
+            fetchWorkflowHistory.mockResolvedValueOnce(history('completed'));
+            const onSpy = vi.spyOn(process, 'on');
+            const exitSpy = vi.spyOn(process, 'exit').mockImplementation((() => undefined));
+            await cmd.run();
+            const sigintCall = onSpy.mock.calls.find(([event]) => event === 'SIGINT');
+            expect(sigintCall).toBeDefined();
+            const handler = sigintCall[1];
+            handler();
+            expect(exitSpy).toHaveBeenCalledWith(130);
+            expect(cmd.log).toHaveBeenCalledWith(expect.stringContaining('Detached'));
+            onSpy.mockRestore();
+            exitSpy.mockRestore();
+        });
+        it('emits NDJSON lines under --format json', async () => {
+            const { cmd, fetchWorkflowHistory } = await createCommand({ format: 'json' });
+            fetchWorkflowHistory.mockResolvedValueOnce(history('completed', { spans: [span('1', 'completed')], totalDurationMs: 1000 }));
+            await cmd.run();
+            const lines = cmd.log.mock.calls.map(([line]) => line);
+            expect(lines.every((line) => {
+                try {
+                    JSON.parse(line);
+                    return true;
+                }
+                catch {
+                    return false;
+                }
+            })).toBe(true);
+            expect(lines.some((line) => JSON.parse(line).span?.id === '1')).toBe(true);
+            expect(lines.some((line) => JSON.parse(line).monitoring === true)).toBe(true);
+        });
+    });
+});

package/dist/generated/framework_version.json

@@ -1,3 +1,3 @@
 {
-    "framework": "0.10.1-next.37650c5.0"
+    "framework": "0.10.1-next.52bedcf.0"
 }

package/dist/services/workflow_history/correlator.d.ts

@@ -19,6 +19,8 @@ export interface Span {
     output?: unknown;
 }
 export type HistoryEvent = Record<string, unknown>;
+export declare function eventTypeName(event: HistoryEvent): string;
+export declare function eventAttributes(event?: HistoryEvent): Record<string, unknown> | undefined;
 /**
  * @param events - flat Temporal history events, in chronological order
  * @param workflowStartTimeMs - epoch ms used as the timeline origin (0 offset)

package/dist/services/workflow_history/correlator.js

@@ -24,13 +24,13 @@ const CHILD_TERMINAL_TYPES = [
     'CHILD_WORKFLOW_EXECUTION_TIMED_OUT', 'CHILD_WORKFLOW_EXECUTION_CANCELED',
     'CHILD_WORKFLOW_EXECUTION_TERMINATED', 'START_CHILD_WORKFLOW_EXECUTION_FAILED'
 ];
-function eventTypeName(event) {
+export function eventTypeName(event) {
     return event.eventTypeName ?? '';
 }
 function eventId(event) {
     return String(event.eventId);
 }
-function eventAttributes(event) {
+export function eventAttributes(event) {
     const key = event && Object.keys(event).find(k => k.endsWith('EventAttributes'));
     return key ? event[key] : undefined;
 }

package/dist/services/workflow_history.d.ts

@@ -12,12 +12,40 @@ export interface FetchWorkflowHistoryOptions {
     workflowId: string;
     runId?: string;
     includePayloads?: boolean;
+    longPollTimeoutMs?: number;
 }
 export interface WorkflowHistoryResult {
     workflow: WorkflowMeta | null;
+    rawWorkflow: WorkflowMeta | null;
     runId: string | null;
     events: HistoryEvent[];
     spans: Span[];
     totalDurationMs: number;
+    continuedAsNewRunId: string | null;
+    cursor: WorkflowHistoryCursor;
+}
+/**
+ * Resume state for `fetchWorkflowHistoryUpdates`: the accumulated events (so spans/duration
+ * are always computed over the full history, not just the latest delta), `lastEventId` for
+ * de-duping a replayed page, and `pageToken` — the position that fetched the *current* end of
+ * history, which is itself always a valid resume point (see `fetchPages`) even though the
+ * server's own `nextPageToken` for that position is empty.
+ */
+export interface WorkflowHistoryCursor {
+    pageToken: string | undefined;
+    lastEventId: number;
+    meta: WorkflowMeta | null;
+    runId: string | undefined;
+    events: HistoryEvent[];
 }
 export declare function fetchWorkflowHistory(options: FetchWorkflowHistoryOptions): Promise<WorkflowHistoryResult>;
+/**
+ * Incremental counterpart to `fetchWorkflowHistory`, for a poller (`workflow monitor`) that
+ * calls repeatedly while a workflow is still running. Pass the previous call's `cursor`
+ * (from either function's result) to resume from where it left off instead of re-paging the
+ * whole history; omit it only to start a completely fresh walk.
+ */
+export declare function fetchWorkflowHistoryUpdates(options: FetchWorkflowHistoryOptions, cursor?: WorkflowHistoryCursor): Promise<{
+    result: WorkflowHistoryResult;
+    cursor: WorkflowHistoryCursor;
+}>;

package/dist/services/workflow_history.js

@@ -8,8 +8,20 @@
  * the `nextPageToken` (the endpoint requires runId once a pageToken is used).
  */
 import { getWorkflowIdHistory } from '#api/generated/api.js';
-import { correlate } from '#services/workflow_history/correlator.js';
+import { correlate, eventAttributes, eventTypeName } from '#services/workflow_history/correlator.js';
+import { normalizeWorkflowStatus } from '#utils/normalize_workflow_status.js';
+import { TERMINAL_STATUSES } from '#utils/format_workflow_result.js';
 const PAGE_SIZE = 50;
+// The status here comes from the request's own describe (fresh whenever `wait` is
+// set), so it can report the run closed before the closing event has been paged in.
+function isRunClosed(meta) {
+    const status = normalizeWorkflowStatus(meta?.status);
+    return status === 'continued_as_new' || (status !== undefined && TERMINAL_STATUSES.has(status));
+}
+function numericEventId(event) {
+    const id = Number(event.eventId);
+    return Number.isFinite(id) ? id : 0;
+}
 function toMs(value) {
     if (!value) {
         return null;
@@ -37,6 +49,13 @@ function workflowStartMs(meta, events) {
     }
     return earliestEventMs(events);
 }
+// The paginated history endpoint doesn't surface a resolved `newRunId` the way
+// the SSE stream endpoint does (see `stream_history.js`'s `doneChunk`), so pull
+// it directly off the WORKFLOW_EXECUTION_CONTINUED_AS_NEW event when present.
+function continuedAsNewRunId(events) {
+    const terminal = events.find(e => eventTypeName(e) === 'WORKFLOW_EXECUTION_CONTINUED_AS_NEW');
+    return eventAttributes(terminal)?.newExecutionRunId ?? null;
+}
 function totalDuration(meta, spans, startMs) {
     const closeMs = toMs(meta?.closeTime ?? undefined);
     if (closeMs !== null && startMs !== null && (closeMs - startMs) > 0) {
@@ -45,35 +64,99 @@ function totalDuration(meta, spans, startMs) {
     const maxEnd = spans.reduce((max, span) => Math.max(max, span.endOffsetMs), 0);
     return Math.max(maxEnd, 1);
 }
-async function fetchAllPages(workflowId, includePayloads, runId, pageToken, acc) {
-    const response = await getWorkflowIdHistory(workflowId, { runId, pageSize: PAGE_SIZE, pageToken, includePayloads });
+/**
+ * Pages through history starting from `acc` (its `pageToken`/`lastEventId`/`events` carry
+ * the resume position — pass a zeroed cursor for a fresh walk). When `longPollTimeoutMs` is
+ * set, every request asks the server to long-poll (`waitNewEvent`) rather than return
+ * immediately, so the final hop blocks — up to that many milliseconds (clamped to the server's
+ * ceiling) — until either a new event exists or the deadline elapses. `lastEventId` de-dupes:
+ * resuming from a previously-seen page token replays that page's events, which are filtered out
+ * here rather than appended twice.
+ */
+async function fetchPages(workflowId, includePayloads, acc, longPollTimeoutMs) {
+    const wait = longPollTimeoutMs !== undefined && longPollTimeoutMs > 0;
+    const { pageToken, runId } = acc;
+    const response = await getWorkflowIdHistory(workflowId, {
+        runId, pageSize: PAGE_SIZE, pageToken, includePayloads,
+        ...(wait ? { longPollTimeoutMs } : {})
+    });
     if (!response.data) {
         throw new Error('API returned invalid response (missing data)');
     }
     const data = response.data;
     // The generated `data.workflow` is an opaque `{ [key: string]: unknown }`, so
     // narrow it to WorkflowMeta via `unknown` (its real fields are validated by
-    // the server, mirroring Atlas's metadata shape).
-    const meta = acc.meta ?? data.workflow ?? null;
+    // the server, mirroring Atlas's metadata shape). Prefer the *fresh* value when the
+    // server sent one — it re-describes on every `wait` call specifically so status
+    // updates (e.g. running -> completed) are seen; falling back to `acc.meta` only
+    // covers the pages within a walk where the server didn't re-describe.
+    const meta = data.workflow ?? acc.meta;
     const resolvedRunId = runId ?? data.runId ?? acc.runId;
-    const events = [...acc.events, ...(data.events ?? [])];
+    const pageEvents = data.events ?? [];
+    const newEvents = pageEvents.filter(event => numericEventId(event) > acc.lastEventId);
+    const events = [...acc.events, ...newEvents];
+    // Events arrive in increasing eventId order, so the last new one is the max — no scan needed.
+    const lastEventId = newEvents.length > 0 ? numericEventId(newEvents[newEvents.length - 1]) : acc.lastEventId;
     const nextToken = data.nextPageToken ?? undefined;
-    const nextAcc = { meta, runId: resolvedRunId, events };
+    const nextAcc = { meta, runId: resolvedRunId, events, lastEventId, pageToken: nextToken ?? pageToken };
+    // While long-polling an open run, stop and hand back the first batch of new events
+    // instead of draining further pages — a poller needs each transition rendered as it
+    // arrives, and the buffered remainder will surface on subsequent ticks. Once the run
+    // is closed, though, no further ticks are coming: the poller acts on the closed
+    // status immediately, so stopping early would strand the trailing pages — including
+    // the terminal or CONTINUED_AS_NEW event — unfetched. Drain to the tip instead.
+    if (wait && newEvents.length > 0 && !isRunClosed(meta)) {
+        return nextAcc;
+    }
+    // The server echoes `pageToken` back unchanged (see `get_history.js`) when a waitNewEvent
+    // call's deadline elapses with nothing new — that's the tip, stop for this tick.
+    const timedOut = wait && nextToken === pageToken;
+    if (timedOut) {
+        return nextAcc;
+    }
     if (nextToken) {
-        return fetchAllPages(workflowId, includePayloads, resolvedRunId, nextToken, nextAcc);
+        return fetchPages(workflowId, includePayloads, nextAcc, longPollTimeoutMs);
     }
+    // Drained: the server has nothing more buffered (`nextToken` is empty), but unlike
+    // `nextToken`, `pageToken` — the position that fetched this now-empty page — is still a
+    // valid resume point: a future waitNewEvent call from here replays this page (de-duped by
+    // `lastEventId`) and then genuinely waits at the tip, instead of restarting from page 1.
     return nextAcc;
 }
-export async function fetchWorkflowHistory(options) {
-    const { workflowId, runId, includePayloads = false } = options;
-    const { meta, runId: resolvedRunId, events } = await fetchAllPages(workflowId, includePayloads, runId, undefined, { meta: null, runId, events: [] });
+function buildResult(pages) {
+    const { meta: rawMeta, runId: resolvedRunId, events } = pages;
+    // Normalize once here so every consumer (monitor, history, etc.) sees the
+    // same status vocabulary, matching status.ts/workflow_runs.ts/etc.
+    const status = normalizeWorkflowStatus(rawMeta?.status);
+    const meta = rawMeta ? { ...rawMeta, status } : rawMeta;
     const startMs = workflowStartMs(meta, events);
     const spans = correlate(events, startMs);
     return {
         workflow: meta,
+        rawWorkflow: rawMeta,
         runId: resolvedRunId ?? meta?.runId ?? null,
         events,
         spans,
-        totalDurationMs: totalDuration(meta, spans, startMs)
+        totalDurationMs: totalDuration(meta, spans, startMs),
+        continuedAsNewRunId: continuedAsNewRunId(events),
+        cursor: pages
     };
 }
+export async function fetchWorkflowHistory(options) {
+    const { workflowId, runId, includePayloads = false } = options;
+    const pages = await fetchPages(workflowId, includePayloads, { meta: null, runId, events: [], lastEventId: 0, pageToken: undefined });
+    return buildResult(pages);
+}
+/**
+ * Incremental counterpart to `fetchWorkflowHistory`, for a poller (`workflow monitor`) that
+ * calls repeatedly while a workflow is still running. Pass the previous call's `cursor`
+ * (from either function's result) to resume from where it left off instead of re-paging the
+ * whole history; omit it only to start a completely fresh walk.
+ */
+export async function fetchWorkflowHistoryUpdates(options, cursor) {
+    const { workflowId, includePayloads = false, longPollTimeoutMs } = options;
+    const seed = cursor ??
+        { meta: null, runId: options.runId, events: [], lastEventId: 0, pageToken: undefined };
+    const pages = await fetchPages(workflowId, includePayloads, seed, longPollTimeoutMs);
+    return { result: buildResult(pages), cursor: pages };
+}