@abot-ai/runtime 1.1.0 → 1.3.0

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

@@ -0,0 +1,102 @@
+import { createDefaultAttachmentStore, createDefaultEventSinkFactory, createDefaultModelGatewayClient, createDefaultLongTermMemoryService, createDefaultSessionStore, createDefaultToolRegistry, } from "./default-environment-adapters.js";
+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 { bindManagedSessionAttachmentDeletion, deleteSessionAttachmentsIfSupported, } from "./session/session-attachment-deletion.js";
+import { SessionRequestAdmission } from "./request/session-admission.js";
+import { createRuntimeScheduler } from "./adapters/scheduler-runtime.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));
+    bindManagedSessionAttachmentDeletion(sessionLifecycle.store, attachments);
+    const admission = new SessionRequestAdmission(sessionLifecycle.isDeleted);
+    const scheduling = createRuntimeScheduler({
+        config,
+        sessions: sessionLifecycle.store,
+        admission,
+        isDeleted: sessionLifecycle.isDeleted,
+        handle: (ws, message, options) => rawRequests.handle(ws, message, options),
+        requestOptions: overrides.scheduledRequestOptions,
+    });
+    sessionLifecycle.onDeleted(async (sessionId) => {
+        await scheduling.ensureStarted();
+        await scheduling.scheduler.deleteSession(sessionId);
+    });
+    const tools = overrides.tools ??
+        createDefaultToolRegistry(config, {
+            service: scheduling.scheduler,
+            ready: scheduling.ensureStarted,
+        });
+    const models = overrides.models ?? createDefaultModelGatewayClient(config);
+    const services = Object.freeze({
+        config,
+        sessions: sessionLifecycle.store,
+        attachments,
+        tools,
+        models,
+        events: overrides.events ?? createDefaultEventSinkFactory(config),
+        sessionMemoryCompactor: overrides.sessionMemoryCompactor ?? createModelSessionMemoryCompactor(),
+        longTermMemory: overrides.longTermMemory ??
+            createDefaultLongTermMemoryService(config, models),
+        scheduler: scheduling.scheduler,
+        startScheduler: scheduling.start,
+        stopScheduler: scheduling.stop,
+        requestAdmission: admission,
+    });
+    // The scheduler has already atomically reserved admission before this handler.
+    let rawRequests = createBoundRuntimeRequestHandler({
+        ...services,
+        requestAdmission: undefined,
+    });
+    const requests = createBoundRuntimeRequestHandler(services);
+    environmentCompositions.set(services, {
+        overrides: { ...overrides, sessions: backingSessions },
+        bindScheduledEvents(events) {
+            // Each invocation captures one immutable handler. An event-only host
+            // override affects future runs without mutating a delegating factory.
+            rawRequests = createBoundRuntimeRequestHandler({
+                ...services,
+                events,
+                requestAdmission: undefined,
+            });
+        },
+    });
+    return {
+        services,
+        requests,
+        start: scheduling.start,
+        stop: scheduling.stop,
+        subscribeScheduledEvents: scheduling.subscribe,
+    };
+}
+export function recomposeRuntimeEnvironment(config, bound, resolved) {
+    const previous = bound
+        ? environmentCompositions.get(bound)?.overrides
+        : undefined;
+    const replacesComposedToolRegistry = previous !== undefined && resolved.tools === bound?.tools;
+    const tools = replacesComposedToolRegistry ? previous.tools : resolved.tools;
+    const sessions = resolved.sessions === bound?.sessions
+        ? (previous?.sessions ?? resolved.sessions)
+        : resolved.sessions;
+    return createRuntimeEnvironment(config, {
+        ...resolved,
+        sessions,
+        tools,
+        scheduledRequestOptions: previous?.scheduledRequestOptions,
+    }).services;
+}
+export function rebindRuntimeEnvironmentEvents(bound, events) {
+    const composition = environmentCompositions.get(bound);
+    if (!composition)
+        return events === bound.events ? bound : undefined;
+    composition.bindScheduledEvents(events);
+    if (events === bound.events)
+        return bound;
+    const services = Object.freeze({ ...bound, events });
+    environmentCompositions.set(services, composition);
+    return services;
+}

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

