@abot-ai/runtime 1.5.0 → 1.6.0

package/dist/src/runtime/automations/input-ledger.js

@@ -0,0 +1,147 @@
+import { randomUUID } from "node:crypto";
+import { requireObservedInputCapacity } from "./input-capacity.js";
+export { MAX_INPUT_SNAPSHOT_BYTES } from "./input-capacity.js";
+export function recordsForSource(state, automationId, sourceId) {
+    return state.inputs.filter((record) => record.automationId === automationId && record.sourceId === sourceId);
+}
+export function hasSourceBaseline(records, root) {
+    return records.some((record) => record.baselineMarker === true && record.canonicalPath === root);
+}
+export function cachedContentVersion(file, records) {
+    const cached = records.find((record) => !record.baselineMarker && record.canonicalPath === file.canonicalPath &&
+        record.observedSizeBytes === file.sizeBytes &&
+        record.observedMtimeMs === file.mtimeMs &&
+        record.observedCtimeMs === file.ctimeMs);
+    return cached?.contentVersion;
+}
+export function findSourceVersion(records, canonicalPath, contentVersion) {
+    return records.find((record) => !record.baselineMarker && record.canonicalPath === canonicalPath &&
+        record.contentVersion === contentVersion);
+}
+export function sourceBaselineMarker(input) {
+    return {
+        id: randomUUID(),
+        automationId: input.automationId,
+        sourceId: input.sourceId,
+        canonicalPath: input.root,
+        contentVersion: "source-baseline-marker-v1",
+        observedAt: input.observedAt,
+        eligibility: "baseline",
+        baselineMarker: true,
+        ...(input.excludedInputIds?.length ? { excludedInputIds: input.excludedInputIds } : {}),
+    };
+}
+export function isReusableSourceInput(record, records, root) {
+    if (record.eligibility !== "eligible")
+        return false;
+    if (record.claimRunId)
+        return false;
+    if (record.outcomeRef)
+        return false;
+    if (!record.snapshot)
+        return false;
+    const baseline = records.find((candidate) => candidate.baselineMarker === true && candidate.canonicalPath === root);
+    return !baseline?.excludedInputIds?.includes(record.id);
+}
+function observedMetadata(file) {
+    return {
+        observedSizeBytes: file.sizeBytes,
+        observedMtimeMs: file.mtimeMs,
+        observedCtimeMs: file.ctimeMs,
+    };
+}
+export function baselineFileRecord(input) {
+    return {
+        id: randomUUID(),
+        automationId: input.automationId,
+        sourceId: input.sourceId,
+        canonicalPath: input.file.canonicalPath,
+        contentVersion: input.file.contentVersion,
+        observedAt: input.observedAt,
+        eligibility: "baseline",
+        ...observedMetadata(input.file),
+    };
+}
+export function eligibleFileRecord(input) {
+    return {
+        id: input.id ?? randomUUID(),
+        automationId: input.automationId,
+        sourceId: input.sourceId,
+        canonicalPath: input.file.canonicalPath,
+        contentVersion: input.file.contentVersion,
+        observedAt: input.observedAt,
+        eligibility: "eligible",
+        ...observedMetadata(input.file),
+        snapshot: {
+            attachment: input.attachment,
+            contentVersion: input.file.contentVersion,
+            sizeBytes: input.file.sizeBytes,
+        },
+    };
+}
+export function commitInputObservation(input) {
+    const additions = [
+        ...(input.marker ? [input.marker] : []),
+        ...(input.baselineFiles ?? []),
+        ...(input.newFiles ?? []),
+    ];
+    for (const candidate of additions) {
+        if (input.state.inputs.some((record) => record.automationId === candidate.automationId &&
+            record.sourceId === candidate.sourceId &&
+            record.baselineMarker === candidate.baselineMarker &&
+            record.canonicalPath === candidate.canonicalPath &&
+            record.contentVersion === candidate.contentVersion))
+            throw new Error("automation_source_changed");
+    }
+    for (const id of input.selectedExistingIds ?? []) {
+        const existing = input.state.inputs.find((record) => record.id === id);
+        if (!existing || existing.eligibility !== "eligible" ||
+            existing.claimRunId || existing.outcomeRef || !existing.snapshot)
+            throw new Error("automation_source_changed");
+    }
+    if (input.runId) {
+        for (const record of input.newFiles ?? []) {
+            input.state.inputs.push({ ...record, claimRunId: input.runId });
+        }
+        for (const id of input.selectedExistingIds ?? []) {
+            replaceInput(input.state, id, (record) => ({ ...record, claimRunId: input.runId }));
+        }
+    }
+    else {
+        input.state.inputs.push(...(input.newFiles ?? []));
+    }
+    input.state.inputs.push(...(input.marker ? [input.marker] : []));
+    input.state.inputs.push(...(input.baselineFiles ?? []));
+    for (const update of input.refresh ?? []) {
+        replaceInput(input.state, update.recordId, (record) => ({
+            ...record,
+            observedAt: update.observedAt,
+            ...observedMetadata(update.file),
+        }));
+    }
+    requireObservedInputCapacity(input.state.inputs, new Set([
+        ...additions.map((record) => record.id),
+        ...(input.selectedExistingIds ?? []),
+        ...(input.refresh ?? []).map((record) => record.recordId),
+    ]));
+}
+function replaceInput(state, id, update) {
+    const index = state.inputs.findIndex((record) => record.id === id);
+    if (index < 0)
+        throw new Error("automation_source_changed");
+    state.inputs[index] = update(state.inputs[index]);
+}
+export function releaseNeverDispatchedInputs(state, runId) {
+    for (const record of state.inputs.filter((item) => item.claimRunId === runId)) {
+        if (record.outcomeRef)
+            continue;
+        replaceInput(state, record.id, ({ claimRunId: _claim, ...rest }) => rest);
+    }
+}
+export function holdInterruptedInputs(state, runId) {
+    for (const record of state.inputs.filter((item) => item.claimRunId === runId)) {
+        if (record.outcomeRef)
+            continue;
+        replaceInput(state, record.id, (existing) => ({ ...existing, eligibility: "held" }));
+    }
+}

