@cuylabs/agent-runtime 0.5.0

package/dist/chunk-ZVISWF7S.js

@@ -0,0 +1,108 @@
+// src/schedule.ts
+import { Cron } from "croner";
+var CRON_CACHE_MAX = 256;
+var cronCache = /* @__PURE__ */ new Map();
+function parseAtMs(at) {
+  if (typeof at === "number") {
+    return Number.isFinite(at) ? at : void 0;
+  }
+  if (at instanceof Date) {
+    const ms2 = at.getTime();
+    return Number.isFinite(ms2) ? ms2 : void 0;
+  }
+  const ms = Date.parse(at);
+  return Number.isFinite(ms) ? ms : void 0;
+}
+function resolveCachedCron(schedule) {
+  const timezone = schedule.timezone?.trim() || "";
+  const key = `${timezone}\0${schedule.expr}`;
+  const cached = cronCache.get(key);
+  if (cached) {
+    return cached;
+  }
+  if (cronCache.size >= CRON_CACHE_MAX) {
+    const oldest = cronCache.keys().next().value;
+    if (oldest) {
+      cronCache.delete(oldest);
+    }
+  }
+  const created = new Cron(schedule.expr, {
+    timezone: timezone || void 0,
+    catch: false
+  });
+  cronCache.set(key, created);
+  return created;
+}
+function normalizeSchedule(input) {
+  if (input.kind === "at") {
+    const atMs = parseAtMs(input.at);
+    if (atMs === void 0) {
+      throw new Error(`Invalid at-schedule timestamp: ${String(input.at)}`);
+    }
+    return { kind: "at", at: atMs };
+  }
+  if (input.kind === "every") {
+    const everyMs = Math.floor(input.everyMs);
+    if (!Number.isFinite(everyMs) || everyMs <= 0) {
+      throw new Error(`Invalid every-schedule interval: ${String(input.everyMs)}`);
+    }
+    let anchorMs;
+    if (input.anchorMs !== void 0) {
+      const nextAnchor = Math.floor(input.anchorMs);
+      if (!Number.isFinite(nextAnchor) || nextAnchor < 0) {
+        throw new Error(`Invalid every-schedule anchor: ${String(input.anchorMs)}`);
+      }
+      anchorMs = nextAnchor;
+    }
+    return { kind: "every", everyMs, ...anchorMs !== void 0 ? { anchorMs } : {} };
+  }
+  const expr = input.expr.trim();
+  if (!expr) {
+    throw new Error("Invalid cron schedule: empty expression");
+  }
+  return {
+    kind: "cron",
+    expr,
+    ...input.timezone?.trim() ? { timezone: input.timezone.trim() } : {}
+  };
+}
+function computeNextRunAtMs(schedule, nowMs) {
+  if (schedule.kind === "at") {
+    return schedule.at > nowMs ? schedule.at : void 0;
+  }
+  if (schedule.kind === "every") {
+    const anchor = schedule.anchorMs ?? nowMs;
+    if (nowMs < anchor) {
+      return anchor;
+    }
+    const elapsed = nowMs - anchor;
+    const steps = Math.max(1, Math.floor((elapsed + schedule.everyMs - 1) / schedule.everyMs));
+    return anchor + steps * schedule.everyMs;
+  }
+  const cron = resolveCachedCron(schedule);
+  const first = cron.nextRun(new Date(nowMs));
+  if (!first) {
+    return void 0;
+  }
+  const firstMs = first.getTime();
+  if (!Number.isFinite(firstMs)) {
+    return void 0;
+  }
+  if (firstMs > nowMs) {
+    return firstMs;
+  }
+  const retry = cron.nextRun(new Date(Math.floor(nowMs / 1e3) * 1e3 + 1e3));
+  if (!retry) {
+    return void 0;
+  }
+  const retryMs = retry.getTime();
+  if (!Number.isFinite(retryMs) || retryMs <= nowMs) {
+    return void 0;
+  }
+  return retryMs;
+}
+
+export {
+  normalizeSchedule,
+  computeNextRunAtMs
+};

package/dist/driver-KdyMlXQq.d.ts

