@abot-ai/runtime 1.5.0 → 1.7.0

package/dist/src/runtime/request/worker-capability-payload.js

@@ -1,38 +1,68 @@
+import { buildRuntimeFilesystemScopeMessage, } from "../context/runtime-filesystem-scope.js";
+import { quarantineOwnedSuperPayloadCheckpoint } from "./super-payload-context-failure.js";
+import { assertSuperWorkerCompactionSidecarBinding } from "../context/super-worker-compaction-sidecar.js";
 import { projectRequestContext } from "../context/request-context.js";
 import { createModelStepCompactionController } from "../context/model-step-compaction.js";
-import { projectCurrentRequestToolResults } from "../context/request-tool-results.js";
-import { createSemanticCompactionSha256Fingerprint, } from "../context/semantic-compaction/index.js";
 import { buildRequestSourceMessage, projectRequestSource, } from "../context/request-source.js";
 import { resolveModelContextBudget } from "../model/model-context-budget.js";
-import { validateJsonSchemaValue } from "../model/json-schema-value.js";
+import { normalizePayloadBody } from "../orchestration/worker-capabilities/payload-body-normalization.js";
 import { invokeRepairableRawModelStep, RawModelValidationError, } from "../model/invoke-raw-step.js";
 import { traceDebug } from "../observability/debug-logger.js";
 import { createWorkerCapabilityPayloadAuthor, workerCapabilityContextCompactionScopeId, WORKER_CAPABILITY_CONTEXT_COMPACTION_ALLOWED_CONSUMERS, WorkerCapabilityPayloadBudgetExceededError, WorkerCapabilityPayloadValidationError, } from "../orchestration/worker-capabilities/index.js";
 import { buildWorkerCapabilityPayloadRepairHint } from "./worker-capability-payload-prompts.js";
+import { projectExecutionPayloadCompactedEvidence } from "./execution-payload-compacted-evidence.js";
 const PAYLOAD_TARGET_CONTENT_MESSAGE_KIND = "runtime_payload_target_content_v1";
 const PAYLOAD_RELATED_ARTIFACT_CONTENT_MESSAGE_KIND = "runtime_payload_related_artifact_content_v1";
 const WORKER_CAPABILITY_PAYLOAD_MAX_REPAIR_ATTEMPTS = 2;
 /** Binds the neutral payload-author port to one request's model boundary. */