@@ -0,0 +1,8 @@
+import type { RuntimeConfig, RuntimeHostStartOptions } from "./ports.js";
+import type { RuntimeEnvironmentServices } from "./composition.js";
+import type { DefaultRuntimeHostBindings } from "./runtime-host.js";
+export declare function resolveRuntimeHostEnvironmentServices(params: Readonly<{
+    config?: RuntimeConfig;
+    defaults: DefaultRuntimeHostBindings;
+    options: RuntimeHostStartOptions;
+}>): RuntimeEnvironmentServices | undefined;

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

@@ -0,0 +1,57 @@
+import { createDefaultAttachmentStore, createDefaultEventSinkFactory, createDefaultLongTermMemoryService, createDefaultModelGatewayClient, createDefaultSessionStore, } from "./default-environment-adapters.js";
+import { createModelSessionMemoryCompactor } from "./context/session-memory/index.js";
+import { rebindRuntimeEnvironmentEvents, recomposeRuntimeEnvironment, } from "./runtime-environment.js";
+export function resolveRuntimeHostEnvironmentServices(params) {
+    const bound = params.defaults.services;
+    const runtimeConfig = params.options.runtimeConfig ?? bound?.config ?? params.config;
+    if (!runtimeConfig) {
+        return undefined;
+    }
+    const mayReuseBound = bound?.config === runtimeConfig;
+    const mayUseLegacyDefaults = !bound && params.config === runtimeConfig;
+    const sessions = params.options.sessionStore ??
+        (mayReuseBound ? bound.sessions : undefined) ??
+        (mayUseLegacyDefaults ? params.defaults.sessionStore : undefined) ??
+        createDefaultSessionStore(runtimeConfig);
+    const attachments = params.options.attachmentStore ??
+        (mayReuseBound ? bound.attachments : undefined) ??
+        (mayUseLegacyDefaults ? params.defaults.attachmentStore : undefined) ??
+        createDefaultAttachmentStore(runtimeConfig);
+    const tools = params.options.toolRegistry ??
+        (mayReuseBound ? bound.tools : undefined) ??
+        (mayUseLegacyDefaults ? params.defaults.toolRegistry : undefined);
+    const models = params.options.modelGatewayClient ??
+        (mayReuseBound ? bound.models : undefined) ??
+        (mayUseLegacyDefaults ? params.defaults.modelGatewayClient : undefined) ??
+        createDefaultModelGatewayClient(runtimeConfig);
+    const events = params.options.eventSinkFactory ??
+        (mayReuseBound ? bound.events : undefined) ??
+        (mayUseLegacyDefaults ? params.defaults.eventSinkFactory : undefined) ??
+        createDefaultEventSinkFactory(runtimeConfig);
+    const sessionMemoryCompactor = bound?.sessionMemoryCompactor ?? createModelSessionMemoryCompactor();
+    const mayReuseBoundLongTermMemory = mayReuseBound && models === bound?.models;
+    const longTermMemory = params.options.longTermMemoryService ??
+        (mayReuseBoundLongTermMemory ? bound?.longTermMemory : undefined) ??
+        createDefaultLongTermMemoryService(runtimeConfig, models);
+    const reusesBoundExecutionServices = mayReuseBound &&
+        sessions === bound.sessions &&
+        attachments === bound.attachments &&
+        tools === bound.tools &&
+        models === bound.models &&
+        sessionMemoryCompactor === bound.sessionMemoryCompactor &&
+        longTermMemory === bound.longTermMemory;
+    const rebound = reusesBoundExecutionServices
+        ? rebindRuntimeEnvironmentEvents(bound, events)
+        : undefined;
+    if (rebound)
+        return rebound;
+    return recomposeRuntimeEnvironment(runtimeConfig, bound, {
+        sessions,
+        attachments,
+        tools,
+        models,
+        events,
+        sessionMemoryCompactor,
+        longTermMemory,
+    });
+}

package/dist/src/runtime/runtime-host-lifecycle.d.ts

@@ -0,0 +1,4 @@
+import type { RuntimeEnvironmentServices, RuntimeRequestHandler } from "./composition.js";
+import type { RuntimeHostHandle } from "./ports.js";
+/** Keep legacy synchronous start while exposing and enforcing async readiness. */
+export declare function startRuntimeHostLifecycle(services: RuntimeEnvironmentServices | undefined, requests: RuntimeRequestHandler | undefined, connect: (requests: RuntimeRequestHandler | undefined) => RuntimeHostHandle): RuntimeHostHandle;

package/dist/src/runtime/runtime-host-lifecycle.js

