opencode-plugboard 0.13.0 → 0.15.0

package/src/runtime.ts

@@ -24,7 +24,9 @@
  *     limits (src/session/prune.ts). Both start from request handling (the store's `register`);
  *  - the metrics registry (src/metrics.ts) and the runtime start time, so counters and uptime
  *     outlive any one generation. `processMetrics` / `processStatus` read them for `/metrics`,
- *     `/v1/status` and the discovery pages.
+ *     `/v1/status` and the discovery pages;
+ *   - the request limiter's queues and rate windows (src/limits.ts), so a cap holds across
+ *     generations. `processLimits` reads them.
  *
  * Registration is explicit: `registerGeneration` returns whether the generation was accepted. A
  * rejected one (different `listen`, options that differ from the live ones, foreign runtime) never
@@ -48,8 +50,11 @@ import { setTimeout as delay } from "node:timers/promises"
 import { Cause, Effect, Stream } from "effect"
 import stableStringify from "safe-stable-stringify"
 import { raceAbort } from "./abort.js"
-import { isPlugError, type CatalogModel, type PlugError } from "./contract.js"
+import { cachedCaller, createCacheStore, type CacheStore } from "./cache.js"
+import type { PlugboardOptions } from "./config.js"
+import { isPlugError, type CatalogModel, type ModelCaller, type PlugError } from "./contract.js"
 import { errorMessage, log, logError, outsideRequest, setLogFormat } from "./log.js"
+import { createLimitState, type LimitState } from "./limits.js"
 import { createMetrics, type Metrics, type RuntimeSnapshot } from "./metrics.js"
 import { ensureAppDir } from "./session/history.js"
 import type { HistoryPort } from "./session/host.js"
@@ -107,8 +112,8 @@ const BACKEND_POLL_MS = 25
 const BIND_RETRY_MS = 15_000
 const BIND_REMINDER_MS = 5 * 60_000
 
-/** 7: the options fingerprint comes from safe-stable-stringify, so it must not be compared with an older one. 6: the listener retries a failed bind (new fields on `Listener`). 5: adds the metrics registry and the start time. 4: the history sweep state and the session store's register hook. 3: confirmed directories and rejected generations. */
-const VERSION = 7
+/** 10: the response cache store (`src/cache.ts`) lives here too. 9: the request limiter state (`src/limits.ts`) lives here, so the concurrency caps and rate windows survive a generation. 8: `Metrics.render` is async and the registry is @prometheus-io/client's. 7: the options fingerprint comes from safe-stable-stringify, so it must not be compared with an older one. 6: the listener retries a failed bind (new fields on `Listener`). 5: adds the metrics registry and the start time. 4: the history sweep state and the session store's register hook. 3: confirmed directories and rejected generations. */
+const VERSION = 10
 const KEY = Symbol.for("opencode-plugboard.runtime")
 
 interface Listener {
@@ -158,8 +163,12 @@ interface Runtime {
   readonly sweep: { nextAt: number; running: boolean }
   /** Process-wide counters, shared by every generation (see src/metrics.ts). */
   readonly metrics: Metrics
+  /** Concurrency queues and requests-per-minute windows (see src/limits.ts). */
+  readonly limits: LimitState
   /** When this runtime was created, epoch ms. */
   readonly startedAt: number
+  /** The response cache store (src/cache.ts) and the fingerprint of the config and `apps` policy it was built for. */
+  cache?: { readonly fingerprint: string; readonly store: CacheStore }
   listener?: Listener
   /** Present while a fiber is subscribed to the server event bus. */
   pump?: Pump
@@ -171,6 +180,7 @@ const REJECTED: Registration = { accepted: false, dispose() {}, confirmed: () =>
 const detachedSessions = createSessionStore()
 const detachedMetrics = createMetrics()
 const detachedStartedAt = Date.now()
+const detachedLimits = createLimitState()
 let foreignVersionLogged = false
 
 /** The process runtime, created on first use; undefined when a different version already owns the process. */
@@ -186,6 +196,7 @@ function runtime(): Runtime | undefined {
       rejected: new Map(),
       sweep: { nextAt: 0, running: false },
       metrics: createMetrics(),
+      limits: createLimitState(),
       startedAt: Date.now(),
     }
     slot[KEY] = created
@@ -261,6 +272,42 @@ export const sessionStore = (): SessionStore => runtime()?.sessions ?? detachedS
 /** The metrics registry shared by every generation in the process (a detached one under a foreign-version runtime). */
 export const processMetrics = (): Metrics => runtime()?.metrics ?? detachedMetrics
 
+/** The request limiter's state shared by every generation in the process (detached under a foreign-version runtime). */
+export const processLimits = (): LimitState => runtime()?.limits ?? detachedLimits
+
+/**
+ * Wraps `caller` with the response cache when option `cache` is set (a no-op without it). The store
+ * lives on the runtime, so it survives plugin generations. It is replaced when the cache option or
+ * any policy input (`apps`, `models`, `aliases`, `fallbacks`) differs from the one it was built for:
+ * the key does not cover policy, and a hit skips the session caller's scope checks. The store is
+ * resolved on the first call, not when the wrapper is built: a rejected generation is built too but
+ * never serves, and must not replace the live store. Under a foreign-version runtime the store is
+ * private to the wrapper.
+ */
+export function withResponseCache(caller: ModelCaller, options: PlugboardOptions): ModelCaller {
+  const config = options.cache
+  if (!config) return caller
+  let wrapped: ModelCaller | undefined
+  const build = (): ModelCaller => {
+    const rt = runtime()
+    const fingerprint = canonicalJson({
+      cache: config,
+      apps: options.apps,
+      models: options.models,
+      aliases: options.aliases,
+      fallbacks: options.fallbacks,
+    })
+    let held = rt?.cache
+    if (!held || held.fingerprint !== fingerprint) {
+      held = { fingerprint, store: createCacheStore({ ttlMs: config.ttlSeconds * 1000, maxEntries: config.maxEntries, maxBytes: config.maxBytes }) }
+      if (rt) rt.cache = held
+    }
+    const count = options.metrics ? (app: string, result: "hit" | "miss") => processMetrics().cache(app, result) : undefined
+    return cachedCaller(caller, config, held.store, count)
+  }
+  return { stream: (request, context) => (wrapped ??= build()).stream(request, context) }
+}
+
 /** What `/v1/status` and the discovery pages report about the process, besides the model catalog. */
 export interface RuntimeStatus extends RuntimeSnapshot {
   readonly runtimeVersion: number