@eidentic/server 0.1.0

package/dist/index.js

@@ -0,0 +1,1590 @@
+// src/index.ts
+import { Hono } from "hono";
+import { streamSSE } from "hono/streaming";
+import { bodyLimit } from "hono/body-limit";
+import { cors } from "hono/cors";
+import { createWorkflowRunRegistry } from "@eidentic/workflow";
+
+// src/rate-limit.ts
+var InMemoryTokenBucketLimiter = class {
+  capacity;
+  refillPerSec;
+  now;
+  buckets = /* @__PURE__ */ new Map();
+  /**
+   * The eviction threshold in ms: entries older than this are guaranteed to be
+   * at full capacity, so removing them is lossless.
+   * = (capacity / refillPerSec) * 1000 * 2
+   * For zero-refill configs a fixed 24-hour window bounds growth.
+   */
+  evictThresholdMs;
+  /**
+   * Sweep runs at most once per this interval. Set to half the eviction
+   * threshold so that stale entries are caught within at most one extra window.
+   */
+  sweepIntervalMs;
+  lastSweepMs = 0;
+  constructor(opts) {
+    this.capacity = opts.capacity;
+    this.refillPerSec = opts.refillPerSec;
+    this.now = opts.now ?? (() => Date.now());
+    if (opts.refillPerSec > 0) {
+      const fullRefillMs = opts.capacity / opts.refillPerSec * 1e3;
+      this.evictThresholdMs = fullRefillMs * 2;
+      this.sweepIntervalMs = fullRefillMs;
+    } else {
+      this.evictThresholdMs = 864e5;
+      this.sweepIntervalMs = 36e5;
+    }
+  }
+  /**
+   * Test-only accessor: number of entries currently held in the buckets map.
+   * Not part of the `RateLimiterPort` contract.
+   */
+  get bucketCount() {
+    return this.buckets.size;
+  }
+  acquire(key, cost = 1) {
+    const nowMs = this.now();
+    if (nowMs - this.lastSweepMs >= this.sweepIntervalMs) {
+      this._sweep(nowMs);
+      this.lastSweepMs = nowMs;
+    }
+    let bucket = this.buckets.get(key);
+    if (!bucket) {
+      bucket = { tokens: this.capacity, lastRefillMs: nowMs };
+      this.buckets.set(key, bucket);
+    }
+    const elapsedSec = (nowMs - bucket.lastRefillMs) / 1e3;
+    bucket.tokens = Math.min(this.capacity, bucket.tokens + elapsedSec * this.refillPerSec);
+    bucket.lastRefillMs = nowMs;
+    if (bucket.tokens >= cost) {
+      bucket.tokens -= cost;
+      return { ok: true, remaining: Math.floor(bucket.tokens) };
+    }
+    const retryAfterMs = this.refillPerSec > 0 ? Math.ceil((cost - bucket.tokens) / this.refillPerSec * 1e3) : void 0;
+    return { ok: false, retryAfterMs, remaining: Math.floor(bucket.tokens) };
+  }
+  /**
+   * Evict bucket entries older than `evictThresholdMs`. Called opportunistically
+   * from `acquire` — no timer involved.
+   */
+  _sweep(nowMs) {
+    for (const [k, state] of this.buckets) {
+      if (nowMs - state.lastRefillMs > this.evictThresholdMs) {
+        this.buckets.delete(k);
+      }
+    }
+  }
+};
+
+// src/quota.ts
+var InMemoryQuota = class {
+  resolve;
+  ledger = /* @__PURE__ */ new Map();
+  /** In-flight run count per key: incremented on check, decremented on record/release. */
+  reserved = /* @__PURE__ */ new Map();
+  /** Per-key monotonic generation counter, bumped on reset() to invalidate outstanding tokens. */
+  generations = /* @__PURE__ */ new Map();
+  /** All live reservation tokens, used by the max-age sweep. */
+  activeReservations = /* @__PURE__ */ new Set();
+  /** Max-age sweep interval handle — cleared on destroy(). */
+  sweepInterval;
+  /** How old a reservation must be (ms) before the sweep discards it. Default 5 minutes. */
+  reservationMaxAgeMs;
+  constructor(limits, options) {
+    this.resolve = typeof limits === "function" ? limits : () => limits;
+    this.reservationMaxAgeMs = options?.reservationMaxAgeMs ?? 3e5;
+    if (this.reservationMaxAgeMs > 0 && isFinite(this.reservationMaxAgeMs)) {
+      this.sweepInterval = setInterval(() => {
+        this.sweepStaleReservations();
+      }, this.reservationMaxAgeMs);
+      if (typeof this.sweepInterval === "object" && this.sweepInterval !== null && typeof this.sweepInterval.unref === "function") {
+        this.sweepInterval.unref();
+      }
+    }
+  }
+  /**
+   * Release all stale reservations (older than `reservationMaxAgeMs`).
+   * Called automatically by the background sweep, but also available for testing.
+   */
+  sweepStaleReservations() {
+    const now = Date.now();
+    for (const reservation of this.activeReservations) {
+      if (now - reservation.createdAt >= this.reservationMaxAgeMs) {
+        this.activeReservations.delete(reservation);
+        if (reservation.generation === this.getGeneration(reservation.key)) {
+          const cur = this.getReserved(reservation.key);
+          if (cur > 0) this.reserved.set(reservation.key, cur - 1);
+        }
+      }
+    }
+  }
+  /**
+   * Stop the background sweep interval. Call this when shutting down to prevent
+   * open handle warnings in tests and to release resources cleanly.
+   */
+  destroy() {
+    if (this.sweepInterval !== void 0) {
+      clearInterval(this.sweepInterval);
+    }
+  }
+  getUsage(key) {
+    let u = this.ledger.get(key);
+    if (!u) {
+      u = { usd: 0, tokens: 0, runs: 0 };
+      this.ledger.set(key, u);
+    }
+    return u;
+  }
+  getGeneration(key) {
+    return this.generations.get(key) ?? 0;
+  }
+  getReserved(key) {
+    return this.reserved.get(key) ?? 0;
+  }
+  /**
+   * Check whether `key` may start another run. On success, reserves 1 run in the in-flight
+   * counter and returns a `reservation` token. Hard ceilings are checked against
+   * `committed + reserved` so concurrent callers see each other's pending runs.
+   *
+   * Always call `record(key, spend, reservation)` or `release(reservation)` after `check`
+   * to free the reservation and prevent in-flight count leakage.
+   */
+  check(key) {
+    const limits = this.resolve(key);
+    const usage = this.getUsage(key);
+    const inFlight = this.getReserved(key);
+    if (limits.hardUsd !== void 0 && usage.usd >= limits.hardUsd) {
+      return { ok: false, reason: `hard USD ceiling reached (${usage.usd} >= ${limits.hardUsd})`, usage };
+    }
+    if (limits.hardTokens !== void 0 && usage.tokens >= limits.hardTokens) {
+      return { ok: false, reason: `hard token ceiling reached (${usage.tokens} >= ${limits.hardTokens})`, usage };
+    }
+    if (limits.hardRuns !== void 0 && usage.runs + inFlight >= limits.hardRuns) {
+      return { ok: false, reason: `hard run ceiling reached (${usage.runs + inFlight} >= ${limits.hardRuns})`, usage };
+    }
+    this.reserved.set(key, inFlight + 1);
+    const generation = this.getGeneration(key);
+    const reservation = { key, generation, createdAt: Date.now() };
+    this.activeReservations.add(reservation);
+    const warn = limits.softUsd !== void 0 && usage.usd >= limits.softUsd;
+    return { ok: true, warn: warn || void 0, usage, reservation };
+  }
+  /**
+   * Settle a reservation by recording actual spend. The 1-run reservation is consumed and the
+   * committed counter is updated with the real spend. If `reservation` is provided and stale
+   * (reset() was called between check and record), the settle is a no-op — no double-counting.
+   *
+   * Legacy callers that omit `reservation` still have their spend committed (backward-compatible),
+   * but the in-flight counter is not decremented (they weren't reserving).
+   */
+  record(key, spend, reservation) {
+    if (reservation !== void 0) {
+      this.activeReservations.delete(reservation);
+      if (reservation.generation === this.getGeneration(key)) {
+        const cur = this.getReserved(key);
+        if (cur > 0) this.reserved.set(key, cur - 1);
+      }
+    }
+    const usage = this.getUsage(key);
+    usage.usd += spend.usd;
+    usage.tokens += spend.tokens;
+    usage.runs += 1;
+  }
+  /**
+   * Release a reservation WITHOUT recording spend (error / abort path).
+   * If the token is stale (reset() was called), this is a no-op.
+   */
+  release(reservation) {
+    this.activeReservations.delete(reservation);
+    if (reservation.generation !== this.getGeneration(reservation.key)) return;
+    const cur = this.getReserved(reservation.key);
+    if (cur > 0) this.reserved.set(reservation.key, cur - 1);
+  }
+  /**
+   * Reset usage counters for a specific key, or ALL keys when called with no argument.
+   * Increments the generation counter for affected keys so outstanding reservation tokens
+   * become stale and cannot settle against the fresh state.
+   * Useful for tests and dev tooling.
+   */
+  reset(key) {
+    if (key !== void 0) {
+      this.ledger.delete(key);
+      this.reserved.delete(key);
+      this.generations.set(key, (this.generations.get(key) ?? 0) + 1);
+      for (const r of this.activeReservations) {
+        if (r.key === key) this.activeReservations.delete(r);
+      }
+    } else {
+      this.ledger.clear();
+      this.reserved.clear();
+      for (const k of [...this.generations.keys()]) {
+        this.generations.set(k, (this.generations.get(k) ?? 0) + 1);
+      }
+      this.activeReservations.clear();
+    }
+  }
+};
+
+// src/ui-message-stream.ts
+import {
+  createUIMessageStream,
+  createUIMessageStreamResponse
+} from "ai";
+function toUIMessageStream(events) {
+  return createUIMessageStream({
+    execute: async ({ writer }) => {
+      writer.write({ type: "start" });
+      writer.write({ type: "start-step" });
+      let textBlockOpen = false;
+      let textBlockId = "text-0";
+      function openTextBlock(id) {
+        if (!textBlockOpen) {
+          textBlockId = id;
+          writer.write({ type: "text-start", id: textBlockId });
+          textBlockOpen = true;
+        }
+      }
+      function closeTextBlock() {
+        if (textBlockOpen) {
+          writer.write({ type: "text-end", id: textBlockId });
+          textBlockOpen = false;
+        }
+      }
+      for await (const ev of events) {
+        switch (ev.type) {
+          // ------------------------------------------------------------------
+          // Streaming token delta — primary hot path for live text streaming
+          // ------------------------------------------------------------------
+          case "stream.delta": {
+            openTextBlock("streaming-text");
+            writer.write({ type: "text-delta", delta: ev.delta.text, id: textBlockId });
+            break;
+          }
+          // ------------------------------------------------------------------
+          // Assistant turn — complete content blocks (text + tool_use)
+          // ------------------------------------------------------------------
+          case "assistant": {
+            closeTextBlock();
+            for (const block of ev.content) {
+              if (block.type === "text") {
+                const id = `text-${crypto.randomUUID()}`;
+                writer.write({ type: "text-start", id });
+                writer.write({ type: "text-delta", delta: block.text, id });
+                writer.write({ type: "text-end", id });
+              } else if (block.type === "tool_use") {
+                writer.write({
+                  type: "tool-input-available",
+                  toolCallId: block.callId,
+                  toolName: block.name,
+                  input: block.input
+                });
+              }
+            }
+            break;
+          }
+          // ------------------------------------------------------------------
+          // Tool result
+          // ------------------------------------------------------------------
+          case "tool.result": {
+            if (ev.isError) {
+              writer.write({
+                type: "tool-output-error",
+                toolCallId: ev.callId,
+                errorText: typeof ev.output === "string" ? ev.output : JSON.stringify(ev.output)
+              });
+            } else {
+              writer.write({
+                type: "tool-output-available",
+                toolCallId: ev.callId,
+                output: ev.output
+              });
+            }
+            break;
+          }
+          // ------------------------------------------------------------------
+          // Terminal result — stream is done
+          // ------------------------------------------------------------------
+          case "result": {
+            closeTextBlock();
+            const finishReason = (() => {
+              switch (ev.subtype) {
+                case "success":
+                  return "stop";
+                case "max_tokens":
+                  return "length";
+                case "error":
+                  return "error";
+                case "max_turns":
+                case "max_cost":
+                case "max_wall_clock":
+                case "aborted":
+                case "suspended":
+                default:
+                  return "other";
+              }
+            })();
+            writer.write({ type: "finish-step" });
+            writer.write({ type: "finish", finishReason });
+            break;
+          }
+          // ------------------------------------------------------------------
+          // Ignored events — metadata / audit signals not meaningful to UI
+          // ------------------------------------------------------------------
+          case "session.init":
+          case "compaction":
+            break;
+        }
+      }
+    },
+    onError: (err) => {
+      const msg = err instanceof Error ? err.message : String(err);
+      return `Stream error: ${msg}`;
+    }
+  });
+}
+function toUIMessageStreamResponse(events, opts = {}) {
+  return createUIMessageStreamResponse({
+    stream: toUIMessageStream(events),
+    status: opts.status,
+    headers: opts.headers
+  });
+}
+
+// src/scheduler.ts
+import { CronExpressionParser } from "cron-parser";
+var realClock = {
+  now: () => Date.now()
+};
+var realTimer = {
+  setInterval: (fn, ms) => globalThis.setInterval(fn, ms),
+  clearInterval: (handle) => globalThis.clearInterval(handle)
+};
+function defaultLogger() {
+  return {
+    log(level, namespace, message, fields) {
+      if (level === "error" || level === "warn") {
+        console.error(`[${level.toUpperCase()}] ${namespace}: ${message}`, fields ?? "");
+      }
+    }
+  };
+}
+var Scheduler = class {
+  tickIntervalMs;
+  clock;
+  timer;
+  logger;
+  tasks = /* @__PURE__ */ new Map();
+  timerHandle = null;
+  running = false;
+  constructor(opts = {}) {
+    this.tickIntervalMs = opts.tickIntervalMs ?? 1e3;
+    this.clock = opts.clock ?? realClock;
+    this.timer = opts.timer ?? realTimer;
+    this.logger = opts.logger ?? defaultLogger();
+  }
+  // ---------------------------------------------------------------------------
+  // Lifecycle
+  // ---------------------------------------------------------------------------
+  /**
+   * Start the scheduler's internal tick loop.
+   * Calling `start()` while already running is a no-op.
+   */
+  start() {
+    if (this.running) return;
+    this.running = true;
+    this.timerHandle = this.timer.setInterval(() => {
+      this.tick(this.clock.now());
+    }, this.tickIntervalMs);
+  }
+  /**
+   * Stop the scheduler. All in-flight callbacks are allowed to complete
+   * (they are not aborted), but no new runs will be triggered.
+   * Calling `stop()` while not running is a no-op.
+   */
+  stop() {
+    if (!this.running) return;
+    this.running = false;
+    if (this.timerHandle !== null) {
+      this.timer.clearInterval(this.timerHandle);
+      this.timerHandle = null;
+    }
+  }
+  // ---------------------------------------------------------------------------
+  // Task management
+  // ---------------------------------------------------------------------------
+  /**
+   * Register a scheduled task. If a task with the same `id` already exists,
+   * it is replaced (the old state is discarded).
+   *
+   * For cron tasks, the first next-fire time is computed immediately from the
+   * current clock value.
+   */
+  add(task) {
+    const now = this.clock.now();
+    let nextFireAt = null;
+    if (task.schedule.kind === "cron") {
+      validateCronExpression(task.schedule.expression);
+      nextFireAt = computeNextCron(task.schedule, now, this.logger);
+    }
+    this.tasks.set(task.id, {
+      task,
+      lastFiredAt: now,
+      nextFireAt,
+      inFlight: false
+    });
+  }
+  /**
+   * Remove a registered task by id.
+   * Any in-flight callback for this task will be allowed to complete, but no
+   * further fires will occur.
+   * Returns `true` if the task was found and removed, `false` otherwise.
+   */
+  remove(id) {
+    return this.tasks.delete(id);
+  }
+  /** Returns the ids of all currently registered tasks. */
+  taskIds() {
+    return [...this.tasks.keys()];
+  }
+  // ---------------------------------------------------------------------------
+  // Tick — can be called manually in tests
+  // ---------------------------------------------------------------------------
+  /**
+   * Evaluate all registered tasks against the given timestamp and fire any
+   * that are due.
+   *
+   * This is the core scheduling method. The `start()` loop calls it
+   * automatically at `tickIntervalMs` granularity, but tests can call it
+   * directly to drive time without real timers.
+   */
+  tick(now) {
+    for (const state of this.tasks.values()) {
+      if (isDue(state, now)) {
+        this._fire(state, now);
+      }
+    }
+  }
+  // ---------------------------------------------------------------------------
+  // Internal fire
+  // ---------------------------------------------------------------------------
+  _fire(state, now) {
+    if (state.inFlight) {
+      this.logger.log("debug", "scheduler", "task skipped (overlap)", {
+        taskId: state.task.id,
+        now
+      });
+      return;
+    }
+    state.inFlight = true;
+    state.lastFiredAt = now;
+    if (state.task.schedule.kind === "cron") {
+      state.nextFireAt = computeNextCron(state.task.schedule, now, this.logger);
+    }
+    const ctx = { taskId: state.task.id, triggeredAt: now };
+    Promise.resolve().then(() => state.task.run(ctx)).catch((err) => {
+      const msg = err instanceof Error ? err.message : String(err);
+      this.logger.log("error", "scheduler", "task run failed", {
+        taskId: state.task.id,
+        error: msg,
+        stack: err instanceof Error ? err.stack : void 0
+      });
+    }).finally(() => {
+      state.inFlight = false;
+    });
+  }
+};
+function isDue(state, now) {
+  const { task } = state;
+  if (task.schedule.kind === "interval") {
+    return now >= state.lastFiredAt + task.schedule.everyMs;
+  }
+  if (state.nextFireAt === null) return false;
+  return now >= state.nextFireAt;
+}
+function validateCronExpression(expression) {
+  try {
+    CronExpressionParser.parse(expression, { tz: "UTC" });
+  } catch (err) {
+    const detail = err instanceof Error ? err.message : String(err);
+    throw new Error(
+      `Invalid cron expression "${expression}": ${detail}`
+    );
+  }
+}
+function computeNextCron(schedule, afterMs, logger) {
+  try {
+    const expr = CronExpressionParser.parse(schedule.expression, {
+      currentDate: new Date(afterMs),
+      tz: schedule.tz ?? "UTC"
+    });
+    return expr.next().getTime();
+  } catch (err) {
+    logger.log("error", "scheduler", "failed to compute next cron time", {
+      expression: schedule.expression,
+      error: err instanceof Error ? err.message : String(err)
+    });
+    return null;
+  }
+}
+
+// src/batch-runner.ts
+var ConcurrentAgentBackend = class {
+  constructor(agent) {
+    this.agent = agent;
+  }
+  agent;
+  async run(item, signal) {
+    try {
+      let finalOutput = "";
+      let finalUsage = { inputTokens: 0, outputTokens: 0 };
+      let finalCost;
+      for await (const ev of this.agent.query(item.input, {
+        sessionId: item.sessionId,
+        ...item.userId ? { userId: item.userId } : {},
+        ...item.orgId ? { orgId: item.orgId } : {},
+        signal
+      })) {
+        if (ev.type === "result") {
+          finalOutput = typeof ev.output === "string" ? ev.output : ev.output == null ? "" : String(ev.output);
+          finalUsage = ev.usage;
+          finalCost = ev.cost;
+        }
+      }
+      return {
+        status: "success",
+        id: item.id,
+        output: finalOutput,
+        usage: finalUsage,
+        cost: finalCost,
+        sessionId: item.sessionId
+      };
+    } catch (err) {
+      return {
+        status: "error",
+        id: item.id,
+        error: err instanceof Error ? err.message : String(err),
+        sessionId: item.sessionId
+      };
+    }
+  }
+};
+var BatchRunner = class {
+  concurrency;
+  backend;
+  constructor(agent, options = {}) {
+    this.concurrency = Math.max(1, options.concurrency ?? 4);
+    this.backend = options.backend ?? new ConcurrentAgentBackend(agent);
+  }
+  /**
+   * Process a list of inputs with bounded concurrency.
+   *
+   * @param items - Items to process. Each must have at least `input` set.
+   * @param opts - Run-level options (signal, progress callback, collectResults).
+   * @returns `BatchResult` containing per-item outcomes and aggregate totals.
+   *
+   * ### Large-batch tip
+   * For very large batches (thousands of items), holding all results in memory may
+   * be impractical. Pass `collectResults: false` to skip in-memory accumulation:
+   * `BatchResult.results` will be empty while `aggregate` totals remain accurate.
+   * Drain results incrementally via `onProgress` instead.
+   */
+  async run(items, opts = {}) {
+    const { signal, onProgress, collectResults = true } = opts;
+    const resolved = items.map((item, idx) => ({
+      id: item.id ?? String(idx),
+      input: item.input,
+      userId: item.userId ?? "",
+      orgId: item.orgId ?? "",
+      sessionId: item.sessionId ?? crypto.randomUUID()
+    }));
+    const results = [];
+    let cancelled = false;
+    let inlineTotalInputTokens = 0;
+    let inlineTotalOutputTokens = 0;
+    let inlineTotalUsd;
+    let inlineSuccessCount = 0;
+    let inlineErrorCount = 0;
+    if (resolved.length === 0) {
+      return { results, aggregate: computeAggregate(results, cancelled) };
+    }
+    let nextIndex = 0;
+    const processOne = async () => {
+      while (true) {
+        if (signal?.aborted) {
+          cancelled = true;
+          return;
+        }
+        const idx = nextIndex;
+        if (idx >= resolved.length) return;
+        nextIndex++;
+        const item = resolved[idx];
+        const itemSignal = signal ?? new AbortController().signal;
+        let result;
+        try {
+          result = await this.backend.run(item, itemSignal);
+        } catch (err) {
+          result = {
+            status: "error",
+            id: item.id,
+            error: err instanceof Error ? err.message : String(err),
+            sessionId: item.sessionId
+          };
+        }
+        if (collectResults) {
+          results.push(result);
+        } else {
+          if (result.status === "success") {
+            inlineSuccessCount++;
+            inlineTotalInputTokens += result.usage.inputTokens;
+            inlineTotalOutputTokens += result.usage.outputTokens;
+            if (result.cost?.usd !== void 0) {
+              inlineTotalUsd = (inlineTotalUsd ?? 0) + result.cost.usd;
+            }
+          } else {
+            inlineErrorCount++;
+          }
+        }
+        onProgress?.(result);
+      }
+    };
+    const lanes = Array.from(
+      { length: Math.min(this.concurrency, resolved.length) },
+      () => processOne()
+    );
+    await Promise.all(lanes);
+    if (signal?.aborted) cancelled = true;
+    if (collectResults) {
+      return { results, aggregate: computeAggregate(results, cancelled) };
+    }
+    return {
+      results,
+      aggregate: {
+        totalUsage: { inputTokens: inlineTotalInputTokens, outputTokens: inlineTotalOutputTokens },
+        ...inlineTotalUsd !== void 0 ? { totalUsd: inlineTotalUsd } : {},
+        successCount: inlineSuccessCount,
+        errorCount: inlineErrorCount,
+        cancelled
+      }
+    };
+  }
+};
+function computeAggregate(results, cancelled) {
+  let totalInputTokens = 0;
+  let totalOutputTokens = 0;
+  let totalUsd;
+  let successCount = 0;
+  let errorCount = 0;
+  for (const r of results) {
+    if (r.status === "success") {
+      successCount++;
+      totalInputTokens += r.usage.inputTokens;
+      totalOutputTokens += r.usage.outputTokens;
+      if (r.cost?.usd !== void 0) {
+        totalUsd = (totalUsd ?? 0) + r.cost.usd;
+      }
+    } else {
+      errorCount++;
+    }
+  }
+  return {
+    totalUsage: { inputTokens: totalInputTokens, outputTokens: totalOutputTokens },
+    ...totalUsd !== void 0 ? { totalUsd } : {},
+    successCount,
+    errorCount,
+    cancelled
+  };
+}
+
+// src/index.ts
+import { WorkflowRunError as WorkflowRunError2 } from "@eidentic/workflow";
+var AsyncRunRegistry = class {
+  runs = /* @__PURE__ */ new Map();
+  maxRuns;
+  constructor(options) {
+    this.maxRuns = options?.maxRuns ?? 1e3;
+  }
+  set(entry) {
+    if (this.runs.size >= this.maxRuns) {
+      this._evictOldestSettled();
+    }
+    this.runs.set(entry.runId, entry);
+  }
+  get(runId) {
+    return this.runs.get(runId);
+  }
+  settle(runId, patch) {
+    const entry = this.runs.get(runId);
+    if (entry) {
+      Object.assign(entry, patch, { settledAt: Date.now() });
+    }
+  }
+  /** Evict the single oldest settled (non-in-flight) entry to make room. */
+  _evictOldestSettled() {
+    let oldestId;
+    let oldestAt = Infinity;
+    for (const [id, e] of this.runs) {
+      if (e.status !== "running" && e.createdAt < oldestAt) {
+        oldestAt = e.createdAt;
+        oldestId = id;
+      }
+    }
+    if (oldestId !== void 0) {
+      this.runs.delete(oldestId);
+    }
+  }
+  /** Return all entries (copy of values). Used by graceful drain to check in-flight count. */
+  values() {
+    return [...this.runs.values()];
+  }
+};
+var NoAuth = {
+  authenticate(_req) {
+    return {};
+  }
+};
+function ApiKeyAuth(keys) {
+  return {
+    authenticate(req) {
+      const authHeader = req.headers["authorization"];
+      const xApiKey = req.headers["x-api-key"];
+      let key;
+      if (authHeader?.startsWith("Bearer ")) {
+        key = authHeader.slice(7);
+      } else if (xApiKey) {
+        key = xApiKey;
+      }
+      if (!key) return null;
+      if (!Object.hasOwn(keys, key)) return null;
+      return keys[key] ?? null;
+    }
+  };
+}
+function makeResolver(agents) {
+  if (typeof agents === "function") return agents;
+  return (id) => agents[id];
+}
+async function runAuth(auth, req) {
+  const headers = {};
+  req.headers.forEach((value, key) => {
+    headers[key.toLowerCase()] = value;
+  });
+  const url = new URL(req.url);
+  const authReq = {
+    method: req.method,
+    path: url.pathname,
+    headers
+  };
+  return auth.authenticate(authReq);
+}
+var BODY_LIMIT = 512 * 1024;
+var STREAM_EVENT_TYPES_THAT_PERSIST = /* @__PURE__ */ new Set([
+  "assistant",
+  "tool.result",
+  "compaction"
+]);
+function makeSseIdTracker(baseSeq) {
+  let next = baseSeq;
+  return {
+    idForSessionInit() {
+      return String(next);
+    },
+    idForPersistedEvent() {
+      next += 1;
+      return String(next);
+    },
+    currentId() {
+      return String(next);
+    }
+  };
+}
+function synthesizeResultFromStore(storedEvents, sessionId) {
+  for (let i = storedEvents.length - 1; i >= 0; i--) {
+    const ev = storedEvents[i];
+    if (ev.kind === "assistant") {
+      const payload = ev.payload;
+      const content = payload.content ?? [];
+      const hasToolUse = content.some((b) => b.type === "tool_use");
+      if (hasToolUse) {
+        return null;
+      }
+      const text = content.filter((b) => b.type === "text").map((b) => b.text).join("");
+      const usage = ev.meta?.usage ?? {
+        inputTokens: 0,
+        outputTokens: 0
+      };
+      return {
+        type: "result",
+        subtype: "success",
+        output: text,
+        usage,
+        numTurns: storedEvents.filter((e) => e.kind === "assistant").length,
+        sessionId
+      };
+    }
+    if (ev.kind === "suspension") {
+      return null;
+    }
+  }
+  return null;
+}
+function storedEventToStreamPayload(ev) {
+  switch (ev.kind) {
+    case "assistant": {
+      const payload = ev.payload;
+      return { type: "assistant", content: payload.content ?? [] };
+    }
+    case "tool_result": {
+      const payload = ev.payload;
+      return {
+        type: "tool.result",
+        callId: payload.callId,
+        toolName: payload.toolName,
+        output: payload.output,
+        isError: false
+      };
+    }
+    case "compaction": {
+      const payload = ev.payload;
+      return {
+        type: "compaction",
+        sessionId: ev.sessionId,
+        before: payload.before,
+        after: payload.after,
+        stages: payload.stages
+      };
+    }
+    // "user", "checkpoint", "tool_call", "suspension" — not replayed
+    default:
+      return null;
+  }
+}
+function assertCallbackUrl(rawUrl, allowPrivateHosts) {
+  let parsed;
+  try {
+    parsed = new URL(rawUrl);
+  } catch {
+    throw new Error("Invalid callbackUrl");
+  }
+  if (parsed.protocol !== "http:" && parsed.protocol !== "https:") {
+    throw new Error("callbackUrl must use http or https");
+  }
+  if (!allowPrivateHosts && isCallbackHostBlocked(parsed.hostname)) {
+    throw new Error("callbackUrl resolves to a blocked private/loopback/metadata host");
+  }
+  return parsed;
+}
+function isCallbackHostBlocked(host) {
+  const h = host.startsWith("[") && host.endsWith("]") ? host.slice(1, -1) : host;
+  if (h.toLowerCase() === "localhost") return true;
+  const v4 = /^(\d{1,3})\.(\d{1,3})\.(\d{1,3})\.(\d{1,3})$/.exec(h);
+  if (v4) {
+    const a = Number(v4[1]), b = Number(v4[2]);
+    if (a === 0 || a === 127 || a === 10) return true;
+    if (a === 172 && b >= 16 && b <= 31) return true;
+    if (a === 192 && b === 168) return true;
+    if (a === 169 && b === 254) return true;
+    return false;
+  }
+  let ndInt;
+  if (/^0x[0-9a-fA-F]+$/.test(h)) ndInt = parseInt(h, 16) >>> 0;
+  else if (/^\d+$/.test(h)) {
+    const n = Number(h);
+    if (!isNaN(n) && n >= 0 && n <= 4294967295) ndInt = n >>> 0;
+  } else if (/^0[0-7]+$/.test(h)) ndInt = parseInt(h, 8) >>> 0;
+  if (ndInt !== void 0) {
+    const a = ndInt >>> 24 & 255, b = ndInt >>> 16 & 255;
+    if (a === 0 || a === 127 || a === 10) return true;
+    if (a === 172 && b >= 16 && b <= 31) return true;
+    if (a === 192 && b === 168) return true;
+    if (a === 169 && b === 254) return true;
+    return false;
+  }
+  let v6 = h.toLowerCase();
+  const pct = v6.indexOf("%");
+  if (pct !== -1) v6 = v6.slice(0, pct);
+  const mapD = /^::(?:ffff:)?(\d{1,3})\.(\d{1,3})\.(\d{1,3})\.(\d{1,3})$/.exec(v6);
+  if (mapD) {
+    const a = Number(mapD[1]), b = Number(mapD[2]);
+    const n = (Number(mapD[1]) << 24 | Number(mapD[2]) << 16 | Number(mapD[3]) << 8 | Number(mapD[4])) >>> 0;
+    const aa = n >>> 24 & 255, bb = n >>> 16 & 255;
+    if (aa === 0 || aa === 127 || aa === 10) return true;
+    if (aa === 172 && bb >= 16 && bb <= 31) return true;
+    if (aa === 192 && bb === 168) return true;
+    if (aa === 169 && bb === 254) return true;
+    void a;
+    void b;
+    return false;
+  }
+  const mapH = /^::ffff:([0-9a-f]{1,4}):([0-9a-f]{1,4})$/.exec(v6);
+  if (mapH) {
+    const n = (parseInt(mapH[1] ?? "0", 16) << 16 | parseInt(mapH[2] ?? "0", 16)) >>> 0;
+    const a = n >>> 24 & 255, b = n >>> 16 & 255;
+    if (a === 0 || a === 127 || a === 10) return true;
+    if (a === 172 && b >= 16 && b <= 31) return true;
+    if (a === 192 && b === 168) return true;
+    if (a === 169 && b === 254) return true;
+    return false;
+  }
+  if (v6 === "::" || v6 === "::1") return true;
+  if (/^f[cd][0-9a-f]{0,2}(:|$)/.test(v6)) return true;
+  if (/^fe[89ab][0-9a-f]?(:|$)/.test(v6)) return true;
+  return false;
+}
+async function deliverWebhook(callbackUrl, payload, signingSecret, logger) {
+  const body = JSON.stringify(payload);
+  const timestamp = String(Date.now());
+  const message = timestamp + "." + body;
+  const enc = new TextEncoder();
+  const key = await crypto.subtle.importKey(
+    "raw",
+    enc.encode(signingSecret),
+    { name: "HMAC", hash: "SHA-256" },
+    false,
+    ["sign"]
+  );
+  const sig = await crypto.subtle.sign("HMAC", key, enc.encode(message));
+  const hexSig = Array.from(new Uint8Array(sig)).map((b) => b.toString(16).padStart(2, "0")).join("");
+  const signature = `sha256=${hexSig}`;
+  const delays = [0, 1e3, 2e3];
+  for (let attempt = 0; attempt < delays.length; attempt++) {
+    if (attempt > 0) {
+      await new Promise((r) => setTimeout(r, delays[attempt]));
+    }
+    try {
+      const controller = new AbortController();
+      const timer = setTimeout(() => controller.abort(), 1e4);
+      try {
+        const res = await fetch(callbackUrl, {
+          method: "POST",
+          headers: {
+            "content-type": "application/json",
+            "X-Eidentic-Signature": signature,
+            "X-Eidentic-Timestamp": timestamp
+          },
+          body,
+          signal: controller.signal,
+          // Never follow redirects
+          redirect: "manual"
+        });
+        clearTimeout(timer);
+        if (res.status >= 200 && res.status < 300) return;
+        logger.error(`[eidentic/server] webhook delivery attempt ${attempt + 1} failed: HTTP ${res.status} for ${callbackUrl}`);
+      } finally {
+        clearTimeout(timer);
+      }
+    } catch (err) {
+      logger.error(`[eidentic/server] webhook delivery attempt ${attempt + 1} error:`, err);
+    }
+  }
+  logger.error(`[eidentic/server] webhook delivery exhausted retries for ${callbackUrl}`);
+}
+var DEFAULT_PRE_AUTH_CAPACITY = 60;
+var DEFAULT_PRE_AUTH_REFILL_PER_SEC = 1;
+function defaultGetClientKey(c, trustProxy) {
+  if (trustProxy) {
+    const xff = c.req.header("x-forwarded-for");
+    if (xff) {
+      const first = xff.split(",")[0]?.trim();
+      if (first) return first;
+    }
+  }
+  const incoming = c.env?.["incoming"];
+  return incoming?.socket?.remoteAddress ?? "unknown";
+}
+function createServer(opts) {
+  const resolve = makeResolver(opts.agents);
+  const auth = opts.auth ?? NoAuth;
+  const defaultKey = (p, _agentId) => p.apiKey ?? p.userId ?? p.orgId ?? "anonymous";
+  const getRateLimitKey = opts.rateLimitKey ?? defaultKey;
+  const getQuotaKey = opts.quotaKey ?? defaultKey;
+  const maxInputChars = opts.maxInputChars ?? 32e3;
+  const quota = opts.quota;
+  const preAuthLimiter = opts.preAuthRateLimiter === null ? null : opts.preAuthRateLimiter ?? new InMemoryTokenBucketLimiter({
+    capacity: DEFAULT_PRE_AUTH_CAPACITY,
+    refillPerSec: DEFAULT_PRE_AUTH_REFILL_PER_SEC
+  });
+  const trustProxy = opts.trustProxy ?? false;
+  const getClientKey = opts.getClientKey ? opts.getClientKey : (c) => defaultGetClientKey(c, trustProxy);
+  let _draining = false;
+  const app = new Hono({ strict: true });
+  const base = opts.basePath ?? "";
+  const r = base ? app.basePath(base) : app;
+  if (opts.cors !== void 0) {
+    r.use("*", cors(opts.cors));
+  }
+  r.use("*", async (c, next) => {
+    await next();
+    c.header("X-Content-Type-Options", "nosniff");
+  });
+  r.use("/v1/*", async (c, next) => {
+    if (_draining) {
+      c.header("Retry-After", "5");
+      return c.json({ error: "service_draining" }, 503);
+    }
+    await next();
+  });
+  if (preAuthLimiter !== null) {
+    r.use("/v1/*", async (c, next) => {
+      const clientKey = getClientKey(c);
+      const rl = await preAuthLimiter.acquire(clientKey);
+      if (!rl.ok) {
+        c.header("X-Content-Type-Options", "nosniff");
+        const retryAfterSec = rl.retryAfterMs !== void 0 ? Math.ceil(rl.retryAfterMs / 1e3) : void 0;
+        if (retryAfterSec !== void 0) {
+          c.header("Retry-After", String(retryAfterSec));
+        }
+        return c.json({ error: "rate_limited", retryAfterMs: rl.retryAfterMs }, 429);
+      }
+      await next();
+    });
+  }
+  const asyncRuns = new AsyncRunRegistry({ maxRuns: opts.maxAsyncRuns });
+  const workflowRuns = opts.workflowRuns ?? createWorkflowRunRegistry();
+  const _setDraining = (v) => {
+    _draining = v;
+  };
+  const _getAsyncRuns = () => asyncRuns;
+  r.get("/health", (c) => c.json({ ok: true }));
+  function checkOwnership(session, principal) {
+    const sessionOwned = session.userId !== void 0 || session.orgId !== void 0 || session.apiKey !== void 0;
+    if (!sessionOwned) return true;
+    if (session.userId !== void 0 && principal.userId === session.userId) return true;
+    if (session.orgId !== void 0 && principal.orgId === session.orgId) return true;
+    if (session.apiKey !== void 0 && principal.apiKey === session.apiKey) return true;
+    return false;
+  }
+  async function runAgentStream(c, agent, agentId, principal, sessionId, getIterable, logTag, emitSessionComment) {
+    const rawLastEventId = c.req.header("last-event-id");
+    let lastEventId;
+    if (rawLastEventId !== void 0) {
+      const parsed = parseInt(rawLastEventId, 10);
+      if (isNaN(parsed) || parsed < 0 || !Number.isSafeInteger(parsed)) {
+        return c.json({ error: "Invalid Last-Event-ID: must be a non-negative integer" }, 400);
+      }
+      lastEventId = parsed;
+    }
+    const hasLastEventId = lastEventId !== void 0;
+    let streamQuotaKey;
+    let streamQuotaReservation;
+    if (quota) {
+      streamQuotaKey = getQuotaKey(principal, agentId);
+      const qc = await quota.check(streamQuotaKey);
+      if (!qc.ok) {
+        return c.json({ error: "quota_exceeded", reason: qc.reason, usage: qc.usage }, 402);
+      }
+      if (qc.warn) c.header("X-Eidentic-Quota-Warning", "soft-limit");
+      streamQuotaReservation = qc.reservation;
+    }
+    const signal = c.req.raw.signal ?? new AbortController().signal;
+    return streamSSE(c, async (stream) => {
+      if (emitSessionComment) {
+        await stream.writeln(`: session=${sessionId.replace(/[\r\n]/g, "")}`);
+      }
+      let storedEventsCache = null;
+      if (hasLastEventId) {
+        const storedEvents = await agent.store.readEvents(sessionId);
+        storedEventsCache = storedEvents;
+        const toReplay = storedEvents.filter((e) => e.seq > lastEventId);
+        for (const ev of toReplay) {
+          if (signal.aborted) break;
+          const payload = storedEventToStreamPayload(ev);
+          if (payload !== null) {
+            await stream.writeSSE({
+              event: payload["type"],
+              data: JSON.stringify(payload),
+              id: String(ev.seq)
+            });
+          }
+        }
+        const syntheticResult = synthesizeResultFromStore(storedEvents, sessionId);
+        if (syntheticResult !== null) {
+          await stream.writeSSE({
+            event: "result",
+            data: JSON.stringify(syntheticResult)
+          });
+          if (quota && streamQuotaReservation !== void 0) {
+            quota.release?.(streamQuotaReservation);
+          }
+          return;
+        }
+      }
+      const existingEvents = storedEventsCache ?? await agent.store.readEvents(sessionId);
+      const baseSeq = existingEvents.length === 0 ? 0 : existingEvents[existingEvents.length - 1].seq + 1;
+      const idTracker = makeSseIdTracker(baseSeq);
+      let terminalResult;
+      try {
+        for await (const ev of getIterable()) {
+          if (signal.aborted) break;
+          if (ev.type === "session.init") {
+            await stream.writeSSE({
+              event: ev.type,
+              data: JSON.stringify(ev),
+              id: idTracker.idForSessionInit()
+            });
+          } else if (STREAM_EVENT_TYPES_THAT_PERSIST.has(ev.type)) {
+            await stream.writeSSE({
+              event: ev.type,
+              data: JSON.stringify(ev),
+              id: idTracker.idForPersistedEvent()
+            });
+          } else {
+            let payload = ev;
+            if (ev.type === "result" && ev.subtype === "error") {
+              console.error(`[eidentic/server] ${logTag} run error:`, ev.output);
+              payload = { ...ev, output: "Agent run failed" };
+            }
+            await stream.writeSSE({ event: ev.type, data: JSON.stringify(payload) });
+          }
+          if (ev.type === "result") {
+            terminalResult = { usage: ev.usage, cost: ev.cost };
+          }
+        }
+      } catch (err) {
+        if (quota && streamQuotaReservation !== void 0) {
+          quota.release?.(streamQuotaReservation);
+          streamQuotaReservation = void 0;
+        }
+        if (!signal.aborted) {
+          console.error(`[eidentic/server] ${logTag} error:`, err);
+          await stream.writeSSE({
+            event: "result",
+            data: JSON.stringify({
+              type: "result",
+              subtype: "error",
+              output: "Agent run failed",
+              usage: { inputTokens: 0, outputTokens: 0 },
+              numTurns: 0,
+              sessionId
+            })
+          });
+        }
+      }
+      if (quota && streamQuotaKey !== void 0 && terminalResult) {
+        const tokens = terminalResult.usage.inputTokens + terminalResult.usage.outputTokens;
+        const usd = terminalResult.cost?.usd ?? 0;
+        await quota.record(streamQuotaKey, { usd, tokens }, streamQuotaReservation);
+      } else if (quota && streamQuotaReservation !== void 0 && !terminalResult) {
+        quota.release?.(streamQuotaReservation);
+      }
+    });
+  }
+  async function checkPostAuthRateLimit(c, principal, agentId) {
+    if (!opts.rateLimiter) return null;
+    const baseKey = getRateLimitKey(principal, agentId);
+    const rlKey = baseKey === "anonymous" ? `anon:${getClientKey(c)}` : baseKey;
+    const rl = await opts.rateLimiter.acquire(rlKey);
+    if (!rl.ok) {
+      const retryAfterSec = rl.retryAfterMs !== void 0 ? Math.ceil(rl.retryAfterMs / 1e3) : void 0;
+      if (retryAfterSec !== void 0) c.header("Retry-After", String(retryAfterSec));
+      return c.json({ error: "rate_limited", retryAfterMs: rl.retryAfterMs }, 429);
+    }
+    return null;
+  }
+  r.post(
+    "/v1/agents/:agentId/query",
+    bodyLimit({ maxSize: BODY_LIMIT }),
+    async (c) => {
+      const principal = await runAuth(auth, c.req.raw);
+      if (principal === null) return c.json({ error: "Unauthorized" }, 401);
+      const agentId = c.req.param("agentId");
+      const rlErr = await checkPostAuthRateLimit(c, principal, agentId);
+      if (rlErr) return rlErr;
+      let body;
+      try {
+        body = await c.req.json();
+      } catch {
+        return c.json({ error: "Invalid JSON body" }, 400);
+      }
+      if (typeof body !== "object" || body === null || typeof body["input"] !== "string" || body["input"] === "") {
+        return c.json({ error: "Missing or invalid 'input' field" }, 400);
+      }
+      const { input, sessionId: bodySessionId } = body;
+      if (input.length > maxInputChars) {
+        return c.json({ error: `Input exceeds maximum length of ${maxInputChars} characters` }, 400);
+      }
+      const agent = resolve(agentId);
+      if (!agent) {
+        return c.json({ error: "Not found" }, 404);
+      }
+      const sessionId = typeof bodySessionId === "string" && bodySessionId.length > 0 ? bodySessionId : crypto.randomUUID();
+      if (typeof bodySessionId === "string" && bodySessionId.length > 0) {
+        const sessionRecord = await agent.store.getSession(bodySessionId);
+        if (sessionRecord && !checkOwnership(sessionRecord, principal)) {
+          return c.json({ error: "Forbidden" }, 403);
+        }
+      }
+      return runAgentStream(
+        c,
+        agent,
+        agentId,
+        principal,
+        sessionId,
+        () => agent.query(input, {
+          sessionId,
+          userId: principal.userId,
+          orgId: principal.orgId,
+          // H1 fix: pass apiKey so apiKey-only principals own their sessions.
+          apiKey: principal.apiKey,
+          signal: c.req.raw.signal ?? new AbortController().signal
+        }),
+        "agent.query",
+        /* emitSessionComment */
+        true
+      );
+    }
+  );
+  r.post(
+    "/v1/agents/:agentId/resume",
+    bodyLimit({ maxSize: BODY_LIMIT }),
+    async (c) => {
+      const principal = await runAuth(auth, c.req.raw);
+      if (principal === null) return c.json({ error: "Unauthorized" }, 401);
+      const agentId = c.req.param("agentId");
+      const rlErr = await checkPostAuthRateLimit(c, principal, agentId);
+      if (rlErr) return rlErr;
+      let body;
+      try {
+        body = await c.req.json();
+      } catch {
+        return c.json({ error: "Invalid JSON body" }, 400);
+      }
+      if (typeof body !== "object" || body === null || typeof body["sessionId"] !== "string" || body["sessionId"] === "") {
+        return c.json({ error: "Missing or invalid 'sessionId' field" }, 400);
+      }
+      const rawDecision = body["decision"];
+      if (typeof rawDecision === "string" && rawDecision.length > maxInputChars) {
+        return c.json({ error: `Decision input exceeds maximum length of ${maxInputChars} characters` }, 400);
+      }
+      const { sessionId, decision } = body;
+      const agent = resolve(agentId);
+      if (!agent) {
+        return c.json({ error: "Not found" }, 404);
+      }
+      const sessionRecord = await agent.store.getSession(sessionId);
+      if (sessionRecord && !checkOwnership(sessionRecord, principal)) {
+        return c.json({ error: "Forbidden" }, 403);
+      }
+      return runAgentStream(
+        c,
+        agent,
+        agentId,
+        principal,
+        sessionId,
+        () => agent.resume(sessionId, {
+          userId: principal.userId,
+          orgId: principal.orgId,
+          decision,
+          signal: c.req.raw.signal ?? new AbortController().signal
+        }),
+        "agent.resume",
+        /* emitSessionComment */
+        false
+      );
+    }
+  );
+  r.post(
+    "/v1/agents/:agentId/runs",
+    bodyLimit({ maxSize: BODY_LIMIT }),
+    async (c) => {
+      const principal = await runAuth(auth, c.req.raw);
+      if (principal === null) return c.json({ error: "Unauthorized" }, 401);
+      const agentId = c.req.param("agentId");
+      const rlErr = await checkPostAuthRateLimit(c, principal, agentId);
+      if (rlErr) return rlErr;
+      let body;
+      try {
+        body = await c.req.json();
+      } catch {
+        return c.json({ error: "Invalid JSON body" }, 400);
+      }
+      if (typeof body !== "object" || body === null || typeof body["input"] !== "string" || body["input"] === "") {
+        return c.json({ error: "Missing or invalid 'input' field" }, 400);
+      }
+      const { input, sessionId: bodySessionId, callbackUrl: rawCallbackUrl } = body;
+      if (input.length > maxInputChars) {
+        return c.json({ error: `Input exceeds maximum length of ${maxInputChars} characters` }, 400);
+      }
+      let validatedCallbackUrl;
+      if (rawCallbackUrl !== void 0) {
+        if (!opts.webhooks) {
+          return c.json({ error: "Webhook callbacks are not configured on this server" }, 400);
+        }
+        if (typeof rawCallbackUrl !== "string" || rawCallbackUrl.length === 0) {
+          return c.json({ error: "callbackUrl must be a non-empty string" }, 400);
+        }
+        try {
+          const u = assertCallbackUrl(rawCallbackUrl, opts.webhooks.allowPrivateHosts ?? false);
+          validatedCallbackUrl = u.href;
+        } catch (err) {
+          return c.json({ error: err instanceof Error ? err.message : "Invalid callbackUrl" }, 400);
+        }
+      }
+      const agent = resolve(agentId);
+      if (!agent) {
+        return c.json({ error: "Not found" }, 404);
+      }
+      const sessionId = typeof bodySessionId === "string" && bodySessionId.length > 0 ? bodySessionId : crypto.randomUUID();
+      if (typeof bodySessionId === "string" && bodySessionId.length > 0) {
+        const sessionRecord = await agent.store.getSession(bodySessionId);
+        if (sessionRecord && !checkOwnership(sessionRecord, principal)) {
+          return c.json({ error: "Forbidden" }, 403);
+        }
+      }
+      let asyncQuotaKey;
+      let asyncQuotaReservation;
+      if (quota) {
+        asyncQuotaKey = getQuotaKey(principal, agentId);
+        const qc = await quota.check(asyncQuotaKey);
+        if (!qc.ok) {
+          return c.json({ error: "quota_exceeded", reason: qc.reason, usage: qc.usage }, 402);
+        }
+        asyncQuotaReservation = qc.reservation;
+      }
+      const runId = crypto.randomUUID();
+      asyncRuns.set({
+        runId,
+        sessionId,
+        agentId,
+        status: "running",
+        owner: {
+          userId: principal.userId,
+          orgId: principal.orgId,
+          apiKey: principal.apiKey
+        },
+        createdAt: Date.now()
+      });
+      (async () => {
+        let terminalOutput;
+        let terminalError;
+        let terminalUsage;
+        let terminalResult;
+        let localReservation = asyncQuotaReservation;
+        try {
+          for await (const ev of agent.query(input, {
+            sessionId,
+            userId: principal.userId,
+            orgId: principal.orgId
+          })) {
+            if (ev.type === "result") {
+              terminalResult = { usage: ev.usage, cost: ev.cost };
+              terminalUsage = ev.usage;
+              if (ev.subtype === "success") {
+                terminalOutput = typeof ev.output === "string" ? ev.output : ev.output !== void 0 ? String(ev.output) : void 0;
+              } else if (ev.subtype === "error") {
+                terminalError = typeof ev.output === "string" ? ev.output : ev.output !== void 0 ? String(ev.output) : void 0;
+              }
+            }
+          }
+          if (quota && asyncQuotaKey !== void 0 && terminalResult) {
+            const tokens = terminalResult.usage.inputTokens + terminalResult.usage.outputTokens;
+            const usd = terminalResult.cost?.usd ?? 0;
+            await quota.record(asyncQuotaKey, { usd, tokens }, localReservation);
+            localReservation = void 0;
+          }
+          const finalStatus = terminalError ? "failed" : "completed";
+          asyncRuns.settle(runId, {
+            status: finalStatus,
+            output: terminalOutput,
+            error: terminalError
+          });
+          if (validatedCallbackUrl && opts.webhooks) {
+            const webhookPayload = {
+              runId,
+              agentId,
+              status: finalStatus,
+              ...terminalOutput !== void 0 ? { output: terminalOutput } : {},
+              ...terminalError !== void 0 ? { error: terminalError } : {},
+              ...terminalUsage !== void 0 ? { usage: terminalUsage } : {}
+            };
+            void deliverWebhook(validatedCallbackUrl, webhookPayload, opts.webhooks.signingSecret, console);
+          }
+        } catch (err) {
+          if (quota && localReservation !== void 0) {
+            quota.release?.(localReservation);
+            localReservation = void 0;
+          }
+          const msg = err instanceof Error ? err.message : String(err);
+          asyncRuns.settle(runId, { status: "failed", error: msg });
+          if (validatedCallbackUrl && opts.webhooks) {
+            const webhookPayload = {
+              runId,
+              agentId,
+              status: "failed",
+              error: msg,
+              ...terminalUsage !== void 0 ? { usage: terminalUsage } : {}
+            };
+            void deliverWebhook(validatedCallbackUrl, webhookPayload, opts.webhooks.signingSecret, console);
+          }
+        } finally {
+          if (quota && localReservation !== void 0 && !terminalResult) {
+            quota.release?.(localReservation);
+          }
+        }
+      })();
+      return c.json({ runId, sessionId, status: "running" }, 202);
+    }
+  );
+  r.get("/v1/agents/:agentId/runs/:runId/status", async (c) => {
+    const principal = await runAuth(auth, c.req.raw);
+    if (principal === null) {
+      return c.json({ error: "Unauthorized" }, 401);
+    }
+    const agentId = c.req.param("agentId");
+    const agent = resolve(agentId);
+    if (!agent) {
+      return c.json({ error: "Not found" }, 404);
+    }
+    const runId = c.req.param("runId");
+    const entry = asyncRuns.get(runId);
+    if (!entry) {
+      return c.json({ error: "Not found" }, 404);
+    }
+    const ownerMatches = entry.owner.userId !== void 0 && entry.owner.userId === principal.userId || entry.owner.orgId !== void 0 && entry.owner.orgId === principal.orgId || entry.owner.apiKey !== void 0 && entry.owner.apiKey === principal.apiKey || // NoAuth / anonymous: allow if owner has no identifying fields set
+    entry.owner.userId === void 0 && entry.owner.orgId === void 0 && entry.owner.apiKey === void 0;
+    if (!ownerMatches) {
+      return c.json({ error: "Forbidden" }, 403);
+    }
+    const response = {
+      runId: entry.runId,
+      sessionId: entry.sessionId,
+      status: entry.status
+    };
+    if (entry.output !== void 0) response["output"] = entry.output;
+    if (entry.error !== void 0) response["error"] = entry.error;
+    if (entry.settledAt !== void 0) response["settledAt"] = entry.settledAt;
+    return c.json(response, 200);
+  });
+  if (opts.exposeEvents === true) {
+    r.get("/v1/agents/:agentId/sessions/:sessionId/events", async (c) => {
+      const principal = await runAuth(auth, c.req.raw);
+      if (principal === null) {
+        return c.json({ error: "Unauthorized" }, 401);
+      }
+      const agentId = c.req.param("agentId");
+      const agent = resolve(agentId);
+      if (!agent) {
+        return c.json({ error: "Not found" }, 404);
+      }
+      const sessionId = c.req.param("sessionId");
+      const sessionRecord = await agent.store.getSession(sessionId);
+      if (sessionRecord && !checkOwnership(sessionRecord, principal)) {
+        return c.json({ error: "Forbidden" }, 403);
+      }
+      const events = await agent.store.readEvents(sessionId);
+      return c.json({ events });
+    });
+  }
+  function checkWorkflowOwnership(rec, principal) {
+    const owner = rec.owner;
+    if (owner === void 0) return true;
+    const hasAnyOwner = owner.userId !== void 0 || owner.orgId !== void 0 || owner.apiKey !== void 0;
+    if (!hasAnyOwner) return true;
+    if (owner.userId !== void 0 && principal.userId === owner.userId) return true;
+    if (owner.orgId !== void 0 && principal.orgId === owner.orgId) return true;
+    if (owner.apiKey !== void 0 && principal.apiKey === owner.apiKey) return true;
+    return false;
+  }
+  r.get("/v1/workflows", async (c) => {
+    const principal = await runAuth(auth, c.req.raw);
+    if (principal === null) {
+      return c.json({ error: "Unauthorized" }, 401);
+    }
+    const summaries = workflowRuns.list().filter((rec) => checkWorkflowOwnership(rec, principal)).map((rec) => ({
+      id: rec.id,
+      name: rec.name,
+      status: rec.status,
+      startedAt: rec.startedAt,
+      durationMs: rec.durationMs,
+      stepCount: rec.stepCount
+    }));
+    return c.json(summaries, 200);
+  });
+  r.get("/v1/workflows/:id", async (c) => {
+    const principal = await runAuth(auth, c.req.raw);
+    if (principal === null) {
+      return c.json({ error: "Unauthorized" }, 401);
+    }
+    const id = c.req.param("id");
+    const rec = workflowRuns.get(id);
+    if (!rec || !checkWorkflowOwnership(rec, principal)) {
+      return c.json({ error: "Not found" }, 404);
+    }
+    const detail = {
+      id: rec.id,
+      name: rec.name,
+      status: rec.status,
+      startedAt: rec.startedAt,
+      durationMs: rec.durationMs,
+      stepCount: rec.stepCount,
+      trace: rec.trace,
+      ...rec.output !== void 0 ? { output: rec.output } : {},
+      ...rec.error !== void 0 ? { error: rec.error } : {}
+    };
+    return c.json(detail, 200);
+  });
+  const handle = {
+    recordWorkflow(name, result, owner, opts2) {
+      const rec = workflowRuns.record(name, result, owner, opts2);
+      return rec.id;
+    },
+    recordWorkflowError(err, owner, opts2) {
+      const msg = err.cause instanceof Error ? err.cause.message : String(err.cause ?? err.message);
+      const rec = workflowRuns.recordError(err.workflowName, err.trace, msg, owner, opts2);
+      return rec.id;
+    }
+  };
+  Object.defineProperties(app, {
+    _setDraining: { value: _setDraining, enumerable: false, writable: false },
+    _getAsyncRuns: { value: _getAsyncRuns, enumerable: false, writable: false }
+  });
+  return Object.assign(app, { handle });
+}
+async function serveNode(app, opts) {
+  let nodeServer;
+  try {
+    nodeServer = await import("./dist-VXER5V4E.js");
+  } catch {
+    throw new Error(
+      "@hono/node-server is not installed. Run `pnpm add @hono/node-server` (or npm/yarn) in your project to use serveNode()."
+    );
+  }
+  const port = opts?.port ?? 3e3;
+  const server = nodeServer.serve({ fetch: app.fetch, port });
+  const _setDraining = app._setDraining;
+  const _getAsyncRuns = app._getAsyncRuns;
+  return {
+    close() {
+      server.close();
+    },
+    async drain(timeoutMs = 3e4) {
+      if (_setDraining) _setDraining(true);
+      await new Promise((resolve) => server.close(() => resolve()));
+      const deadline = Date.now() + timeoutMs;
+      while (Date.now() < deadline) {
+        if (_getAsyncRuns) {
+          const running = _getAsyncRuns().values().filter((e) => e.status === "running");
+          if (running.length === 0) break;
+        } else {
+          break;
+        }
+        await new Promise((r) => setTimeout(r, 100));
+      }
+    }
+  };
+}
+export {
+  ApiKeyAuth,
+  AsyncRunRegistry,
+  BatchRunner,
+  InMemoryQuota,
+  InMemoryTokenBucketLimiter,
+  NoAuth,
+  Scheduler,
+  WorkflowRunError2 as WorkflowRunError,
+  createServer,
+  serveNode,
+  toUIMessageStream,
+  toUIMessageStreamResponse
+};