experimental-ash 0.22.2 → 0.24.0

package/dist/src/execution/continuous-entry.js

@@ -1,487 +0,0 @@
-import { buildAdapterContext } from "#channel/adapter-context.js";
-import { defaultDeliverResult } from "#channel/adapter.js";
-import { toContextAccessor } from "#context/container.js";
-import { runHookLifecycleStep } from "#context/hook-lifecycle.js";
-import { AuthKey, BundleKey, CapabilitiesKey, ChannelKey, ContinuationTokenKey, InitiatorAuthKey, ModeKey, SessionIdKey, } from "#context/keys.js";
-import { runStep } from "#context/run-step.js";
-import { getHarnessEmissionState, isHarnessBetweenTurns } from "#harness/emission.js";
-import { hasPendingInputBatch } from "#harness/input-requests.js";
-import { coalesceDeliveries, coalesceTurnInputs } from "#harness/messages.js";
-import { hasProxyInputRequests, upsertProxyInputRequests } from "#harness/proxy-input-requests.js";
-import { accumulateRuntimeActionResults, getPendingRuntimeActionBatch, hasPendingRuntimeActionBatch, recordPendingSubagentChildToken, } from "#harness/runtime-actions.js";
-import { createErrorId, createLogger } from "#internal/logging.js";
-import { createSubagentCalledEvent } from "#protocol/message.js";
-import { drainPendingConnectionAuthorizations } from "#runtime/framework-tools/connection-search.js";
-import { toErrorMessage } from "#shared/errors.js";
-import { isRuntimeNoActiveSessionError } from "#execution/runtime-errors.js";
-import { registerContinuousSubagentInputRequestDispatcher, unregisterContinuousSubagentInputRequestDispatcher, } from "#execution/subagent-adapter.js";
-import { createExecutionNodeStep } from "#execution/node-step.js";
-import { emitProxiedInputRequest, routeDeliverPayload } from "#execution/subagent-hitl-proxy.js";
-import { createSession } from "#execution/session.js";
-import { buildSubagentRunInput } from "#execution/subagent-tool.js";
-import { createTaskModeWaitError } from "#execution/task-mode.js";
-const log = createLogger("execution.continuous-entry");
-/**
- * Main body of a continuous (in-memory) run.
- */
-export async function continuousEntry(input) {
-    const { createRuntime, ctx, emit, input: entryInput, park, queue, wake } = input;
-    const bundle = ctx.require(BundleKey);
-    const capabilities = ctx.get(CapabilitiesKey);
-    const mode = ctx.require(ModeKey);
-    const session = createSession({
-        compactionOverrides: {
-            thresholdPercent: bundle.resolvedAgent.config.compaction?.thresholdPercent,
-        },
-        continuationToken: ctx.require(ContinuationTokenKey),
-        sessionId: ctx.require(SessionIdKey),
-        turnAgent: bundle.turnAgent,
-    });
-    const rawStep = createExecutionNodeStep({
-        capabilities,
-        compiledArtifactsSource: bundle.compiledArtifactsSource,
-        createRuntime,
-        emit,
-        mode,
-        node: bundle.graph.root,
-    });
-    // Every step in the continuous runtime runs inside `runStep(ctx, ...)`.
-    // After each step returns we drain any `connection.authorization_required`
-    // events that tools flagged during the step so the channel sees them
-    // while the scope is still active. Keeping this here (and not in the
-    // harness) preserves the channel-harness-runtime split.
-    const runScopedStep = async (stepSession, body) => {
-        return runStep(ctx, stepSession, async (enrichedSession) => {
-            const result = await body(enrichedSession);
-            await drainPendingConnectionAuthorizations({
-                ctx,
-                emit,
-                state: getHarnessEmissionState(result.session),
-            });
-            return result;
-        });
-    };
-    const deliverStep = (item) => {
-        return async (stepSession, _stepInput) => {
-            ctx.clearVirtualContext();
-            if (item.auth !== undefined) {
-                ctx.set(AuthKey, item.auth ?? null);
-            }
-            // Split the payload into parent-local and proxied-child buckets
-            // before handing any of it to the parent's own adapter. Each
-            // proxied bucket is pushed onto the target child's queue and
-            // wakes the child runtime; the parent processes only the
-            // residual payload (if any).
-            const routed = await routeDeliverQueueItem(stepSession, item);
-            if (routed === undefined) {
-                return { next: null, session: stepSession };
-            }
-            const remainders = routed.payloads;
-            // Re-read adapter from context each delivery so state mutations
-            // from previous deliveries are visible.
-            const adapter = ctx.require(ChannelKey);
-            const adapterCtx = buildAdapterContext(adapter, toContextAccessor(ctx));
-            const results = [];
-            for (const payload of remainders) {
-                const result = adapter.deliver
-                    ? await adapter.deliver(payload, adapterCtx)
-                    : defaultDeliverResult(payload);
-                if (result !== undefined && result !== null) {
-                    results.push(result);
-                }
-            }
-            // Update adapter state after deliver mutations.
-            const updatedAdapter = { ...adapter, state: { ...adapterCtx.state } };
-            ctx.set(ChannelKey, updatedAdapter);
-            // Adapter handled all deliveries inline — re-park without a model turn.
-            if (results.length === 0) {
-                return { next: null, session: stepSession };
-            }
-            const resolved = results.reduce(coalesceTurnInputs);
-            return await runScopedStep(stepSession, (enrichedSession) => {
-                // Gate lifecycle dispatch on the harness being between turns —
-                // same contract as the workflow runtime. A fresh delivery is
-                // the start of a new turn; a deliver carrying HITL
-                // `inputResponses` while the harness still owns a turn is a
-                // continuation of that turn, and lifecycle hooks must not
-                // re-fire.
-                if (isHarnessBetweenTurns(enrichedSession)) {
-                    return runHookLifecycleStep({
-                        ctx,
-                        emit,
-                        input: resolved,
-                        mode,
-                        registry: bundle.hookRegistry,
-                        session: enrichedSession,
-                    }, rawStep);
-                }
-                return rawStep(enrichedSession, resolved);
-            });
-        };
-    };
-    const subagentInputRequestStep = async (sessionIn, item) => {
-        ctx.clearVirtualContext();
-        // `emitProxiedInputRequest` fires the `input.requested` event
-        // through the parent's adapter (the outer-scope `emit` applies the
-        // transform) and, when the parent is in conversation mode, follows
-        // it with a `turn.completed` + `session.waiting` pair so HTTP /
-        // REPL clients can stop draining the stream and prompt the user
-        // for HITL input. The parent session's emission state advances
-        // through the pseudo-turn and is returned on `result.session`.
-        const result = await emitProxiedInputRequest({
-            emit,
-            hookPayload: {
-                callId: item.callId,
-                childContinuationToken: item.childContinuationToken,
-                childSessionId: item.childSessionId,
-                event: item.event,
-                kind: "subagent-input-request",
-                subagentName: item.subagentName,
-            },
-            mode,
-            session: sessionIn,
-        });
-        return upsertProxyInputRequests({
-            entries: result.entries,
-            forChildContinuationToken: item.childContinuationToken,
-            session: result.session,
-        });
-    };
-    const runtimeActionResultStep = (item) => {
-        return async (stepSession, _stepInput) => await runScopedStep(stepSession, (enrichedSession) => rawStep(enrichedSession, {
-            runtimeActionResults: item.results,
-        }));
-    };
-    /**
-     * Routes one inbound deliver queue item to any descendant subagents
-     * whose proxied HITL requests match the payload's `inputResponses`.
-     * Returns the parent-local remainder (`undefined` means the whole
-     * item was routed away). Short-circuits when the session has no
-     * proxy entries so the common path skips the routing loop entirely.
-     */
-    const routeDeliverQueueItem = async (sessionIn, item) => {
-        if (!hasProxyInputRequests(sessionIn)) {
-            return item;
-        }
-        const remainders = await routeProxiedDeliverPayloads({
-            auth: item.auth,
-            createRuntime,
-            ctx,
-            payloads: item.payloads,
-            session: sessionIn,
-        });
-        if (remainders.length === 0) {
-            return undefined;
-        }
-        return { ...item, payloads: remainders };
-    };
-    const wrapContinuation = (innerStep) => {
-        return async (stepSession, stepInput) => await runScopedStep(stepSession, (enrichedSession) => innerStep(enrichedSession, stepInput));
-    };
-    let currentStep = deliverStep({
-        kind: "deliver",
-        payloads: [{ message: entryInput.message }],
-    });
-    let currentSession = session;
-    const bufferedDeliveries = [];
-    while (true) {
-        const stepResult = await currentStep(currentSession, undefined);
-        currentSession = stepResult.session;
-        if (stepResult.next !== null &&
-            typeof stepResult.next === "object" &&
-            "done" in stepResult.next) {
-            return { output: stepResult.next.output, status: "completed" };
-        }
-        if (stepResult.next === null) {
-            if (hasPendingRuntimeActionBatch(currentSession)) {
-                currentSession = dispatchPendingRuntimeActions({
-                    createRuntime,
-                    ctx,
-                    emit,
-                    queue,
-                    session: currentSession,
-                    wake,
-                });
-                const waited = await waitForRuntimeActionResults({
-                    bufferedDeliveries,
-                    park,
-                    proxyInputRequestStep: subagentInputRequestStep,
-                    queue,
-                    routeDeliver: routeDeliverQueueItem,
-                    session: currentSession,
-                });
-                currentSession = waited.session;
-                currentStep = runtimeActionResultStep(waited.result);
-                continue;
-            }
-            // Task-mode HITL park is allowed when the session has HITL
-            // capabilities — the proxy bridge will forward the request up
-            // to a capable ancestor. Conversation mode always allows a park
-            // for the next user message.
-            if (capabilities?.requestInput === true && hasPendingInputBatch(currentSession)) {
-                const waited = await waitForDeliverQueueItem({
-                    bufferedDeliveries,
-                    park,
-                    proxyInputRequestStep: subagentInputRequestStep,
-                    queue,
-                    session: currentSession,
-                });
-                currentSession = waited.session;
-                currentStep = deliverStep(waited.item);
-                continue;
-            }
-            if (mode === "task") {
-                throw createTaskModeWaitError();
-            }
-            const waited = await waitForDeliverQueueItem({
-                bufferedDeliveries,
-                park,
-                proxyInputRequestStep: subagentInputRequestStep,
-                queue,
-                session: currentSession,
-            });
-            currentSession = waited.session;
-            currentStep = deliverStep(waited.item);
-            continue;
-        }
-        currentStep = wrapContinuation(stepResult.next);
-    }
-}
-async function routeProxiedDeliverPayloads(input) {
-    const remainders = [];
-    const compiledArtifactsSource = input.ctx.require(BundleKey).compiledArtifactsSource;
-    for (const payload of input.payloads) {
-        const routed = routeDeliverPayload({ payload, session: input.session });
-        for (const forChild of routed.forChildren) {
-            // The child runtime owns its own queue. Reach it through the
-            // shared `createRuntime` closure — the continuous runtime's
-            // `deliver` implementation looks up the queue by continuation
-            // token and wakes the parked child.
-            const childRuntime = input.createRuntime({ compiledArtifactsSource });
-            try {
-                await childRuntime.deliver({
-                    auth: input.auth ?? null,
-                    continuationToken: forChild.childContinuationToken,
-                    payload: forChild.payload,
-                });
-            }
-            catch (error) {
-                // The child session may have already completed or failed
-                // between the HITL emission and the user's response. Treat
-                // the deliver as a no-op — the response effectively falls
-                // through to the parent as stale input.
-                if (!isRuntimeNoActiveSessionError(error)) {
-                    throw error;
-                }
-                // Breadcrumb the drop so an operator chasing a "user
-                // clicked approve and nothing happened" report can correlate
-                // the request ids to the child session that had already
-                // completed. Warn-level because the condition is expected
-                // (races between child completion and parent delivery) but
-                // worth surfacing.
-                log.warn("dropped stale HITL response for completed subagent", {
-                    childContinuationToken: forChild.childContinuationToken,
-                    errorId: createErrorId(),
-                    requestIds: forChild.payload.inputResponses.map((response) => response.requestId),
-                    sessionId: input.session.sessionId,
-                });
-            }
-        }
-        if (routed.forSelf !== undefined) {
-            remainders.push(routed.forSelf);
-        }
-    }
-    return remainders;
-}
-function dispatchPendingRuntimeActions(input) {
-    const batch = getPendingRuntimeActionBatch(input.session);
-    if (batch === undefined) {
-        return input.session;
-    }
-    const bundle = input.ctx.require(BundleKey);
-    const auth = input.ctx.get(AuthKey) ?? null;
-    const capabilities = input.ctx.get(CapabilitiesKey);
-    const initiatorAuth = input.ctx.get(InitiatorAuthKey) ?? null;
-    let nextSession = input.session;
-    for (const action of batch.actions) {
-        if (action.kind !== "subagent-call") {
-            throw new Error(`Unsupported runtime action kind "${action.kind}" in continuous runtime.`);
-        }
-        const childRuntime = input.createRuntime({
-            compiledArtifactsSource: bundle.compiledArtifactsSource,
-            nodeId: action.nodeId,
-        });
-        const { childContinuationToken, runInput } = buildSubagentRunInput({
-            action,
-            auth,
-            batchEvent: batch.event,
-            capabilities,
-            initiatorAuth,
-            session: input.session,
-        });
-        nextSession = recordPendingSubagentChildToken({
-            callId: action.callId,
-            childContinuationToken,
-            session: nextSession,
-        });
-        // Register the continuous-runtime dispatcher for this child so
-        // its subagent-adapter `input.requested` handler can forward
-        // HITL requests to this parent's queue without going through
-        // the workflow `resumeHook` path.
-        registerContinuousSubagentInputRequestDispatcher({
-            childContinuationToken,
-            dispatcher: (payload) => {
-                input.queue.push(payload);
-                input.wake();
-            },
-        });
-        void childRuntime
-            .run(runInput)
-            .then(async (handle) => {
-            await input.emit(createSubagentCalledEvent({
-                callId: action.callId,
-                childSessionId: handle.sessionId,
-                name: action.name,
-                sequence: batch.event.sequence,
-                sessionId: input.session.sessionId,
-                toolName: action.subagentName,
-                turnId: batch.event.turnId,
-                workflowId: "continuous://subagent",
-            }));
-            const result = await handle.result;
-            if (result.status !== "completed") {
-                throw new Error(`Subagent "${action.subagentName}" did not complete (status: ${result.status}).`);
-            }
-            return result.output;
-        })
-            .then((output) => {
-            input.queue.push({
-                kind: "runtime-action-result",
-                results: [
-                    {
-                        callId: action.callId,
-                        kind: "subagent-result",
-                        output,
-                        subagentName: action.subagentName,
-                    },
-                ],
-            });
-            input.wake();
-        }, (error) => {
-            // Surface the failure through the shared structured-log path
-            // (`log.error` records on the active OTel span and walks
-            // the `error` cause chain via `formatError`) before
-            // enqueueing the result. Without this log the
-            // fire-and-forget rejection branch silently stuffed a
-            // generic "SUBAGENT_EXECUTION_FAILED" message into the queue
-            // with no operator-visible breadcrumb.
-            const errorId = createErrorId();
-            log.error("subagent child run failed", {
-                callId: action.callId,
-                childContinuationToken,
-                errorId,
-                sessionId: input.session.sessionId,
-                subagentName: action.subagentName,
-                error,
-            });
-            input.queue.push({
-                kind: "runtime-action-result",
-                results: [
-                    {
-                        callId: action.callId,
-                        isError: true,
-                        kind: "subagent-result",
-                        output: {
-                            code: "SUBAGENT_EXECUTION_FAILED",
-                            message: toErrorMessage(error),
-                        },
-                        subagentName: action.subagentName,
-                    },
-                ],
-            });
-            input.wake();
-        })
-            .finally(() => {
-            unregisterContinuousSubagentInputRequestDispatcher(childContinuationToken);
-        });
-    }
-    return nextSession;
-}
-async function waitForRuntimeActionResults(input) {
-    let currentSession = input.session;
-    const results = await accumulateRuntimeActionResults({
-        bufferedDeliveries: input.bufferedDeliveries,
-        async getNext() {
-            while (true) {
-                const item = await takeNextQueueItem(input.queue, input.park);
-                if (item.kind === "deliver") {
-                    // Inbound deliveries mid-wait may carry `inputResponses`
-                    // bound to a descendant's pending HITL batch. Route them
-                    // down **before** buffering — otherwise the response would
-                    // sit in `bufferedDeliveries` until the child completes,
-                    // which it can never do without the response. That
-                    // asymmetry is the parent↔child deadlock this branch
-                    // exists to prevent.
-                    const remainder = await input.routeDeliver(currentSession, item);
-                    if (remainder === undefined) {
-                        continue;
-                    }
-                    return { kind: "deliver", value: remainder };
-                }
-                if (item.kind === "runtime-action-result") {
-                    return { kind: "runtime-action-result", results: item.results };
-                }
-                // subagent-input-request: proxy the child's HITL up through
-                // the parent's adapter and keep waiting.
-                currentSession = await input.proxyInputRequestStep(currentSession, item);
-            }
-        },
-        session: currentSession,
-    });
-    return {
-        result: {
-            kind: "runtime-action-result",
-            results: (results ?? []),
-        },
-        session: currentSession,
-    };
-}
-async function waitForDeliverQueueItem(input) {
-    let currentSession = input.session;
-    if (input.bufferedDeliveries.length > 0) {
-        return {
-            item: coalesceDeliveries(input.bufferedDeliveries.splice(0)),
-            session: currentSession,
-        };
-    }
-    while (true) {
-        const first = await takeNextQueueItem(input.queue, input.park);
-        if (first.kind === "subagent-input-request") {
-            currentSession = await input.proxyInputRequestStep(currentSession, first);
-            continue;
-        }
-        if (first.kind !== "deliver") {
-            continue;
-        }
-        const deliveries = [first];
-        await Promise.resolve();
-        while (input.queue[0]?.kind === "deliver") {
-            deliveries.push(input.queue.shift());
-        }
-        return {
-            item: coalesceDeliveries(deliveries),
-            session: currentSession,
-        };
-    }
-}
-async function takeNextQueueItem(queue, park) {
-    while (queue.length === 0) {
-        await park();
-        await Promise.resolve();
-    }
-    const next = queue.shift();
-    if (next === undefined) {
-        throw new Error("Expected one queued runtime item.");
-    }
-    return next;
-}

