@jini-ai/server 0.5.0 → 0.6.0

package/CHANGELOG.md

@@ -1,4 +1,4 @@
-## Unreleased
+## 0.5.1 — 2026-10-08
 
 - Align pack contributions, bindings, HTTP mounting, retry classification, executor settings and
   event-log cleanup with the current core/daemon object argument contracts.

package/dist/builtin-features.js

@@ -151,7 +151,10 @@ export function projectDetectedAgent(agent) {
         available: agent.available,
         ...(agent.version !== undefined ? { version: agent.version } : {}),
         ...(agent.authStatus !== undefined ? { authStatus: agent.authStatus } : {}),
-        models: agent.models.map(({ id, label }) => ({ id, label })),
+        models: agent.models.map(({ id, label, identityKind, resolvedId }) => ({ id, label, ...(identityKind ? { identityKind } : {}), ...(resolvedId ? { resolvedId } : {}) })),
+        ...(agent.modelCatalog ? { modelCatalog: agent.modelCatalog } : {}),
+        ...(agent.defaultModelResolution ? { defaultModelResolution: agent.defaultModelResolution } : {}),
+        ...(agent.supportsConcreteModelSelection !== undefined ? { supportsConcreteModelSelection: agent.supportsConcreteModelSelection } : {}),
         ...(agent.reasoningOptions !== undefined
             ? { reasoningOptions: agent.reasoningOptions.map(({ id, label }) => ({ id, label })) }
             : {}),
@@ -229,6 +232,9 @@ export function createBuiltInFeatures(options = {}) {
                         registerRunRoutes({ app: app, deps: {
                                 lifecycle: services.context.kernel.lifecycle,
                                 ...(onStarted === undefined ? {} : { onStarted }),
+                                // A mid-run message reaches whichever live run the kernel's own executor is driving;
+                                // a run some other driver owns reads as not-running, never as delivered.
+                                deliverUserMessage: (input) => services.context.kernel.agentExecutor.sendUserMessage(input),
                             }, adapter: services.context.adapter });
                     },
                 }),