@@ -0,0 +1,64 @@
+import { acquireHostScheduler } from "./runtime-host-scheduler-ownership.js";
+/** Keep legacy synchronous start while exposing and enforcing async readiness. */
+export function startRuntimeHostLifecycle(services, requests, connect) {
+    let transport;
+    let stopping;
+    let stopped = false;
+    const scheduler = acquireHostScheduler(services);
+    const ready = scheduler.ready.then(() => {
+        if (stopped)
+            throw new Error("runtime_host_stopped");
+    });
+    function stop() {
+        if (stopping)
+            return stopping;
+        stopped = true;
+        const shutdowns = [transport?.stop, scheduler.release];
+        stopping = Promise.all(shutdowns.map(async (shutdown) => shutdown?.())).then(() => undefined);
+        return stopping;
+    }
+    function assertHostRunning() {
+        if (stopped)
+            throw new Error("runtime_host_stopped");
+    }
+    const steer = requests?.steer?.bind(requests);
+    const readyRequests = requests
+        ? Object.freeze({
+            ...requests,
+            ...(steer
+                ? {
+                    async steer(...args) {
+                        await ready;
+                        assertHostRunning();
+                        return steer(...args);
+                    },
+                }
+                : {}),
+            async handle(...args) {
+                await ready;
+                assertHostRunning();
+                return requests.handle(...args);
+            },
+        })
+        : undefined;
+    // Hosts that use the historical { stop } handle still get automatic startup
+    // and cleanup. Reading ready is optional and surfaces the original failure.
+    void ready.catch(async (error) => {
+        await stop().catch((cleanupError) => {
+            console.error("Runtime host cleanup failed:", cleanupError);
+        });
+        if (error instanceof Error && error.message === "runtime_host_stopped")
+            return;
+        console.error("Runtime host startup failed:", error);
+    });
+    try {
+        transport = connect(readyRequests);
+    }
+    catch (error) {
+        void stop().catch((cleanupError) => {
+            console.error("Runtime host cleanup failed:", cleanupError);
+        });
+        throw error;
+    }
+    return Object.freeze({ ready, stop });
+}

package/dist/src/runtime/runtime-host-scheduler-ownership.d.ts

@@ -0,0 +1,5 @@
+import type { RuntimeEnvironmentServices } from "./composition.js";
+export declare function acquireHostScheduler(services: RuntimeEnvironmentServices | undefined): {
+    ready: Promise<void>;
+    release(): Promise<void>;
+};

package/dist/src/runtime/runtime-host-scheduler-ownership.js

@@ -0,0 +1,67 @@
+// Event-only environment wrappers retain this canonical scheduler identity.
+const owners = new WeakMap();
+export function acquireHostScheduler(services) {
+    if (!services) {
+        return { ready: Promise.resolve(), release: async () => { } };
+    }
+    const key = services.scheduler ?? services.startScheduler ?? services;
+    const owner = retainSchedulerOwner(key, services);
+    let released;
+    function release() {
+        if (released)
+            return released;
+        owner.references -= 1;
+        if (hasSchedulerHostReferences(owner)) {
+            released = Promise.resolve();
+            return released;
+        }
+        if (owner.started) {
+            owner.stopping = (async () => {
+                await services?.stopScheduler?.();
+            })();
+        }
+        owner.stopping ??= Promise.resolve();
+        const forgetStoppedOwner = () => {
+            if (owners.get(key) === owner)
+                owners.delete(key);
+        };
+        void owner.stopping.then(forgetStoppedOwner, forgetStoppedOwner);
+        // An abandoned queued start owns no resources and must not wait for its
+        // predecessor. Keep that predecessor's barrier for the next acquisition.
+        released = owner.started ? owner.stopping : Promise.resolve();
+        return released;
+    }
+    return { ready: owner.ready, release };
+}
+function hasSchedulerHostReferences(owner) {
+    return owner.references > 0;
+}
+function retainActiveSchedulerOwner(owner) {
+    if (!owner)
+        return undefined;
+    if (!hasSchedulerHostReferences(owner))
+        return undefined;
+    owner.references += 1;
+    return owner;
+}
+function retainSchedulerOwner(key, services) {
+    const previous = owners.get(key);
+    const retained = retainActiveSchedulerOwner(previous);
+    if (retained)
+        return retained;
+    const owner = {
+        references: 1,
+        started: false,
+        ready: Promise.resolve(),
+        stopping: previous?.stopping,
+    };
+    owners.set(key, owner);
+    const start = async () => {
+        if (!hasSchedulerHostReferences(owner))
+            return;
+        owner.started = true;
+        await services.startScheduler?.();
+    };
+    owner.ready = previous?.stopping ? previous.stopping.then(start) : start();
+    return owner;
+}

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

