@jini-ai/server 0.5.1 → 0.6.1

package/dist/builtin-features.js

@@ -232,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 });
                     },
                 }),

package/dist/storage/legacy/sqlite.d.ts

@@ -8,19 +8,24 @@ import { type SqliteDb, type SqliteSyncOpener } from '@jini-ai/db/sqlite';
 export declare function migrate({ db }: {
     db: SqliteDb;
 }): void;
-/**
- * Opens/caches <dataDir>/app.sqlite using the injected opener, WAL and foreign keys.
- * A new path closes the previous singleton; setup failure closes only the newly acquired handle.
- * @throws The original host acquisition/schema failure, or a missing opener.
- * @complexity O(1) acquisition/bootstrap calls, independent of stored row count.
- */
-export declare function openDatabase({ projectRoot, open }: {
+/** Creates one owned connection cache; other hosts' paths and handles are independent.
+ * Returns lazy open/close ports; creation performs no I/O. @complexity O(1). */
+export declare function createLegacySqliteStorage(_required: Record<string, never>, _optional?: Record<string, never>): {
+    openDatabase: ({ projectRoot, open }: {
+        projectRoot: string;
+        open: SqliteSyncOpener;
+    }, options?: {
+        dataDir?: string;
+        filesystem?: Pick<typeof fs, "mkdirSync">;
+    }) => SqliteDb;
+    closeDatabase: () => void;
+};
+export declare const openDatabase: ({ projectRoot, open }: {
     projectRoot: string;
     open: SqliteSyncOpener;
 }, options?: {
     dataDir?: string;
-    filesystem?: Pick<typeof fs, 'mkdirSync'>;
-}): SqliteDb;
-/** Close the active owned singleton once; clearing state first permits a clean retry after failure. */
-export declare function closeDatabase(): void;
+    filesystem?: Pick<typeof fs, "mkdirSync">;
+}) => SqliteDb;
+export declare const closeDatabase: () => void;
 //# sourceMappingURL=sqlite.d.ts.map

package/dist/storage/legacy/sqlite.js

@@ -1,12 +1,10 @@
-/** Local app.sqlite singleton policy; the host explicitly supplies its SQLite driver. */
+/** Host-owned app.sqlite lifecycle; the host explicitly supplies its SQLite driver. */
 import path from 'node:path';
 import fs from 'node:fs';
 import { openSqliteConnection } from '@jini-ai/db/sqlite';
 import { LEGACY_CHAT_DDL } from '@jini-ai/chat/store/legacy/sqlite';
 import { LEGACY_AGENT_SESSIONS_DDL } from '@jini-ai/daemon/store/agent-sessions/sqlite';
 import { LEGACY_PROJECTS_DDL } from '../../store/projects/sqlite.js';