package/dist/src/runtime/automations/late-settlement.d.ts

@@ -0,0 +1,9 @@
+import type { AutomationPersistence } from "./persistence.js";
+import type { AutomationObservedToolSettlement } from "./tool-lifetimes.js";
+/** Append evidence for effects that completed after their attempt became uncertain. */
+export declare function recordAutomationLateSettlements(input: {
+    persistence: AutomationPersistence;
+    runId: string;
+    observed: readonly AutomationObservedToolSettlement[];
+    now?: () => number;
+}): Promise<void>;

package/dist/src/runtime/automations/late-settlement.js

@@ -0,0 +1,42 @@
+/** Append evidence for effects that completed after their attempt became uncertain. */
+export async function recordAutomationLateSettlements(input) {
+    if (input.observed.length === 0)
+        return;
+    const now = input.now ?? Date.now;
+    await input.persistence.update((state) => {
+        const executionIndex = state.executions.findIndex((item) => item.id === input.runId);
+        if (executionIndex < 0)
+            throw new Error("automation_run_not_found");
+        const execution = state.executions[executionIndex];
+        const nextRevision = execution.revision + 1;
+        const observedAt = new Date(now()).toISOString();
+        let changed = false;
+        for (const item of input.observed) {
+            const attemptIndex = state.attempts.findIndex((attempt) => attempt.runId === input.runId && attempt.invocationId === item.invocationId);
+            if (attemptIndex < 0)
+                continue;
+            const attempt = state.attempts[attemptIndex];
+            if (attempt.state === "settled" || attempt.lateSettlement)
+                continue;
+            const settlement = item.settlement;
+            state.attempts[attemptIndex] = {
+                ...attempt,
+                state: "uncertain",
+                lateSettlement: {
+                    revision: nextRevision,
+                    observedAt,
+                    status: settlement.status === "rejected"
+                        ? "rejected"
+                        : settlement.ok ? "succeeded" : "failed",
+                    ...(settlement.errorCode ? { errorCode: settlement.errorCode } : {}),
+                },
+            };
+            changed = true;
+        }
+        if (changed)
+            state.executions[executionIndex] = {
+                ...execution,
+                revision: nextRevision,
+            };
+    });
+}

package/dist/src/runtime/automations/limits.d.ts