@@ -0,0 +1,19 @@
+import type { RuntimeConfig, RuntimeHost, EventSinkFactory, ModelGatewayClient, SessionStore, ToolRegistry } from "./ports.js";
+import type { RuntimeAttachmentStore } from "./attachments/store.js";
+import type { LongTermMemoryService } from "./long-term-memory/index.js";
+import type { RuntimeEnvironmentServices, RuntimeRequestHandler } from "./composition.js";
+export declare function createDefaultRuntimeHost(config?: RuntimeConfig, defaults?: DefaultRuntimeHostBindings): RuntimeHost;
+export type DefaultRuntimeHostBindings = Readonly<{
+    runtimeId?: string;
+    agentBridgeUrl?: string;
+    agentBridgeToken?: string;
+    eventSinkFactory?: EventSinkFactory;
+    modelGatewayClient?: ModelGatewayClient;
+    sessionStore?: SessionStore;
+    attachmentStore?: RuntimeAttachmentStore;
+    toolRegistry?: ToolRegistry;
+    longTermMemoryService?: LongTermMemoryService;
+    services?: RuntimeEnvironmentServices;
+    requestHandler?: RuntimeRequestHandler;
+    requestHandlerFactory?: (services: RuntimeEnvironmentServices) => RuntimeRequestHandler;
+}>;

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

@@ -0,0 +1,63 @@
+import { startAgentBridge } from "../bridge/start-agent-bridge.js";
+import { createDefaultAttachmentStore, createDefaultToolRegistry, } from "./default-environment-adapters.js";
+import { createBoundRuntimeRequestHandler } from "./request/bound-runtime-handler.js";
+import { resolveRuntimeHostEnvironmentServices } from "./runtime-host-environment.js";
+import { startRuntimeHostLifecycle } from "./runtime-host-lifecycle.js";
+export function createDefaultRuntimeHost(config, defaults = {}) {
+    return {
+        start(options = {}) {
+            const services = resolveRuntimeHostEnvironmentServices({
+                config,
+                defaults,
+                options,
+            });
+            const runtimeConfig = services?.config ?? options.runtimeConfig ?? config;
+            const defaultRuntimeConfig = defaults.services?.config ?? config;
+            const runtimeConfigIdentityChanged = runtimeConfig !== undefined && runtimeConfig !== defaultRuntimeConfig;
+            const requestHandler = services
+                ? resolveRuntimeHostRequestHandler(services, defaults)
+                : defaults.requestHandler;
+            return startRuntimeHostLifecycle(services, requestHandler, (readyHandler) => startAgentBridge({
+                runtimeConfig,
+                runtimeId: options.runtimeId ??
+                    (runtimeConfigIdentityChanged
+                        ? runtimeConfig.runtimeId
+                        : defaults.runtimeId),
+                token: options.agentBridgeToken ??
+                    (runtimeConfigIdentityChanged
+                        ? runtimeConfig.agentBridgeToken
+                        : defaults.agentBridgeToken),
+                url: options.agentBridgeUrl ??
+                    (runtimeConfigIdentityChanged
+                        ? runtimeConfig.agentBridgeUrl
+                        : defaults.agentBridgeUrl),
+                eventSinkFactory: services?.events ??
+                    options.eventSinkFactory ??
+                    defaults.eventSinkFactory,
+                modelGatewayClient: services?.models ??
+                    options.modelGatewayClient ??
+                    defaults.modelGatewayClient,
+                sessionStore: services?.sessions ??
+                    options.sessionStore ??
+                    defaults.sessionStore,
+                attachmentStore: services?.attachments ??
+                    options.attachmentStore ??
+                    defaults.attachmentStore ??
+                    (runtimeConfig
+                        ? createDefaultAttachmentStore(runtimeConfig)
+                        : undefined),
+                toolRegistry: services?.tools ??
+                    options.toolRegistry ??
+                    defaults.toolRegistry ??
+                    createDefaultToolRegistry(runtimeConfig),
+                requestHandler: readyHandler,
+            }));
+        },
+    };
+}
+function resolveRuntimeHostRequestHandler(services, defaults) {
+    if (services === defaults.services && defaults.requestHandler) {
+        return defaults.requestHandler;
+    }
+    return (defaults.requestHandlerFactory ?? createBoundRuntimeRequestHandler)(services);
+}

