@abot-ai/runtime 1.5.0 → 1.7.0

package/dist/src/runtime/automations/run-report.d.ts

@@ -0,0 +1,83 @@
+import type { SchedulerAutomationRun } from "../scheduler/contracts.js";
+import type { AutomationRevision } from "./definition-contracts.js";
+import type { AutomationPersistence } from "./persistence.js";
+import type { AutomationResultStore } from "./result-store.js";
+import type { AutomationAttemptRecord, AutomationExecutionRecord, AutomationResultRecord } from "./storage-records.js";
+import { type AutomationRunEffectSummary } from "./step-evidence-effects.js";
+export type AutomationRunReport = Readonly<{
+    runId: string;
+    automationId: string;
+    definitionRevision: number;
+    outcome: "succeeded" | "completed_with_skips" | "failed" | "cancelled" | "interrupted" | "missed";
+    startedAt: string | null;
+    finishedAt: string;
+    inputIds: readonly string[];
+    inputVersions: readonly Readonly<{
+        inputId: string;
+        sourceId: string;
+        canonicalPath: string;
+        contentVersion: string;
+    }>[];
+    nodeResults: readonly Readonly<{
+        nodeId: string;
+        title?: string;
+        status: string;
+        errorCode?: string;
+        resultRef?: string;
+    }>[];
+    uncertainEffects: readonly Readonly<{
+        nodeId: string;
+        attemptId: string;
+    }>[];
+    /** Supplemental evidence does not change the terminal run outcome. */
+    lateEvidence: readonly Readonly<{
+        nodeId: string;
+        attemptId: string;
+        revision: number;
+        observedAt: string;
+        status: "succeeded" | "failed" | "rejected";
+        errorCode?: string;
+    }>[];
+    artifacts: readonly Readonly<{
+        id: string;
+        nodeId?: string;
+        kind: string;
+    }>[];
+    effectSummary?: AutomationRunEffectSummary;
+    modelCalls: number | null;
+    toolCalls: number | null;
+    /** Admitted attempts consume the tool limit even when execution is rejected. */
+    toolAttempts?: number;
+}>;
+export declare function verifiedToolCallCount(summary: AutomationRunEffectSummary | undefined, admittedAttempts: number): number | null;
+export declare function createAutomationReportService(options: {
+    persistence: AutomationPersistence;
+    results: AutomationResultStore;
+    now?: () => number;
+}): {
+    create: (input: {
+        run: SchedulerAutomationRun;
+        definition: AutomationRevision;
+        outcome: AutomationRunReport["outcome"];
+    }) => Promise<{
+        report: AutomationRunReport;
+        record: AutomationResultRecord;
+    }>;
+};
+export declare function buildAutomationRunReport(input: {
+    run: SchedulerAutomationRun;
+    definition: AutomationRevision;
+    execution: AutomationExecutionRecord;
+    inputs: readonly {
+        id: string;
+        sourceId: string;
+        canonicalPath: string;
+        contentVersion: string;
+    }[];
+    attempts: readonly Pick<AutomationAttemptRecord, "id" | "nodeId" | "state" | "lateSettlement">[];
+    results: readonly AutomationResultRecord[];
+    outcome: AutomationRunReport["outcome"];
+    finishedAt: string;
+    effectSummary?: AutomationRunEffectSummary;
+}): AutomationRunReport;
+export declare function projectAutomationLateEvidence(attempts: readonly Pick<AutomationAttemptRecord, "id" | "nodeId" | "lateSettlement">[]): AutomationRunReport["lateEvidence"];

package/dist/src/runtime/automations/run-report.js

