@jini-ai/daemon 0.3.8 → 0.5.1

package/dist/frontend-session-registry.d.ts

@@ -40,7 +40,7 @@ export interface FrontendSessionHandle {
      * Detaches the surface. Every invocation still awaiting it is rejected rather than left pending,
      * so a closed tab surfaces as a failed tool call instead of a run that never finishes.
      */
-    detach(): void;
+    detach(_args: Record<string, never>): void;
 }
 export interface FrontendSessionRegistry {
     /**
@@ -49,7 +49,10 @@ export interface FrontendSessionRegistry {
      *
      * @throws If `sessionId` is already attached.
      */
-    attach(descriptor: FrontendSessionDescriptor, deliver: (invocation: FrontendInvocation) => void): FrontendSessionHandle;
+    attach(args: {
+        readonly descriptor: FrontendSessionDescriptor;
+        readonly deliver: (invocation: FrontendInvocation) => void;
+    }): FrontendSessionHandle;
     /**
      * Associates a started run with the surface that originated it, so capability calls made by that
      * run's agent reach that surface. Re-binding the same run to the same session is a no-op; binding
@@ -61,7 +64,10 @@ export interface FrontendSessionRegistry {
      * @throws If `sessionId` is not attached. Binding a run to a surface that is already gone would
      * produce calls that hang until their tool timeout instead of failing immediately.
      */
-    bindRun(runId: string, sessionId: string): () => void;
+    bindRun(args: {
+        readonly runId: string;
+        readonly sessionId: string;
+    }): () => void;
     /**
      * Binds a run to whichever surface holds `bindToken` — the wire-safe form of {@link bindRun}.
      *
@@ -77,29 +83,46 @@ export interface FrontendSessionRegistry {
      * distinguish "never existed" from "detached" — telling a caller which one it guessed is how a
      * probe learns whether a token is worth retrying.
      */
-    bindRunByToken(runId: string, bindToken: string): () => void;
+    bindRunByToken(args: {
+        readonly runId: string;
+        readonly bindToken: string;
+    }): () => void;
     /**
      * Routes one capability call to the surface bound to `runId` and resolves with its output.
      *
      * @throws If no surface is bound to `runId`, if the bound surface does not claim `capabilityId`,
      * if delivery fails, if the surface answers with a refusal, or if `signal` aborts first.
      */
-    invoke(runId: string, capabilityId: string, input: Record<string, unknown>, signal?: AbortSignal): Promise<unknown>;
+    invoke(args: {
+        readonly runId: string;
+        readonly capabilityId: string;
+        readonly input: Record<string, unknown>;
+    }, optionalArgs?: {
+        readonly signal?: AbortSignal;
+    }): Promise<unknown>;
     /**
      * Settles a pending invocation with the surface's answer.
      *
      * @returns `true` if this call settled it; `false` if it was already settled, unknown, or belongs
      * to a different session — the duplicate-answer case, which is a no-op by design.
      */
-    settle(sessionId: string, invocationId: string, outcome: FrontendOutcome): boolean;
+    settle(args: {
+        readonly sessionId: string;
+        readonly invocationId: string;
+        readonly outcome: FrontendOutcome;
+    }): boolean;
     /**
      * Capability ids reachable for `runId` right now — empty when nothing is bound. A caller uses
      * this to advertise only what can actually be served, so an agent is never offered a capability
      * that would fail the moment it tried.
      */
-    capabilitiesFor(runId: string): readonly string[];
+    capabilitiesFor(args: {
+        readonly runId: string;
+    }): readonly string[];
     /** The surface bound to `runId`, or `undefined` when there is none. */
-    sessionFor(runId: string): FrontendSessionDescriptor | undefined;
+    sessionFor(args: {
+        readonly runId: string;
+    }): FrontendSessionDescriptor | undefined;
 }
 export interface CreateFrontendSessionRegistryOptions {
     /** Injectable id source for invocation ids — defaults to `randomUUID`. Test-only hook. */
@@ -123,5 +146,5 @@ export interface CreateFrontendSessionRegistryOptions {
  * @complexity Every operation is O(1) except `detach`, which is O(p + b) in that surface\'s pending
  * invocations and bound runs.
  */
-export declare function createFrontendSessionRegistry(options?: CreateFrontendSessionRegistryOptions): FrontendSessionRegistry;
+export declare function createFrontendSessionRegistry(requiredArgs: Record<string, never>, optionalArgs?: Pick<CreateFrontendSessionRegistryOptions, "newInvocationId" | "newBindToken">): FrontendSessionRegistry;
 //# sourceMappingURL=frontend-session-registry.d.ts.map

package/dist/frontend-session-registry.js

@@ -56,7 +56,8 @@ import { randomUUID } from 'node:crypto';
  * @complexity Every operation is O(1) except `detach`, which is O(p + b) in that surface\'s pending
  * invocations and bound runs.
  */
-export function createFrontendSessionRegistry(options = {}) {
+export function createFrontendSessionRegistry(requiredArgs, optionalArgs = {}) {
+    const options = { ...requiredArgs, ...optionalArgs };
     const newInvocationId = options.newInvocationId ?? randomUUID;
     const newBindToken = options.newBindToken ?? randomUUID;
     const sessions = new Map();
@@ -105,7 +106,7 @@ export function createFrontendSessionRegistry(options = {}) {
         }
         return session;
     }
-    function attach(descriptor, deliver) {
+    function attach({ descriptor, deliver }) {
         if (sessions.has(descriptor.sessionId)) {
             throw new Error(`FrontendSessionRegistry: session "${descriptor.sessionId}" is already attached`);
         }
@@ -116,7 +117,7 @@ export function createFrontendSessionRegistry(options = {}) {
         return {
             sessionId: descriptor.sessionId,
             bindToken,
-            detach() {
+            detach(_args) {
                 // Only tear down state this attachment still owns. A stale handle — one whose attachment
                 // already detached and whose session id has since been re-attached — must not remove the
                 // replacement or its bindings; the replacement's own token/pending state is not this
@@ -138,7 +139,7 @@ export function createFrontendSessionRegistry(options = {}) {
             },
         };
     }
-    function bindRun(runId, sessionId) {
+    function bindRun({ runId, sessionId }) {
         const session = sessions.get(sessionId);
         if (session === undefined) {
             throw new Error(`FrontendSessionRegistry: cannot bind run "${runId}" to unattached session "${sessionId}"`);
@@ -152,7 +153,7 @@ export function createFrontendSessionRegistry(options = {}) {
                 runBindings.delete(runId);
         };
     }
-    function bindRunByToken(runId, bindToken) {
+    function bindRunByToken({ runId, bindToken }) {
         const sessionId = bindTokens.get(bindToken);
         // One message for both "no such token" and "the surface holding it detached". Distinguishing
         // them tells a caller whether a guess was close, which is the feedback a probe needs and the
@@ -160,13 +161,13 @@ export function createFrontendSessionRegistry(options = {}) {
         if (sessionId === undefined) {
             throw new Error(`FrontendSessionRegistry: cannot bind run "${runId}" — unknown or expired bind token`);
         }
-        return bindRun(runId, sessionId);
+        return bindRun({ runId: runId, sessionId: sessionId });
     }
     // `async` so that a routing refusal from `resolveTarget` surfaces as a rejected promise like
     // every other failure here. Throwing synchronously out of a Promise-returning function would
     // make `invoke(...).catch(...)` an uncaught exception for exactly the fail-closed cases this
     // registry exists to report.
-    async function invoke(runId, capabilityId, input, signal) {
+    async function invoke({ runId, capabilityId, input }, { signal } = {}) {
         const target = resolveTarget(runId, capabilityId);
         const invocationId = newInvocationId();
         return new Promise((resolve, reject) => {
@@ -193,7 +194,7 @@ export function createFrontendSessionRegistry(options = {}) {
             }
         });
     }
-    function settle(sessionId, invocationId, outcome) {
+    function settle({ sessionId, invocationId, outcome }) {
         const session = sessions.get(sessionId);
         const entry = session?.pending.get(invocationId);
         if (session === undefined || entry === undefined)
@@ -206,11 +207,11 @@ export function createFrontendSessionRegistry(options = {}) {
             entry.reject(new Error(outcome.message));
         return true;
     }
-    function sessionFor(runId) {
+    function sessionFor({ runId }) {
         return runBindings.get(runId)?.descriptor;
     }
-    function capabilitiesFor(runId) {
-        return sessionFor(runId)?.capabilities ?? [];
+    function capabilitiesFor({ runId }) {
+        return sessionFor({ runId: runId })?.capabilities ?? [];
     }
     return { attach, bindRun, bindRunByToken, invoke, settle, capabilitiesFor, sessionFor };
 }

package/dist/http/active-context.d.ts

@@ -0,0 +1,105 @@
+/**
+ * @module active-context
+ *
+ * Generic "what resource is the caller currently focused on?" channel: an
+ * in-memory, TTL-scoped pointer a client POSTs to record its current focus
+ * and GETs to read back (resolved against a real display name via an
+ * injected lookup). Ported from the routes-classification table's
+ * `active-context.ts` MIXED row (see `archived provenance ledger`) — the origin's only
+ * real coupling was `handleGetActive` calling into an OD project store to
+ * resolve a display name; the TTL store and both handlers were already
+ * product-neutral, and all handlers are synchronous (no async risk).
+ *
+ * The origin's `projectId`/`fileName` fields are generalized here to a
+ * single opaque `resourceRef` (was `projectId`) plus an optional `detail`
+ * string (was `fileName` — a sub-locator within that resource), matching
+ * the source-map's own "renaming to a generic resource ref" note. The
+ * origin's `deps.getProject` lookup becomes an injected `resolveResource`
+ * dependency, matching this branch's DI convention (see
+ * `daemon-status.ts`/`host-tools.ts`: real collaborators supplied by the
+ * caller rather than read from a global store).
+ */
+import type { Express } from 'express';
+import { type AdapterContext } from '@jini-ai/http-kit';
+/** How long a recorded focus stays valid before a GET treats it as stale and clears it. */
+export declare const ACTIVE_CONTEXT_TTL_MS: number;
+interface ActiveContext {
+    resourceRef: string;
+    detail: string | null;
+    ts: number;
+}
+interface ActiveContextStore {
+    current: ActiveContext | null;
+}
+type SetActiveInput = {
+    kind: 'clear';
+} | {
+    kind: 'set';
+    resourceRef: string;
+    detail: string | null;
+};
+type SetActiveOutput = {
+    active: false;
+} | {
+    active: true;
+    resourceRef: string;
+    detail: string | null;
+    ts: number;
+};
+type GetActiveOutput = {
+    active: false;
+} | {
+    active: true;
+    resourceRef: string;
+    resourceName: string | null;
+    detail: string | null;
+    ts: number;
+    ageMs: number;
+};
+/** A resolved resource's display name. `resolveResource` itself may return `null`/`undefined` (not this type) when the caller has no entry at all for a given resource ref (e.g. unknown or deleted). */
+export interface ActiveContextResource {
+    readonly name?: string | null;
+}
+/** What a caller must supply to mount the active-context routes. */
+export interface ActiveContextDeps {
+    /**
+     * Resolves a display name for a resource ref (was OD's project store's
+     * `getProject`). Injected so this module has no dependency on any
+     * particular resource store; may return `null`/`undefined` if the ref is
+     * unknown.
+     */
+    resolveResource: ({ resourceRef }: {
+        resourceRef: string;
+    }) => ActiveContextResource | null | undefined;
+    /** Returns the current time in epoch ms. Defaults to `Date.now` when omitted. */
+    now?: () => number;
+}
+/**
+ * Internal deps threaded to both handlers: the caller-supplied
+ * {@link ActiveContextDeps} plus the shared in-memory store built once per
+ * `registerActiveContextRoutes` call, so the two routes see the same state.
+ */
+interface ActiveContextRouteDeps {
+    store: ActiveContextStore;
+    resolveResource: ActiveContextDeps['resolveResource'];
+    now: () => number;
+}
+/**
+ * `POST /api/active` — records (or, with `{active: false}`, clears) the
+ * caller's current resource focus.
+ */
+export declare const setActiveRoute: import("@jini-ai/http-kit").JsonRouteSpec<SetActiveInput, SetActiveOutput, ActiveContextRouteDeps>;
+/**
+ * `GET /api/active` — reads back the current resource focus, resolving a
+ * display name for it, or `{active: false}` if nothing is set or the
+ * recorded focus has aged past {@link ACTIVE_CONTEXT_TTL_MS}.
+ */
+export declare const getActiveRoute: import("@jini-ai/http-kit").JsonRouteSpec<void, GetActiveOutput, ActiveContextRouteDeps>;
+/** Mounts both active-context routes on `app`, sharing one in-memory store between them. A pack's `http(app, services)` calls this directly. */
+export declare function registerActiveContextRoutes({ app, deps, adapter }: {
+    readonly app: Express;
+    readonly deps: ActiveContextDeps;
+    readonly adapter: AdapterContext;
+}, _optional?: Record<string, never>): void;
+export {};
+//# sourceMappingURL=active-context.d.ts.map

package/dist/http/active-context.js

@@ -0,0 +1,67 @@
+import { createApiError } from '@jini-ai/protocol';
+import { defineJsonRoute, mountJsonRoute } from '@jini-ai/http-kit';
+import { err, ok } from '@jini-ai/http-kit';
+/** How long a recorded focus stays valid before a GET treats it as stale and clears it. */
+export const ACTIVE_CONTEXT_TTL_MS = 5 * 60 * 1000;
+function parseSetActive(raw) {
+    const body = (raw.body ?? {});
+    if (body.active === false) {
+        return ok({ value: { kind: 'clear' } });
+    }
+    const resourceRef = typeof body.resourceRef === 'string' ? body.resourceRef : '';
+    if (!resourceRef) {
+        return err({ error: createApiError({ code: 'BAD_REQUEST', message: 'resourceRef is required' }) });
+    }
+    const detail = typeof body.detail === 'string' && body.detail.length > 0 ? body.detail : null;
+    return ok({ value: { kind: 'set', resourceRef, detail } });
+}
+function handleSetActive({ input, deps }) {
+    if (input.kind === 'clear') {
+        deps.store.current = null;
+        return ok({ value: { active: false } });
+    }
+    const next = { resourceRef: input.resourceRef, detail: input.detail, ts: deps.now() };
+    deps.store.current = next;
+    return ok({ value: { active: true, ...next } });
+}
+function handleGetActive({ input: _input, deps }) {
+    const current = deps.store.current;
+    if (!current || deps.now() - current.ts > ACTIVE_CONTEXT_TTL_MS) {
+        deps.store.current = null;
+        return ok({ value: { active: false } });
+    }
+    const resource = deps.resolveResource({ resourceRef: current.resourceRef });
+    return ok({
+        value: {
+            active: true,
+            resourceRef: current.resourceRef,
+            resourceName: resource?.name ?? null,
+            detail: current.detail,
+            ts: current.ts,
+            ageMs: deps.now() - current.ts,
+        }
+    });
+}
+/**
+ * `POST /api/active` — records (or, with `{active: false}`, clears) the
+ * caller's current resource focus.
+ */
+export const setActiveRoute = defineJsonRoute({ method: 'post', path: '/api/active', parse: parseSetActive, handle: handleSetActive }, { requireSameOrigin: true });
+/**
+ * `GET /api/active` — reads back the current resource focus, resolving a
+ * display name for it, or `{active: false}` if nothing is set or the
+ * recorded focus has aged past {@link ACTIVE_CONTEXT_TTL_MS}.
+ */
+export const getActiveRoute = defineJsonRoute({ method: 'get', path: '/api/active', parse: () => ok({ value: undefined }), handle: handleGetActive }, { requireSameOrigin: true });
+/** Mounts both active-context routes on `app`, sharing one in-memory store between them. A pack's `http(app, services)` calls this directly. */
+export function registerActiveContextRoutes({ app, deps, adapter }, _optional = {}) {
+    const store = { current: null };
+    const routeDeps = {
+        store,
+        resolveResource: deps.resolveResource,
+        now: deps.now ?? (() => Date.now()),
+    };
+    mountJsonRoute({ app, spec: setActiveRoute, deps: routeDeps, adapter });
+    mountJsonRoute({ app, spec: getActiveRoute, deps: routeDeps, adapter });
+}
+//# sourceMappingURL=active-context.js.map

package/dist/http/agents.d.ts

@@ -0,0 +1,68 @@
+/**
+ * @module agents
+ *
+ * `GET /api/agents` — lists the agents a host can expose to a client,
+ * including host-probed availability/model metadata when supplied.
+ * `POST /api/agents/rescan` asks the host to invalidate its discovery cache
+ * and probe again.
+ *
+ * `listAgents` is injected (matching `daemon-status.ts`/`active-context.ts`'s
+ * DI convention) rather than this module importing `@jini-ai/agent-runtime`
+ * directly — a host typically already has that package's `AGENT_DEFS` array
+ * in scope and just needs to project it, and this keeps this route pack from
+ * depending on subprocess discovery. The host owns probing,
+ * timeouts, caching, PATH/env policy, and the projection of spawn-only
+ * metadata; this transport only serializes the safe summary.
+ */
+import type { Express } from 'express';
+import { type AdapterContext } from '@jini-ai/http-kit';
+export interface AgentModelSummary {
+    readonly id: string;
+    readonly label: string;
+}
+/**
+ * Client-safe agent discovery data. Optional probe fields preserve the
+ * original static-registry contract for hosts that only expose `{id, name}`.
+ * Spawn internals (`bin`, resolved path, argv builders, env) never cross HTTP.
+ */
+export interface AgentSummary {
+    readonly id: string;
+    readonly name: string;
+    readonly available?: boolean;
+    readonly version?: string | null;
+    readonly authStatus?: 'ok' | 'missing' | 'unknown';
+    readonly models?: readonly AgentModelSummary[];
+    readonly reasoningOptions?: readonly AgentModelSummary[];
+    readonly modelsSource?: 'live' | 'fallback';
+    readonly supportsCustomModel?: boolean;
+    readonly diagnostic?: string;
+    /**
+     * Whether this runtime can receive external MCP servers (the host application's or this engine's
+     * own tools) at all, per
+     * `@jini-ai/agent-runtime`'s `runtimeSupportsExternalTools(def)` — the def-level source of
+     * truth. `undefined` means the host did not populate this field (pre-existing hosts on an older
+     * `@jini-ai/daemon/http` continue to omit it); a UI gating on this should treat `undefined` the same
+     * as `true` (no known reason to warn) rather than assuming the worst.
+     */
+    readonly supportsTools?: boolean;
+}
+export interface AgentsHttpDeps {
+    /** Returns the host's cached or freshly resolved client-safe agent inventory. */
+    readonly listAgents: () => Promise<readonly AgentSummary[]> | readonly AgentSummary[];
+    /** Forces host-owned discovery to run again. Falls back to `listAgents` when omitted. */
+    readonly rescanAgents?: () => Promise<readonly AgentSummary[]> | readonly AgentSummary[];
+}
+export interface AgentListResponse {
+    readonly agents: readonly AgentSummary[];
+}
+/** `GET /api/agents` — read-only, no side effects; matches `runListRoute`/`runStatusRoute`'s posture of not requiring same-origin. */
+export declare const agentListRoute: import("@jini-ai/http-kit").JsonRouteSpec<void, AgentListResponse, AgentsHttpDeps>;
+/** `POST /api/agents/rescan` — explicit state refresh, protected by the local same-origin gate. */
+export declare const agentRescanRoute: import("@jini-ai/http-kit").JsonRouteSpec<void, AgentListResponse, AgentsHttpDeps>;
+/** Mounts the read and explicit-rescan agent discovery routes. */
+export declare function registerAgentRoutes({ app, deps, adapter }: {
+    readonly app: Express;
+    readonly deps: AgentsHttpDeps;
+    readonly adapter: AdapterContext;
+}, _optional?: Record<string, never>): void;
+//# sourceMappingURL=agents.d.ts.map

package/dist/http/agents.js

@@ -0,0 +1,12 @@
+import { defineJsonRoute, mountJsonRoute } from '@jini-ai/http-kit';
+import { ok } from '@jini-ai/http-kit';
+/** `GET /api/agents` — read-only, no side effects; matches `runListRoute`/`runStatusRoute`'s posture of not requiring same-origin. */
+export const agentListRoute = defineJsonRoute({ method: 'get', path: '/api/agents', parse: () => ok({ value: undefined }), handle: async ({ input: _input, deps }) => ok({ value: { agents: await deps.listAgents() } }) });
+/** `POST /api/agents/rescan` — explicit state refresh, protected by the local same-origin gate. */
+export const agentRescanRoute = defineJsonRoute({ method: 'post', path: '/api/agents/rescan', parse: () => ok({ value: undefined }), handle: async ({ input: _input, deps }) => ok({ value: { agents: await (deps.rescanAgents ?? deps.listAgents)() } }) }, { requireSameOrigin: true });
+/** Mounts the read and explicit-rescan agent discovery routes. */
+export function registerAgentRoutes({ app, deps, adapter }, _optional = {}) {
+    mountJsonRoute({ app, spec: agentListRoute, deps, adapter });
+    mountJsonRoute({ app, spec: agentRescanRoute, deps, adapter });
+}
+//# sourceMappingURL=agents.js.map