@purista/harness 1.2.1 → 1.2.3

package/dist/sessions/index.js

@@ -3,6 +3,8 @@ import { ulid } from '../ulid/index.js';
 import { runDefaultAgent } from '../agents/index.js';
 import { runWorkflow } from '../workflows/index.js';
 import { createMemoryFacade, createSessionMemory } from '../ports/memory.js';
+import { beginDurableWorkflow, DURABLE_RUN_ID_PATTERN, isExecutableDurableRuntime } from '../runtime/sessionDurable.js';
+import { HarnessConfigError } from '../errors/catalog.js';
 import { loadSkillsSync } from '../skills/index.js';
 import { createModelRegistry } from '../models/registry.js';
 import { createMetrics, createTelemetryShim } from '../telemetry/index.js';
@@ -11,6 +13,82 @@ const NEVER_ABORT_SIGNAL = new AbortController().signal;
 function now() {
     return new Date().toISOString();
 }
+const STREAM_MAX_BUFFERED_EVENTS = 1024;
+const STREAM_TERMINAL_EVENT_TYPES = new Set(['run.finished', 'agent.finished']);
+/**
+ * Relay run events from an in-process run to a stream consumer.
+ *
+ * The unread events live in a bounded queue: consumed events are removed (no
+ * growing cursor over a shared array), and on overflow the oldest non-terminal
+ * unread event is dropped and counted, so a slow consumer never silently skips
+ * an unread event. Delivery is promise-notified rather than time-polled, so
+ * there is no fixed per-event latency or periodic timer.
+ */
+export async function* relayRunEvents(run) {
+    const queue = [];
+    let dropped = 0;
+    let liveRunId = 'unknown';
+    let done = false;
+    let failure;
+    let wake;
+    const notify = () => {
+        const resolve = wake;
+        wake = undefined;
+        resolve?.();
+    };
+    const result = run((event) => {
+        if ('runId' in event)
+            liveRunId = event.runId;
+        if (queue.length >= STREAM_MAX_BUFFERED_EVENTS) {
+            const dropIndex = queue.findIndex((candidate) => !STREAM_TERMINAL_EVENT_TYPES.has(candidate.type));
+            if (dropIndex >= 0) {
+                queue.splice(dropIndex, 1);
+                dropped += 1;
+            }
+        }
+        queue.push(event);
+        notify();
+        return Promise.resolve();
+    })
+        .catch((error) => {
+        failure = error;
+        return undefined;
+    })
+        .finally(() => {
+        done = true;
+        notify();
+    });
+    try {
+        while (true) {
+            if (dropped > 0) {
+                const droppedCount = dropped;
+                dropped = 0;
+                yield { type: 'stream.overflow', runId: liveRunId, at: now(), dropped: droppedCount };
+            }
+            while (queue.length > 0) {
+                yield queue.shift();
+                // Surface a fresh overflow notice promptly between events.
+                if (dropped > 0)
+                    break;
+            }
+            if (queue.length === 0 && dropped === 0) {
+                if (done) {
+                    break;
+                }
+                // No await between the empty check and installing `wake`, so a producer
+                // push cannot be lost between them.
+                await new Promise((resolve) => {
+                    wake = resolve;
+                });
+            }
+        }
+    }
+    finally {
+        await result.catch(() => undefined);
+    }
+    if (failure)
+        throw failure;
+}
 function validateInvokeOptions(opts) {
     if (opts?.historyWindow !== undefined && opts.historyWindow < 0) {
         throw new ValidationError('Invoke options are invalid.', { where: 'invoke_options', issues: { historyWindow: opts.historyWindow } });
@@ -30,6 +108,12 @@ function normalizeMessage(message, sessionId) {
 export function createSessionHarness(definition) {
     const resolvedSkills = loadSkillsSync(definition.skills);
     const sessionStates = new Map();
+    // In-flight session-state creations, memoized so concurrent first-time callers
+    // share one sandbox open (no orphaned sessions) and one SessionState object
+    // (so the synchronous busy check/set below serializes runs correctly).
+    const sessionStateOpenings = new Map();
+    // Stable per-harness-instance worker id used as the default durable lease owner.
+    const durableWorkerId = `worker_${ulid()}`;
     const contentCaptureMode = resolveContentCaptureMode(definition.telemetry);
     const telemetry = withTelemetryFlavor(definition.telemetryShim ?? createTelemetryShim(), definition.telemetry);
     const adapterMetrics = createMetrics(telemetry, { 'harness.name': definition.name });
@@ -45,6 +129,7 @@ export function createSessionHarness(definition) {
             toolTimeoutMs: definition.defaults.toolTimeoutMs ?? 120_000,
             skillTimeoutMs: definition.defaults.skillTimeoutMs ?? 60_000,
             modelTimeoutMs: definition.defaults.modelTimeoutMs ?? 300_000,
+            maxParallelToolCalls: definition.defaults.maxParallelToolCalls ?? 8,
             ...(definition.defaults.historyWindow !== undefined ? { historyWindow: definition.defaults.historyWindow } : {})
         }
     };
@@ -56,24 +141,36 @@ export function createSessionHarness(definition) {
         if (existing) {
             return existing;
         }
+        const createdAt = now();
         const created = {
             id: sessionId,
-            createdAt: now(),
-            updatedAt: now(),
+            createdAt,
+            updatedAt: createdAt,
             runCount: 0
         };
         await definition.state.upsertSession(created);
         return created;
     }
-    async function getSessionState(sessionId) {
+    function getSessionState(sessionId) {
         const existing = sessionStates.get(sessionId);
         if (existing) {
-            return existing;
+            return Promise.resolve(existing);
         }
-        const sandboxSession = await definition.sandbox.open({ sessionId, runId: `init_${ulid()}` });
-        const created = { busy: false, sandboxSession, mountedSkills: new Set() };
-        sessionStates.set(sessionId, created);
-        return created;
+        const pending = sessionStateOpenings.get(sessionId);
+        if (pending) {
+            return pending;
+        }
+        const opening = (async () => {
+            const sandboxSession = await definition.sandbox.open({ sessionId, runId: `init_${ulid()}` });
+            const created = { busy: false, sandboxSession, mountedSkills: new Set() };
+            sessionStates.set(sessionId, created);
+            sessionStateOpenings.delete(sessionId);
+            return created;
+        })();
+        // Let a failed open be retried instead of caching the rejection forever.
+        opening.catch(() => sessionStateOpenings.delete(sessionId));
+        sessionStateOpenings.set(sessionId, opening);
+        return opening;
     }
     async function appendEvents(runId, events) {
         try {
@@ -141,6 +238,21 @@ export function createSessionHarness(definition) {
     function memoryFacade(opts) {
         return createMemoryFacade(memoryOptions(opts.sessionId, opts.sandboxSession, opts.signal, opts));
     }
+    /**
+     * Validates `opts.durable` and returns the executable durable runtime, or
+     * `undefined` for an ephemeral run. Throws before any run record is created.
+     */
+    function resolveDurableRuntime(opts) {
+        if (!opts?.durable)
+            return undefined;
+        if (!DURABLE_RUN_ID_PATTERN.test(opts.durable.runId)) {
+            throw new ValidationError('Durable run id is invalid.', { where: 'invoke_options', issues: { 'durable.runId': opts.durable.runId } });
+        }
+        if (!isExecutableDurableRuntime(definition.runtime)) {
+            throw new HarnessConfigError('Durable execution requires an executable .runtime(...) adapter.', { reason: 'durable_runtime_required', path: 'runtime' });
+        }
+        return definition.runtime;
+    }
     return {
         inspect() {
             return definition.inspection;
@@ -202,14 +314,21 @@ export function createSessionHarness(definition) {
                             throw new ValidationError('Session history replacement failed validation.', { where: 'session_history', issues: { message } }, error);
                         }
                     });
-                    await definition.state.clearMessages(sessionId);
-                    if (parsed.length > 0) {
-                        await definition.state.appendMessages(sessionId, parsed);
+                    if (definition.state.replaceMessages) {
+                        await definition.state.replaceMessages(sessionId, parsed);
+                    }
+                    else {
+                        // Non-atomic fallback for adapters without atomic replace.
+                        await definition.state.clearMessages(sessionId);
+                        if (parsed.length > 0) {
+                            await definition.state.appendMessages(sessionId, parsed);
+                        }
                     }
                 },
                 async close() {
                     await definition.state.closeSession(sessionId);
                     sessionStates.delete(sessionId);
+                    sessionStateOpenings.delete(sessionId);
                     await state.sandboxSession.close();
                 }
             };
@@ -248,51 +367,13 @@ export function createSessionHarness(definition) {
         $infer: {}
     };
     async function* streamAgentCall(sessionId, agentId, agent, input, opts) {
-        const buffer = [];
-        const maxBufferedEvents = 1024;
-        let dropped = 0;
-        let done = false;
-        let failure;
-        let liveRunId = 'unknown';
-        const result = runAgentCall(sessionId, agentId, agent, input, opts, (event) => {
-            if ('runId' in event)
-                liveRunId = event.runId;
-            if (buffer.length >= maxBufferedEvents) {
-                const dropIndex = buffer.findIndex((candidate) => candidate.type !== 'run.finished');
-                if (dropIndex >= 0) {
-                    buffer.splice(dropIndex, 1);
-                    dropped += 1;
-                }
-            }
-            buffer.push(event);
-            return Promise.resolve();
-        }).catch((error) => {
-            failure = error;
-            return undefined;
-        }).finally(() => {
-            done = true;
-        });
-        let cursor = 0;
-        while (true) {
-            if (dropped > 0) {
-                yield { type: 'stream.overflow', runId: liveRunId, at: now(), dropped };
-                dropped = 0;
-            }
-            while (cursor < buffer.length) {
-                yield buffer[cursor];
-                cursor += 1;
-            }
-            if (done) {
-                await result.catch(() => undefined);
-                if (failure)
-                    throw failure;
-                return;
-            }
-            await new Promise((resolve) => setTimeout(resolve, 5));
-        }
+        yield* relayRunEvents((onEvent) => runAgentCall(sessionId, agentId, agent, input, opts, onEvent));
     }
     async function runAgentCall(sessionId, agentId, agent, input, opts, onEvent) {
         validateInvokeOptions(opts);
+        if (opts?.durable) {
+            throw new ValidationError('Durable execution is only supported for workflow runs.', { where: 'invoke_options', issues: { durable: 'agent_run' } });
+        }
         if (opts?.signal?.aborted) {
             throw new OperationCancelledError('Run was cancelled before start.', { scope: 'run' });
         }
@@ -352,7 +433,12 @@ export function createSessionHarness(definition) {
                     input,
                     history: await definition.state.listMessages(sessionId),
                     agent,
-                    models: modelRegistry,
+                    models: withRunEventModelRegistry(modelRegistry, {
+                        harnessName: definition.name,
+                        sessionId,
+                        runId,
+                        agentId
+                    }, emit),
                     skills: resolvedSkills,
                     customTools: definition.tools,
                     mcpRegistry,
@@ -363,6 +449,7 @@ export function createSessionHarness(definition) {
                     maxSteps: definition.defaults.agentMaxIterations ?? 16,
                     signal: runSignal.signal,
                     toolTimeoutMs: definition.defaults.toolTimeoutMs ?? 120_000,
+                    maxParallelToolCalls: definition.defaults.maxParallelToolCalls ?? 8,
                     logger: definition.logger,
                     telemetry,
                     emitEvent: emit,
@@ -418,51 +505,11 @@ export function createSessionHarness(definition) {
         }
     }
     async function* streamWorkflowCall(sessionId, workflowId, workflow, input, opts) {
-        const buffer = [];
-        const maxBufferedEvents = 1024;
-        let dropped = 0;
-        let done = false;
-        let failure;
-        let liveRunId = 'unknown';
-        const result = runWorkflowCall(sessionId, workflowId, workflow, input, opts, (event) => {
-            if ('runId' in event)
-                liveRunId = event.runId;
-            if (buffer.length >= maxBufferedEvents) {
-                const dropIndex = buffer.findIndex((candidate) => candidate.type !== 'run.finished');
-                if (dropIndex >= 0) {
-                    buffer.splice(dropIndex, 1);
-                    dropped += 1;
-                }
-            }
-            buffer.push(event);
-            return Promise.resolve();
-        }).catch((error) => {
-            failure = error;
-            return undefined;
-        }).finally(() => {
-            done = true;
-        });
-        let cursor = 0;
-        while (true) {
-            if (dropped > 0) {
-                yield { type: 'stream.overflow', runId: liveRunId, at: now(), dropped };
-                dropped = 0;
-            }
-            while (cursor < buffer.length) {
-                yield buffer[cursor];
-                cursor += 1;
-            }
-            if (done) {
-                await result.catch(() => undefined);
-                if (failure)
-                    throw failure;
-                return;
-            }
-            await new Promise((resolve) => setTimeout(resolve, 5));
-        }
+        yield* relayRunEvents((onEvent) => runWorkflowCall(sessionId, workflowId, workflow, input, opts, onEvent));
     }
     async function runWorkflowCall(sessionId, workflowId, workflow, input, opts, onEvent) {
         validateInvokeOptions(opts);
+        const durableRuntime = resolveDurableRuntime(opts);
         if (opts?.signal?.aborted) {
             throw new OperationCancelledError('Run was cancelled before start.', { scope: 'run' });
         }
@@ -473,7 +520,7 @@ export function createSessionHarness(definition) {
         }
         state.busy = true;
         const startedAt = now();
-        const runId = ulid();
+        const runId = opts?.durable ? opts.durable.runId : ulid();
         const memory = memoryFacade({
             sessionId,
             runId,
@@ -503,7 +550,22 @@ export function createSessionHarness(definition) {
             state.busy = false;
             throw error;
         }
+        let durableBinding;
         try {
+            if (durableRuntime && opts?.durable) {
+                durableBinding = await beginDurableWorkflow({
+                    runtime: durableRuntime,
+                    ...(definition.workspaceStore ? { workspaceStore: definition.workspaceStore } : {}),
+                    durable: opts.durable,
+                    defaultWorkerId: durableWorkerId,
+                    sessionId,
+                    workflowId,
+                    input: input,
+                    signal: runSignal.signal,
+                    logger: definition.logger,
+                    harnessName: definition.name
+                });
+            }
             const result = await withIncomingTraceContext(telemetry, opts, definition.logger, async () => telemetry.span('harness.session.prompt', {
                 'harness.name': definition.name,
                 'harness.session.id': sessionId,
@@ -528,10 +590,16 @@ export function createSessionHarness(definition) {
                         signal: runSignal.signal,
                         runId,
                         sessionId,
-                        models: modelRegistry,
+                        models: withRunEventModelRegistry(modelRegistry, {
+                            harnessName: definition.name,
+                            sessionId,
+                            runId,
+                            workflowId
+                        }, emit),
                         metadata: opts?.metadata ?? {},
                         metrics: workflowMetrics,
                         memory,
+                        step: durableBinding ? durableBinding.step : passthroughStep,
                         agents: Object.fromEntries(Object.entries(definition.agents).map(([agentId, agent]) => [
                             agentId,
                             async (agentInput, agentOpts) => {
@@ -557,7 +625,13 @@ export function createSessionHarness(definition) {
                                         input: agentInput,
                                         history: await definition.state.listMessages(sessionId),
                                         agent: agent,
-                                        models: modelRegistry,
+                                        models: withRunEventModelRegistry(modelRegistry, {
+                                            harnessName: definition.name,
+                                            sessionId,
+                                            runId,
+                                            workflowId,
+                                            agentId
+                                        }, emit),
                                         skills: resolvedSkills,
                                         customTools: definition.tools,
                                         mcpRegistry,
@@ -568,6 +642,7 @@ export function createSessionHarness(definition) {
                                         maxSteps: definition.defaults.agentMaxIterations ?? 16,
                                         signal: agentSignal.signal,
                                         toolTimeoutMs: definition.defaults.toolTimeoutMs ?? 120_000,
+                                        maxParallelToolCalls: definition.defaults.maxParallelToolCalls ?? 8,
                                         logger: definition.logger,
                                         telemetry,
                                         emitEvent: emit,
@@ -597,6 +672,9 @@ export function createSessionHarness(definition) {
                 }));
             }));
             const finishedAt = now();
+            if (durableBinding) {
+                await guardDurableStep({ sessionId, runId, workflowId, operation: 'finish_success' }, () => durableBinding.finishSuccess(result));
+            }
             const runFinished = { type: 'run.finished', runId, at: finishedAt, output: result };
             await emit(runFinished);
             await definition.state.finishRun(runId, { status: 'succeeded', finishedAt, output: result });
@@ -608,6 +686,9 @@ export function createSessionHarness(definition) {
             const finalError = normalizeRunError(error, runSignal.signal);
             const finishedAt = now();
             const serialized = serializeError(finalError);
+            if (durableBinding && finalError instanceof OperationCancelledError) {
+                await guardDurableStep({ sessionId, runId, workflowId, operation: 'finish_cancelled' }, () => durableBinding.finishCancelled(finalError));
+            }
             const log = finalError instanceof OperationCancelledError ? definition.logger.warn.bind(definition.logger) : definition.logger.error.bind(definition.logger);
             log('Harness workflow run failed.', {
                 harness: definition.name,
@@ -637,10 +718,41 @@ export function createSessionHarness(definition) {
             throw finalError;
         }
         finally {
+            // Releases the lease for a non-cancel failure so a retry with the same run
+            // id can resume; a no-op once the run was settled (success/cancel).
+            if (durableBinding)
+                await durableBinding.dispose();
             runSignal.cleanup();
             state.busy = false;
         }
     }
+    /** Pass-through step used when a workflow runs without durable execution. */
+    function passthroughStep(_stepId, fn) {
+        return fn();
+    }
+    /**
+     * Runs a durable finalization side effect (runtime finish / workspace lifecycle)
+     * without ever masking the primary run outcome (spec 21 §16.1 step 7).
+     */
+    async function guardDurableStep(args, step) {
+        try {
+            await step();
+        }
+        catch (error) {
+            telemetry.recordCounter('harness.runs.durable_errors', 1, {
+                harness: definition.name,
+                'harness.run.durable.operation': args.operation
+            });
+            definition.logger.error('Durable finalization step failed; preserving run outcome.', {
+                harness: definition.name,
+                session_id: args.sessionId,
+                run_id: args.runId,
+                workflow_id: args.workflowId,
+                operation: args.operation,
+                error: serializeError(error)
+            });
+        }
+    }
     async function terminalizeFailedRun(args) {
         await runFailureTerminalizationStep(args, 'emit_run_finished', args.emitRunFinished);
         await runFailureTerminalizationStep(args, 'finish_run', args.finishRun);
@@ -668,6 +780,100 @@ export function createSessionHarness(definition) {
         }
     }
 }
+function withRunEventModelRegistry(models, context, emitEvent) {
+    return Object.fromEntries(Object.entries(models).map(([alias, handle]) => [alias, withRunEventModelHandle(alias, handle, context, emitEvent)]));
+}
+function withRunEventModelHandle(alias, handle, context, emitEvent) {
+    if (!handle || typeof handle !== 'object')
+        return handle;
+    const source = handle;
+    const wrapped = { ...source };
+    for (const method of ['text', 'object', 'embed', 'rerank']) {
+        const fn = source[method];
+        if (typeof fn !== 'function')
+            continue;
+        wrapped[method] = (req, signal, ctx) => fn.call(source, req, signal, mergeModelRunContext(context, ctx));
+    }
+    const textStream = source['textStream'];
+    if (typeof textStream === 'function') {
+        wrapped['textStream'] = (req, signal, ctx) => {
+            const streamContext = modelStreamRunContext(context, ctx, alias);
+            return emitTextStreamRunEvents(textStream.call(source, req, signal, streamContext), streamContext, emitEvent);
+        };
+    }
+    const objectStream = source['objectStream'];
+    if (typeof objectStream === 'function') {
+        wrapped['objectStream'] = (req, signal, ctx) => {
+            const streamContext = modelStreamRunContext(context, ctx, alias);
+            return emitObjectStreamRunEvents(objectStream.call(source, req, signal, streamContext), streamContext, emitEvent);
+        };
+    }
+    return wrapped;
+}
+function mergeModelRunContext(context, override) {
+    return { ...context, ...(override ?? {}) };
+}
+function modelStreamRunContext(context, override, alias) {
+    const merged = mergeModelRunContext(context, override);
+    return {
+        ...merged,
+        modelAlias: alias,
+        ...(merged.emitRunEvents === true ? { streamId: `model_${ulid()}` } : {})
+    };
+}
+async function* emitTextStreamRunEvents(stream, context, emitEvent) {
+    for await (const chunk of stream) {
+        if (context.emitRunEvents === true && isTextDeltaChunk(chunk)) {
+            await emitEvent({
+                type: 'model.delta',
+                runId: context.runId,
+                ...(context.agentId ? { agentId: context.agentId } : {}),
+                ...(context.workflowId ? { workflowId: context.workflowId } : {}),
+                ...(context.modelAlias ? { modelAlias: context.modelAlias } : {}),
+                streamId: context.streamId,
+                delta: chunk.text
+            });
+        }
+        yield chunk;
+    }
+}
+async function* emitObjectStreamRunEvents(stream, context, emitEvent) {
+    for await (const chunk of stream) {
+        if (context.emitRunEvents === true && isObjectPartialChunk(chunk)) {
+            await emitEvent({
+                type: 'model.object.partial',
+                runId: context.runId,
+                ...(context.agentId ? { agentId: context.agentId } : {}),
+                ...(context.workflowId ? { workflowId: context.workflowId } : {}),
+                ...(context.modelAlias ? { modelAlias: context.modelAlias } : {}),
+                streamId: context.streamId,
+                partial: chunk.partial
+            });
+        }
+        else if (context.emitRunEvents === true && isObjectFinishChunk(chunk)) {
+            await emitEvent({
+                type: 'model.object',
+                runId: context.runId,
+                ...(context.agentId ? { agentId: context.agentId } : {}),
+                ...(context.workflowId ? { workflowId: context.workflowId } : {}),
+                ...(context.modelAlias ? { modelAlias: context.modelAlias } : {}),
+                ...(context.streamId ? { streamId: context.streamId } : {}),
+                object: chunk.object,
+                ...(chunk.usage ? { usage: chunk.usage } : {})
+            });
+        }
+        yield chunk;
+    }
+}
+function isTextDeltaChunk(chunk) {
+    return Boolean(chunk && typeof chunk === 'object' && chunk.kind === 'delta' && typeof chunk.text === 'string');
+}
+function isObjectPartialChunk(chunk) {
+    return Boolean(chunk && typeof chunk === 'object' && chunk.kind === 'partial');
+}
+function isObjectFinishChunk(chunk) {
+    return Boolean(chunk && typeof chunk === 'object' && chunk.kind === 'finish' && Object.prototype.hasOwnProperty.call(chunk, 'object'));
+}
 function configureHarnessAdapters(context, models, state, sandbox, memory, tools) {
     const seen = new Set();
     for (const alias of Object.values(models)) {
@@ -844,12 +1050,12 @@ function sanitizeEventForPersistence(event) {
         case 'model.message':
             return { agentId: event.agentId, message: '[redacted]' };
         case 'model.delta':
-            return { agentId: event.agentId, delta: '[redacted]' };
+            return { ...modelStreamEventMeta(event), delta: '[redacted]' };
         case 'model.object.partial':
-            return { ...(event.agentId ? { agentId: event.agentId } : {}), partial: '[redacted]' };
+            return { ...modelStreamEventMeta(event), partial: '[redacted]' };
         case 'model.object':
             return {
-                ...(event.agentId ? { agentId: event.agentId } : {}),
+                ...modelStreamEventMeta(event),
                 object: '[redacted]',
                 ...(event.usage ? { usage: event.usage } : {})
             };
@@ -869,8 +1075,22 @@ function sanitizeEventForPersistence(event) {
             };
         case 'stream.overflow':
             return { dropped: event.dropped };
+        default: {
+            // Exhaustiveness guard: adding a RunEvent variant without updating this
+            // sanitizer becomes a compile error instead of silently persisting undefined.
+            event;
+            return {};
+        }
     }
 }
+function modelStreamEventMeta(event) {
+    return {
+        ...(event.agentId ? { agentId: event.agentId } : {}),
+        ...(event.workflowId ? { workflowId: event.workflowId } : {}),
+        ...(event.modelAlias ? { modelAlias: event.modelAlias } : {}),
+        ...(event.streamId ? { streamId: event.streamId } : {})
+    };
+}
 function isJsonRecord(value) {
     return value !== null && typeof value === 'object' && !Array.isArray(value);
 }
@@ -891,9 +1111,11 @@ function normalizeSerializedRunError(error) {
 }
 function createRunSignal(parent, timeoutMs) {
     const controller = new AbortController();
-    const relay = () => controller.abort(parent?.reason);
+    const relay = () => controller.abort(runAbortReason(parent?.reason));
     if (parent)
         parent.addEventListener('abort', relay, { once: true });
+    if (parent?.aborted)
+        relay();
     const timeout = timeoutMs && timeoutMs > 0
         ? setTimeout(() => controller.abort(new OperationTimeoutError('Run timed out.', { scope: 'run', timeout_ms: timeoutMs })), timeoutMs)
         : undefined;
@@ -911,10 +1133,14 @@ function combineSignals(primary, secondary) {
     if (!secondary)
         return { signal: primary, cleanup: () => undefined };
     const controller = new AbortController();
-    const relayPrimary = () => controller.abort(primary.reason);
-    const relaySecondary = () => controller.abort(secondary.reason);
+    const relayPrimary = () => controller.abort(runAbortReason(primary.reason));
+    const relaySecondary = () => controller.abort(runAbortReason(secondary.reason));
     primary.addEventListener('abort', relayPrimary, { once: true });
     secondary.addEventListener('abort', relaySecondary, { once: true });
+    if (primary.aborted)
+        relayPrimary();
+    else if (secondary.aborted)
+        relaySecondary();
     return {
         signal: controller.signal,
         cleanup: () => {
@@ -923,3 +1149,8 @@ function combineSignals(primary, secondary) {
         }
     };
 }
+function runAbortReason(reason) {
+    if (reason instanceof OperationCancelledError || reason instanceof OperationTimeoutError)
+        return reason;
+    return new OperationCancelledError('Run was cancelled.', { scope: 'run' }, reason);
+}