@@ -0,0 +1,25 @@
+export type AutomationLimits = Readonly<{
+    maxConcurrentNodes: number;
+    maxModelCallsPerRun: number;
+    maxToolCallsPerRun: number;
+    maxRunDurationMs: number;
+    maxRunsPerDay: number;
+    maxStoredArtifactBytes: number;
+    stopReportDeadlineMs: number;
+}>;
+export declare const AUTOMATION_GRAPH_LIMITS: Readonly<{
+    executableNodes: 64;
+    branchesPerGroup: 8;
+    nestingDepth: 4;
+    sourceFilesPerBatch: 100;
+    sourceBatchBytes: number;
+    eligibleInputRecords: 1000;
+    inputMetadataBytes: number;
+}>;
+export declare const AUTOMATION_OUTPUT_SCHEMA_LIMITS: Readonly<{
+    maxProperties: 16;
+    maxStringLength: 4096;
+    maxArrayItems: 64;
+}>;
+export declare const DEFAULT_AUTOMATION_LIMITS: AutomationLimits;
+export declare function validateAutomationLimits(limits: AutomationLimits): string[];

package/dist/src/runtime/automations/limits.js

@@ -0,0 +1,41 @@
+export const AUTOMATION_GRAPH_LIMITS = Object.freeze({
+    executableNodes: 64,
+    branchesPerGroup: 8,
+    nestingDepth: 4,
+    sourceFilesPerBatch: 100,
+    sourceBatchBytes: 32 * 1024 * 1024,
+    eligibleInputRecords: 1_000,
+    inputMetadataBytes: 32 * 1024 * 1024,
+});
+export const AUTOMATION_OUTPUT_SCHEMA_LIMITS = Object.freeze({
+    maxProperties: 16,
+    maxStringLength: 4_096,
+    maxArrayItems: 64,
+});
+export const DEFAULT_AUTOMATION_LIMITS = Object.freeze({
+    maxConcurrentNodes: 2,
+    maxModelCallsPerRun: 24,
+    maxToolCallsPerRun: 64,
+    maxRunDurationMs: 30 * 60 * 1_000,
+    maxRunsPerDay: 24,
+    maxStoredArtifactBytes: 256 * 1024 * 1024,
+    stopReportDeadlineMs: 30 * 1_000,
+});
+export function validateAutomationLimits(limits) {
+    const issues = [];
+    for (const [name, value] of Object.entries(limits)) {
+        if (!Number.isSafeInteger(value) || value <= 0) {
+            issues.push(`${name} must be a positive safe integer`);
+        }
+    }
+    if (limits.maxConcurrentNodes > AUTOMATION_GRAPH_LIMITS.executableNodes) {
+        issues.push("maxConcurrentNodes exceeds the graph node ceiling");
+    }
+    if (limits.stopReportDeadlineMs > limits.maxRunDurationMs) {
+        issues.push("stopReportDeadlineMs exceeds maxRunDurationMs");
+    }
+    if (limits.maxRunDurationMs + limits.stopReportDeadlineMs > 2_147_483_647) {
+        issues.push("The run and stop deadlines exceed the supported timer range");
+    }
+    return issues;
+}

package/dist/src/runtime/automations/model-capacity.d.ts

@@ -0,0 +1,9 @@
+import type { ModelGatewayPolicyConfig } from "../../model-gateway/types.js";
+import type { ModelGatewayInvokeParams, ModelGatewayRawInvokeParams } from "../ports.js";
+type Invocation = ModelGatewayInvokeParams | ModelGatewayRawInvokeParams;
+export type AutomationModelCapacity = Readonly<{
+    withInvocation: <T>(params: Invocation, fallbackPolicy: ModelGatewayPolicyConfig | undefined, invoke: () => Promise<T>) => Promise<T>;
+}>;
+/** Capacity is scoped to one Runtime environment, never to a single Agent node. */
+export declare function createAutomationModelCapacity(): AutomationModelCapacity;
+export {};

package/dist/src/runtime/automations/model-capacity.js