package/dist/src/execution/continuous-runtime.d.ts

@@ -1,17 +0,0 @@
-import type { Runtime } from "#channel/types.js";
-import type { RuntimeCompiledArtifactsSource } from "#runtime/compiled-artifacts-source.js";
-import type { CreateRuntime } from "#execution/node-step.js";
-export { RuntimeNoActiveSessionError, isRuntimeNoActiveSessionError, } from "#execution/runtime-errors.js";
-/**
- * Creates a {@link CreateRuntime} factory for the continuous
- * (non-durable) runtime.
- */
-export declare function createContinuousLoopRuntimeFactory(): CreateRuntime;
-/**
- * Creates an in-memory runtime that provides the delivery shell for a
- * continuous (non-durable) run.
- */
-export declare function createContinuousLoopRuntime(config: {
-    readonly compiledArtifactsSource: RuntimeCompiledArtifactsSource;
-    readonly nodeId?: string;
-}): Runtime;

package/dist/src/execution/continuous-runtime.js

@@ -1,123 +0,0 @@
-import { buildAdapterContext } from "#channel/adapter-context.js";
-import { callAdapterEventHandler } from "#channel/adapter.js";
-import { toContextAccessor } from "#context/container.js";
-import { dispatchStreamEventHooks } from "#context/hook-lifecycle.js";
-import { BundleKey, ChannelKey, SessionIdKey } from "#context/keys.js";
-import { getCompiledRuntimeAgentBundle } from "#runtime/sessions/compiled-agent-cache.js";
-import { continuousEntry } from "#execution/continuous-entry.js";
-import { buildRunContext } from "#execution/runtime-context.js";
-import { RuntimeNoActiveSessionError } from "#execution/runtime-errors.js";
-export { RuntimeNoActiveSessionError, isRuntimeNoActiveSessionError, } from "#execution/runtime-errors.js";
-/**
- * Creates a {@link CreateRuntime} factory for the continuous
- * (non-durable) runtime.
- */
-export function createContinuousLoopRuntimeFactory() {
-    const state = {
-        queues: new Map(),
-        parked: new Map(),
-    };
-    return function createRuntime(config) {
-        return buildContinuousRuntime({ config, createRuntime, state });
-    };
-}
-/**
- * Creates an in-memory runtime that provides the delivery shell for a
- * continuous (non-durable) run.
- */
-export function createContinuousLoopRuntime(config) {
-    const factory = createContinuousLoopRuntimeFactory();
-    return factory(config);
-}
-function buildContinuousRuntime(input) {
-    const { config, createRuntime, state } = input;
-    const { queues, parked } = state;
-    return {
-        async run(input) {
-            const bundle = await getCompiledRuntimeAgentBundle({
-                compiledArtifactsSource: config.compiledArtifactsSource,
-                nodeId: config.nodeId,
-            });
-            const sessionId = crypto.randomUUID();
-            const ctx = buildRunContext({ bundle, run: input });
-            ctx.set(SessionIdKey, sessionId);
-            const eventStream = new TransformStream(undefined, undefined, new CountQueuingStrategy({ highWaterMark: 1024 }));
-            const queue = [];
-            const effectiveToken = input.continuationToken ?? `continuous:${crypto.randomUUID()}`;
-            queues.set(effectiveToken, queue);
-            const result = (async () => {
-                const writer = eventStream.writable.getWriter();
-                const wake = () => {
-                    const signal = parked.get(effectiveToken);
-                    if (signal !== undefined) {
-                        parked.delete(effectiveToken);
-                        signal();
-                    }
-                };
-                const adapter = ctx.require(ChannelKey);
-                const adapterCtx = buildAdapterContext(adapter, toContextAccessor(ctx));
-                const bundle = ctx.require(BundleKey);
-                const hookRegistry = bundle.hookRegistry;
-                const emit = async (event) => {
-                    const toEmit = await callAdapterEventHandler(adapter, event, adapterCtx);
-                    await writer.write(toEmit);
-                    await dispatchStreamEventHooks({ ctx, registry: hookRegistry, event: toEmit });
-                };
-                try {
-                    const entryResult = await continuousEntry({
-                        createRuntime,
-                        ctx,
-                        emit,
-                        input: input.input,
-                        park: () => new Promise((resolve) => {
-                            parked.set(effectiveToken, resolve);
-                        }),
-                        queue,
-                        wake,
-                    });
-                    await writer.close();
-                    return entryResult;
-                }
-                catch (error) {
-                    await writer.abort(error);
-                    throw error;
-                }
-                finally {
-                    queues.delete(effectiveToken);
-                    parked.delete(effectiveToken);
-                }
-            })();
-            return {
-                continuationToken: effectiveToken,
-                events: eventStream.readable,
-                result,
-                sessionId,
-            };
-        },
-        async deliver(input) {
-            const queue = queues.get(input.continuationToken);
-            if (queue === undefined) {
-                throw new RuntimeNoActiveSessionError(input.continuationToken);
-            }
-            queue.push({
-                auth: input.auth,
-                kind: "deliver",
-                payloads: [input.payload],
-            });
-            const signal = parked.get(input.continuationToken);
-            if (signal !== undefined) {
-                parked.delete(input.continuationToken);
-                signal();
-            }
-            return { sessionId: input.continuationToken };
-        },
-        async getEventStream(_sessionId, _options) {
-            // The continuous runtime delivers events synchronously through the
-            // `RunHandle.events` stream returned by `run()`. There is no
-            // out-of-band durable event store to read from, so a separate
-            // event-stream lookup by session id is unsupported here. Routes
-            // that need this method should target the workflow runtime.
-            throw new Error("createContinuousLoopRuntime does not support getEventStream(); read events from RunHandle.events instead.");
-        },
-    };
-}