@theoremjs/agents 0.0.0-stage → 0.3.0

package/esm/src/kernel/engine/runner/stages.d.ts

@@ -0,0 +1,28 @@
+import { type InjectUnit, type StageApplyWarning, type StageCallBag, type StageContext, type StageHandler } from '../../stages.js';
+import type { Profile, ResolvedGeneration, TurnEvent, TurnStage } from '../../types.js';
+import type { StepExecutionState } from './state.js';
+export interface ApplyTurnStageArgs extends StageCallBag {
+    profile: Profile;
+    generation: ResolvedGeneration;
+    state: StepExecutionState;
+    stage: StageContext['stage'];
+    step: number;
+    onStage?: StageHandler;
+    signal?: AbortSignal;
+    /** Another provider step would exceed maxSteps — reject inject. */
+    injectWouldExceedMaxSteps?: boolean;
+    host?: unknown;
+}
+export interface ApplyTurnStageResult {
+    abort?: boolean | {
+        reason?: string;
+    };
+    injectCount: number;
+    warnings: StageApplyWarning[];
+}
+/** Injects must arrive sanitized; they are mirrored into an active Interactions continuation too. */
+export declare function applyStageInjects(state: StepExecutionState, stage: TurnStage, units: readonly InjectUnit[], extra?: {
+    callId?: string;
+    toolName?: string;
+}): Generator<TurnEvent, number>;
+export declare function applyTurnStage(args: ApplyTurnStageArgs): AsyncGenerator<TurnEvent, ApplyTurnStageResult>;

package/esm/src/kernel/engine/runner/stages.js

@@ -0,0 +1,48 @@
+import { throwIfAborted } from '../../../guardrails/error.js';
+import { injectedStageEvent, injectMessages, runStage, } from '../../stages.js';
+import { profileAllowsInject } from '../../stop.js';
+/** Injects must arrive sanitized; they are mirrored into an active Interactions continuation too. */
+export function* applyStageInjects(state, stage, units, extra) {
+    const inject = injectMessages(units);
+    if (inject.length === 0)
+        return 0;
+    state.currentHistory.push(...inject);
+    if (state.interactionsContinuation) {
+        for (const msg of inject) {
+            if (msg.role === 'tool')
+                continue;
+            state.interactionsContinuation.messages.push(msg);
+        }
+    }
+    const landed = injectedStageEvent(stage, units, extra);
+    if (landed) {
+        state.allEmittedEvents.push(landed);
+        yield landed;
+    }
+    return inject.length;
+}
+export async function* applyTurnStage(args) {
+    const { profile, generation, state, onStage, host, ...call } = args;
+    throwIfAborted(call.signal);
+    const run = runStage({
+        ...call,
+        history: state.currentHistory,
+        handlers: onStage ? [onStage] : [],
+        guardrails: profile.guardrails,
+        injectAllowed: profileAllowsInject(profile),
+        host: host ?? generation.host,
+        span: state.trace.root,
+    });
+    let next = await run.next();
+    while (!next.done) {
+        state.allEmittedEvents.push(next.value);
+        yield next.value;
+        next = await run.next();
+    }
+    const out = next.value;
+    return {
+        abort: out.abort,
+        injectCount: yield* applyStageInjects(state, call.stage, out.inject),
+        warnings: out.warnings,
+    };
+}

package/esm/src/kernel/engine/runner/state.d.ts