@@ -0,0 +1,127 @@
+type RuntimeRunStatus = "ok" | "error" | "skipped";
+type RuntimeTrigger = "due" | "manual";
+type RuntimeRetryStrategy = "fixed" | "exponential";
+interface RuntimeRetryPolicy {
+    maxAttempts: number;
+    backoffMs?: number;
+    strategy?: RuntimeRetryStrategy;
+    maxBackoffMs?: number;
+}
+interface RuntimeAtSchedule {
+    kind: "at";
+    at: number;
+}
+interface RuntimeEverySchedule {
+    kind: "every";
+    everyMs: number;
+    anchorMs?: number;
+}
+interface RuntimeCronSchedule {
+    kind: "cron";
+    expr: string;
+    timezone?: string;
+}
+type RuntimeJobSchedule = RuntimeAtSchedule | RuntimeEverySchedule | RuntimeCronSchedule;
+interface RuntimeAtScheduleInput {
+    kind: "at";
+    at: number | string | Date;
+}
+type RuntimeJobScheduleInput = RuntimeAtScheduleInput | RuntimeEverySchedule | RuntimeCronSchedule;
+interface RuntimeJobState {
+    nextRunAtMs?: number;
+    lastRunAtMs?: number;
+    lastStatus?: RuntimeRunStatus;
+    lastError?: string;
+    lastAttemptCount?: number;
+    deadLetterCount?: number;
+    lastDeadLetterAtMs?: number;
+    running?: boolean;
+}
+interface RuntimeJobRecord<TPayload = unknown> {
+    id: string;
+    name: string;
+    payload: TPayload;
+    schedule: RuntimeJobSchedule;
+    retryPolicy?: RuntimeRetryPolicy;
+    enabled: boolean;
+    metadata?: Record<string, string>;
+    createdAt: string;
+    updatedAt: string;
+    state: RuntimeJobState;
+}
+interface RuntimeScheduleInput<TPayload = unknown> {
+    id?: string;
+    name: string;
+    payload: TPayload;
+    schedule: RuntimeJobScheduleInput;
+    retryPolicy?: RuntimeRetryPolicy;
+    enabled?: boolean;
+    metadata?: Record<string, string>;
+}
+interface RuntimeSchedulePatch<TPayload = unknown> {
+    name?: string;
+    payload?: TPayload;
+    schedule?: RuntimeJobScheduleInput;
+    retryPolicy?: RuntimeRetryPolicy;
+    enabled?: boolean;
+    metadata?: Record<string, string>;
+}
+interface RuntimeExecutionContext {
+    trigger: RuntimeTrigger;
+    startedAt: number;
+    attempt: number;
+    signal: AbortSignal;
+    deadlineAt?: number;
+}
+interface RuntimeExecutionResult {
+    status?: RuntimeRunStatus;
+    error?: string;
+}
+type RuntimeExecutor<TPayload = unknown> = (job: RuntimeJobRecord<TPayload>, context: RuntimeExecutionContext) => Promise<RuntimeExecutionResult | void> | RuntimeExecutionResult | void;
+interface RuntimeDispatchInput {
+    jobId: string;
+    trigger: RuntimeTrigger;
+}
+interface RuntimeRunResult {
+    jobId: string;
+    trigger: RuntimeTrigger;
+    status: RuntimeRunStatus;
+    startedAt: number;
+    endedAt: number;
+    error?: string;
+}
+interface RuntimeDeadLetterEvent<TPayload = unknown> {
+    job: RuntimeJobRecord<TPayload>;
+    trigger: RuntimeTrigger;
+    attempts: number;
+    startedAt: number;
+    endedAt: number;
+    error: string;
+}
+
+type RuntimeLogMeta = Record<string, unknown>;
+interface RuntimeLogger {
+    debug(message: string, meta?: RuntimeLogMeta): void;
+    info(message: string, meta?: RuntimeLogMeta): void;
+    warn(message: string, meta?: RuntimeLogMeta): void;
+    error(message: string, meta?: RuntimeLogMeta): void;
+}
+declare const silentRuntimeLogger: RuntimeLogger;
+declare function createConsoleRuntimeLogger(prefix?: string): RuntimeLogger;
+
+interface RuntimeDriverContext<TPayload = unknown> {
+    now: () => number;
+    onDue: (jobId: string) => Promise<void | RuntimeRunResult>;
+    logger: RuntimeLogger;
+}
+interface RuntimeDriver<TPayload = unknown> {
+    readonly name: string;
+    start(context: RuntimeDriverContext<TPayload>): Promise<void>;
+    stop(): Promise<void>;
+    listJobs(): Promise<RuntimeJobRecord<TPayload>[]>;
+    getJob?(jobId: string): Promise<RuntimeJobRecord<TPayload> | undefined>;
+    upsertJob(job: RuntimeJobRecord<TPayload>): Promise<RuntimeJobRecord<TPayload>>;
+    removeJob(jobId: string): Promise<boolean>;
+}
+
+export { type RuntimeDriver as R, type RuntimeDriverContext as a, type RuntimeJobRecord as b, type RuntimeJobSchedule as c, type RuntimeJobScheduleInput as d, type RuntimeAtSchedule as e, type RuntimeAtScheduleInput as f, type RuntimeCronSchedule as g, type RuntimeDeadLetterEvent as h, type RuntimeDispatchInput as i, type RuntimeEverySchedule as j, type RuntimeExecutionContext as k, type RuntimeExecutionResult as l, type RuntimeExecutor as m, type RuntimeJobState as n, type RuntimeLogMeta as o, type RuntimeLogger as p, type RuntimeRetryPolicy as q, type RuntimeRetryStrategy as r, type RuntimeRunResult as s, type RuntimeRunStatus as t, type RuntimeScheduleInput as u, type RuntimeSchedulePatch as v, type RuntimeTrigger as w, createConsoleRuntimeLogger as x, silentRuntimeLogger as y };