@@ -0,0 +1,67 @@
+import { resolveModelInvocation } from "../../model-gateway/invocation-policy.js";
+/** Capacity is scoped to one Runtime environment, never to a single Agent node. */
+export function createAutomationModelCapacity() {
+    const slots = new Map();
+    function lease(key, slot) {
+        let released = false;
+        return () => {
+            if (released)
+                return;
+            released = true;
+            const next = slot.waiting.shift();
+            if (next) {
+                next.signal.removeEventListener("abort", next.onAbort);
+                next.grant(lease(key, slot));
+            }
+            else {
+                slot.active = false;
+                slots.delete(key);
+            }
+        };
+    }
+    function acquire(key, signal) {
+        signal.throwIfAborted();
+        const slot = slots.get(key) ?? { active: false, waiting: [] };
+        slots.set(key, slot);
+        if (!slot.active) {
+            slot.active = true;
+            return Promise.resolve(lease(key, slot));
+        }
+        return new Promise((grant, reject) => {
+            const waiter = {
+                signal, grant, reject,
+                onAbort: () => {
+                    const index = slot.waiting.indexOf(waiter);
+                    if (index < 0)
+                        return;
+                    slot.waiting.splice(index, 1);
+                    signal.removeEventListener("abort", waiter.onAbort);
+                    reject(signal.reason);
+                },
+            };
+            slot.waiting.push(waiter);
+            signal.addEventListener("abort", waiter.onAbort, { once: true });
+            if (signal.aborted)
+                waiter.onAbort();
+        });
+    }
+    return {
+        async withInvocation(params, fallbackPolicy, invoke) {
+            params.abortSignal.throwIfAborted();
+            const profile = resolveModelInvocation({
+                ...params,
+                modelPolicy: params.modelPolicy ?? fallbackPolicy,
+            }).profile;
+            if (profile.provider !== "ollama")
+                return invoke();
+            const release = await acquire(profile.providerId, params.abortSignal);
+            try {
+                params.abortSignal.throwIfAborted();
+                return await invoke();
+            }
+            finally {
+                release();
+            }
+        },
+    };
+}

package/dist/src/runtime/automations/model-dependency-projection.d.ts

@@ -0,0 +1,56 @@
+import type { RuntimeConfig } from "../ports.js";
+import type { AgentNode } from "./definition-contracts.js";
+import type { RequestExecutionPolicyId } from "../config/model-execution-policy.js";
+/** Projects canonical routing outcomes, never an unrelated model catalog. */
+export declare function projectAutomationModelDependencies(config: RuntimeConfig, nodes: readonly AgentNode[]): {
+    modelGatewayUrl: string;
+    contextBudget: import("../config/runner/contracts.js").RequestContextConfig | undefined;
+    agents: {
+        key: string;
+        admission: Readonly<{
+            policy: RequestExecutionPolicyId;
+            primaryProfileId?: string;
+            source: "model_profile" | "default";
+        }>;
+        execution: Readonly<{
+            policy: RequestExecutionPolicyId;
+            primaryProfileId?: string;
+            source: "model_profile" | "default";
+        }>;
+        invocations: ({
+            profile: {
+                id: string;
+                providerId: string;
+                provider: import("../../model-gateway/types.js").ModelProvider;
+                providerConfig?: import("../../model-gateway/types.js").ModelGatewayProviderConfig;
+                model: string;
+                contextWindowTokens: number;
+                supportsThinking: boolean;
+                capabilities: Required<import("../../model-gateway/types.js").ModelGatewayProfileCapabilities>;
+                options: Record<string, unknown>;
+                generation: import("../../model-gateway/types.js").ModelGenerationConfig;
+                context: import("../../model-gateway/types.js").ModelContextConfig;
+            };
+            timeoutMs: number;
+            model: string;
+            think?: import("../../shared/types.js").ModelReasoningLevel;
+            format?: import("../../model-gateway/types.js").ModelGatewayFormat;
+            instructions: string[] | Readonly<{
+                blockCount: number;
+                characterCount: number;
+                refs: readonly string[];
+                contentHashes: readonly string[];
+            }> | undefined;
+            modelStep: "learning.batch" | "supervisor.decision" | "supervisor.response" | "worker.decision" | "worker.result" | "capability.controls" | "planner.decision" | "planner.graph" | "reviewer.decision" | "degraded.finalization" | "execution.decision" | "execution.response" | "auditor.decision" | "context.compact" | "tool_payload.raw";
+        } | {
+            unavailable: import("../../model-gateway/invocation-policy.js").ModelInvocationResolutionErrorCode;
+            modelStep: "learning.batch" | "supervisor.decision" | "supervisor.response" | "worker.decision" | "worker.result" | "capability.controls" | "planner.decision" | "planner.graph" | "reviewer.decision" | "degraded.finalization" | "execution.decision" | "execution.response" | "auditor.decision" | "context.compact" | "tool_payload.raw";
+            instructions: Readonly<{
+                blockCount: number;
+                characterCount: number;
+                refs: readonly string[];
+                contentHashes: readonly string[];
+            }> | undefined;
+        })[];
+    }[];
+} | undefined;