@@ -0,0 +1,76 @@
+import { type GivenUrlSets } from '../../../guardrails/egress-urls.js';
+import type { GuardrailHit, TurnTaint } from '../../../guardrails/types.js';
+import type { SpanHandle } from '../../../observability/trace-span.js';
+import type { ToolRegistry } from '../../tools/registry.js';
+import type { InteractionPart, ModelBinding, Profile, ResolvedGeneration, TurnEvent, TurnHistoryMessage, TurnRequest, TurnStop } from '../../types.js';
+import type { MediaTokenFamily } from '../token-estimate.js';
+import type { CallUsage } from './usage.js';
+interface TurnTraceState {
+    /** The turn's `invoke_agent` span; model calls and tools open under it. */
+    root: SpanHandle;
+    /** Validation / egress attempt the next model call belongs to (0-based). */
+    attempt: number;
+    calls: number;
+    binding: ModelBinding | undefined;
+}
+interface StepExecutionState {
+    /** The turn's scope's tools: calls and provider builtins are looked up here. */
+    tools: ToolRegistry;
+    trace: TurnTraceState;
+    currentHistory: TurnHistoryMessage[];
+    stepCount: number;
+    /** Media family of the turn's model binding, for estimating unreported usage. */
+    mediaFamily: MediaTokenFamily | undefined;
+    allEmittedEvents: TurnEvent[];
+    attemptEvents: TurnEvent[];
+    /**
+     * If the mid-stream window tripped but the final verdict on the whole text passes, nothing was
+     * streamed, so the attempt gate must release the buffered text rather than drop it.
+     */
+    withheldVisible?: boolean;
+    /** The canary opening the last provider call ended on, read in front of the next call's reply. */
+    canaryCarry?: string;
+    /** What the last provider call's thoughts ended on, read in front of the next call's thoughts. */
+    thoughtCarry?: string;
+    /** System-prompt leaks withheld under a host policy; they pin the end-of-attempt verdict to block. */
+    promptLeaks?: GuardrailHit[];
+    /** Untrusted content read so far, so a later tool call is judged against all the turn ingested. */
+    taint?: TurnTaint;
+    /** Every URL the model has been given this turn (`GuardrailContext.givenUrls`). */
+    givenUrls: GivenUrlSets;
+    /** Last provider stop from a discarded provider `done` event. */
+    lastStop?: TurnStop;
+    lastInteractionId?: string;
+    /** Tool results and stage injects pending for the next step's Interactions `continuation`. */
+    interactionsContinuation?: {
+        previousInteractionId: string;
+        messages: TurnHistoryMessage[];
+    };
+    /** Usage of the last model call; a continuation's prompt estimate extends it. */
+    lastCall?: CallUsage;
+}
+interface AttemptFlowState {
+    currentAttempt: number;
+    currentReq: TurnRequest;
+    currentGen: ResolvedGeneration;
+}
+declare function recordStepEvent(event: TurnEvent, state: StepExecutionState): void;
+/** Append user parts to turn history as one user message (plain text stays a string). */
+declare function appendUserInput(state: StepExecutionState, parts: readonly InteractionPart[]): void;
+/**
+ * Step state for one turn. A text turn's history grows inside the turn (tool
+ * steps, stage injects, repair retries), so its opening input moves into turn
+ * history here and everything later lands after it; `generation.input` is then
+ * empty. Image and speech turns are one call that reads only the input, so
+ * theirs stays put.
+ */
+declare function openTurnState(args: {
+    tools: ToolRegistry;
+    profile: Profile;
+    generation: ResolvedGeneration;
+    trace: TurnTraceState;
+    mediaFamily: MediaTokenFamily | undefined;
+    allEmittedEvents?: TurnEvent[];
+}): StepExecutionState;
+export type { AttemptFlowState, StepExecutionState, TurnTraceState };
+export { appendUserInput, openTurnState, recordStepEvent };

package/esm/src/kernel/engine/runner/state.js

@@ -0,0 +1,40 @@
+import { givenUrlSets } from '../../../guardrails/egress-urls.js';
+function recordStepEvent(event, state) {
+    state.allEmittedEvents.push(event);
+    state.attemptEvents.push(event);
+}
+/** Append user parts to turn history as one user message (plain text stays a string). */
+function appendUserInput(state, parts) {
+    if (parts.length === 0)
+        return;
+    const textOnly = parts.every((p) => p.type === 'text');
+    state.currentHistory.push(textOnly
+        ? { role: 'user', content: parts.map((p) => (p.type === 'text' ? p.text : '')).join('') }
+        : { role: 'user', parts: [...parts] });
+}
+/**
+ * Step state for one turn. A text turn's history grows inside the turn (tool
+ * steps, stage injects, repair retries), so its opening input moves into turn
+ * history here and everything later lands after it; `generation.input` is then
+ * empty. Image and speech turns are one call that reads only the input, so
+ * theirs stays put.
+ */
+function openTurnState(args) {
+    const { profile, generation } = args;
+    const state = {
+        tools: args.tools,
+        trace: args.trace,
+        currentHistory: [...(generation.history ?? [])],
+        stepCount: 0,
+        mediaFamily: args.mediaFamily,
+        allEmittedEvents: args.allEmittedEvents ?? [],
+        attemptEvents: [],
+        givenUrls: givenUrlSets(),
+    };
+    if (profile.type === 'text') {
+        appendUserInput(state, generation.input);
+        generation.input = [];
+    }
+    return state;
+}
+export { appendUserInput, openTurnState, recordStepEvent };

