@atolis-hq/wake 0.2.96 → 0.3.0

package/dist/src/execution/application/active-run-cancellation.js

@@ -0,0 +1,14 @@
+import { runId } from '../contracts/identifiers.js';
+import { RunStatus } from '../contracts/vocabulary.js';
+import { confirmCancellation, requestCancellation } from './run-liveness-service.js';
+export async function cancelActiveRuns(repository, clock, workflowInstanceIds, reason, active) {
+    const workflowIds = new Set(workflowInstanceIds);
+    const cancelled = [];
+    for (const run of await repository.list()) {
+        if (run.status !== RunStatus.Started || !workflowIds.has(run.workflowInstanceId))
+            continue;
+        await requestCancellation(repository, clock, runId(run.runId), reason, active);
+        cancelled.push(await confirmCancellation(repository, clock, runId(run.runId)));
+    }
+    return cancelled;
+}

package/dist/src/execution/application/execution-activity.js

@@ -0,0 +1,97 @@
+import { ExecutionEventType } from '../contracts/events.js';
+import { parseAgentRunnerResponse } from '../infrastructure/agent-runner-adapter.js';
+import { createRunEvent } from './run-lifecycle.js';
+export async function executeActivity(runtime, currentRunId, request) {
+    const { activation, context, occurredAt, runner } = request;
+    const controller = new AbortController();
+    runtime.active.set(currentRunId, controller);
+    const executionContext = {
+        signal: controller.signal,
+        occurredAt,
+        runId: currentRunId,
+        ...(request.resumeSessionId === undefined ? {} : { resumeSessionId: request.resumeSessionId }),
+        ...(request.usageBaseline === undefined ? {} : { usageBaseline: request.usageBaseline }),
+        ...(request.reportRunnerStarted === undefined
+            ? {}
+            : { reportRunnerStarted: request.reportRunnerStarted }),
+        ...workspaceContext(request.workspace),
+        ...(runner === undefined ? {} : { runner }),
+        ...(runtime.dependencies.transcriptRecorder === undefined
+            ? {}
+            : { transcriptRecorder: runtime.dependencies.transcriptRecorder }),
+        ...(runtime.dependencies.logOperationalError === undefined
+            ? {}
+            : { logOperationalError: runtime.dependencies.logOperationalError }),
+        ...(request.runnerName === undefined
+            ? {}
+            : {
+                runnerContext: {
+                    runnerName: request.runnerName,
+                    ...(request.runnerCli === undefined ? {} : { runnerCli: request.runnerCli }),
+                    activationOrdinal: activation.ordinal,
+                    ...(request.runnerModel === undefined ? {} : { model: request.runnerModel }),
+                    ...(request.runnerEffort === undefined ? {} : { effort: request.runnerEffort }),
+                },
+            }),
+        reportExternalExecution: externalExecutionReporter(runtime, currentRunId, context, activation),
+        reportRunnerResult: runnerResultReporter(runtime, currentRunId, context, activation, request),
+    };
+    return runtime.activities.execute({
+        activationId: activation.activationId,
+        activity: activation.activity,
+        workItemId: context.workItemId,
+        workflowInstanceId: context.workflowInstanceId,
+        orchestrationGroupId: context.orchestrationGroupId,
+        causationId: activation.activationId,
+        input: activation.input,
+        resources: context.resources,
+    }, executionContext);
+}
+function externalExecutionReporter(runtime, currentRunId, context, activation) {
+    return async (reference) => {
+        const loaded = await runtime.repository.load(currentRunId);
+        await runtime.repository.append(currentRunId, loaded.sequence, [
+            createRunEvent({
+                runId: currentRunId,
+                eventId: `${currentRunId}:external:${reference.id}`,
+                eventType: ExecutionEventType.RunExternalExecutionReported,
+                occurredAt: runtime.dependencies.clock.now().toISOString(),
+                correlationId: context.orchestrationGroupId,
+                causationId: activation.activationId,
+                payload: reference,
+            }),
+        ]);
+    };
+}
+function runnerResultReporter(runtime, currentRunId, context, activation, request) {
+    return async (result) => {
+        const loaded = await runtime.repository.load(currentRunId);
+        const event = createRunEvent({
+            runId: currentRunId,
+            eventId: `${currentRunId}:runner-result`,
+            eventType: ExecutionEventType.RunRunnerResultReported,
+            occurredAt: runtime.dependencies.clock.now().toISOString(),
+            correlationId: context.orchestrationGroupId,
+            causationId: activation.activationId,
+            payload: { transport: result.transport, agent: parseAgentRunnerResponse(result) },
+        });
+        await appendIdempotently(runtime.repository, currentRunId, loaded.sequence, event);
+        if (result.failure?.kind === 'provider-quota-exceeded' && request.runnerName !== undefined)
+            await runtime.dependencies.reportRunnerQuota?.({
+                runnerName: request.runnerName,
+                message: result.failure.message,
+            });
+    };
+}
+function workspaceContext(workspace) {
+    return workspace === undefined ? {} : { workspace };
+}
+async function appendIdempotently(repository, currentRunId, sequence, event) {
+    try {
+        await repository.append(currentRunId, sequence, [event]);
+    }
+    catch {
+        const current = await repository.load(currentRunId);
+        await repository.append(currentRunId, current.sequence, [event]);
+    }
+}