package/dist/src/runtime/automations/model-dependency-projection.js

@@ -0,0 +1,88 @@
+import { ModelInvocationResolutionError, resolveModelInvocation, } from "../../model-gateway/invocation-policy.js";
+import { MODEL_STEPS } from "../../shared/model-steps.js";
+import { loadRequestRunnerConfig } from "../config/runner/loader.js";
+import { createRequestModelPolicy } from "../config/runner/model-policy.js";
+import { resolveConfiguredStepInstructionMetadata } from "../config/runner/step-instructions.js";
+import { resolveModelSelection } from "../model/model-selection.js";
+import { resolveModelStepTimeout } from "../model/model-step-timeout-policy.js";
+// Root and delegated contracts in request/role-executor-composition.ts own these paths.
+// The delegated Planner also invokes planner.graph; the direct Planner invokes only that step.
+const POLICY_MODEL_STEPS = {
+    "supervisor-worker-v1": [MODEL_STEPS.SUPERVISOR_DECISION, MODEL_STEPS.SUPERVISOR_RESPONSE,
+        MODEL_STEPS.PLANNER_DECISION, MODEL_STEPS.PLANNER_GRAPH, MODEL_STEPS.WORKER_DECISION,
+        MODEL_STEPS.WORKER_RESULT, MODEL_STEPS.REVIEWER_DECISION],
+    "execution-agent-v1": [MODEL_STEPS.EXECUTION_DECISION, MODEL_STEPS.EXECUTION_RESPONSE,
+        MODEL_STEPS.PLANNER_GRAPH, MODEL_STEPS.AUDITOR_DECISION],
+};
+function reachableModelSteps(policy, hasTools) {
+    // Both policies can compact or finalize a failed request. Tool helpers need an allowed operation.
+    // Passive learning is a separate background request, never part of an automation agent attempt.
+    return [...POLICY_MODEL_STEPS[policy], MODEL_STEPS.CONTEXT_COMPACTION, MODEL_STEPS.DEGRADED_FINALIZATION,
+        ...(hasTools ? [MODEL_STEPS.CAPABILITY_CONTROLS, MODEL_STEPS.TOOL_PAYLOAD_RAW] : [])];
+}
+function configuredInstructionDependency(runnerConfig, modelStep) {
+    if (!runnerConfig)
+        return undefined;
+    const metadata = resolveConfiguredStepInstructionMetadata({ runnerConfig, modelStep });
+    if (metadata.blockCount === 0)
+        return undefined;
+    return metadata;
+}
+function invocationDependency(input) {
+    const modelPreference = { profileId: input.node.modelProfileId, scope: "all" };
+    const dependency = { modelStep: input.modelStep,
+        instructions: configuredInstructionDependency(input.runnerConfig, input.modelStep) };
+    try {
+        const invocation = resolveModelInvocation({
+            agentMode: input.node.agentMode, modelPreference,
+            modelStep: input.modelStep, modelPolicy: input.modelPolicy,
+        });
+        // Unused calibration slots and display labels are not execution dependencies.
+        const { label: _label, calibration: _calibration, ...profile } = invocation.profile;
+        const timeout = resolveModelStepTimeout({
+            modelStep: input.modelStep, modelPreference, modelPolicy: input.modelPolicy,
+            fallbackTimeoutMs: input.runnerConfig?.steps[input.modelStep]?.timeoutMs ?? 0,
+        });
+        return { ...dependency, ...invocation, profile, timeoutMs: timeout.timeoutMs };
+    }
+    catch (error) {
+        if (!(error instanceof ModelInvocationResolutionError))
+            throw error;
+        return { ...dependency, unavailable: error.code };
+    }
+}
+/** Projects canonical routing outcomes, never an unrelated model catalog. */
+export function projectAutomationModelDependencies(config, nodes) {
+    if (nodes.length === 0)
+        return undefined;
+    const configPath = config.requestRunner?.configPath;
+    const runner = configPath ? loadRequestRunnerConfig({ configPath }) : undefined;
+    const modelPolicy = runner
+        ? createRequestModelPolicy({ platformPolicy: config.models, runnerConfig: runner })
+        : config.models;
+    const selected = new Map();
+    for (const node of nodes) {
+        const key = JSON.stringify([node.modelProfileId, node.agentMode]);
+        const hasTools = node.tools.length > 0 || selected.get(key)?.hasTools === true;
+        selected.set(key, { node, hasTools });
+    }
+    return {
+        modelGatewayUrl: config.modelGatewayUrl,
+        // Every Agent invocation uses these canonical admission/compaction reserves.
+        contextBudget: runner?.context,
+        agents: [...selected.entries()].sort(([a], [b]) => a.localeCompare(b)).map(([key, { node, hasTools }]) => {
+            const request = { agentMode: node.agentMode,
+                modelPreference: { profileId: node.modelProfileId, scope: "all" },
+                modelExecutionPolicies: config.modelExecutionPolicies };
+            const execution = resolveModelSelection({ ...request, modelPolicy }).execution;
+            return {
+                key,
+                admission: resolveModelSelection({ ...request, modelPolicy: config.models }).execution,
+                execution,
+                invocations: reachableModelSteps(execution.policy, hasTools).map((modelStep) => invocationDependency({
+                    node, modelStep, modelPolicy, runnerConfig: runner,
+                })),
+            };
+        }),
+    };
+}