package/esm/src/kernel/engine/runner/steps.d.ts

@@ -0,0 +1,14 @@
+import type { BoundSystem } from '../../system-parts.js';
+import type { ModelProvider, Profile, ResolvedGeneration, TurnEvent, TurnRequest } from '../../types.js';
+import { type StepExecutionState } from './state.js';
+declare function executeAttempt(args: {
+    safe: TurnRequest;
+    profile: Profile;
+    generation: ResolvedGeneration;
+    system: BoundSystem;
+    provider: ModelProvider;
+    state: StepExecutionState;
+}): AsyncGenerator<TurnEvent, {
+    latestStructured?: unknown;
+}>;
+export { executeAttempt };

package/esm/src/kernel/engine/runner/steps.js

@@ -0,0 +1,360 @@
+import { addRequestUrls } from '../../../guardrails/egress-urls.js';
+import { isAbortError, throwIfAborted } from '../../../guardrails/error.js';
+import { resolveGuardrailPolicy } from '../../../guardrails/policy.js';
+import { recordTaint } from '../../../guardrails/tool-result.js';
+import { profileTurnOutputs } from '../../registry/profile-outputs.js';
+import { providerCompleteRequest } from '../../registry/provider-request.js';
+import { injectWouldExceedMaxSteps } from '../../stages.js';
+import { profileAllowsInject, stageAbortStop } from '../../stop.js';
+import { failureEvent, toolCallRequestEvent } from '../../tools/events.js';
+import { executeRegisteredTool } from '../../tools/execute.js';
+import { formatToolFailureForModel, formatToolResult } from '../../tools/model-text.js';
+import { findLast } from '../../util/find-last.js';
+import { startToolTrace } from '../tool-trace.js';
+import { startCallTrace } from '../turn-trace.js';
+import { applyStageInjects } from './stages.js';
+import { recordStepEvent } from './state.js';
+import { isWithheldOnBlock, yieldProviderEvents } from './stream.js';
+import { callTokensEvent, observeCallEvent, startCallUsage } from './usage.js';
+function isStepLimitReached(step, maxSteps) {
+    if (maxSteps === undefined || maxSteps <= 0) {
+        return false;
+    }
+    return step >= maxSteps;
+}
+function generationForProviderStep(generation, state) {
+    if (state.interactionsContinuation) {
+        const { previousInteractionId, messages } = state.interactionsContinuation;
+        state.interactionsContinuation = undefined;
+        return {
+            ...generation,
+            history: [],
+            input: [],
+            previousInteractionId,
+            continuation: [...messages],
+        };
+    }
+    return { ...generation, history: state.currentHistory };
+}
+function captureInteractionId(event, state) {
+    if ((event.type === 'tokens' || event.type === 'done') && event.interactionId) {
+        state.lastInteractionId = event.interactionId;
+    }
+}
+/**
+ * Hold the model's calls until its stream ends: a raw call, and a provider's
+ * failure for a call it already sent. Returns false for any other tool event.
+ */
+function holdModelCall(calls, tool) {
+    if (tool.phase === undefined) {
+        calls.push({
+            name: tool.name,
+            callId: tool.callId,
+            arguments: tool.arguments,
+            ...(tool.thoughtSignature ? { thoughtSignature: tool.thoughtSignature } : {}),
+        });
+        return true;
+    }
+    const call = findLast(calls, (held) => held.callId === tool.callId);
+    if (tool.phase !== 'error' || !call)
+        return false;
+    call.failure = tool.failure;
+    return true;
+}
+async function* executeAutonomousStep(args, state, buffer = {
+    holdLate: false,
+}) {
+    const { generation, system, provider, signal } = args;
+    const continuation = state.interactionsContinuation;
+    const usage = startCallUsage(system.text, continuation && state.lastCall
+        ? { previous: state.lastCall, continuation: continuation.messages }
+        : { history: state.currentHistory, input: generation.input });
+    state.lastCall = usage;
+    const genForStep = generationForProviderStep(generation, state);
+    const request = providerCompleteRequest(state.tools, genForStep, system.text);
+    addRequestUrls(state.givenUrls, request);
+    state.trace.calls += 1;
+    const call = startCallTrace((name, options) => state.trace.root.child(name, options), {
+        req: request,
+        usage,
+        binding: state.trace.binding,
+        transport: genForStep.transport,
+        step: state.stepCount,
+        attempt: state.trace.attempt,
+    });
+    const calls = [];
+    let latestStructured;
+    // The stop this call ended with after gates: a canary block or provider
+    // error outranks what the provider reported.
+    let stop;
+    const control = {
+        withholdVisible: false,
+        ...(state.canaryCarry ? { canaryCarry: state.canaryCarry } : {}),
+        ...(state.thoughtCarry ? { thoughtCarry: state.thoughtCarry } : {}),
+    };
+    try {
+        for await (const event of yieldProviderEvents({
+            profile: args.profile,
+            generation: genForStep,
+            request,
+            privateSystem: system.private,
+            provider,
+            call,
+            signal,
+            control,
+            givenUrls: state.givenUrls,
+        })) {
+            captureInteractionId(event, state);
+            if (observeCallEvent(usage, event)) {
+                continue;
+            }
+            if (event.type === 'guardrail') {
+                call.guardrail(event.guardrail);
+            }
+            if (event.type === 'structured') {
+                latestStructured = event.structured;
+            }
+            if (event.type === 'done') {
+                stop = event.stop;
+                state.lastStop = event.stop;
+                continue;
+            }
+            if (event.type === 'tool' && holdModelCall(calls, event.tool)) {
+                continue;
+            }
+            recordStepEvent(event, state);
+            if (control.withholdVisible && isWithheldOnBlock(event)) {
+                // Progressive-yield blocked this attempt — keep events for egress/repair only.
+                // Record the decision so the attempt gate knows nothing reached the host.
+                state.withheldVisible = true;
+                continue;
+            }
+            // Text and media stream via progressive-yield under egress, thoughts
+            // stream unguarded; holdLate only buffers non-visible events (e.g.
+            // structured) for validation.
+            const isUserVisible = event.type === 'thought' || event.type === 'text' || event.type === 'media';
+            const streamNow = !buffer.holdLate || isUserVisible;
+            if (streamNow) {
+                yield event;
+            }
+        }
+    }
+    catch (err) {
+        call.end(isAbortError(err) ? { stop: { kind: 'cancelled' } } : { stop, thrown: err });
+        throw err;
+    }
+    state.canaryCarry = control.canaryCarry;
+    state.thoughtCarry = control.thoughtCarry;
+    if (control.promptLeaks) {
+        state.promptLeaks = [...(state.promptLeaks ?? []), ...control.promptLeaks];
+    }
+    const tokens = await callTokensEvent(usage, generation, state.mediaFamily);
+    call.end({ tokens: tokens?.tokens, stop });
+    if (tokens) {
+        recordStepEvent(tokens, state);
+        yield tokens;
+    }
+    return { calls, latestStructured };
+}
+function toolResultMessage(call, result) {
+    return {
+        role: 'tool',
+        tool_call_id: call.callId,
+        name: call.name,
+        content: formatToolResult(result),
+        ...(result.parts && result.parts.length > 0 ? { parts: result.parts } : {}),
+    };
+}
+/**
+ * One step's calls as one assistant message, the way the model made them.
+ * Providers read a step's calls together, then their results: Google rejects
+ * a call replayed after an earlier call's result (probe 25/09/2026).
+ */
+function stepCallsMessage(calls) {
+    return {
+        role: 'assistant',
+        tool_calls: calls.map((call) => ({
+            id: call.callId,
+            type: 'function',
+            function: { name: call.name, arguments: JSON.stringify(call.arguments) },
+            ...(call.thoughtSignature ? { thoughtSignature: call.thoughtSignature } : {}),
+        })),
+    };
+}
+/**
+ * The stored interaction a step's results chain on, or `undefined` when they go
+ * in history: the turn does not chain, or no interaction id arrived to chain on.
+ */
+function chainedInteractionId(generation, state) {
+    return generation.chains
+        ? (state.lastInteractionId ?? generation.previousInteractionId)
+        : undefined;
+}
+function queueInteractionsToolContinuation(state, message, previousInteractionId) {
+    if (state.interactionsContinuation?.previousInteractionId === previousInteractionId) {
+        state.interactionsContinuation.messages.push(message);
+        return;
+    }
+    state.interactionsContinuation = { previousInteractionId, messages: [message] };
+}
+/** A call's result: chained on the stored interaction, else after the step's calls in history. */
+function recordToolModelResult(state, call, modelResult, chainOn) {
+    const message = toolResultMessage(call, modelResult);
+    if (chainOn) {
+        queueInteractionsToolContinuation(state, message, chainOn);
+        return;
+    }
+    state.currentHistory.push(message);
+}
+async function* forwardToolEvents(exec, state) {
+    let next = await exec.next();
+    while (!next.done) {
+        state.allEmittedEvents.push(next.value);
+        yield next.value;
+        next = await exec.next();
+    }
+    return next.value;
+}
+function toolSpanOpener(state) {
+    return (name, attributes) => state.trace.root.child(name, { attributes });
+}
+/**
+ * Settle a call the provider handed over already failed (malformed arguments,
+ * no function name): nothing runs, and the model reads the failure back.
+ */
+function recordProviderToolFailure(state, call, failure, chainOn) {
+    const event = failureEvent(call, failure);
+    state.allEmittedEvents.push(event);
+    const modelResult = formatToolFailureForModel(failure);
+    startToolTrace(toolSpanOpener(state), {
+        name: call.name,
+        callId: call.callId,
+        call,
+        step: state.stepCount,
+    }).end({
+        outcome: 'error',
+        result: { text: formatToolResult(modelResult) },
+        failure,
+    });
+    recordToolModelResult(state, call, modelResult, chainOn);
+    return event;
+}
+function* applyToolSettlement(settlement, state, call, chainOn) {
+    if (settlement.aborted) {
+        state.lastStop = stageAbortStop(settlement.aborted);
+        return 'stop_cancelled';
+    }
+    if (settlement.gated) {
+        return 'gated';
+    }
+    if (settlement.modelResult?.provenance) {
+        state.taint = recordTaint(state.taint, settlement.modelResult.provenance, settlement.modelResult.suspicious);
+    }
+    if (!settlement.modelResult)
+        return 'continue';
+    recordToolModelResult(state, call, settlement.modelResult, chainOn);
+    if (settlement.pendingInject) {
+        yield* applyStageInjects(state, 'post_tool', settlement.pendingInject, {
+            callId: call.callId,
+            toolName: call.name,
+        });
+    }
+    return 'continue';
+}
+/**
+ * Run the model's calls in order. Each reaches the host as its raw call first,
+ * then its phases. A call that gates waits for its own approval; the step's
+ * other calls still run. After the step, any gate stops the turn.
+ */
+async function* handleModelCalls(calls, generation, profile, state, { onStage, signal, credentials, resolveHost } = {}) {
+    const chainOn = chainedInteractionId(generation, state);
+    if (!chainOn && calls.length > 0) {
+        state.currentHistory.push(stepCallsMessage(calls));
+    }
+    // One id for every call this model response made.
+    const stepId = crypto.randomUUID();
+    const announce = (call) => {
+        const request = toolCallRequestEvent(call, call.arguments, {
+            thoughtSignature: call.thoughtSignature,
+            stepId,
+        });
+        state.allEmittedEvents.push(request);
+        return request;
+    };
+    let gated = false;
+    for (const call of calls) {
+        yield announce(call);
+        if (call.failure) {
+            yield recordProviderToolFailure(state, call, call.failure, chainOn);
+            continue;
+        }
+        const stages = {
+            handlers: onStage ? [onStage] : [],
+            profile,
+            step: state.stepCount,
+            history: () => state.currentHistory,
+            injectAllowed: profileAllowsInject(profile),
+            injectWouldExceedMaxSteps: injectWouldExceedMaxSteps(state.stepCount, generation.maxSteps),
+            host: generation.host,
+            signal,
+        };
+        const settlement = yield* forwardToolEvents(executeRegisteredTool({
+            tools: state.tools,
+            profile,
+            name: call.name,
+            input: call.arguments,
+            callId: call.callId,
+            ctx: {
+                sessionPermissions: generation.sessionPermissions,
+                path: generation.tools.path,
+                turn: { step: state.stepCount, taint: state.taint },
+                credentials,
+                resolveHost,
+                host: generation.host,
+                resume: undefined,
+                signal,
+            },
+            snapshot: generation.tools,
+            stages,
+            openSpan: toolSpanOpener(state),
+        }), state);
+        const outcome = yield* applyToolSettlement(settlement, state, call, chainOn);
+        if (outcome === 'stop_cancelled')
+            return false;
+        if (outcome === 'gated')
+            gated = true;
+    }
+    if (gated) {
+        state.lastStop = { kind: 'gate' };
+        return false;
+    }
+    return calls.length > 0;
+}
+async function* executeAttempt(args) {
+    const { profile, generation, system, provider, state } = args;
+    let latestStructured;
+    // Text streams via progressive-yield under egress, thoughts unguarded; validation and egress
+    // both hold non-visible events (structured) until the attempt gate, so a policy
+    // sees the structured payload before any of it reaches the host.
+    const holdLate = Boolean(profileTurnOutputs(profile)?.validation ||
+        resolveGuardrailPolicy(profile.guardrails).egress?.enforce);
+    // Ceiling is cumulative `state.stepCount` across before_end inject re-entries
+    // within this attempt. Validation/egress repair resets stepCount at the start
+    // of each attempt cycle.
+    while (!isStepLimitReached(state.stepCount, generation.maxSteps ?? 0)) {
+        throwIfAborted(args.safe.signal);
+        state.stepCount++;
+        // Mid-loop inject lives on `post_tool` (after tools). Opening inject is `pre_turn`
+        // outside this loop.
+        const stepResult = yield* executeAutonomousStep({ profile, generation, system, provider, signal: args.safe.signal }, state, { holdLate });
+        if (stepResult.latestStructured !== undefined) {
+            latestStructured = stepResult.latestStructured;
+        }
+        const executed = yield* handleModelCalls(stepResult.calls, generation, profile, state, args.safe);
+        if (!executed) {
+            break;
+        }
+    }
+    return { latestStructured };
+}
+export { executeAttempt };