-export function createRequestWorkerCapabilityPayloadAuthor(request, capabilityAuthorities) {
-    return createWorkerCapabilityPayloadAuthor({
-        requestId: request.requestId,
-        abortSignal: request.abortSignal,
-        ...(capabilityAuthorities ? { capabilityAuthorities } : {}),
-        model: Object.freeze({
-            invoke: (input) => invokePayloadModel(request, input),
-        }),
+export function createRequestWorkerCapabilityPayloadAuthor(request, capabilityAuthorities, filesystemScope) {
+    const frozenAuthorities = capabilityAuthorities
+        ? Object.freeze([...capabilityAuthorities])
+        : undefined;
+    return Object.freeze({
+        author: (authorInput) => {
+            return createWorkerCapabilityPayloadAuthor({
+                requestId: request.requestId,
+                abortSignal: request.abortSignal,
+                ...(frozenAuthorities
+                    ? { capabilityAuthorities: frozenAuthorities }
+                    : {}),
+                model: Object.freeze({
+                    invoke: (input) => invokePayloadModel(request, input, buildRuntimeFilesystemScopeMessage({
+                        scope: filesystemScope,
+                        workingDirectory: authorInput.call.workingDirectory,
+                        capabilities: [authorInput.descriptor],
+                    })),
+                }),
+            }).author(authorInput);
+        },
     });
 }
-async function invokePayloadModel(request, input) {
+async function invokePayloadModel(request, input, filesystemMessage) {
     const compactionOptions = payloadCompactionOptions(input);
+    if (input.superWorkerCompaction)
+        assertSuperWorkerCompactionSidecarBinding(input.superWorkerCompaction, {
+            requestId: request.requestId,
+            callId: payloadContextCallId(input.context),
+        });
     try {
+        const projection = payloadMessages(request, input, filesystemMessage);
         return await invokeRepairableRawModelStep({
             request,
             modelStep: input.modelStep,
-            messages: payloadMessages(request, input),
+            messages: projection.messages,
             contextCompaction: createModelStepCompactionController(request, {
+                consumer: input.modelStep,
+                hasVerifiedCompactedEvidence: projection.hasVerifiedCompactedEvidence,
                 call: payloadCompactionCall(request.prompt, input.context),
-                sourceRevision: payloadCompactionSourceRevision(input.context),
+                sourceRevision: input.superWorkerCompaction?.sourceRevision ??
+                    payloadCompactionSourceRevision(input.context),
+                ...(input.superWorkerCompaction
+                    ? {
+                        superWorkerCompaction: input.superWorkerCompaction,
+                        requireSuperWorkerSources: true,
+                    }
+                    : {}),
                 allowedConsumers: compactionOptions.allowedConsumers,
                 scopeId: compactionOptions.scopeId,
                 ...(compactionOptions.resultSourceOverrides
@@ -49,6 +79,7 @@ async function invokePayloadModel(request, input) {
         });
     }
     catch (error) {
+        quarantineOwnedSuperPayloadCheckpoint(request, input, error);
         const code = payloadValidationCode(error);
         if (code) {
             throw new WorkerCapabilityPayloadValidationError(code);
@@ -62,24 +93,11 @@ async function invokePayloadModel(request, input) {
     }
 }
 function validatePayloadModelOutput(text, minBytes, maxBytes, responseFormat) {
-    let normalized = text;
-    if (responseFormat) {
-        let parsed;
-        try {
-            parsed = JSON.parse(text);
-        }
-        catch {
-            return invalidStructuredPayload("output", "Return one valid JSON value matching the frozen response format.");
-        }
-        if (responseFormat !== "json") {
-            const schemaIssue = validateJsonSchemaValue(responseFormat, parsed);
-            if (schemaIssue) {
-                return invalidStructuredPayload(schemaIssue.path, schemaIssue.message);
-            }
-        }
-        normalized = JSON.stringify(parsed);
+    const normalized = normalizePayloadBody(text, responseFormat);
+    if (!normalized.ok) {
+        return invalidStructuredPayload(normalized.issue.path, normalized.issue.message);
     }
-    const payloadBytes = Buffer.byteLength(normalized, "utf8");
+    const payloadBytes = Buffer.byteLength(normalized.body, "utf8");
     if (payloadBytes >= minBytes && payloadBytes <= maxBytes) {
         return Object.freeze({ ok: true, value: text });
     }
@@ -127,7 +145,7 @@ function payloadValidationCode(error) {
         ? code
         : undefined;
 }
-function payloadMessages(request, input) {
+function payloadMessages(request, input, filesystemMessage) {
     const callId = payloadContextCallId(input.context);
     const budget = resolveModelContextBudget({
         runnerConfig: request.runnerConfig,
@@ -147,12 +165,13 @@ function payloadMessages(request, input) {
             historyMessages: request.historyMessages,
         })
         : undefined;
-    const projectedContext = projectPayloadContext(input.context);
+    const projectedContext = projectPayloadContext(input.context, request);
     traceDebug("runtime.worker_capability_payload_context", "projected", {
         requestId: request.requestId,
         modelStep: input.modelStep,
         callId,
         contextScope: projectedContext.contextScope,
+        reusedCompactedSourceCount: projectedContext.reusedCompactedSourceCount,
         settledCapabilityResultCount: input.context.settledCapabilityResults.length,
         ...projectedContext.settledResultDiagnostics,
         relatedArtifactContextCount: projectedContext.relatedArtifactMessages.length,
@@ -160,12 +179,14 @@ function payloadMessages(request, input) {
         hasTargetContext: input.context.targetContext !== undefined,
         requestSourceProjection: input.requestSourceProjection,
     });
+    const canonicalContext = `Canonical runtime context:\n${JSON.stringify(projectedContext.metadata)}`;
     try {
-        return projectRequestContext({
+        const messages = projectRequestContext({
             instructions: input.instructions,
             historyMessages: [],
-            prompt: `Canonical runtime context:\n${JSON.stringify(projectedContext.metadata)}`,
+            prompt: canonicalContext,
             referenceMessages: [
+                ...(filesystemMessage ? [filesystemMessage] : []),
                 ...(requestSource ? [buildRequestSourceMessage(requestSource)] : []),
                 ...projectedContext.relatedArtifactMessages,
             ],
@@ -181,6 +202,14 @@ function payloadMessages(request, input) {
             onEvent: request.onEvent,
             deferCompactionFailure: true,
         }).messages;
+        return Object.freeze({
+            messages,
+            hasVerifiedCompactedEvidence(candidateMessages) {
+                if (projectedContext.reusedCompactedSourceCount === 0)
+                    return false;
+                return candidateMessages.some((message) => message.role === "user" && message.content === canonicalContext);
+            },
+        });
     }
     catch (error) {
         if (error instanceof Error &&
@@ -221,7 +250,9 @@ function payloadCompactionOptions(input) {
         return Object.freeze({
             allowedConsumers: WORKER_CAPABILITY_CONTEXT_COMPACTION_ALLOWED_CONSUMERS,
             scopeId: workerCapabilityContextCompactionScopeId(input.context.worker.callId),
-            resultSourceOverrides: createWorkerPayloadResultSources(input.context),
+            ...(input.superWorkerCompaction
+                ? { resultSourceOverrides: input.superWorkerCompaction.sources }
+                : {}),
         });
     }
     return Object.freeze({
@@ -234,17 +265,7 @@ function payloadCompactionOptions(input) {
         ].join(":"),
     });
 }
-function createWorkerPayloadResultSources(context) {
-    return Object.freeze(projectCurrentRequestToolResults(context.settledCapabilityResults).map((result) => {
-        const content = JSON.stringify(result);
-        return Object.freeze({
-            sourceRef: result.executionId,
-            sourceFingerprint: createSemanticCompactionSha256Fingerprint(content),
-            content,
-        });
-    }));
-}
-function projectPayloadContext(context) {
+function projectPayloadContext(context, request) {
     const contextScope = context.contextScope;
     const targetProjection = context.targetContext
         ? projectTargetContext(context.targetContext)
@@ -253,13 +274,17 @@ function projectPayloadContext(context) {
         ? []
         : (context.relatedArtifactContexts ?? []).map((artifact, index) => projectRelatedArtifactContext(artifact, index));
     const settledResultProjection = projectSettledResultsForPayload(context, contextScope);
+    const compactedEvidence = projectExecutionPayloadCompactedEvidence(request, context, settledResultProjection.results);
     const baseMetadata = { ...context };
     delete baseMetadata.targetContext;
     delete baseMetadata.relatedArtifactContexts;
     return Object.freeze({
         metadata: Object.freeze({
             ...baseMetadata,
-            settledCapabilityResults: settledResultProjection.results,
+            settledCapabilityResults: compactedEvidence.results,
+            ...(compactedEvidence.evidence
+                ? { compactedSourceEvidence: compactedEvidence.evidence }
+                : {}),
             ...(targetProjection ? { targetContext: targetProjection.metadata } : {}),
             ...(relatedArtifactProjections.length > 0
                 ? {
@@ -273,6 +298,7 @@ function projectPayloadContext(context) {
             : {}),
         contextScope,
         settledResultDiagnostics: settledResultProjection.diagnostics,
+        reusedCompactedSourceCount: compactedEvidence.evidence?.sources.length ?? 0,
     });
 }
 /**

package/dist/src/runtime/runtime-environment.d.ts

@@ -1,4 +1,5 @@
 import { SessionRequestAdmission } from "./request/session-admission.js";
+import { type AutomationService } from "./automations/service.js";
 import type { EventSinkFactory, RuntimeConfig } from "./ports.js";
 import type { RuntimeApplicationOverrides, RuntimeEnvironmentServices } from "./composition.js";
 export declare function createRuntimeEnvironment(config: RuntimeConfig, overrides?: RuntimeApplicationOverrides): {
@@ -13,7 +14,8 @@ export declare function createRuntimeEnvironment(config: RuntimeConfig, override
         sessionMemoryCompactor: import("./context/session-memory/contracts.js").SessionMemoryCompactor;
         longTermMemory: import("./index.js").LongTermMemoryService;
         passiveLearning?: import("./passive-learning/contracts.js").PassiveLearningService;
-        scheduler?: import("./index.js").SchedulerService;
+        automations?: AutomationService;
+        scheduler?: import("./scheduler/contracts.js").SchedulerService;
         startScheduler?: () => Promise<void>;
         stopScheduler?: () => Promise<void>;
         requestAdmission?: SessionRequestAdmission;

package/dist/src/runtime/runtime-environment.js

@@ -5,19 +5,41 @@ import { createDefaultAttachmentStore, createDefaultEventSinkFactory, createDefa
 import { createBoundRuntimeRequestHandler } from "./request/bound-runtime-handler.js";
 import { createModelSessionMemoryCompactor } from "./context/session-memory/index.js";
 import { createSessionLifecycleStore } from "./session/session-lifecycle-store.js";
+import { createSparkSessionClearBoundary } from "./session/spark-session-clear.js";
 import { bindManagedSessionAttachmentDeletion, deleteSessionAttachmentsIfSupported, } from "./session/session-attachment-deletion.js";
 import { SessionRequestAdmission } from "./request/session-admission.js";
 import { createRuntimeScheduler } from "./adapters/scheduler-runtime.js";
+import { createAutomationPersistence } from "./automations/persistence.js";
+import { createAutomationResultStore } from "./automations/result-store.js";
+import { createAutomationNodeTransactions } from "./automations/node-transactions.js";
+import { createAutomationService } from "./automations/service.js";
+import { createAutomationRuntimeExecutor } from "./automations/runtime-executor.js";
+import { compileAutomationGraph } from "./automations/graph-validation.js";
+import { executeAutomationGraph } from "./automations/graph-executor.js";
+import { createAutomationStepRunner } from "./automations/step-runner.js";
+import { createAutomationAgentStepExecutor } from "./automations/agent-step-executor.js";
+import { createAutomationReportService } from "./automations/run-report.js";
+import { readAutomationCatalog } from "./automations/catalog.js";
+import { fingerprintAutomationDependencies } from "./automations/dependency-fingerprint.js";
+import { validateAutomationWorkingDirectory } from "./automations/working-directory.js";
+import { createAutomationModelCapacity } from "./automations/model-capacity.js";
+import { createAutomationToolLifetimes } from "./automations/tool-lifetimes.js";
 // Composition metadata, never request state. A rebound graph retains caller
 // supplied adapters while replacing closures that belong to its old scheduler.
 const environmentCompositions = new WeakMap();
 export function createRuntimeEnvironment(config, overrides = {}) {
     const backingSessions = overrides.sessions ?? createDefaultSessionStore(config);
     const attachments = overrides.attachments ?? createDefaultAttachmentStore(config);
-    const sessionLifecycle = createSessionLifecycleStore(backingSessions, (result) => deleteSessionAttachmentsIfSupported(attachments, result.sessionId));
+    const sessionLifecycle = createSessionLifecycleStore(backingSessions, (result) => deleteSessionAttachmentsIfSupported(attachments, result.sessionId), undefined, createSparkSessionClearBoundary(backingSessions, () => admission, attachments, config.paths.runtimeDir));
     bindManagedSessionAttachmentDeletion(sessionLifecycle.store, attachments);
     const admission = new SessionRequestAdmission(sessionLifecycle.isDeleted, async (sessionId) => Boolean((await sessionLifecycle.store.requestLifecycle?.listWaiting(sessionId))
         ?.length));
+    let boundAutomationExecutor;
+    function requireAutomationExecutor() {
+        if (!boundAutomationExecutor)
+            throw new Error("automation_executor_not_ready");
+        return boundAutomationExecutor;
+    }
     const scheduling = createRuntimeScheduler({
         config,
         sessions: sessionLifecycle.store,
@@ -25,17 +47,159 @@ export function createRuntimeEnvironment(config, overrides = {}) {
         isDeleted: sessionLifecycle.isDeleted,
         handle: (ws, message, options) => rawRequests.handle(ws, message, options),
         requestOptions: overrides.scheduledRequestOptions,
+        automationExecutor: {
+            prepare: (...args) => requireAutomationExecutor().prepare(...args),
+            prepareReplay: (...args) => requireAutomationExecutor().prepareReplay(...args),
+            start: (...args) => requireAutomationExecutor().start(...args),
+            stop: (...args) => requireAutomationExecutor().stop(...args),
+            recover: (...args) => requireAutomationExecutor().recover(...args),
+            reconcileSessions: () => requireAutomationExecutor().reconcileSessions(),
+            settle: (...args) => requireAutomationExecutor().settle(...args),
+            cancelPending: (...args) => requireAutomationExecutor().cancelPending(...args),
+            maintainRetention: (...args) => requireAutomationExecutor().maintainRetention(...args),
+        },
     });
     sessionLifecycle.onDeleted(async (sessionId) => {
         await scheduling.ensureStarted();
         await scheduling.scheduler.deleteSession(sessionId);
     });
+    let automations;
+    function requireAutomations() {
+        if (!automations)
+            throw new Error("automation_service_not_ready");
+        return automations;
+    }
     const tools = overrides.tools ??
         createDefaultToolRegistry(config, {
             service: scheduling.scheduler,
             ready: scheduling.ensureStarted,
+        }, {
+            getService: requireAutomations,
+            ready: scheduling.ensureStarted,
         });
     const models = overrides.models ?? createDefaultModelGatewayClient(config);
+    const automationPersistence = createAutomationPersistence(scheduling.store);
+    const automationResults = createAutomationResultStore(config.paths.runtimeDir);
+    const automationTransactions = createAutomationNodeTransactions({
+        persistence: automationPersistence,
+    });
+    const automationModelCapacity = createAutomationModelCapacity();
+    const automationToolLifetimes = createAutomationToolLifetimes();
+    automations = createAutomationService({
+        config,
+        scheduler: scheduling.scheduler,
+        persistence: automationPersistence,
+        results: automationResults,
+        tools,
+    });
+    const automationReports = createAutomationReportService({
+        persistence: automationPersistence,
+        results: automationResults,
+    });
+    boundAutomationExecutor = createAutomationRuntimeExecutor({
+        config,
+        sessions: backingSessions,
+        persistence: automationPersistence,
+        attachments,
+        results: automationResults,
+        toolLifetimes: automationToolLifetimes,
+        async execute(_job, run, signal) {
+            const state = await automationPersistence.read();
+            const published = state.definitions.find((entry) => entry.automationId === run.target.automationId &&
+                entry.revision === run.target.definitionRevision);
+            const definition = published?.definition;
+            if (!definition)
+                return {
+                    status: "failed", error: "automation_definition_not_found",
+                    reportRef: `derived:${run.id}`,
+                };
+            const workingDirectoryIssue = validateAutomationWorkingDirectory(definition.workingDirectory);
+            if (workingDirectoryIssue)
+                return {
+                    status: "failed", error: workingDirectoryIssue.code,
+                    reportRef: `derived:${run.id}`,
+                };
+            const compiled = compileAutomationGraph(definition);
+            if (!compiled.ok)
+                return {
+                    status: "failed", error: "automation_graph_invalid",
+                    reportRef: `derived:${run.id}`,
+                };
+            if (published.dependencyFingerprint) {
+                const available = await readAutomationCatalog({
+                    automationId: run.target.automationId,
+                    environmentId: config.runtimeId,
+                    config, tools, persistence: automationPersistence,
+                });
+                if (fingerprintAutomationDependencies({
+                    definition, config, operations: available.operations,
+                }) !== published.dependencyFingerprint)
+                    return {
+                        status: "failed", error: "automation_contract_changed",
+                        reportRef: `derived:${run.id}`,
+                    };
+            }
+            const agent = createAutomationAgentStepExecutor({
+                // Agent attempts own their deletion guard; user-session tombstones are permanent.
+                config, sessions: backingSessions, attachments, models, tools,
+                modelCapacity: automationModelCapacity,
+                toolLifetimes: automationToolLifetimes,
+                persistence: automationPersistence, results: automationResults,
+                transactions: automationTransactions, grants: { get: automations.getGrant },
+                automationId: run.target.automationId, runId: run.id, definition,
+            });
+            const steps = createAutomationStepRunner({
+                runId: run.id, automationId: run.target.automationId,
+                definition, graph: compiled.graph, config, tools, attachments,
+                persistence: automationPersistence, results: automationResults,
+                transactions: automationTransactions, grants: { get: automations.getGrant },
+                toolLifetimes: automationToolLifetimes,
+                executeAgent: ({ step, inputs, sourceAttachments, signal: stepSignal }) => {
+                    if (step.node.kind !== "agent")
+                        throw new Error("automation_node_kind_invalid");
+                    return agent.execute({ node: step.node, inputs, sourceAttachments, signal: stepSignal });
+                },
+            });
+            try {
+                const outcome = await executeAutomationGraph({
+                    runId: run.id, automationId: run.target.automationId,
+                    definition, inputIds: state.executions.find((entry) => entry.id === run.id)?.inputIds ?? [],
+                    graph: compiled.graph, transactions: automationTransactions,
+                    abortSignal: signal, executeStep: steps.run,
+                });
+                const current = await automationTransactions.get(run.id);
+                if (!current || current.nodes.some((node) => node.status === "pending" || node.status === "ready" || node.status === "running"))
+                    throw new Error("automation_run_not_settled");
+                let reportRef;
+                try {
+                    const report = await automationReports.create({
+                        run,
+                        definition,
+                        outcome: outcome.status,
+                    });
+                    reportRef = report.record.id;
+                }
+                catch (error) {
+                    if (!(error instanceof Error) ||
+                        error.message !== "automation_artifact_budget_exhausted")
+                        throw error;
+                    // The durable node state can still project a compact report at capacity.
+                    reportRef = `derived:${run.id}`;
+                }
+                return {
+                    status: outcome.status,
+                    ...(outcome.errorCode ? { error: outcome.errorCode } : {}),
+                    reportRef,
+                };
+            }
+            catch (error) {
+                return {
+                    status: "failed", error: error instanceof Error ? error.message : "automation_run_failed",
+                    reportRef: `derived:${run.id}`,
+                };
+            }
+        },
+    });
     const longTermMemory = overrides.longTermMemory ??
         createDefaultLongTermMemoryService(config, models);
     const passiveLearning = overrides.passiveLearning ??
@@ -44,6 +208,7 @@ export function createRuntimeEnvironment(config, overrides = {}) {
             models,
             memory: longTermMemory,
             sessions: sessionLifecycle.store,
+            deliveryAdmission: admission,
         });
     sessionLifecycle.onDeleted(async (sessionId) => {
         try {
@@ -66,6 +231,7 @@ export function createRuntimeEnvironment(config, overrides = {}) {
         sessionMemoryCompactor: overrides.sessionMemoryCompactor ?? createModelSessionMemoryCompactor(),
         longTermMemory,
         passiveLearning,
+        automations,
         scheduler: scheduling.scheduler,
         startScheduler: scheduling.start,
         stopScheduler: scheduling.stop,

package/dist/src/runtime/scheduler/automation-job-management.d.ts

@@ -0,0 +1,12 @@
+import type { AutomationExecutionRecord, AutomationJournalState } from "../automations/storage-records.js";
+import type { CreateAutomationSchedulerJobInput, SchedulerAutomationJob, SchedulerAutomationRun, UpdateAutomationSchedulerJobInput } from "./contracts.js";
+import { type SchedulerContext } from "./service-context.js";
+type PublicationCommit = (state: AutomationJournalState, candidate: SchedulerAutomationJob) => void;
+export declare function createAutomationSchedulerJob(context: SchedulerContext, input: CreateAutomationSchedulerJobInput, commitPublication?: PublicationCommit): Promise<SchedulerAutomationJob>;
+export declare function updateAutomationSchedulerJob(context: SchedulerContext, jobId: string, patch: UpdateAutomationSchedulerJobInput, commitPublication?: PublicationCommit): Promise<SchedulerAutomationJob>;
+export declare function changeAutomationSchedulerJobState(context: SchedulerContext, jobId: string, target: "active" | "paused"): Promise<SchedulerAutomationJob>;
+export declare function requestAutomationSchedulerRunNow(context: SchedulerContext, jobId: string, options?: {
+    idempotencyKey?: string;
+}): Promise<SchedulerAutomationRun>;
+export declare function requireCommittedAutomationExecution(state: AutomationJournalState, runId: string): AutomationExecutionRecord;
+export {};