package/dist/src/runtime/scheduler/calendar-time.d.ts

@@ -0,0 +1,10 @@
+export interface CalendarDate {
+    year: number;
+    month: number;
+    day: number;
+}
+export declare function calendarDateAt(instant: number, timeZone: string): CalendarDate;
+export declare function addCalendarDays(date: CalendarDate, days: number): CalendarDate;
+export declare function calendarWeekday(date: CalendarDate): number;
+/** Missing wall times are skipped; repeated wall times select the first occurrence. */
+export declare function resolveCalendarTime(date: CalendarDate, at: string, timeZone: string): number | null;

package/dist/src/runtime/scheduler/calendar-time.js

@@ -0,0 +1,58 @@
+function calendarFormatter(timeZone) {
+    return new Intl.DateTimeFormat("en-CA", {
+        timeZone,
+        year: "numeric",
+        month: "2-digit",
+        day: "2-digit",
+        hour: "2-digit",
+        minute: "2-digit",
+        second: "2-digit",
+        hourCycle: "h23",
+    });
+}
+function readCalendarParts(formatter, instant) {
+    const parts = Object.fromEntries(formatter.formatToParts(instant).map((part) => [part.type, part.value]));
+    return {
+        year: Number(parts.year),
+        month: Number(parts.month),
+        day: Number(parts.day),
+        hour: Number(parts.hour),
+        minute: Number(parts.minute),
+        second: Number(parts.second),
+    };
+}
+function calendarPartsAsUtc(parts) {
+    return Date.UTC(parts.year, parts.month - 1, parts.day, parts.hour, parts.minute, parts.second);
+}
+export function calendarDateAt(instant, timeZone) {
+    const { year, month, day } = readCalendarParts(calendarFormatter(timeZone), instant);
+    return { year, month, day };
+}
+export function addCalendarDays(date, days) {
+    const next = new Date(Date.UTC(date.year, date.month - 1, date.day + days));
+    return {
+        year: next.getUTCFullYear(),
+        month: next.getUTCMonth() + 1,
+        day: next.getUTCDate(),
+    };
+}
+export function calendarWeekday(date) {
+    return new Date(Date.UTC(date.year, date.month - 1, date.day)).getUTCDay();
+}
+/** Missing wall times are skipped; repeated wall times select the first occurrence. */
+export function resolveCalendarTime(date, at, timeZone) {
+    const [hour, minute] = at.split(":").map(Number);
+    const wanted = Date.UTC(date.year, date.month - 1, date.day, hour, minute);
+    const formatter = calendarFormatter(timeZone);
+    const offsets = new Set();
+    // Both sides of a transition are observed, including half-hour and date-line changes.
+    for (let hours = -36; hours <= 36; hours += 6) {
+        const probe = wanted + hours * 3_600_000;
+        offsets.add(calendarPartsAsUtc(readCalendarParts(formatter, probe)) - probe);
+    }
+    const candidates = [...offsets]
+        .map((offset) => wanted - offset)
+        .filter((instant) => calendarPartsAsUtc(readCalendarParts(formatter, instant)) === wanted)
+        .sort((a, b) => a - b);
+    return candidates[0] ?? null;
+}

package/dist/src/runtime/scheduler/contracts.d.ts