@@ -241,13 +247,14 @@ export function createBuiltInFeatures(options = {}) {
         compose: (context) => {
             // Promise-cached so concurrent clients never spawn duplicate probe sets; invalidated by
             // POST /api/agents/rescan.
-            const detector = options.agents?.detector ?? (() => detectAgents({}));
+            const detector = options.agents?.detector ?? ((force) => detectAgents({}, { force }));
             let scan = null;
+            let expiresAt = 0;
             const scanAgents = (force) => {
-                if (force)
+                if (force || Date.now() >= expiresAt)
                     scan = null;
                 if (!scan) {
-                    const pending = detector()
+                    const pending = detector(force)
                         // Filtered before projection so the executor's answer is computed from the full def —
                         // see `isExecutableDetectedAgent`'s doc for why the projected shape is not enough.
                         .then((agents) => agents.filter(isExecutableDetectedAgent).map(projectDetectedAgent))
@@ -261,6 +268,7 @@ export function createBuiltInFeatures(options = {}) {
                         throw error;
                     });
                     scan = pending;
+                    expiresAt = Date.now() + 15 * 60_000;
                 }
                 return scan;
             };

package/dist/create-local-node-daemon.d.ts

@@ -6,7 +6,7 @@ import type { Bindings, Principal, ToolRegistration } from '@jini-ai/core';
 import type { AnyPack, MissingTokenIds } from '@jini-ai/core/composition';
 import type { ResolveRunInput, RunLifecycle } from '@jini-ai/daemon';
 import { type AdapterContext } from '@jini-ai/http-kit';
-import { type DelegatedToolExecuteRequest, type RunStartHandler, type WorkspaceRootResolver } from '@jini-ai/daemon/http';
+import type { DelegatedToolExecuteRequest, RunStartHandler, WorkspaceRootResolver } from '@jini-ai/daemon/http';
 import { type JiniKernelSecurity, type KernelBoundIds } from './compose-jini-kernel.js';
 import type { CapabilityId, JiniProfileId } from './feature.js';
 export { buildDaemonDbOperations, projectDetectedAgent } from './builtin-features.js';

package/dist/create-local-node-daemon.js

@@ -33,7 +33,6 @@
 import { createRequire } from 'node:module';
 import express, {} from 'express';
 import { installRouteRegistrationGuard, mountPackHttp } from '@jini-ai/http-kit';
-import {} from '@jini-ai/daemon/http';
 import { removeDaemonRegistryRecordIfCurrent, resolveDaemonRegistryPath, writeDaemonRegistryRecord } from '@jini-ai/sidecar';
 import { composeJiniKernel } from './compose-jini-kernel.js';
 import { closeHttpServer, normalizeDaemonBindHost } from './host-bootstrap.js';

package/dist/index.d.ts

@@ -1,141 +1,34 @@
 /**
  * @module @jini-ai/server
  *
- * The Node.js host preset (extraction-plan.md §2.4): `createLocalNodeDaemon`, the piece that
- * assembles `@jini-ai/core`/`@jini-ai/daemon`/concern-owned storage adapters/`@jini-ai/http-kit` into an actually-runnable
- * daemon process, plus the generic host-lifecycle primitives it's built on. See `archived provenance ledger`
- * for full provenance and scope-decision notes.
-
- * Archived provenance rationale:
- * ## Design decisions
- *
- * **1. Two function overloads instead of one generic signature with a defaulted `BoundIds`.** The
- * task brief's literal shown signature was
- * `createLocalNodeDaemon<const Packs, BoundIds extends string = KernelBoundIds>(config: ...)`.
- * Empirically verified against this repo's TypeScript (5.9.3, `strict`) that this shape does not
- * actually preserve `createDaemon`'s compile-time "missing binding" gate: when a type parameter both
- * has a default *and* is referenced inside a conditional type in the same position where it also
- * needs inference from a nested callback's return type, TypeScript resolves it to the default
- * instead of inferring from the callback — silently defeating the gate on exactly the call shape
- * (`bindings` customizer provided) where it matters most. Fixed by splitting into two overloads — one
- * where `bindings` is absent and `BoundIds` is the concrete `KernelBoundIds`, one where `bindings` is
- * required and `BoundIds` is inferred fresh with no default — which sidesteps the inference conflict
- * entirely. Both directions (and an under-binding customizer, and a satisfied customizer) are proven
- * in `create-local-node-daemon.typecheck.ts`. Documented in full inline on the exported function.
- *
- * **2. `resolveBoundPort`/`resolveReportHost` extracted as small pure, exported helpers.** The
- * origin's `.listen()` tail inlined both the "is `server.address()` actually usable" check and the
- * "substitute 127.0.0.1 for an all-interfaces bind host" substitution directly in the `'listening'`
- * callback. Pulling them out makes two genuinely-defensive branches (a `server.address()` that is
- * `null`/a Unix-socket-path string/a non-positive port — provably unreachable via any real TCP
- * listener once `'listening'` has fired, per the origin's own "belt-and-braces" framing) directly
- * unit-testable without mocking Express or the underlying socket at all.
- *
- * **3. `@jini/core/internal`'s `AnyPack`/`RequiredTokenIds`/`MissingTokenIds` re-export.** Needed so
- * this package could re-derive `createDaemon`'s exact compile-time gate rather than duplicate the
- * type-level logic. See `packages/core/src/internal.ts`'s own module doc and
- * `packages/core/src/daemon.ts` — these three types are now `export`ed there (previously
- * module-private) but deliberately *not* re-exported from `@jini/core`'s public `index.ts` (which
- * switched from a `daemon.js` wildcard re-export to an explicit named list for exactly this reason).
- *
- * **4. `createDaemon`'s own compile-time gate is bypassed (via a cast) inside
- * `createLocalNodeDaemon`'s implementation body**, the same way
- * `packages/core/src/__tests__/index.test.ts`'s `createDaemonUnsafe` reaches `createDaemon`'s runtime
- * path directly: `Packs`/`BoundIds` are still abstract, unresolved type parameters inside a generic
- * function body, so `createDaemon`'s own conditional gate can never collapse to a definite branch
- * there regardless of which overload the real call site matched. Safety was already established by
- * this function's own equivalent gate (present on both exported overloads) at the real call site.
- *
- * **5. `stop()` always closes the durable `EventLog`, even when the caller's `onShutdown` hook
- * rejects** — `try { await config.onShutdown?.() } finally { await eventLog.close() }` — so a
- * caller-supplied hook failing can never leak an open sqlite file handle; the original rejection
- * still propagates to whoever awaited `stop()`.
- *
- * **6. `env[JINI_BIND_HOST]` is set before serving any request — a documented, only-partially-fixable
- * wrinkle.** `@jini/http`'s own `guardSameOrigin` (used by `registerDaemonStatusRoutes`' shutdown
- * route) resolves `bindHost` purely from real `process.env.JINI_BIND_HOST`, with **no parameter path**
- * of its own — unlike most of that module's other functions, it never accepts an injected `env`.
- * `createLocalNodeDaemon` sets `env[JINI_BIND_HOST] = host` (where `env` is `config.env ??
- * process.env`) before returning, which correctly fixes the common case (no `env` override — the
- * default, real `process.env` gets the right value). When a caller *does* inject a distinct `env`
- * object for full test isolation, this line cannot make `guardSameOrigin`'s hardwired real-`process.env`
- * read reflect it — a pre-existing `@jini/http` limitation this call cannot reach around without
- * editing `origin.ts` itself (out of scope here, same reasoning as the origin-validation duplication
- * flagged in `packages/http/archived provenance ledger`).
- *
- * ## 2026-07-29 — post-merge audit fixes (six teardown/config/URL defects)
- *
- * Independent review of the `feat/agentic-capability-layer` merge (OpenAI Codex `gpt-5.6-sol` as peer
- * reviewer, then re-verified against source here) surfaced six real defects in this package. Each was
- * reproduced with a failing test before any fix landed.
- *
- * **1. Caller packs were never disposed.** `composeJiniKernel` calls `createDaemon` on `config.packs`,
- * so it — not the caller — builds their services; but neither the failure-cleanup path nor `close()`
- * ever ran their `dispose`. A caller pack whose `services()` opened a socket, timer or database handle
- * leaked it past `createLocalNodeDaemon().stop()`, and the wrapper exposes no caller daemon for the
- * host to tear down itself. Added `JiniKernel.disposeCallerPacks()` — memoized, best-effort, symmetric
- * with `disposeFeatures()` — called by `close()`, by the composition-failure `catch`, and by the
- * daemon's `stop()`. Disposal order is reverse of construction: features first (they were composed
- * against an already-built caller daemon), caller packs second.
- *
- * **2. `journal.db` opened outside the cleanup block.** `createJiniKernelBase` opened `events.db`, then
- * `journal.db`, and only *then* entered the `try` whose `catch` closed them. `journal.db` failing (a
- * corrupt file, or a directory sitting where a database was expected) left the `events.db` handle open
- * in a process that has no kernel. Every acquisition now happens inside the one block, tracked in an
- * `opened` array the cleanup drains — the shape the module's own comment already claimed.
- *
- * **3. Capability keys were not runtime-validated.** Feature ids in `config.features` threw on a typo;
- * capability ids in `config.capabilities` did not. `{'host:exce': false}` deleted a grant nobody held,
- * so `host:exec` survived and `terminal`/`hostTools` stayed mounted — a security switch that fails
- * *open* on a typo, in the direction that reads as applied. `feature.ts` now carries the runtime half
- * of `CapabilityId` as a `Record<CapabilityId, true>` (drift is a compile error in both directions, so
- * the list cannot silently fall behind the union it validates) plus `CAPABILITY_IDS`/`isCapabilityId`;
- * `resolveFeatureActivation` validates the keys next to where it validates feature ids.
- *
- * **4. An injected `config.env` never reached the per-route same-origin guard.** `env[JINI_BIND_HOST] =
- * host` writes into the caller's object when one is supplied, and `@jini-ai/http-kit`'s `guardSameOrigin`
- * read real `process.env`. The origin-guard *middleware* was already handed the injected `env`, so the
- * two halves of one decision read two different environments: the middleware admitted an origin the
- * host configured through `config.env` and the route then rejected it. Fixed at the seam —
- * `OriginContext` (and so `AdapterContext`) grew an optional `env`, defaulting to `process.env`, and
- * this preset sets it. That covers `JINI_BIND_HOST`, `JINI_ALLOWED_ORIGINS` and `JINI_WEB_PORT` alike.
- *
- * **5. Shutdown could skip its own teardown, or crash the process.** `closeHttpServer` rejecting (which
- * its own contract documents) skipped feature disposal, discovery-record removal, `onShutdown` and the
- * sqlite close — leaving a half-torn-down daemon, strictly worse than the failure that caused it. It is
- * a `try`/`finally` now; the original rejection still propagates once teardown finishes. Separately,
- * `requestShutdown` dropped `stop()`'s promise with a bare `void`, so a failing shutdown became an
- * unhandled rejection — which on Node's default policy terminates the process this was gracefully
- * shutting down. It is reported through `console.error` now; the rejection stays on `stopPromise` so an
- * explicit `stop()` caller still observes it.
- *
- * **6. `resolveReportHost` produced an unparseable URL for an IPv6 bind host.** `'::1'` passed through
- * unchanged, so the reported base URL was `http://::1:54321` — which `new URL()` and `fetch` both
- * reject, and which was written verbatim into the discovery record. It now returns the bracketed
- * authority form (RFC 3986 §3.2.2), idempotently.
- *
- * Two lower-severity items from the same review, also fixed:
- *
- * - **`agents`' scan cache was not keyed by promise identity.** A slow scan that failed *after* `POST
- *   /api/agents/rescan` had already replaced it with a successful one cleared the newer entry, forcing
- *   a duplicate probe of every agent CLI on the machine. The `catch` now clears only its own entry.
- * - **`createFrontendControl`'s bind boundary did not cover `resolveBindToken` or its own error sink.**
- *   A `RunStartHandler` throwing is not a no-op — `@jini-ai/http-kit`'s run-start route marks the run
- *   `failed` and answers 500 — so a host-supplied `resolveBindToken` throwing (it parses an opaque host
- *   blob) produced exactly the killed run the `onBindError` doc promises never to cause. Both are inside
- *   the boundary now; a throwing sink is swallowed, because the reporting channel is what failed.
- *
- * **One pre-existing gap closed while here.** The package's committed 100% function-coverage gate was
- * already failing on `main` (99.09%): `sidecar-strict`'s origin-guard `getResolvedPort` closure had no
- * end-to-end coverage, because both of that mode's gates are request-time middleware. Added six real
- * `security: sidecar-strict` tests (unauthenticated 401, authenticated 201, cross-origin 403 with a
- * valid token, unset-token 503, probe routes reachable tokenless, `exemptPaths`) — the one block in
- * `compose-jini-kernel.test.ts` that opens a socket, and only because it has to.
- *
- * **Verified, personally, this session**: `packages/server` **231/231 passing** across 8 files (was
- * 215 before the sidecar-strict block), **100/100/100/100 coverage**; `packages/http-kit` 1245/1245 and
- * 100% ; `packages/chat-core` 261/261; `packages/chat-react` 610/610 and 100%;
- * `examples/reference-web` 41/41. Repo-wide `pnpm typecheck` and `pnpm guard` clean.
+ * Node host preset: createLocalNodeDaemon assembles core, daemon, concern-owned
+ * storage and http-kit into a listening service. composeJiniKernel is the same
+ * composition core for hosts mounting their own app without a second listener.
+ *
+ * Composition and lifecycle invariants:
+ * - The preset's two overloads preserve the missing-binding type gate: defaulted
+ *   BoundIds would defeat inference from a custom bindings callback. Core's
+ *   internal token-gate types are reused, rather than reimplemented. The cast
+ *   inside the generic body is protected by both exported overloads' gate.
+ * - resolveBoundPort and resolveReportHost are pure helpers so defensive address
+ *   checks are directly testable without a listener. Wildcard hosts are reported
+ *   as loopback and IPv6 authorities are bracketed so discovery URLs are usable.
+ * - Resource acquisition stays inside cleanup boundaries so a later database
+ *   open cannot leak an earlier handle. Features dispose before caller packs,
+ *   reversing construction; the preset constructed those services and owns
+ *   teardown. Listener-close or onShutdown failures cannot skip storage close,
+ *   feature disposal or discovery removal. Explicit stop callers observe failures;
+ *   requested shutdown failures are reported rather than dropped as rejections.
+ * - Feature and capability keys are runtime-validated: silently accepting a typo
+ *   in a disabled capability would leave the real security-sensitive grant active.
+ * - Bind-host configuration is set before serving requests. The injected env is
+ *   shared with origin middleware and route guards so both enforce the same policy.
+ * - Agent scan cache cleanup checks promise identity so an older failed scan
+ *   cannot clear its replacement. Frontend binding contains resolver and error-sink
+ *   failures so a host binding error cannot fail the underlying run.
+ *
+ * Frontend control belongs to daemon/http; this entry retains its public forwarding
+ * exports. See owning modules and packages/server/README.md for detailed contracts.
  */
 export type { CreateLocalNodeDaemonConfig, KernelBoundIds, LocalNodeDaemon, LocalNodeHttpExtension, LocalNodeHttpExtensionContext, } from './create-local-node-daemon.js';
 export { buildDaemonDbOperations, classifyRunFailureForRetry, createLocalNodeDaemon, projectDetectedAgent, resolveBoundPort, resolveReportHost, } from './create-local-node-daemon.js';

package/dist/kernel-base.js

@@ -70,8 +70,8 @@ export async function createJiniKernelBase(options) {
         if (sqliteStorage && eventsDbPath !== null && dataDir !== null) {
             // A *second* connection to the same `events.db` the log above owns — safe: both run in WAL
             // mode, which permits multiple concurrently open handles on one file within a single process.
-            featureConnection = openSqliteConnection({ filePath: eventsDbPath, open(file, settings) {
-                    featureConnection = sqliteStorage.open(file, settings);
+            featureConnection = openSqliteConnection({ filePath: eventsDbPath, open({ filePath }, settings) {
+                    featureConnection = sqliteStorage.open(filePath, settings);
                     return featureConnection;
                 } });
             sqlite = { connection: featureConnection, eventsDbPath, dataDir };

package/dist/storage/legacy/sqlite.js

@@ -39,7 +39,7 @@ export function openDatabase({ projectRoot, open }, options = {}) {
     (options.filesystem ?? fs).mkdirSync(dir, { recursive: true });
     let db;
     try {
-        db = openSqliteConnection({ filePath: file, open(file, settings) { db = open(file, settings); return db; }, pragmas: ['journal_mode = WAL', 'foreign_keys = ON'] });
+        db = openSqliteConnection({ filePath: file, open({ filePath }, settings) { db = open(filePath, settings); return db; } }, { pragmas: ['journal_mode = WAL', 'foreign_keys = ON'] });
         migrate({ db });
         dbInstance = db;
         dbFile = file;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jini-ai/server",
-  "version": "0.5.0",
+  "version": "0.6.0",
   "license": "Apache-2.0",
   "repository": {
     "type": "git",
@@ -11,7 +11,12 @@
     "domain": "server",
     "kind": "host",
     "runtime": "node",
-    "admission": "locked"
+    "admission": "locked",
+    "isolation": {
+      "entries": {
+        "./store/projects/sqlite": "storage"
+      }
+    }
   },
   "type": "module",
   "main": "./dist/index.js",
@@ -54,35 +59,68 @@
     "access": "public",
     "registry": "https://registry.npmjs.org"
   },
-  "dependencies": {
-    "express": "^4.21.0",
-    "@jini-ai/agent-runtime": "0.4.0",
-    "@jini-ai/core": "0.4.0",
-    "@jini-ai/http-kit": "0.4.0",
-    "@jini-ai/daemon": "0.5.0",
-    "@jini-ai/sidecar": "0.4.0",
-    "@jini-ai/db": "0.2.0",
-    "@jini-ai/registry": "0.5.0",
-    "@jini-ai/chat": "0.5.0"
-  },
   "devDependencies": {
     "@types/better-sqlite3": "^7.6.11",
     "@types/express": "^4.17.21",
     "@vitest/coverage-v8": "^2.1.9",
-    "better-sqlite3": "^13.0.0"
+    "better-sqlite3": "^13.0.0",
+    "express": "^4.21.0",
+    "@jini-ai/agent-runtime": "0.4.4",
+    "@jini-ai/daemon": "0.6.0",
+    "@jini-ai/sidecar": "0.4.1",
+    "@jini-ai/http-kit": "0.4.1",
+    "@jini-ai/core": "0.4.2",
+    "@jini-ai/registry": "0.5.2",
+    "@jini-ai/db": "0.3.1",
+    "@jini-ai/chat": "0.5.7"
+  },
+  "dependencies": {
+    "@jini-ai/core": "^0.4.2"
   },
   "peerDependencies": {
-    "better-sqlite3": "^13.0.0"
+    "better-sqlite3": "^13.0.0",
+    "@jini-ai/agent-runtime": "^0.4.4",
+    "@jini-ai/daemon": "^0.6.0",
+    "@jini-ai/http-kit": "^0.4.0",
+    "@jini-ai/sidecar": "^0.4.0",
+    "express": "^4.21.0",
+    "@jini-ai/db": "^0.3.0",
+    "@jini-ai/chat": "^0.5.7",
+    "@jini-ai/registry": "^0.5.1"
   },
   "peerDependenciesMeta": {
     "better-sqlite3": {
       "optional": true
+    },
+    "@jini-ai/agent-runtime": {
+      "optional": true
+    },
+    "@jini-ai/daemon": {
+      "optional": true
+    },
+    "@jini-ai/http-kit": {
+      "optional": true
+    },
+    "@jini-ai/sidecar": {
+      "optional": true
+    },
+    "express": {
+      "optional": true
+    },
+    "@jini-ai/db": {
+      "optional": true
+    },
+    "@jini-ai/chat": {
+      "optional": true
+    },
+    "@jini-ai/registry": {
+      "optional": true
     }
   },
   "sideEffects": false,
   "scripts": {
-    "build": "tsc -p tsconfig.json",
-    "typecheck": "tsc -p tsconfig.json --noEmit",
+    "build": "tsc -p tsconfig.tests.json && tsc -p tsconfig.json",
+    "typecheck": "tsc -p tsconfig.tests.json && tsc -p tsconfig.json --noEmit",
     "test": "vitest run",
     "test:coverage": "vitest run --coverage"
   }

package/dist/frontend-control.d.ts

@@ -1,76 +0,0 @@
-import type { ToolPolicy, ToolRegistration } from '@jini-ai/core';
-import { type FrontendCapabilitySpec } from '@jini-ai/daemon';
-import { type RunCreateRequest, type RunStartHandler } from '@jini-ai/http-kit';
-import type { LocalNodeHttpExtension } from './create-local-node-daemon.js';
-export interface FrontendBindErrorContext {
-    readonly runId: string;
-    readonly error: unknown;
-}
-export interface CreateFrontendControlOptions {
-    /**
-     * The capabilities to expose. `@jini-ai/agentic`'s `PAGE_CAPABILITIES` and `@jini-ai/chat-core`'s
-     * `CHAT_CAPABILITIES` satisfy this structurally — the engine never imports that vocabulary
-     * (see `frontend-capability-tools.ts`'s module doc for why the edge points one way).
-     */
-    readonly capabilities: readonly FrontendCapabilitySpec[];
-    /**
-     * Reads this run's bind token out of the host's own run request, or returns `undefined` when the
-     * run has no originating surface.
-     *
-     * Required, and deliberately not defaulted. A default would have to guess where a host keeps the
-     * token, and guessing wrong fails *open* in the confusing direction: the run starts, the agent
-     * gets its tools, and every page call fails later with "no frontend is bound" — a symptom that
-     * looks like a browser problem and is actually a config one.
-     *
-     * Returning `undefined` is normal, not an error. A run started from a CLI has no surface, and
-     * capabilities whose `surface` is `'server'` do not need one.
-     */
-    readonly resolveBindToken: (request: RunCreateRequest) => string | undefined;
-    /** @default `@jini-ai/daemon`'s `denyAllFrontendCapabilityPolicy` — a host grants access explicitly. */
-    readonly policy?: ToolPolicy;
-    /** @default `@jini-ai/daemon`'s `DEFAULT_FRONTEND_CAPABILITY_TIMEOUT_MS`. */
-    readonly timeoutMs?: number;
-    /** Applied to every registration. Frontend output is untrusted page text; bound it. */
-    readonly maxOutputBytes?: number;
-    /**
-     * Host-owned sink for a bind failure. Defaults to `console.error`.
-     *
-     * A failed bind does not fail the run. The run is still legitimate — the agent simply cannot
-     * drive the page, and every capability call it makes will say so by name. Killing a run because
-     * one optional channel could not be established would turn a degraded session into no session.
-     */
-    readonly onBindError?: (context: FrontendBindErrorContext) => void;
-}
-export interface FrontendControl {
-    /** Mounts the frontend-session stream and response routes. Pass in `httpExtensions`. */
-    readonly httpExtension: LocalNodeHttpExtension;
-    /** One gated tool per capability. Pass in `toolRegistrations`. */
-    readonly toolRegistrations: readonly ToolRegistration[];
-    /**
-     * Binds each starting run to the surface that originated it, and releases the binding when the
-     * run reaches a terminal state so a long-lived tab does not accumulate dead bindings.
-     *
-     * Compose it with whatever the host already does on run start — this hook only binds, it never
-     * executes anything:
-     *
-     * ```ts
-     * onRunStarted: (context) => {
-     *   frontend.bindOnStarted(context);
-     *   void startMyAgent(context);
-     * }
-     * ```
-     */
-    readonly bindOnStarted: RunStartHandler;
-}
-/**
- * Builds the frontend-control bundle.
- *
- * @param options - Capabilities to expose, how to find the bind token, and the gate to apply.
- * @returns An HTTP extension, tool registrations, and a run-start bind hook — never the registry.
- * @throws Never at construction. A duplicate capability id throws later, when the registrations are
- * registered, naming the id (`ToolRegistry.register`'s own error).
- *
- * @complexity O(n) in `capabilities`.
- */
-export declare function createFrontendControl(options: CreateFrontendControlOptions): FrontendControl;
-//# sourceMappingURL=frontend-control.d.ts.map

package/dist/frontend-control.js

@@ -1,77 +0,0 @@
-import { createFrontendCapabilityRegistrations, createFrontendSessionRegistry, } from '@jini-ai/daemon';
-import { registerFrontendSessionRoutes, } from '@jini-ai/http-kit';
-function defaultBindErrorSink(context) {
-    // eslint-disable-next-line no-console
-    console.error(`[@jini-ai/server] could not bind run "${context.runId}" to a frontend surface`, context.error);
-}
-/**
- * Builds the frontend-control bundle.
- *
- * @param options - Capabilities to expose, how to find the bind token, and the gate to apply.
- * @returns An HTTP extension, tool registrations, and a run-start bind hook — never the registry.
- * @throws Never at construction. A duplicate capability id throws later, when the registrations are
- * registered, naming the id (`ToolRegistry.register`'s own error).
- *
- * @complexity O(n) in `capabilities`.
- */
-export function createFrontendControl(options) {
-    // Closed over, never exposed. See the module doc: reaching this is reaching an ungated `invoke`.
-    const registry = createFrontendSessionRegistry();
-    const onBindError = options.onBindError ?? defaultBindErrorSink;
-    const toolRegistrations = createFrontendCapabilityRegistrations({
-        registry,
-        capabilities: options.capabilities,
-        ...(options.policy !== undefined ? { policy: options.policy } : {}),
-        ...(options.timeoutMs !== undefined ? { timeoutMs: options.timeoutMs } : {}),
-        ...(options.maxOutputBytes !== undefined ? { maxOutputBytes: options.maxOutputBytes } : {}),
-    });
-    const httpExtension = (app, context) => {
-        registerFrontendSessionRoutes(app, { registry }, context.adapter);
-    };
-    /**
-     * The error boundary the `onBindError` contract actually needs. A `RunStartHandler` throwing is
-     * not a no-op: `@jini-ai/http-kit`'s run-start route catches it, marks the run `failed` and answers
-     * 500 — so anything inside this hook that can throw can produce exactly the killed run that
-     * contract promises never to cause. `resolveBindToken` is host-supplied and reads an opaque host
-     * blob (a `JSON.parse` away from throwing), and the sink itself is host-supplied too. A sink that
-     * throws leaves nowhere left to report, so that one is swallowed rather than escalated.
-     */
-    const reportBindError = (context) => {
-        try {
-            onBindError(context);
-        }
-        catch {
-            // Deliberately terminal: the reporting channel is what failed.
-        }
-    };
-    const bindOnStarted = ({ request, run, lifecycle }) => {
-        let bindToken;
-        try {
-            bindToken = options.resolveBindToken(request);
-        }
-        catch (error) {
-            reportBindError({ runId: run.id, error });
-            return;
-        }
-        if (bindToken === undefined)
-            return;
-        let release;
-        try {
-            release = registry.bindRunByToken(run.id, bindToken);
-        }
-        catch (error) {
-            reportBindError({ runId: run.id, error });
-            return;
-        }
-        // Release on terminal so a tab that outlives many runs does not accumulate bindings for runs
-        // that ended. `waitForTerminal` rejecting is itself a reason to release, not to keep waiting,
-        // so both paths run it — and the whole chain is swallowed, because a bookkeeping failure must
-        // never surface as an unhandled rejection that takes the process down.
-        void lifecycle
-            .waitForTerminal(run.id)
-            .then(release, release)
-            .catch(() => undefined);
-    };
-    return { httpExtension, toolRegistrations, bindOnStarted };
-}
-//# sourceMappingURL=frontend-control.js.map