package/esm/src/kernel/engine/runner/stream.d.ts

@@ -0,0 +1,40 @@
+import type { GivenUrls } from '../../../guardrails/egress-urls.js';
+import type { GuardrailHit } from '../../../guardrails/types.js';
+import type { ModelProvider, Profile, ProviderCompleteRequest, ProviderEvent, ResolvedGeneration } from '../../types.js';
+import type { CallTrace } from '../turn-trace.js';
+/** What the stream yields to the step runner: every provider event but `response`, which only the trace reads. */
+export type StreamEvent = Exclude<ProviderEvent, {
+    type: 'response';
+}>;
+interface OutboundStreamControl {
+    /** Stop releasing text/media to the host; keep recording for egress. */
+    withholdVisible: boolean;
+    /**
+     * The canary opening the turn's earlier steps ended on (`canaryCarry`): read
+     * in front of this call's reply, and replaced by where this call ends.
+     */
+    canaryCarry?: string;
+    /** System-prompt leak hits this call withheld under a host policy; they pin its verdict. */
+    promptLeaks?: GuardrailHit[];
+    /** What the turn's thoughts so far ended on (`ThoughtGuard.carryOut`): read in front of this call's, and replaced. */
+    thoughtCarry?: string;
+}
+declare function shouldSkipStreamEvent(event: ProviderEvent, profile: Profile): boolean;
+/** Host-visible output a mid-stream block withholds. A thought is never withheld, only omitted from. */
+declare function isWithheldOnBlock(event: ProviderEvent): boolean;
+declare function yieldProviderEvents(args: {
+    profile: Profile;
+    generation: ResolvedGeneration;
+    request: ProviderCompleteRequest;
+    /** The private stretches of `request.system` (`BoundSystem.private`). */
+    privateSystem: readonly string[];
+    provider: ModelProvider;
+    /** This call's recorder: sees every tap row and every provider event before any gate. */
+    call: Pick<CallTrace, 'tap' | 'observe'> & Partial<Pick<CallTrace, 'guardTime'>>;
+    signal?: AbortSignal;
+    control?: OutboundStreamControl;
+    /** Every URL the model has been given this turn. */
+    givenUrls: GivenUrls;
+}): AsyncGenerator<StreamEvent>;
+export type { OutboundStreamControl };
+export { isWithheldOnBlock, shouldSkipStreamEvent, yieldProviderEvents };