package/dist/drivers/in-memory.d.ts

@@ -0,0 +1,27 @@
+import { R as RuntimeDriver, a as RuntimeDriverContext, b as RuntimeJobRecord } from '../driver-KdyMlXQq.js';
+
+interface InMemoryRuntimeDriverOptions {
+    maxTimerDelayMs?: number;
+}
+declare class InMemoryRuntimeDriver<TPayload = unknown> implements RuntimeDriver<TPayload> {
+    readonly name = "in-memory";
+    private readonly jobs;
+    private readonly scheduled;
+    private readonly maxTimerDelayMs;
+    private context;
+    private started;
+    constructor(options?: InMemoryRuntimeDriverOptions);
+    start(context: RuntimeDriverContext<TPayload>): Promise<void>;
+    stop(): Promise<void>;
+    listJobs(): Promise<RuntimeJobRecord<TPayload>[]>;
+    getJob(jobId: string): Promise<RuntimeJobRecord<TPayload> | undefined>;
+    upsertJob(job: RuntimeJobRecord<TPayload>): Promise<RuntimeJobRecord<TPayload>>;
+    removeJob(jobId: string): Promise<boolean>;
+    private now;
+    private clearScheduled;
+    private armJob;
+    private armTimeout;
+    private trigger;
+}
+
+export { InMemoryRuntimeDriver };

package/dist/drivers/in-memory.js

@@ -0,0 +1,7 @@
+import {
+  InMemoryRuntimeDriver
+} from "../chunk-DBQSJ476.js";
+import "../chunk-ZVISWF7S.js";
+export {
+  InMemoryRuntimeDriver
+};

package/dist/index-CbLKNFMq.d.ts