package/dist/src/runtime/automations/node-transactions.d.ts

@@ -0,0 +1,57 @@
+import type { CompiledAutomationGraph } from "./graph-validation.js";
+import type { AutomationPersistence } from "./persistence.js";
+import type { AutomationAttemptRecord, AutomationExecutionRecord, AutomationNodeStateRecord, AutomationResultRecord } from "./storage-records.js";
+type TerminalNodeStatus = Extract<AutomationNodeStateRecord["status"], "succeeded" | "skipped" | "failed" | "cancelled" | "interrupted">;
+export declare function createAutomationNodeTransactions(options: {
+    persistence: AutomationPersistence;
+    now?: () => number;
+}): {
+    begin: (input: {
+        runId: string;
+        automationId: string;
+        definitionRevision: number;
+        inputIds: readonly string[];
+        graph: CompiledAutomationGraph;
+    }) => Promise<AutomationExecutionRecord>;
+    startNode: (runId: string, nodeId: string) => Promise<void>;
+    recordAttempt: (input: {
+        runId: string;
+        nodeId: string;
+        invocationId: string;
+        fingerprint: string;
+        maxToolCalls?: number;
+    }) => Promise<AutomationAttemptRecord>;
+    recordAgentAttempt: (input: {
+        runId: string;
+        nodeId: string;
+        invocationId: string;
+        fingerprint: string;
+        maxToolCalls: number;
+    }) => Promise<AutomationAttemptRecord>;
+    recordModelCall: (runId: string, nodeId: string, maxModelCalls: number) => Promise<number>;
+    settleAgentAttempt: (input: {
+        runId: string;
+        nodeId: string;
+        invocationId: string;
+        result: AutomationResultRecord;
+        uncertain: boolean;
+        notDispatched?: boolean;
+        maxStoredArtifactBytes: number;
+    }) => Promise<void>;
+    hasUnsettledEffect: (runId: string, nodeId: string) => Promise<boolean>;
+    settleNode: (input: {
+        runId: string;
+        nodeId: string;
+        status: TerminalNodeStatus;
+        attemptId?: string;
+        result?: AutomationResultRecord;
+        maxStoredArtifactBytes?: number;
+        errorCode?: string;
+        uncertain?: boolean;
+        notDispatched?: boolean;
+    }) => Promise<void>;
+    requestStop: (runId: string) => Promise<void>;
+    get: (runId: string) => Promise<AutomationExecutionRecord | null>;
+};
+export type AutomationNodeTransactions = ReturnType<typeof createAutomationNodeTransactions>;
+export {};