@@ -0,0 +1,121 @@
+import { remainingAutomationResultBytes, requireAutomationResultCapacity } from "./result-capacity.js";
+import { publishAutomationResult } from "./result-publication.js";
+import { findAutomationStep, readAutomationRunEffectSummary, } from "./step-evidence-effects.js";
+export function verifiedToolCallCount(summary, admittedAttempts) {
+    if (!summary)
+        return admittedAttempts === 0 ? 0 : null;
+    if (summary.unresolvedAttempts > 0)
+        return null;
+    return summary.verifiedExecutions;
+}
+export function createAutomationReportService(options) {
+    const now = options.now ?? Date.now;
+    async function create(input) {
+        const state = await options.persistence.read();
+        const execution = state.executions.find((item) => item.id === input.run.id);
+        if (!execution)
+            throw new Error("automation_run_not_found");
+        const effectSummary = await readAutomationRunEffectSummary({
+            state, results: options.results, runId: input.run.id, definition: input.definition,
+        });
+        const report = buildAutomationRunReport({
+            run: input.run,
+            definition: input.definition,
+            execution,
+            inputs: state.inputs.filter((item) => execution.inputIds.includes(item.id)),
+            attempts: state.attempts.filter((item) => item.runId === input.run.id),
+            results: state.results.filter((item) => item.runId === input.run.id),
+            outcome: input.outcome,
+            finishedAt: new Date(now()).toISOString(),
+            effectSummary,
+        });
+        const usedBytes = state.results
+            .filter((item) => item.runId === input.run.id)
+            .reduce((sum, item) => sum + item.sizeBytes, 0);
+        const remaining = input.definition.limits.maxStoredArtifactBytes - usedBytes;
+        const record = await options.results.save({
+            runId: input.run.id,
+            kind: "report",
+            value: report,
+            maxBytes: Math.min(remaining, remainingAutomationResultBytes(state)),
+            at: report.finishedAt,
+        });
+        await publishAutomationResult({ ...options, record,
+            publish: () => options.persistence.update((current) => {
+                if (!current.executions.some((item) => item.id === input.run.id))
+                    throw new Error("automation_run_not_found");
+                if (current.results.some((item) => item.id === record.id))
+                    throw new Error("automation_result_duplicate");
+                const used = current.results.filter((item) => item.runId === input.run.id)
+                    .reduce((sum, item) => sum + item.sizeBytes, record.sizeBytes);
+                if (used > input.definition.limits.maxStoredArtifactBytes)
+                    throw new Error("automation_artifact_budget_exhausted");
+                requireAutomationResultCapacity(current, record.sizeBytes);
+                current.results.push(record);
+            }),
+        });
+        return { report, record };
+    }
+    return { create };
+}
+export function buildAutomationRunReport(input) {
+    const hasAgent = input.execution.nodes.some((node) => containsAgent(input.definition.body, node.nodeId));
+    return {
+        runId: input.run.id,
+        automationId: input.execution.automationId,
+        definitionRevision: input.execution.definitionRevision,
+        outcome: input.outcome,
+        startedAt: input.run.startedAt ?? null,
+        finishedAt: input.finishedAt,
+        inputIds: input.execution.inputIds,
+        inputVersions: input.inputs.map((item) => ({
+            inputId: item.id,
+            sourceId: item.sourceId,
+            canonicalPath: item.canonicalPath,
+            contentVersion: item.contentVersion,
+        })),
+        nodeResults: input.execution.nodes.map((node) => {
+            const step = findAutomationStep(input.definition.body, node.nodeId);
+            return {
+                nodeId: node.nodeId,
+                ...(step ? { title: step.title } : {}),
+                status: node.status,
+                ...(node.errorCode ? { errorCode: node.errorCode } : {}),
+                ...(node.resultRef ? { resultRef: node.resultRef } : {}),
+            };
+        }),
+        uncertainEffects: input.attempts
+            .filter((attempt) => attempt.state === "uncertain" || attempt.state === "started")
+            .map((attempt) => ({ nodeId: attempt.nodeId, attemptId: attempt.id })),
+        lateEvidence: projectAutomationLateEvidence(input.attempts),
+        artifacts: input.results
+            .filter((result) => result.kind === "artifact")
+            .map((result) => ({
+            id: result.id,
+            ...(result.nodeId ? { nodeId: result.nodeId } : {}),
+            kind: result.kind,
+        })),
+        ...(input.effectSummary ? { effectSummary: input.effectSummary } : {}),
+        modelCalls: input.execution.modelCalls ?? (hasAgent ? null : 0),
+        // A durable pre-dispatch attempt is not proof that the invocation ran.
+        toolCalls: verifiedToolCallCount(input.effectSummary, input.attempts.length),
+        toolAttempts: input.attempts.length,
+    };
+}
+export function projectAutomationLateEvidence(attempts) {
+    return attempts.flatMap((attempt) => attempt.lateSettlement ? [{
+            nodeId: attempt.nodeId,
+            attemptId: attempt.id,
+            ...attempt.lateSettlement,
+        }] : []);
+}
+function containsAgent(node, nodeId) {
+    const stack = [node];
+    while (stack.length > 0) {
+        const current = stack.pop();
+        if (current.id === nodeId)
+            return current.kind === "agent";
+        stack.push(...(current.children ?? []), ...(current.branches ?? []));
+    }
+    return false;
+}