@@ -0,0 +1,143 @@
+import type { AgentMode } from "../../shared/types.js";
+export type SchedulerScheduleInput = {
+    kind: "timer";
+    delayMs: number;
+} | {
+    kind: "once";
+    at: string;
+} | {
+    kind: "interval";
+    everyMs: number;
+    anchorAt?: string;
+} | {
+    kind: "daily";
+    at: string;
+} | {
+    kind: "weekly";
+    at: string;
+    weekdays: number[];
+} | {
+    kind: "monthly";
+    at: string;
+    dayOfMonth: number;
+};
+export type SchedulerSchedule = {
+    kind: "timer";
+    delayMs: number;
+    at: string;
+} | {
+    kind: "once";
+    at: string;
+} | {
+    kind: "interval";
+    everyMs: number;
+    anchorAt: string;
+} | {
+    kind: "daily";
+    at: string;
+} | {
+    kind: "weekly";
+    at: string;
+    weekdays: number[];
+} | {
+    kind: "monthly";
+    at: string;
+    dayOfMonth: number;
+};
+export type SchedulerJobState = "active" | "paused" | "cancelled" | "completed";
+export interface SchedulerJob {
+    id: string;
+    environmentId: string;
+    sessionId: string;
+    title: string;
+    prompt: string;
+    modelProfileId: string;
+    agentMode: AgentMode;
+    toolPermissionMode: "full_access";
+    timeZone: string;
+    schedule: SchedulerSchedule;
+    state: SchedulerJobState;
+    createdAt: string;
+    updatedAt: string;
+    nextRunAt: string | null;
+    revision: number;
+}
+export interface CreateSchedulerJobInput {
+    sessionId: string;
+    title: string;
+    prompt: string;
+    modelProfileId: string;
+    agentMode: AgentMode;
+    timeZone: string;
+    schedule: SchedulerScheduleInput;
+}
+export type UpdateSchedulerJobInput = Partial<Omit<CreateSchedulerJobInput, "sessionId">>;
+export type SchedulerRunStatus = "pending" | "running" | "succeeded" | "failed" | "cancelled" | "interrupted" | "missed";
+export interface SchedulerRun {
+    id: string;
+    jobId: string;
+    environmentId: string;
+    sessionId: string;
+    requestId: string;
+    title: string;
+    prompt: string;
+    modelProfileId: string;
+    agentMode: AgentMode;
+    timeZone: string;
+    jobRevision: number;
+    scheduledAt: string;
+    startedAt?: string;
+    finishedAt?: string;
+    trigger: "schedule" | "manual";
+    status: SchedulerRunStatus;
+    resultText?: string;
+    resultMessageId?: string;
+    error?: string;
+}
+export interface SchedulerRunOutcome {
+    status: "succeeded" | "failed";
+    resultText?: string;
+    resultMessageId?: string;
+    error?: string;
+}
+export interface SchedulerExecutor {
+    sessionExists(sessionId: string): Promise<boolean>;
+    tryReserve(sessionId: string): (() => void) | null;
+    start(job: SchedulerJob, run: SchedulerRun): Promise<SchedulerRunOutcome>;
+}
+export interface SchedulerSnapshot {
+    schemaVersion: 1;
+    jobs: SchedulerJob[];
+    runs: SchedulerRun[];
+}
+export interface SchedulerStore {
+    acquire(): Promise<() => Promise<void>>;
+    read(view?: "active"): Promise<SchedulerSnapshot>;
+    update<T>(mutate: (state: SchedulerSnapshot) => T, view?: "active"): Promise<T>;
+    readRuns?(jobId?: string, query?: SchedulerRunListQuery): Promise<SchedulerRun[]>;
+}
+export interface SchedulerListFilter {
+    sessionId?: string;
+    state?: SchedulerJobState;
+    search?: string;
+}
+export interface SchedulerRunListQuery {
+    cursor?: string;
+    /** Bounded newest-first results; 101 allows a 100-record page plus lookahead. */
+    limit: number;
+}
+export interface SchedulerService {
+    start(): Promise<void>;
+    stop(): Promise<void>;
+    tick(): Promise<void>;
+    create(input: CreateSchedulerJobInput): Promise<SchedulerJob>;
+    list(filter?: SchedulerListFilter): Promise<SchedulerJob[]>;
+    get(jobId: string): Promise<SchedulerJob | null>;
+    update(jobId: string, patch: UpdateSchedulerJobInput): Promise<SchedulerJob>;
+    pause(jobId: string): Promise<SchedulerJob>;
+    resume(jobId: string): Promise<SchedulerJob>;
+    cancel(jobId: string): Promise<SchedulerJob>;
+    runNow(jobId: string): Promise<SchedulerRun>;
+    deleteSession(sessionId: string): Promise<void>;
+    listRuns(jobId?: string, query?: SchedulerRunListQuery): Promise<SchedulerRun[]>;
+}

package/dist/src/runtime/scheduler/contracts.js

@@ -0,0 +1 @@
+export {};

package/dist/src/runtime/scheduler/file-store.d.ts

@@ -0,0 +1,2 @@
+import type { SchedulerStore } from "./contracts.js";
+export declare function createFileSchedulerStore(directory: string): SchedulerStore;