-let dbInstance = null;
-let dbFile = null;
 /**
  * Explicit idempotent bootstrap of unchanged legacy tables; no versioned migration ledger.
  * @param db Borrowed host handle; this operation neither opens nor closes it.
@@ -21,43 +19,54 @@ let dbFile = null;
 export function migrate({ db }) {
     db.exec(LEGACY_PROJECTS_DDL + LEGACY_CHAT_DDL + LEGACY_AGENT_SESSIONS_DDL);
 }
-/**
- * Opens/caches <dataDir>/app.sqlite using the injected opener, WAL and foreign keys.
- * A new path closes the previous singleton; setup failure closes only the newly acquired handle.
- * @throws The original host acquisition/schema failure, or a missing opener.
- * @complexity O(1) acquisition/bootstrap calls, independent of stored row count.
- */
-export function openDatabase({ projectRoot, open }, options = {}) {
-    // Keep the historical refusal text for JavaScript callers that omit the required port.
-    if (!open)
-        throw new Error('openDatabase: inject options.open');
-    const dir = options.dataDir ? path.resolve(options.dataDir) : path.join(projectRoot, '.jini');
-    const file = path.join(dir, 'app.sqlite');
-    if (dbInstance && dbFile === file)
-        return dbInstance;
-    closeDatabase();
-    (options.filesystem ?? fs).mkdirSync(dir, { recursive: true });
-    let db;
-    try {
-        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;
-        return db;
-    }
-    catch (error) {
+/** Creates one owned connection cache; other hosts' paths and handles are independent.
+ * Returns lazy open/close ports; creation performs no I/O. @complexity O(1). */
+export function createLegacySqliteStorage(_required, _optional = {}) {
+    let dbInstance = null;
+    let dbFile = null;
+    /**
+     * Opens/caches <dataDir>/app.sqlite using the injected opener, WAL and foreign keys.
+     * A new path closes the previous handle owned by this storage instance; setup failure closes only the newly acquired handle.
+     * @throws The original host acquisition/schema failure, or a missing opener.
+     * @complexity O(1) acquisition/bootstrap calls, independent of stored row count.
+     */
+    function openDatabase({ projectRoot, open }, options = {}) {
+        // Keep the historical refusal text for JavaScript callers that omit the required port.
+        if (!open)
+            throw new Error('openDatabase: inject options.open');
+        const dir = options.dataDir ? path.resolve(options.dataDir) : path.join(projectRoot, '.jini');
+        const file = path.join(dir, 'app.sqlite');
+        if (dbInstance && dbFile === file)
+            return dbInstance;
+        closeDatabase();
+        (options.filesystem ?? fs).mkdirSync(dir, { recursive: true });
+        let db;
         try {
-            db?.close();
+            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;
+            return db;
+        }
+        catch (error) {
+            try {
+                db?.close();
+            }
+            catch { /* Keep the original bootstrap failure. */ }
+            throw error;
         }
-        catch { /* Keep the original bootstrap failure. */ }
-        throw error;
     }
+    /** Close the active owned handle once; clearing state first permits a clean retry after failure. */
+    function closeDatabase() {
+        const db = dbInstance;
+        dbInstance = null;
+        dbFile = null;
+        db?.close();
+    }
+    return { openDatabase, closeDatabase };
 }
-/** Close the active owned singleton once; clearing state first permits a clean retry after failure. */
-export function closeDatabase() {
-    const db = dbInstance;
-    dbInstance = null;
-    dbFile = null;
-    db?.close();
-}
+// Compatibility facade for existing hosts; new hosts inject their own storage instance.
+const defaultStorage = createLegacySqliteStorage({});
+export const openDatabase = defaultStorage.openDatabase;
+export const closeDatabase = defaultStorage.closeDatabase;
 //# sourceMappingURL=sqlite.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jini-ai/server",
-  "version": "0.5.1",
+  "version": "0.6.1",
   "license": "Apache-2.0",
   "repository": {
     "type": "git",
@@ -65,27 +65,27 @@
     "@vitest/coverage-v8": "^2.1.9",
     "better-sqlite3": "^13.0.0",
     "express": "^4.21.0",
-    "@jini-ai/core": "0.4.2",
-    "@jini-ai/http-kit": "0.4.1",
-    "@jini-ai/daemon": "0.5.4",
-    "@jini-ai/agent-runtime": "0.4.2",
+    "@jini-ai/agent-runtime": "0.4.5",
     "@jini-ai/sidecar": "0.4.1",
-    "@jini-ai/db": "0.3.1",
-    "@jini-ai/chat": "0.5.5",
+    "@jini-ai/daemon": "0.6.1",
+    "@jini-ai/db": "0.3.2",
+    "@jini-ai/http-kit": "0.4.1",
+    "@jini-ai/core": "0.4.3",
+    "@jini-ai/chat": "0.5.8",
     "@jini-ai/registry": "0.5.2"
   },
   "dependencies": {
-    "@jini-ai/core": "^0.4.2"
+    "@jini-ai/core": "^0.4.3"
   },
   "peerDependencies": {
     "better-sqlite3": "^13.0.0",
-    "@jini-ai/agent-runtime": "^0.4.1",
-    "@jini-ai/daemon": "^0.5.4",
+    "@jini-ai/agent-runtime": "^0.4.5",
+    "@jini-ai/daemon": "^0.6.1",
     "@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.4",
+    "@jini-ai/db": "^0.3.2",
+    "@jini-ai/chat": "^0.5.8",
     "@jini-ai/registry": "^0.5.1"
   },
   "peerDependenciesMeta": {

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