package/dist/src/runtime/automations/runtime-executor.d.ts

@@ -0,0 +1,16 @@
+import type { RuntimeAttachmentStore } from "../attachments/store.js";
+import type { RuntimeConfig, SessionStore } from "../ports.js";
+import type { SchedulerAutomationExecutor, SchedulerAutomationJob, SchedulerAutomationRun, SchedulerAutomationRunOutcome } from "../scheduler/contracts.js";
+import type { AutomationPersistence } from "./persistence.js";
+import type { AutomationResultStore } from "./result-store.js";
+import type { AutomationToolLifetimes } from "./tool-lifetimes.js";
+export declare function createAutomationRuntimeExecutor(options: {
+    config: RuntimeConfig;
+    sessions?: SessionStore;
+    persistence: AutomationPersistence;
+    attachments: RuntimeAttachmentStore;
+    results: AutomationResultStore;
+    toolLifetimes: AutomationToolLifetimes;
+    execute(job: SchedulerAutomationJob, run: SchedulerAutomationRun, signal: AbortSignal): Promise<SchedulerAutomationRunOutcome>;
+    now?: () => number;
+}): Omit<SchedulerAutomationExecutor, "tryReserve">;

package/dist/src/runtime/automations/runtime-executor.js

@@ -0,0 +1,260 @@
+import { deleteSessionAttachmentsIfSupported } from "../session/session-attachment-deletion.js";
+import { traceDebug } from "../observability/debug-logger.js";
+import { isAutomationSchedulerRun } from "../scheduler/scheduler-target.js";
+import { createAutomationOccurrencePreparer } from "./occurrence-preparation.js";
+import { createAutomationReplayPreparer } from "./replay-preparation.js";
+import { holdInterruptedInputs, releaseNeverDispatchedInputs } from "./input-ledger.js";
+import { DEFAULT_AUTOMATION_LIMITS } from "./limits.js";
+import { recordAutomationLateSettlements } from "./late-settlement.js";
+import { maintainAutomationRetention } from "./retention.js";
+import { createAutomationSnapshotStaging } from "./snapshot-staging.js";
+const DERIVED_REPORT = (runId) => `derived:${runId}`;
+function requireExecution(state, runId) {
+    const execution = state.executions.find((item) => item.id === runId);
+    if (!execution)
+        throw new Error("automation_execution_checkpoint_missing");
+    return execution;
+}
+function replaceExecution(state, execution, update) {
+    const index = state.executions.findIndex((item) => item.id === execution.id);
+    if (index < 0)
+        throw new Error("automation_execution_checkpoint_missing");
+    state.executions[index] = { ...execution, ...update, revision: execution.revision + 1 };
+}
+function stoppedNodes(nodes, uncertain) {
+    return nodes.map((node) => {
+        if (node.status === "running")
+            return {
+                ...node,
+                status: "interrupted",
+                errorCode: uncertain ? "automation_effect_uncertain" : "automation_run_stopped",
+            };
+        if (node.status === "pending" || node.status === "ready")
+            return {
+                ...node,
+                status: "cancelled",
+                errorCode: "automation_run_stopped",
+            };
+        return node;
+    });
+}
+function markUnsettledAttempts(state, runId) {
+    let uncertain = false;
+    state.attempts = state.attempts.map((attempt) => {
+        if (attempt.runId !== runId)
+            return attempt;
+        if (attempt.state === "uncertain") {
+            uncertain = true;
+            return attempt;
+        }
+        if (attempt.state !== "started")
+            return attempt;
+        uncertain = true;
+        return { ...attempt, state: "uncertain" };
+    });
+    return uncertain;
+}
+function markInputOutcome(state, runId, reportRef, hold) {
+    state.inputs = state.inputs.map((record) => record.claimRunId !== runId
+        ? record
+        : {
+            ...record,
+            ...(hold ? { eligibility: "held" } : {}),
+            outcomeRef: reportRef,
+        });
+}
+export function createAutomationRuntimeExecutor(options) {
+    const active = new Map();
+    const stopsBeforeStart = new Set();
+    const snapshots = createAutomationSnapshotStaging({
+        runtimeDir: options.config.paths.runtimeDir,
+        persistence: options.persistence, attachments: options.attachments,
+    });
+    const prepare = createAutomationOccurrencePreparer({ ...options, snapshots });
+    const prepareReplay = createAutomationReplayPreparer(options);
+    let lastMaintenanceAt = Number.NEGATIVE_INFINITY;
+    async function reconcileSessions() {
+        const reportFailure = (sessionId, error) => traceDebug("runtime.automations", "agent_session.recovery_failed", {
+            sessionId, error: error instanceof Error ? error.message : String(error),
+        });
+        try {
+            await options.sessions?.reconcileAutomationSessions?.((id) => deleteSessionAttachmentsIfSupported(options.attachments, id), reportFailure);
+        }
+        catch (error) {
+            reportFailure("", error);
+        }
+    }
+    async function maintainRetention(now) {
+        if (now - lastMaintenanceAt < 5 * 60_000)
+            return;
+        lastMaintenanceAt = now;
+        await reconcileSessions();
+        await snapshots.reconcile();
+        await maintainAutomationRetention({
+            persistence: options.persistence,
+            results: options.results,
+            attachments: options.attachments,
+            now,
+        });
+    }
+    function signalStop(runId) {
+        const execution = active.get(runId);
+        if (!execution) {
+            stopsBeforeStart.add(runId);
+            return;
+        }
+        if (execution.stopRequested)
+            return;
+        execution.stopRequested = true;
+        execution.controller.abort(new Error("automation_run_stopped"));
+        if (execution.deadlineMs !== undefined)
+            scheduleDeadline(runId, execution);
+    }
+    function scheduleDeadline(runId, execution) {
+        if (execution.deadlineTimer)
+            return;
+        execution.deadlineTimer = setTimeout(() => execution.publishDeadline({
+            status: "cancelled",
+            error: "automation_stop_deadline_elapsed",
+            reportRef: DERIVED_REPORT(runId),
+        }), execution.deadlineMs ?? DEFAULT_AUTOMATION_LIMITS.stopReportDeadlineMs);
+        execution.deadlineTimer.unref();
+    }
+    function scheduleBudgetDeadline(runId, execution, durationMs) {
+        execution.budgetTimer = setTimeout(() => {
+            execution.controller.abort(new Error("automation_run_duration_exceeded"));
+            execution.publishDeadline({
+                status: execution.stopRequested ? "cancelled" : "failed",
+                error: "automation_run_deadline_elapsed",
+                reportRef: DERIVED_REPORT(runId),
+            });
+        }, durationMs);
+        execution.budgetTimer.unref();
+    }
+    function start(job, run) {
+        let publishDeadline;
+        const deadline = new Promise((resolve) => {
+            publishDeadline = resolve;
+        });
+        const execution = {
+            controller: new AbortController(),
+            stopRequested: false,
+            publishDeadline,
+        };
+        active.set(run.id, execution);
+        if (stopsBeforeStart.delete(run.id))
+            signalStop(run.id);
+        const actual = (async () => {
+            const state = await options.persistence.read();
+            const definition = state.definitions.find((item) => item.automationId === run.target.automationId &&
+                item.revision === run.target.definitionRevision)?.definition;
+            if (!definition)
+                throw new Error("automation_definition_not_found");
+            execution.deadlineMs = definition.limits.stopReportDeadlineMs;
+            if (execution.stopRequested)
+                scheduleDeadline(run.id, execution);
+            if (execution.controller.signal.aborted)
+                return {
+                    status: "cancelled",
+                    reportRef: DERIVED_REPORT(run.id),
+                };
+            scheduleBudgetDeadline(run.id, execution, definition.limits.maxRunDurationMs + definition.limits.stopReportDeadlineMs);
+            return options.execute(job, run, execution.controller.signal);
+        })().catch((error) => ({
+            status: "failed",
+            error: error instanceof Error ? error.message : String(error),
+            reportRef: DERIVED_REPORT(run.id),
+        }));
+        const outcome = Promise.race([actual, deadline]);
+        // Terminal deadlines detach stalled graph/model work. Tool dispatch is fenced
+        // by the aborted signal, and every admitted Tool promise still drains below.
+        const resourcesSettled = outcome.then(() => undefined).finally(async () => {
+            try {
+                const observed = await options.toolLifetimes.whenSettled(run.id);
+                await recordAutomationLateSettlements({
+                    persistence: options.persistence,
+                    runId: run.id,
+                    observed,
+                    now: options.now,
+                });
+            }
+            finally {
+                cleanup(run.id, execution);
+            }
+        });
+        return { outcome, resourcesSettled };
+    }
+    function cleanup(runId, execution) {
+        if (execution.deadlineTimer)
+            clearTimeout(execution.deadlineTimer);
+        if (execution.budgetTimer)
+            clearTimeout(execution.budgetTimer);
+        if (active.get(runId) === execution)
+            active.delete(runId);
+    }
+    function recover(scheduler, automations, recoveredRunIds) {
+        for (const runId of recoveredRunIds) {
+            const run = scheduler.runs.find((item) => item.id === runId);
+            if (!run || !isAutomationSchedulerRun(run))
+                throw new Error("automation_run_not_found");
+            let execution = automations.executions.find((item) => item.id === runId);
+            if (!execution) {
+                execution = {
+                    id: runId,
+                    automationId: run.target.automationId,
+                    definitionRevision: run.target.definitionRevision,
+                    revision: 1,
+                    inputIds: [],
+                    nodes: [],
+                };
+                automations.executions.push(execution);
+            }
+            const missed = run.status === "missed";
+            if (missed)
+                releaseNeverDispatchedInputs(automations, runId);
+            else
+                holdInterruptedInputs(automations, runId);
+            const uncertain = missed ? false : markUnsettledAttempts(automations, runId);
+            replaceExecution(automations, execution, {
+                nodes: stoppedNodes(execution.nodes, uncertain),
+                reportRef: DERIVED_REPORT(runId),
+                terminalAt: new Date(options.now?.() ?? Date.now()).toISOString(),
+            });
+            run.reportRef = DERIVED_REPORT(runId);
+        }
+    }
+    function settle(run, state, outcome) {
+        const execution = requireExecution(state, run.id);
+        if (!outcome.reportRef)
+            throw new Error("automation_report_missing");
+        const derived = outcome.reportRef === DERIVED_REPORT(run.id);
+        const successful = outcome.status === "succeeded" ||
+            outcome.status === "completed_with_skips";
+        if (derived && successful && (execution.nodes.some((node) => node.status === "pending" || node.status === "ready" || node.status === "running") ||
+            state.attempts.some((item) => item.runId === run.id && item.state !== "settled")))
+            throw new Error("automation_run_not_settled");
+        if (!derived && !state.results.some((item) => item.id === outcome.reportRef &&
+            item.runId === run.id && item.kind === "report"))
+            throw new Error("automation_report_missing");
+        const uncertain = derived ? markUnsettledAttempts(state, run.id) :
+            state.attempts.some((item) => item.runId === run.id &&
+                (item.state === "started" || item.state === "uncertain"));
+        replaceExecution(state, execution, {
+            ...(derived ? { nodes: stoppedNodes(execution.nodes, uncertain) } : {}),
+            reportRef: outcome.reportRef,
+            terminalAt: new Date(options.now?.() ?? Date.now()).toISOString(),
+        });
+        markInputOutcome(state, run.id, outcome.reportRef, uncertain || (derived && !successful));
+    }
+    function cancelPending(run, state) {
+        const execution = requireExecution(state, run.id);
+        releaseNeverDispatchedInputs(state, run.id);
+        replaceExecution(state, execution, {
+            nodes: stoppedNodes(execution.nodes, false),
+            reportRef: DERIVED_REPORT(run.id),
+            terminalAt: new Date(options.now?.() ?? Date.now()).toISOString(),
+        });
+    }
+    return { prepare, prepareReplay, start, stop: signalStop, recover, settle,
+        cancelPending, maintainRetention, reconcileSessions };
+}