package/dist/src/execution/application/execution-projection.js

@@ -0,0 +1,17 @@
+import { selectRunExecutionEvent } from '../contracts/events.js';
+import { foldRun } from '../domain/run.js';
+export const executionProjection = {
+    name: 'execution',
+    select(event) {
+        const owned = selectRunExecutionEvent(event);
+        return owned === null ? null : { key: owned.stream.id };
+    },
+    initial: () => ({ events: [], view: null }),
+    project(previous, event) {
+        const owned = selectRunExecutionEvent(event);
+        if (owned === null)
+            return previous;
+        const events = [...previous.events, owned];
+        return { events, view: foldRun(events) };
+    },
+};

package/dist/src/execution/application/execution-service.js

@@ -0,0 +1,372 @@
+/* eslint-disable max-lines */
+import { ActivityExecutionKind, } from '../../activities/index.js';
+import { runId } from '../contracts/identifiers.js';
+import { ExecutionStreamKind } from '../contracts/streams.js';
+import { RunStatus, WorkspaceMode } from '../contracts/vocabulary.js';
+import { claimActivation, releaseActivation } from './activation-claim.js';
+import { cancelActiveRuns } from './active-run-cancellation.js';
+import { executeActivity, } from './execution-activity.js';
+import { acquireWorkspace, validateResourceRequirements } from './execution-validation.js';
+import { recordRunFailure, recordRunSuccess, recordWorkspaceCleanupFailure, startRun, } from './run-lifecycle.js';
+import { claimRun, confirmCancellation, renewLease, requestCancellation, } from './run-liveness-service.js';
+import { RunRepository } from './run-repository.js';
+export function createExecutionService(journal, activities, config, dependencies) {
+    const repository = new RunRepository(journal);
+    const active = new Map();
+    return {
+        attempt: (activation, context) => attemptExecution({ activities, config, dependencies, repository, active, journal }, activation, context),
+        list: (activationId) => repository.list(activationId),
+        isLocallyActive: (id) => active.has(runId(id)),
+        claim: (id, owner) => claimRun(repository, dependencies.clock, config, runId(id), owner),
+        renewLease: (id, owner) => renewLease(repository, dependencies.clock, config, runId(id), owner),
+        requestCancellation: (id, reason) => requestCancellation(repository, dependencies.clock, runId(id), reason, active),
+        confirmCancellation: (id) => confirmCancellation(repository, dependencies.clock, runId(id)),
+        cancelActive: (workflowInstanceIds, reason) => cancelActiveRuns(repository, dependencies.clock, workflowInstanceIds, reason, active),
+    };
+}
+// Starts the durable Run and hands agent invocation ownership to the detached worker.
+// eslint-disable-next-line max-lines-per-function
+async function attemptExecution(runtime, activation, context) {
+    const definition = runtime.activities.describe(activation.activity);
+    runtime.activities.validateInput(activation.activity, activation.input);
+    validateResources(definition.resources, context.resources);
+    const runner = resolveRunner(runtime, definition.executionKind, activation, context);
+    const owner = context.owner ?? 'execution';
+    const prior = await runtime.repository.list(activation.activationId);
+    const resumeCandidates = context.sessionPolicy === 'resume-stage' ? await runtime.repository.list() : prior;
+    const resumeScope = {
+        workflowInstanceId: context.workflowInstanceId,
+        stage: activation.stage,
+        ...(context.sessionPolicy === undefined ? {} : { policy: context.sessionPolicy }),
+    };
+    const resumeSessionId = resumeSessionIdFor(resumeCandidates, runner.cli, resumeScope);
+    const usageBaseline = usageBaselineFor(resumeCandidates, runner.cli, resumeSessionId, resumeScope);
+    const existing = existingRun(prior, runtime.dependencies.clock, owner);
+    if (existing !== undefined)
+        return existing;
+    const currentRunId = runId(runtime.dependencies.ids.next(ExecutionStreamKind.Run));
+    const startedAt = runtime.dependencies.clock.now().toISOString();
+    let reportRunnerStarted = () => { };
+    const runnerStarted = new Promise((resolve) => {
+        reportRunnerStarted = resolve;
+    });
+    let lease;
+    let claimed = false;
+    try {
+        await claimActivationForAttempt(runtime, activation, currentRunId, owner, startedAt);
+        claimed = true;
+        lease = await acquireAttemptWorkspace(runtime, activation, context, currentRunId);
+        await startRun({
+            dependencies: runLifecycleDependencies(runtime),
+            runId: currentRunId,
+            activation,
+            context,
+            attempt: prior.length + 1,
+            startedAt,
+            runner,
+            lease,
+        });
+    }
+    catch (error) {
+        const persisted = await runtime.repository.load(currentRunId);
+        if (persisted.view?.status === RunStatus.Started) {
+            try {
+                await recordRunFailure({
+                    dependencies: runLifecycleDependencies(runtime),
+                    runId: currentRunId,
+                    activation,
+                    context,
+                    error,
+                });
+            }
+            finally {
+                await cleanupRun(runtime, currentRunId, activation, context, lease);
+            }
+            return (await runtime.repository.load(currentRunId)).view;
+        }
+        await releasePreStartResources(runtime, activation, currentRunId, lease, claimed);
+        throw error;
+    }
+    const completion = completeRun(runtime, currentRunId, activation, context, startedAt, runner, resumeSessionId, usageBaseline, lease, reportRunnerStarted);
+    void completion.catch(() => {
+        reportRunnerStarted();
+        // A detached worker must never create an unhandled rejection for its caller.
+    });
+    await yieldToRunStart(definition.executionKind === ActivityExecutionKind.Deterministic &&
+        context.awaitImmediateCompletion
+        ? undefined
+        : definition.executionKind === ActivityExecutionKind.Deterministic
+            ? Promise.resolve()
+            : runnerStarted);
+    return (await runtime.repository.load(currentRunId)).view;
+}
+async function yieldToRunStart(runnerStarted) {
+    if (runnerStarted !== undefined)
+        return runnerStarted;
+    await new Promise((resolve) => setImmediate(resolve));
+}
+// A Run completion atomically carries the full execution lease context.
+// eslint-disable-next-line max-params
+async function completeRun(runtime, currentRunId, activation, context, startedAt, runner, resumeSessionId, usageBaseline, lease, reportRunnerStarted) {
+    const renewal = renewWhileRunning(runtime, currentRunId, context.owner ?? 'execution');
+    try {
+        const outcome = await executeActivity(runtime, currentRunId, {
+            activation,
+            context,
+            occurredAt: startedAt,
+            runner: runner.runner,
+            ...(runner.name === undefined ? {} : { runnerName: runner.name }),
+            ...(runner.cli === undefined ? {} : { runnerCli: runner.cli }),
+            ...(runner.model === undefined ? {} : { runnerModel: runner.model }),
+            ...(runner.effort === undefined ? {} : { runnerEffort: runner.effort }),
+            ...(resumeSessionId === undefined ? {} : { resumeSessionId }),
+            ...(usageBaseline === undefined ? {} : { usageBaseline }),
+            ...(lease === undefined ? {} : { workspace: { path: lease.path, mode: lease.mode } }),
+            reportRunnerStarted,
+        });
+        await renewal.stop();
+        await recordRunSuccess({
+            dependencies: runLifecycleDependencies(runtime),
+            runId: currentRunId,
+            activation,
+            context,
+            outcome,
+        });
+    }
+    catch (error) {
+        try {
+            await renewal.stop();
+            await recordRunFailure({
+                dependencies: runLifecycleDependencies(runtime),
+                runId: currentRunId,
+                activation,
+                context,
+                error,
+            });
+        }
+        catch {
+            // The caller already has a durable started Run; cleanup must still run.
+        }
+    }
+    finally {
+        reportRunnerStarted();
+        await renewal.stop();
+        await cleanupRun(runtime, currentRunId, activation, context, lease);
+    }
+}
+function renewWhileRunning(runtime, currentRunId, owner) {
+    const leaseDurationMs = runtime.config.leaseDurationMs ?? 60_000;
+    const intervalMs = runtime.config.leaseRenewalIntervalMs ?? Math.max(1, Math.floor(leaseDurationMs / 2));
+    let inFlight;
+    let stopped = false;
+    const timer = setInterval(() => {
+        if (stopped || inFlight !== undefined)
+            return;
+        const renewal = renewLease(runtime.repository, runtime.dependencies.clock, runtime.config, currentRunId, owner).then(() => undefined, () => {
+            // Recovery will reconcile a worker only after this process no longer tracks it.
+        });
+        inFlight = renewal;
+        void renewal.finally(() => {
+            if (inFlight === renewal)
+                inFlight = undefined;
+        });
+    }, intervalMs);
+    return {
+        async stop() {
+            stopped = true;
+            clearInterval(timer);
+            await inFlight;
+        },
+    };
+}
+async function cleanupRun(runtime, currentRunId, activation, context, lease) {
+    try {
+        await releaseActivation({
+            journal: runtime.journal,
+            clock: runtime.dependencies.clock,
+            activationId: activation.activationId,
+            runId: currentRunId,
+        });
+    }
+    finally {
+        runtime.active.delete(currentRunId);
+        try {
+            await lease?.release();
+        }
+        catch (error) {
+            try {
+                await recordWorkspaceCleanupFailure({
+                    dependencies: runLifecycleDependencies(runtime),
+                    runId: currentRunId,
+                    activation,
+                    context,
+                    error,
+                });
+            }
+            catch {
+                // A cleanup diagnostic must not make an already-finished run fatal.
+            }
+        }
+    }
+}
+async function releasePreStartResources(runtime, activation, currentRunId, lease, claimed) {
+    if (claimed) {
+        try {
+            await releaseActivation({
+                journal: runtime.journal,
+                clock: runtime.dependencies.clock,
+                activationId: activation.activationId,
+                runId: currentRunId,
+            });
+        }
+        catch {
+            // Preserve the original pre-start failure.
+        }
+    }
+    try {
+        await lease?.release();
+    }
+    catch {
+        // There is no durable Run on which to record a cleanup diagnostic.
+    }
+}
+export function resumeSessionIdFor(prior, cli, scope) {
+    if (cli === undefined || scope?.policy === 'fresh')
+        return undefined;
+    const eligible = resumeEligibleRuns(prior, scope);
+    return [...eligible]
+        .filter((run) => isResumeTerminal(run.status))
+        .sort(compareNewestTerminalRun)
+        .find((run) => run.runner?.cli === cli &&
+        typeof run.agent?.metadata.sessionId === 'string' &&
+        run.agent.metadata.sessionId.trim().length > 0)?.agent?.metadata.sessionId;
+}
+export function usageBaselineFor(prior, cli, sessionId, scope) {
+    if (cli === undefined || sessionId === undefined)
+        return undefined;
+    const matching = resumeEligibleRuns(prior, scope).filter((run) => isResumeTerminal(run.status) &&
+        run.runner?.cli === cli &&
+        run.agent?.metadata.sessionId === sessionId);
+    if (matching.length === 0)
+        return undefined;
+    const requiredInput = sumCompleteCounters(matching, 'inputTokens');
+    const requiredOutput = sumCompleteCounters(matching, 'outputTokens');
+    if (requiredInput === undefined || requiredOutput === undefined)
+        return undefined;
+    const cacheRead = optionalCacheBaseline(matching, 'cacheReadTokens');
+    const cacheWrite = optionalCacheBaseline(matching, 'cacheWriteTokens');
+    if (cacheRead === 'invalid' || cacheWrite === 'invalid')
+        return undefined;
+    return {
+        input: requiredInput,
+        output: requiredOutput,
+        ...(cacheRead === undefined ? {} : { cacheRead }),
+        ...(cacheWrite === undefined ? {} : { cacheWrite }),
+    };
+}
+function sumCompleteCounters(runs, key) {
+    let total = 0;
+    for (const run of runs) {
+        const value = run.agent?.metadata[key];
+        if (!isValidHistoricalCounter(value))
+            return undefined;
+        total += value;
+    }
+    return total;
+}
+function optionalCacheBaseline(runs, key) {
+    const values = runs.map((run) => run.agent?.metadata[key]);
+    let incomplete = false;
+    let total = 0;
+    for (const value of values) {
+        if (value === undefined) {
+            incomplete = true;
+            continue;
+        }
+        if (!isValidHistoricalCounter(value))
+            return 'invalid';
+        total += value;
+    }
+    return incomplete ? undefined : total;
+}
+function isValidHistoricalCounter(value) {
+    return typeof value === 'number' && Number.isFinite(value) && value >= 0;
+}
+function resumeEligibleRuns(prior, scope) {
+    return scope?.policy !== 'resume-stage' || scope.stage === undefined
+        ? prior
+        : prior.filter((run) => run.workflowInstanceId === scope.workflowInstanceId && run.stage === scope.stage);
+}
+function isResumeTerminal(status) {
+    return (status === RunStatus.Succeeded || status === RunStatus.Failed || status === RunStatus.Cancelled);
+}
+function compareNewestTerminalRun(left, right) {
+    const byFinishedAt = (right.finishedAt ?? '').localeCompare(left.finishedAt ?? '');
+    if (byFinishedAt !== 0)
+        return byFinishedAt;
+    const byAttempt = right.attempt - left.attempt;
+    if (byAttempt !== 0)
+        return byAttempt;
+    return right.runId.localeCompare(left.runId);
+}
+function resolveRunner(runtime, executionKind, activation, context) {
+    const runnerPool = activation.execution?.runnerPool ?? runtime.config.defaultRunnerPool;
+    if (runtime.config.runnerPools[runnerPool] === undefined)
+        throw new Error(`Unknown execution runner pool: ${runnerPool}`);
+    if (executionKind !== ActivityExecutionKind.Agent)
+        return { runner: undefined };
+    const resolved = runtime.dependencies.runners?.resolve(runnerPool, context.ineligibleRunners ?? new Set());
+    return describeResolvedRunner(runtime, runnerPool, resolved);
+}
+function describeResolvedRunner(runtime, pool, resolved) {
+    if (resolved === undefined)
+        return { runner: undefined };
+    return {
+        runner: resolved.runner,
+        name: resolved.name,
+        model: runtime.config.agentRunners?.[resolved.name]?.model,
+        effort: runtime.config.agentRunners?.[resolved.name]?.effort,
+        pool,
+        cli: runtime.config.agentRunners?.[resolved.name]?.kind,
+    };
+}
+function runLifecycleDependencies(runtime) {
+    return {
+        clock: runtime.dependencies.clock,
+        config: runtime.config,
+        repository: runtime.repository,
+    };
+}
+async function claimActivationForAttempt(runtime, activation, currentRunId, owner, occurredAt) {
+    await claimActivation({
+        journal: runtime.journal,
+        clock: runtime.dependencies.clock,
+        config: runtime.config,
+        activationId: activation.activationId,
+        runId: currentRunId,
+        owner,
+        occurredAt,
+    });
+}
+function acquireAttemptWorkspace(runtime, activation, context, currentRunId) {
+    return acquireWorkspace(currentRunId, activation.execution?.workspace ?? WorkspaceMode.None, context.workItemId, context.resources, runtime.dependencies.workspaces);
+}
+function existingRun(runs, clock, owner) {
+    const completed = runs.find((run) => run.status === RunStatus.Succeeded);
+    if (completed !== undefined)
+        return completed;
+    const ambiguous = runs.find((run) => run.status === RunStatus.Ambiguous);
+    if (ambiguous !== undefined)
+        return ambiguous;
+    const active = runs.find((run) => run.status === RunStatus.Started);
+    if (active === undefined)
+        return undefined;
+    if (active.lease !== undefined &&
+        new Date(active.lease.expiresAt) > clock.now() &&
+        active.lease.owner !== owner)
+        throw new Error(`Run ${active.runId} has an unexpired lease`);
+    return active;
+}
+function validateResources(requirements, resources) {
+    validateResourceRequirements(requirements, resources);
+}