@@ -0,0 +1,266 @@
+import { w as RuntimeTrigger, b as RuntimeJobRecord, t as RuntimeRunStatus, h as RuntimeDeadLetterEvent, R as RuntimeDriver, m as RuntimeExecutor, p as RuntimeLogger, u as RuntimeScheduleInput, v as RuntimeSchedulePatch, s as RuntimeRunResult, i as RuntimeDispatchInput } from './driver-KdyMlXQq.js';
+
+interface RuntimeLifecycleEvent {
+    driver: string;
+    at: number;
+}
+interface RuntimeDispatchQueuedEvent {
+    jobId: string;
+    trigger: RuntimeTrigger;
+    queuedAt: number;
+    queueLength: number;
+}
+interface RuntimeDispatchDroppedEvent {
+    jobId: string;
+    trigger: RuntimeTrigger;
+    droppedAt: number;
+    queueLength: number;
+    reason: string;
+}
+interface RuntimeRunStartEvent<TPayload = unknown> {
+    job: RuntimeJobRecord<TPayload>;
+    trigger: RuntimeTrigger;
+    startedAt: number;
+}
+interface RuntimeRunRetryEvent<TPayload = unknown> {
+    job: RuntimeJobRecord<TPayload>;
+    trigger: RuntimeTrigger;
+    attempt: number;
+    nextAttempt: number;
+    delayMs: number;
+    error?: string;
+}
+interface RuntimeRunCompleteEvent<TPayload = unknown> {
+    job: RuntimeJobRecord<TPayload>;
+    trigger: RuntimeTrigger;
+    startedAt: number;
+    endedAt: number;
+    attempts: number;
+    status: RuntimeRunStatus;
+    error?: string;
+    deadLettered?: boolean;
+}
+interface RuntimeObserver<TPayload = unknown> {
+    notifyRuntimeStart?(event: RuntimeLifecycleEvent): void | Promise<void>;
+    notifyRuntimeStop?(event: RuntimeLifecycleEvent): void | Promise<void>;
+    notifyDispatchQueued?(event: RuntimeDispatchQueuedEvent): void | Promise<void>;
+    notifyDispatchDropped?(event: RuntimeDispatchDroppedEvent): void | Promise<void>;
+    notifyRunStart?(event: RuntimeRunStartEvent<TPayload>): void | Promise<void>;
+    notifyRunRetry?(event: RuntimeRunRetryEvent<TPayload>): void | Promise<void>;
+    notifyRunComplete?(event: RuntimeRunCompleteEvent<TPayload>): void | Promise<void>;
+    notifyDeadLetter?(event: RuntimeDeadLetterEvent<TPayload>): void | Promise<void>;
+}
+
+interface AgentRuntimeOptions<TPayload = unknown> {
+    driver: RuntimeDriver<TPayload>;
+    execute: RuntimeExecutor<TPayload>;
+    logger?: RuntimeLogger;
+    maxConcurrentRuns?: number;
+    maxQueuedDispatches?: number;
+    createId?: () => string;
+    executionTimeoutMs?: number;
+    abortInFlightOnStop?: boolean;
+    onDeadLetter?: (event: RuntimeDeadLetterEvent<TPayload>) => void | Promise<void>;
+    observers?: RuntimeObserver<TPayload>[];
+}
+declare class AgentRuntime<TPayload = unknown> {
+    private readonly driver;
+    private readonly executeJob;
+    private readonly logger;
+    private readonly maxConcurrentRuns;
+    private readonly maxQueuedDispatches;
+    private readonly createId;
+    private readonly executionTimeoutMs;
+    private readonly abortInFlightOnStop;
+    private readonly onDeadLetter;
+    private readonly observers;
+    private started;
+    private activeRuns;
+    private readonly inFlight;
+    private readonly runControllers;
+    private readonly pendingDispatches;
+    private readonly pendingDispatchByJobId;
+    constructor(options: AgentRuntimeOptions<TPayload>);
+    private forEachObserver;
+    start(): Promise<void>;
+    stop(): Promise<void>;
+    status(): {
+        started: boolean;
+        driver: string;
+        inFlightJobs: string[];
+        queuedJobs: string[];
+        maxConcurrentRuns: number;
+        maxQueuedDispatches?: number;
+    };
+    listJobs(): Promise<RuntimeJobRecord<TPayload>[]>;
+    getJob(jobId: string): Promise<RuntimeJobRecord<TPayload> | undefined>;
+    schedule(input: RuntimeScheduleInput<TPayload>): Promise<RuntimeJobRecord<TPayload>>;
+    update(jobId: string, patch: RuntimeSchedulePatch<TPayload>): Promise<RuntimeJobRecord<TPayload>>;
+    pause(jobId: string): Promise<RuntimeJobRecord<TPayload>>;
+    resume(jobId: string): Promise<RuntimeJobRecord<TPayload>>;
+    remove(jobId: string): Promise<boolean>;
+    runNow(jobId: string): Promise<RuntimeRunResult>;
+    dispatch(input: RuntimeDispatchInput): Promise<RuntimeRunResult>;
+    dispatchDue(jobId: string): Promise<RuntimeRunResult>;
+    private runJob;
+    private requireJob;
+    private tryReserveRun;
+    private enqueuePendingDispatch;
+    private executeJobAttempt;
+    private emitDeadLetter;
+    private executeReservedJob;
+    private releaseRunReservation;
+    private drainPendingDispatches;
+}
+declare function createAgentRuntime<TPayload = unknown>(options: AgentRuntimeOptions<TPayload>): AgentRuntime<TPayload>;
+
+type OrchestratorRunStatus = "queued" | "running" | "completed" | "failed" | "cancelled";
+type OrchestratorRunMode = "invoke" | "guide";
+interface OrchestratorRunState<TResult = unknown> {
+    status: OrchestratorRunStatus;
+    running: boolean;
+    attempt: number;
+    guideCount: number;
+    startedAtMs?: number;
+    endedAtMs?: number;
+    error?: string;
+    result?: TResult;
+}
+interface OrchestratorRunRecord<TInput = unknown, TResult = unknown> {
+    id: string;
+    label: string;
+    input: TInput;
+    parentRunId?: string;
+    metadata?: Record<string, string>;
+    createdAt: string;
+    updatedAt: string;
+    state: OrchestratorRunState<TResult>;
+}
+interface OrchestratorJobPayload<TInput = unknown> {
+    runId: string;
+    input: TInput;
+    mode: OrchestratorRunMode;
+    guideMessage?: string;
+}
+interface OrchestratorInvokeInput<TInput = unknown> {
+    id?: string;
+    label?: string;
+    input: TInput;
+    parentRunId?: string;
+    metadata?: Record<string, string>;
+}
+interface OrchestratorInvokeResult<TInput = unknown, TResult = unknown> {
+    run: OrchestratorRunRecord<TInput, TResult>;
+    jobId: string;
+}
+interface OrchestratorWaitOptions {
+    timeoutMs?: number;
+    signal?: AbortSignal;
+}
+interface OrchestratorListOptions {
+    status?: OrchestratorRunStatus | OrchestratorRunStatus[];
+    parentRunId?: string;
+    limit?: number;
+}
+interface OrchestratorCloseOptions {
+    reason?: string;
+}
+interface OrchestratorGuideInput<TInput = unknown> {
+    runId: string;
+    message: string;
+    input?: TInput;
+    metadata?: Record<string, string>;
+}
+interface OrchestratorExecutionContext {
+    signal: AbortSignal;
+    trigger: RuntimeTrigger;
+    mode: OrchestratorRunMode;
+    attempt: number;
+    startedAt: number;
+    deadlineAt?: number;
+    guideMessage?: string;
+}
+type OrchestratorExecutor<TInput = unknown, TResult = unknown> = (run: OrchestratorRunRecord<TInput, TResult>, context: OrchestratorExecutionContext) => Promise<TResult> | TResult;
+type OrchestratorGuidedInputResolver<TInput = unknown, TResult = unknown> = (params: {
+    run: OrchestratorRunRecord<TInput, TResult>;
+    guideMessage: string;
+}) => TInput;
+declare function isTerminalRunStatus(status: OrchestratorRunStatus): boolean;
+
+interface OrchestratorRunStore<TInput = unknown, TResult = unknown> {
+    start?(): Promise<void>;
+    stop?(): Promise<void>;
+    get(runId: string): Promise<OrchestratorRunRecord<TInput, TResult> | undefined>;
+    list(): Promise<OrchestratorRunRecord<TInput, TResult>[]>;
+    upsert(run: OrchestratorRunRecord<TInput, TResult>): Promise<OrchestratorRunRecord<TInput, TResult>>;
+    remove(runId: string): Promise<boolean>;
+}
+
+declare class InMemoryOrchestratorRunStore<TInput = unknown, TResult = unknown> implements OrchestratorRunStore<TInput, TResult> {
+    private readonly runs;
+    get(runId: string): Promise<OrchestratorRunRecord<TInput, TResult> | undefined>;
+    list(): Promise<OrchestratorRunRecord<TInput, TResult>[]>;
+    upsert(run: OrchestratorRunRecord<TInput, TResult>): Promise<OrchestratorRunRecord<TInput, TResult>>;
+    remove(runId: string): Promise<boolean>;
+}
+
+interface AgentOrchestratorOptions<TInput = unknown, TResult = unknown> {
+    driver: RuntimeDriver<OrchestratorJobPayload<TInput>>;
+    execute: OrchestratorExecutor<TInput, TResult>;
+    runtime?: Omit<AgentRuntimeOptions<OrchestratorJobPayload<TInput>>, "driver" | "execute">;
+    store?: OrchestratorRunStore<TInput, TResult>;
+    logger?: RuntimeLogger;
+    createId?: () => string;
+    jobIdPrefix?: string;
+    runLabelPrefix?: string;
+    scheduleAheadMs?: number;
+    resolveGuidedInput?: OrchestratorGuidedInputResolver<TInput, TResult>;
+}
+declare class AgentOrchestrator<TInput = unknown, TResult = unknown> {
+    readonly runtime: AgentRuntime<OrchestratorJobPayload<TInput>>;
+    private readonly store;
+    private readonly executeRun;
+    private readonly logger;
+    private readonly createId;
+    private readonly jobIdPrefix;
+    private readonly runLabelPrefix;
+    private readonly scheduleAheadMs;
+    private readonly resolveGuidedInput;
+    private readonly waiters;
+    private readonly runControllers;
+    private readonly closeReasons;
+    private readonly pendingGuides;
+    constructor(options: AgentOrchestratorOptions<TInput, TResult>);
+    start(): Promise<void>;
+    stop(): Promise<void>;
+    status(): Promise<{
+        runtime: ReturnType<AgentRuntime<OrchestratorJobPayload<TInput>>["status"]>;
+        runs: {
+            total: number;
+            queued: number;
+            running: number;
+            completed: number;
+            failed: number;
+            cancelled: number;
+        };
+    }>;
+    invoke(input: OrchestratorInvokeInput<TInput>): Promise<OrchestratorInvokeResult<TInput, TResult>>;
+    get(runId: string): Promise<OrchestratorRunRecord<TInput, TResult> | undefined>;
+    listInvocations(options?: OrchestratorListOptions): Promise<OrchestratorRunRecord<TInput, TResult>[]>;
+    waitForInvocation(runId: string, options?: OrchestratorWaitOptions): Promise<OrchestratorRunRecord<TInput, TResult>>;
+    close(runId: string, options?: OrchestratorCloseOptions): Promise<OrchestratorRunRecord<TInput, TResult>>;
+    guide(input: OrchestratorGuideInput<TInput>): Promise<OrchestratorRunRecord<TInput, TResult>>;
+    private ensureStarted;
+    private toJobId;
+    private resolveStatusFilter;
+    private requireRun;
+    private failRunLaunch;
+    private failPendingRunLaunch;
+    private disableRunJob;
+    private launchRun;
+    private notifyWaiters;
+    private executeRuntimeJob;
+}
+declare function createAgentOrchestrator<TInput = unknown, TResult = unknown>(options: AgentOrchestratorOptions<TInput, TResult>): AgentOrchestrator<TInput, TResult>;
+
+export { AgentOrchestrator as A, InMemoryOrchestratorRunStore as I, type OrchestratorCloseOptions as O, type RuntimeObserver as R, type AgentOrchestratorOptions as a, AgentRuntime as b, type AgentRuntimeOptions as c, type OrchestratorExecutionContext as d, type OrchestratorExecutor as e, type OrchestratorGuideInput as f, type OrchestratorGuidedInputResolver as g, type OrchestratorInvokeInput as h, type OrchestratorInvokeResult as i, type OrchestratorJobPayload as j, type OrchestratorListOptions as k, type OrchestratorRunMode as l, type OrchestratorRunRecord as m, type OrchestratorRunState as n, type OrchestratorRunStatus as o, type OrchestratorRunStore as p, type OrchestratorWaitOptions as q, type RuntimeDispatchDroppedEvent as r, type RuntimeDispatchQueuedEvent as s, type RuntimeLifecycleEvent as t, type RuntimeRunCompleteEvent as u, type RuntimeRunRetryEvent as v, type RuntimeRunStartEvent as w, createAgentOrchestrator as x, createAgentRuntime as y, isTerminalRunStatus as z };