package/dist/src/runtime/automations/saved-agent-management.d.ts

@@ -0,0 +1,16 @@
+import type { AutomationPersistence } from "./persistence.js";
+import type { AutomationSavedAgentRecord } from "./storage-records.js";
+export declare function createAutomationSavedAgentManager(options: {
+    persistence: AutomationPersistence;
+    now?: () => number;
+}): {
+    get: (agentId: string, revision?: number) => Promise<AutomationSavedAgentRecord | null>;
+    list: () => Promise<AutomationSavedAgentRecord[]>;
+    saveFromDraft: (input: {
+        automationId: string;
+        nodeId: string;
+        expectedDraftRevision: number;
+        agentId?: string;
+        expectedAgentRevision?: number;
+    }) => Promise<AutomationSavedAgentRecord>;
+};

package/dist/src/runtime/automations/saved-agent-management.js

@@ -0,0 +1,94 @@
+import { randomUUID } from "node:crypto";
+function findAgent(node, nodeId) {
+    if (node.id === nodeId)
+        return node.kind === "agent" ? node : undefined;
+    if (node.kind === "sequence") {
+        for (const child of node.children) {
+            const found = findAgent(child, nodeId);
+            if (found)
+                return found;
+        }
+    }
+    if (node.kind === "parallel") {
+        for (const branch of node.branches) {
+            const found = findAgent(branch, nodeId);
+            if (found)
+                return found;
+        }
+    }
+    return undefined;
+}
+/** A reusable step template. Runtime inputs, prior grants and execution state never enter it. */
+function snapshotAgent(agent, id) {
+    return structuredClone({
+        kind: "agent",
+        id,
+        title: agent.title,
+        onFailure: agent.onFailure,
+        modelProfileId: agent.modelProfileId,
+        agentMode: agent.agentMode,
+        roleInstructions: agent.roleInstructions,
+        prompt: agent.prompt,
+        inputs: {},
+        tools: agent.tools,
+        result: agent.result,
+        ...(agent.acceptance ? { acceptance: agent.acceptance } : {}),
+    });
+}
+export function createAutomationSavedAgentManager(options) {
+    const now = options.now ?? Date.now;
+    async function get(agentId, revision) {
+        const state = await options.persistence.read();
+        return state.savedAgents
+            .filter((record) => record.agentId === agentId &&
+            (revision === undefined || record.revision === revision))
+            .sort((left, right) => right.revision - left.revision)[0] ?? null;
+    }
+    async function list() {
+        const state = await options.persistence.read();
+        const latest = new Map();
+        for (const record of state.savedAgents) {
+            const previous = latest.get(record.agentId);
+            if (!previous || record.revision > previous.revision)
+                latest.set(record.agentId, record);
+        }
+        return [...latest.values()].sort((left, right) => left.agent.title.localeCompare(right.agent.title));
+    }
+    async function saveFromDraft(input) {
+        if (!Number.isSafeInteger(input.expectedDraftRevision) || input.expectedDraftRevision < 1)
+            throw new Error("automation_revision_conflict");
+        if (input.agentId && (!Number.isSafeInteger(input.expectedAgentRevision) ||
+            Number(input.expectedAgentRevision) < 1))
+            throw new Error("automation_revision_conflict");
+        if (!input.agentId && input.expectedAgentRevision !== undefined)
+            throw new Error("automation_revision_conflict");
+        return options.persistence.update((state) => {
+            const draft = state.drafts.find((record) => record.automationId === input.automationId);
+            if (!draft)
+                throw new Error("automation_not_found");
+            if (draft.revision !== input.expectedDraftRevision)
+                throw new Error("automation_revision_conflict");
+            const agent = findAgent(draft.definition.body, input.nodeId);
+            if (!agent)
+                throw new Error("automation_dependency_missing");
+            const prior = input.agentId
+                ? state.savedAgents.filter((record) => record.agentId === input.agentId)
+                    .sort((left, right) => right.revision - left.revision)[0]
+                : undefined;
+            if (input.agentId && (!prior || prior.revision !== input.expectedAgentRevision))
+                throw new Error("automation_revision_conflict");
+            const agentId = input.agentId ?? randomUUID();
+            const revision = (prior?.revision ?? 0) + 1;
+            const saved = {
+                id: `agent:${agentId}:${revision}`,
+                agentId,
+                revision,
+                agent: snapshotAgent(agent, `n_${randomUUID().replaceAll("-", "")}`),
+                updatedAt: new Date(now()).toISOString(),
+            };
+            state.savedAgents.push(saved);
+            return saved;
+        });
+    }
+    return { get, list, saveFromDraft };
+}