package/dist/src/execution/application/execution-validation.js

@@ -0,0 +1,26 @@
+import { ActivityResourceCardinality } from '../../activities/index.js';
+import { BuiltInResourceKind } from '../../resources/index.js';
+import { WorkspaceMode } from '../contracts/vocabulary.js';
+export async function acquireWorkspace(runId, mode, workItemId, resources, provider) {
+    if (mode === WorkspaceMode.None)
+        return undefined;
+    if (provider === undefined)
+        throw new Error('Workspace provider is required');
+    const repositoryResource = resources.find((resource) => resource.kind === BuiltInResourceKind.Repository) ??
+        resources.find((resource) => resource.kind === BuiltInResourceKind.Issue ||
+            resource.kind === BuiltInResourceKind.PullRequest);
+    if (repositoryResource === undefined)
+        throw new Error('Repository Resource is required');
+    return provider.acquire({ runId, mode, workItemId, repositoryResource });
+}
+export function validateResourceRequirements(requirements, resources) {
+    for (const requirement of requirements) {
+        const count = resources.filter((resource) => resource.capabilities.includes(requirement.capability)).length;
+        if (requirement.cardinality === ActivityResourceCardinality.ExactlyOne && count !== 1)
+            throw new Error(`Activity requires exactly one ${requirement.capability} Resource`);
+        if (requirement.cardinality === ActivityResourceCardinality.OneOrMore && count < 1)
+            throw new Error(`Activity requires ${requirement.capability} Resources`);
+        if (requirement.cardinality === ActivityResourceCardinality.ZeroOrOne && count > 1)
+            throw new Error(`Activity allows at most one ${requirement.capability} Resource`);
+    }
+}