package/dist/index.d.ts

@@ -0,0 +1,44 @@
+import { c as RuntimeJobSchedule, d as RuntimeJobScheduleInput } from './driver-KdyMlXQq.js';
+export { e as RuntimeAtSchedule, f as RuntimeAtScheduleInput, g as RuntimeCronSchedule, h as RuntimeDeadLetterEvent, i as RuntimeDispatchInput, R as RuntimeDriver, a as RuntimeDriverContext, j as RuntimeEverySchedule, k as RuntimeExecutionContext, l as RuntimeExecutionResult, m as RuntimeExecutor, b as RuntimeJobRecord, n as RuntimeJobState, o as RuntimeLogMeta, p as RuntimeLogger, q as RuntimeRetryPolicy, r as RuntimeRetryStrategy, s as RuntimeRunResult, t as RuntimeRunStatus, u as RuntimeScheduleInput, v as RuntimeSchedulePatch, w as RuntimeTrigger, x as createConsoleRuntimeLogger, y as silentRuntimeLogger } from './driver-KdyMlXQq.js';
+import { R as RuntimeObserver } from './index-CbLKNFMq.js';
+export { A as AgentOrchestrator, a as AgentOrchestratorOptions, b as AgentRuntime, c as AgentRuntimeOptions, I as InMemoryOrchestratorRunStore, O as OrchestratorCloseOptions, d as OrchestratorExecutionContext, e as OrchestratorExecutor, f as OrchestratorGuideInput, g as OrchestratorGuidedInputResolver, h as OrchestratorInvokeInput, i as OrchestratorInvokeResult, j as OrchestratorJobPayload, k as OrchestratorListOptions, l as OrchestratorRunMode, m as OrchestratorRunRecord, n as OrchestratorRunState, o as OrchestratorRunStatus, p as OrchestratorRunStore, q as OrchestratorWaitOptions, r as RuntimeDispatchDroppedEvent, s as RuntimeDispatchQueuedEvent, t as RuntimeLifecycleEvent, u as RuntimeRunCompleteEvent, v as RuntimeRunRetryEvent, w as RuntimeRunStartEvent, x as createAgentOrchestrator, y as createAgentRuntime, z as isTerminalRunStatus } from './index-CbLKNFMq.js';
+export { InMemoryRuntimeDriver } from './drivers/in-memory.js';
+
+declare const PROMETHEUS_TEXT_CONTENT_TYPE = "text/plain; version=0.0.4; charset=utf-8";
+interface PrometheusRuntimeMetricsOptions {
+    metricPrefix?: string;
+    defaultLabels?: Record<string, string>;
+    durationBucketsMs?: number[];
+}
+interface PrometheusMetricSample {
+    labels: Record<string, string>;
+    value: number;
+}
+interface PrometheusHistogramBucketSample {
+    le: number;
+    value: number;
+}
+interface PrometheusHistogramSample {
+    labels: Record<string, string>;
+    count: number;
+    sum: number;
+    buckets: PrometheusHistogramBucketSample[];
+}
+interface PrometheusRuntimeMetricsSnapshot {
+    counters: Record<string, PrometheusMetricSample[]>;
+    gauges: Record<string, PrometheusMetricSample[]>;
+    histograms: Record<string, PrometheusHistogramSample[]>;
+}
+interface PrometheusRuntimeMetrics<TPayload = unknown> {
+    observer: RuntimeObserver<TPayload>;
+    contentType: typeof PROMETHEUS_TEXT_CONTENT_TYPE;
+    snapshot(): PrometheusRuntimeMetricsSnapshot;
+    render(): string;
+    reset(): void;
+}
+declare function createPrometheusRuntimeMetrics<TPayload = unknown>(options?: PrometheusRuntimeMetricsOptions): PrometheusRuntimeMetrics<TPayload>;
+
+declare function normalizeSchedule(input: RuntimeJobScheduleInput): RuntimeJobSchedule;
+declare function computeNextRunAtMs(schedule: RuntimeJobSchedule, nowMs: number): number | undefined;
+
+export { PROMETHEUS_TEXT_CONTENT_TYPE, type PrometheusHistogramBucketSample, type PrometheusHistogramSample, type PrometheusMetricSample, type PrometheusRuntimeMetrics, type PrometheusRuntimeMetricsOptions, type PrometheusRuntimeMetricsSnapshot, RuntimeJobSchedule, RuntimeJobScheduleInput, RuntimeObserver, computeNextRunAtMs, createPrometheusRuntimeMetrics, normalizeSchedule };