@jini-ai/daemon 0.5.3 → 0.6.0

package/dist/http/daemon-status.d.ts

@@ -58,7 +58,7 @@ export interface DaemonShutdownResponse {
  * injectable readiness check) and are guaranteed reachable without a bearer token or an `Origin`
  * header. This route is still useful for a human/CLI wanting the richer operator detail below.
  */
-export declare const daemonStatusRoute: import("@jini-ai/http-kit").JsonRouteSpec<void, DaemonStatusResponse, DaemonStatusDeps>;
+export declare const daemonStatusRoute: import("@jini-ai/http-kit").JsonRouteSpec<void, DaemonStatusResponse, DaemonStatusDeps, undefined>;
 /**
  * `POST /api/daemon/shutdown` — schedules a graceful shutdown. Responds
  * immediately (matching the origin's behavior) and defers the actual
@@ -66,7 +66,7 @@ export declare const daemonStatusRoute: import("@jini-ai/http-kit").JsonRouteSpe
  * written before whatever the caller's shutdown callback does takes effect.
  * Gated same-origin: this is a control-plane action, not a public read.
  */
-export declare const daemonShutdownRoute: import("@jini-ai/http-kit").JsonRouteSpec<void, DaemonShutdownResponse, DaemonStatusDeps>;
+export declare const daemonShutdownRoute: import("@jini-ai/http-kit").JsonRouteSpec<void, DaemonShutdownResponse, DaemonStatusDeps, undefined>;
 /** Mounts both daemon-status routes on `app`. A pack's `http(app, services)` calls this directly. */
 export declare function registerDaemonStatusRoutes({ app, deps, adapter }: {
     readonly app: Express;

package/dist/http/db-ops.d.ts

@@ -107,13 +107,13 @@ export interface DaemonDbHttpDeps {
     readonly onInternalError?: (context: DaemonDbInternalErrorContext) => void;
 }
 /** `GET /api/daemon/db` — the database inventory (schema version, tables, row counts, size). */
-export declare const daemonDbInspectRoute: import("@jini-ai/http-kit").JsonRouteSpec<void, DaemonDbStatusReport, DaemonDbHttpDeps>;
+export declare const daemonDbInspectRoute: import("@jini-ai/http-kit").JsonRouteSpec<void, DaemonDbStatusReport, DaemonDbHttpDeps, undefined>;
 /** `POST /api/daemon/db/verify?quick=` — `PRAGMA integrity_check`/`quick_check` plus `foreign_key_check`. */
 export declare const daemonDbVerifyRoute: import("@jini-ai/http-kit").JsonRouteSpec<{
     quick: boolean;
-}, DbIntegrityReport, DaemonDbHttpDeps>;
+}, DbIntegrityReport, DaemonDbHttpDeps, undefined>;
 /** `POST /api/daemon/db/vacuum` — runs `VACUUM` and reports bytes reclaimed. */
-export declare const daemonDbVacuumRoute: import("@jini-ai/http-kit").JsonRouteSpec<void, DaemonDbVacuumResult, DaemonDbHttpDeps>;
+export declare const daemonDbVacuumRoute: import("@jini-ai/http-kit").JsonRouteSpec<void, DaemonDbVacuumResult, DaemonDbHttpDeps, undefined>;
 /** Mounts all three DB-ops routes on `app`. A pack's `http({ app, services })` calls this directly. */
 export declare function registerDaemonDbRoutes({ app, deps, adapter }: {
     readonly app: Express;

package/dist/http/delegated-tools.d.ts

@@ -103,7 +103,7 @@ export interface DelegatedToolsHttpDeps {
  * became terminal between this route's existence check and the bridge's first emitted event)
  * reaches the same SEC-005 redaction path.
  */
-export declare const delegatedToolExecuteRoute: import("@jini-ai/http-kit").JsonRouteSpec<DelegatedToolExecuteRequest, DelegatedToolExecuteResponse, DelegatedToolsHttpDeps>;
+export declare const delegatedToolExecuteRoute: import("@jini-ai/http-kit").JsonRouteSpec<DelegatedToolExecuteRequest, DelegatedToolExecuteResponse, DelegatedToolsHttpDeps, undefined>;
 /** Mounts `POST /api/delegated-tool-calls` on `app`. A pack's `http(app, services)` calls this directly. */
 export declare function registerDelegatedToolRoutes({ app, deps, adapter }: {
     readonly app: Express;

package/dist/http/delegated-tools.js

@@ -31,7 +31,7 @@ import { createDelegatedToolBridge } from '../index.js';
 import { defineJsonRoute, mountJsonRoute } from '@jini-ai/http-kit';
 import { validationError } from '@jini-ai/http-kit';
 import { err, ok } from '@jini-ai/http-kit';
-import * as readOnlyTools from '../read-only-tools.js';
+import * as readOnlyTools from '../core/read-only-tools.js';
 /** Route preflight shares the same registration decision as nested dispatch. */
 function checkReadOnlyConstraint(deps, input) {
     if (input.requireReadOnly !== true)

package/dist/http/frontend-sessions.d.ts

@@ -93,7 +93,7 @@ export declare function handleFrontendSessionStream({ req, res, deps }: {
  * handler awaiting it. Always `200`; `{settled:false}` reports a duplicate or unknown answer,
  * which is an expected outcome rather than a transport error.
  */
-export declare const frontendSessionResponseRoute: import("@jini-ai/http-kit").JsonRouteSpec<FrontendSessionResponseRequest, FrontendSessionResponseBody, FrontendSessionsHttpDeps>;
+export declare const frontendSessionResponseRoute: import("@jini-ai/http-kit").JsonRouteSpec<FrontendSessionResponseRequest, FrontendSessionResponseBody, FrontendSessionsHttpDeps, undefined>;
 /**
  * Mounts both frontend-session routes on `app`.
  *

package/dist/http/health.d.ts

@@ -80,12 +80,12 @@ export interface ReadinessResponse {
 export interface VersionResponse {
     readonly version: string;
 }
-export declare const healthRoute: import("@jini-ai/http-kit").JsonRouteSpec<void, LivenessResponse, HealthHttpDeps>;
-export declare const apiHealthRoute: import("@jini-ai/http-kit").JsonRouteSpec<void, LivenessResponse, HealthHttpDeps>;
-export declare const readyRoute: import("@jini-ai/http-kit").JsonRouteSpec<void, ReadinessResponse, HealthHttpDeps>;
-export declare const apiReadyRoute: import("@jini-ai/http-kit").JsonRouteSpec<void, ReadinessResponse, HealthHttpDeps>;
-export declare const versionInfoRoute: import("@jini-ai/http-kit").JsonRouteSpec<void, VersionResponse, HealthHttpDeps>;
-export declare const apiVersionInfoRoute: import("@jini-ai/http-kit").JsonRouteSpec<void, VersionResponse, HealthHttpDeps>;
+export declare const healthRoute: import("@jini-ai/http-kit").JsonRouteSpec<void, LivenessResponse, HealthHttpDeps, undefined>;
+export declare const apiHealthRoute: import("@jini-ai/http-kit").JsonRouteSpec<void, LivenessResponse, HealthHttpDeps, undefined>;
+export declare const readyRoute: import("@jini-ai/http-kit").JsonRouteSpec<void, ReadinessResponse, HealthHttpDeps, undefined>;
+export declare const apiReadyRoute: import("@jini-ai/http-kit").JsonRouteSpec<void, ReadinessResponse, HealthHttpDeps, undefined>;
+export declare const versionInfoRoute: import("@jini-ai/http-kit").JsonRouteSpec<void, VersionResponse, HealthHttpDeps, undefined>;
+export declare const apiVersionInfoRoute: import("@jini-ai/http-kit").JsonRouteSpec<void, VersionResponse, HealthHttpDeps, undefined>;
 /** Mounts all six health/readiness/version routes on `app`. Call this before installing `express.json()`/the bearer-auth/origin-guard middleware — see module doc. */
 export declare function registerHealthRoutes({ app, deps, adapter }: {
     readonly app: Express;

package/dist/http/host-tools.d.ts

@@ -164,7 +164,7 @@ export declare function listAvailableEditors(_required: Record<string, never>, {
     readonly probeEnv?: HostToolProbeEnv | undefined;
 }): Promise<HostEditorsResponse>;
 /** `GET /api/editors` — lists the host-tool catalogue applicable to this platform with live availability. */
-export declare const hostEditorsRoute: import("@jini-ai/http-kit").JsonRouteSpec<void, HostEditorsResponse, Record<string, never>>;
+export declare const hostEditorsRoute: import("@jini-ai/http-kit").JsonRouteSpec<void, HostEditorsResponse, Record<string, never>, undefined>;
 export interface OpenResourceInEditorRequest {
     readonly resourceRef: string;
     readonly editorId: string;
@@ -204,7 +204,7 @@ export interface HostToolsOpenInDeps {
  * operationally useful to the caller and does not cross a trust boundary
  * the way an internal agent-run exception can.
  */
-export declare const openResourceInEditorRoute: import("@jini-ai/http-kit").JsonRouteSpec<OpenResourceInEditorRequest, OpenResourceInEditorResponse, HostToolsOpenInDeps>;
+export declare const openResourceInEditorRoute: import("@jini-ai/http-kit").JsonRouteSpec<OpenResourceInEditorRequest, OpenResourceInEditorResponse, HostToolsOpenInDeps, undefined>;
 /** Mounts `GET /api/editors` and `POST /api/resources/:resourceRef/open-in` on `app`. A pack's `http(app, services)` calls this directly. */
 export declare function registerHostToolsRoutes({ app, adapter }: {
     readonly app: Express;

package/dist/http/index.d.ts

@@ -9,8 +9,8 @@ export type { CatalogueEntry, HostEditor, HostEditorsResponse, HostToolLaunchPla
 export { applicableForPlatform, CATALOGUE, currentPlatform, defaultProbeEnv, hostEditorsRoute, launchHostTool, listAvailableEditors, pathDirs, probeCommandOnPath, probeMacBundle, registerHostToolsRoutes, resolveEntry, resolveHostToolLaunchPlan, } from './host-tools.js';
 export type { DaemonShutdownResponse, DaemonStatusDeps, DaemonStatusResponse, } from './daemon-status.js';
 export { daemonShutdownRoute, daemonStatusRoute, registerDaemonStatusRoutes } from './daemon-status.js';
-export type { RunCancelResponse, RunCreateRequest, RunHttpDeps, RunInternalErrorContext, RunListResponse, RunStartContext, RunStartHandler, RunStartResponse, RunStatusResponse, } from './runs.js';
-export { registerRunEventStream, registerRunRoutes, RUN_EVENTS_ROUTE_PATH, runCancelRoute, runListRoute, runStartRoute, runStatusRoute, } from './runs.js';
+export type { RunCancelResponse, RunCreateRequest, RunHttpDeps, RunInternalErrorContext, RunListResponse, RunStartContext, RunMessageRequest, RunMessageResponse, RunStartHandler, RunStartResponse, RunStatusResponse, } from './runs.js';
+export { registerRunEventStream, registerRunRoutes, RUN_EVENTS_ROUTE_PATH, runCancelRoute, runListRoute, runMessageRoute, RUN_MESSAGE_MAX_CHARS, runStartRoute, runStatusRoute, } from './runs.js';
 export { JINI_ROUTE_MANIFEST, manifestRoutesForFamilies, routeFamilyManifest } from './route-manifest.js';
 export type { AgentListResponse, AgentModelSummary, AgentsHttpDeps, AgentSummary } from './agents.js';
 export { agentListRoute, agentRescanRoute, registerAgentRoutes } from './agents.js';

package/dist/http/index.js

@@ -3,7 +3,7 @@ export { cancelRunsOwnedBy } from './cancel-owned-runs.js';
 export { ACTIVE_CONTEXT_TTL_MS, getActiveRoute, registerActiveContextRoutes, setActiveRoute, } from './active-context.js';
 export { applicableForPlatform, CATALOGUE, currentPlatform, defaultProbeEnv, hostEditorsRoute, launchHostTool, listAvailableEditors, pathDirs, probeCommandOnPath, probeMacBundle, registerHostToolsRoutes, resolveEntry, resolveHostToolLaunchPlan, } from './host-tools.js';
 export { daemonShutdownRoute, daemonStatusRoute, registerDaemonStatusRoutes } from './daemon-status.js';
-export { registerRunEventStream, registerRunRoutes, RUN_EVENTS_ROUTE_PATH, runCancelRoute, runListRoute, runStartRoute, runStatusRoute, } from './runs.js';
+export { registerRunEventStream, registerRunRoutes, RUN_EVENTS_ROUTE_PATH, runCancelRoute, runListRoute, runMessageRoute, RUN_MESSAGE_MAX_CHARS, runStartRoute, runStatusRoute, } from './runs.js';
 export { JINI_ROUTE_MANIFEST, manifestRoutesForFamilies, routeFamilyManifest } from './route-manifest.js';
 export { agentListRoute, agentRescanRoute, registerAgentRoutes } from './agents.js';
 export { memoryClearExtractionsRoute, memoryClearVerificationsRoute, memoryCreateEntryRoute, memoryDeleteEntryRoute, memoryListExtractionsRoute, memoryListVerificationsRoute, memoryOverviewRoute, memoryReadEntryRoute, memoryRemoveExtractionRoute, memoryRemoveVerificationRoute, memoryTreeRoute, memoryUpdateEntryRoute, memoryUpdateTreeNodeRoute, memoryWriteConfigRoute, memoryWriteIndexRoute, registerMemoryEventStream, registerMemoryRoutes, } from './memory.js';

package/dist/http/media.d.ts

@@ -123,19 +123,19 @@ interface MediaTaskListQuery {
 export interface MediaGenerateResponse {
     readonly task: MediaTask;
 }
-export declare const mediaGenerateRoute: import("@jini-ai/http-kit").JsonRouteSpec<MediaGenerateRequest, MediaGenerateResponse, MediaHttpDeps>;
+export declare const mediaGenerateRoute: import("@jini-ai/http-kit").JsonRouteSpec<MediaGenerateRequest, MediaGenerateResponse, MediaHttpDeps, undefined>;
 export interface MediaTaskResponse {
     readonly task: MediaTask;
 }
-export declare const mediaTaskGetRoute: import("@jini-ai/http-kit").JsonRouteSpec<string, MediaTaskResponse, MediaHttpDeps>;
+export declare const mediaTaskGetRoute: import("@jini-ai/http-kit").JsonRouteSpec<string, MediaTaskResponse, MediaHttpDeps, undefined>;
 export interface MediaTaskDeleteResponse {
     readonly ok: true;
 }
-export declare const mediaTaskDeleteRoute: import("@jini-ai/http-kit").JsonRouteSpec<string, MediaTaskDeleteResponse, MediaHttpDeps>;
+export declare const mediaTaskDeleteRoute: import("@jini-ai/http-kit").JsonRouteSpec<string, MediaTaskDeleteResponse, MediaHttpDeps, undefined>;
 export interface MediaTaskListResponse {
     readonly tasks: readonly MediaTask[];
 }
-export declare const mediaTaskListRoute: import("@jini-ai/http-kit").JsonRouteSpec<MediaTaskListQuery, MediaTaskListResponse, MediaHttpDeps>;
+export declare const mediaTaskListRoute: import("@jini-ai/http-kit").JsonRouteSpec<MediaTaskListQuery, MediaTaskListResponse, MediaHttpDeps, undefined>;
 /** Mounts every media route on `app`. A pack's `http(app, services)` calls this directly. */
 export declare function registerMediaRoutes({ app, deps, adapter }: {
     readonly app: Express;

package/dist/http/memory.d.ts

@@ -162,13 +162,13 @@ export interface MemoryOverviewResponse {
     readonly index: string;
     readonly entries: readonly MemoryNoteEntrySummary[];
 }
-export declare const memoryOverviewRoute: import("@jini-ai/http-kit").JsonRouteSpec<void, MemoryOverviewResponse, MemoryHttpDeps>;
+export declare const memoryOverviewRoute: import("@jini-ai/http-kit").JsonRouteSpec<void, MemoryOverviewResponse, MemoryHttpDeps, undefined>;
 export interface MemoryTreeResponse {
     readonly enabled: boolean;
     readonly rootDir: string;
     readonly tree: readonly MemoryTreeNode[];
 }
-export declare const memoryTreeRoute: import("@jini-ai/http-kit").JsonRouteSpec<void, MemoryTreeResponse, MemoryHttpDeps>;
+export declare const memoryTreeRoute: import("@jini-ai/http-kit").JsonRouteSpec<void, MemoryTreeResponse, MemoryHttpDeps, undefined>;
 export interface MemoryTreeNodePatch {
     readonly name?: string;
     readonly description?: string;
@@ -183,30 +183,30 @@ export interface MemoryUpdateTreeNodeResponse {
     readonly entry: MemoryNoteEntry;
     readonly tree: readonly MemoryTreeNode[];
 }
-export declare const memoryUpdateTreeNodeRoute: import("@jini-ai/http-kit").JsonRouteSpec<MemoryUpdateTreeNodeInput, MemoryUpdateTreeNodeResponse, MemoryHttpDeps>;
+export declare const memoryUpdateTreeNodeRoute: import("@jini-ai/http-kit").JsonRouteSpec<MemoryUpdateTreeNodeInput, MemoryUpdateTreeNodeResponse, MemoryHttpDeps, undefined>;
 export interface MemoryIndexResponse {
     readonly index: string;
 }
-export declare const memoryWriteIndexRoute: import("@jini-ai/http-kit").JsonRouteSpec<string, MemoryIndexResponse, MemoryHttpDeps>;
+export declare const memoryWriteIndexRoute: import("@jini-ai/http-kit").JsonRouteSpec<string, MemoryIndexResponse, MemoryHttpDeps, undefined>;
 export interface MemoryConfigResponse {
     readonly enabled: boolean;
 }
-export declare const memoryWriteConfigRoute: import("@jini-ai/http-kit").JsonRouteSpec<Partial<MemoryNoteStoreOptions>, MemoryConfigResponse, MemoryHttpDeps>;
+export declare const memoryWriteConfigRoute: import("@jini-ai/http-kit").JsonRouteSpec<Partial<MemoryNoteStoreOptions>, MemoryConfigResponse, MemoryHttpDeps, undefined>;
 export interface MemoryExtractionsResponse {
     readonly extractions: readonly unknown[];
 }
-export declare const memoryListExtractionsRoute: import("@jini-ai/http-kit").JsonRouteSpec<void, MemoryExtractionsResponse, MemoryHttpDeps>;
+export declare const memoryListExtractionsRoute: import("@jini-ai/http-kit").JsonRouteSpec<void, MemoryExtractionsResponse, MemoryHttpDeps, undefined>;
 export interface MemoryRemovedResponse {
     readonly removed: number;
 }
-export declare const memoryClearExtractionsRoute: import("@jini-ai/http-kit").JsonRouteSpec<void, MemoryRemovedResponse, MemoryHttpDeps>;
-export declare const memoryRemoveExtractionRoute: import("@jini-ai/http-kit").JsonRouteSpec<string, MemoryRemovedResponse, MemoryHttpDeps>;
+export declare const memoryClearExtractionsRoute: import("@jini-ai/http-kit").JsonRouteSpec<void, MemoryRemovedResponse, MemoryHttpDeps, undefined>;
+export declare const memoryRemoveExtractionRoute: import("@jini-ai/http-kit").JsonRouteSpec<string, MemoryRemovedResponse, MemoryHttpDeps, undefined>;
 export interface MemoryVerificationsResponse {
     readonly verifications: readonly unknown[];
 }
-export declare const memoryListVerificationsRoute: import("@jini-ai/http-kit").JsonRouteSpec<void, MemoryVerificationsResponse, MemoryHttpDeps>;
-export declare const memoryClearVerificationsRoute: import("@jini-ai/http-kit").JsonRouteSpec<void, MemoryRemovedResponse, MemoryHttpDeps>;
-export declare const memoryRemoveVerificationRoute: import("@jini-ai/http-kit").JsonRouteSpec<string, MemoryRemovedResponse, MemoryHttpDeps>;
+export declare const memoryListVerificationsRoute: import("@jini-ai/http-kit").JsonRouteSpec<void, MemoryVerificationsResponse, MemoryHttpDeps, undefined>;
+export declare const memoryClearVerificationsRoute: import("@jini-ai/http-kit").JsonRouteSpec<void, MemoryRemovedResponse, MemoryHttpDeps, undefined>;
+export declare const memoryRemoveVerificationRoute: import("@jini-ai/http-kit").JsonRouteSpec<string, MemoryRemovedResponse, MemoryHttpDeps, undefined>;
 export interface MemoryEntryInput {
     readonly id?: string;
     readonly name: string;
@@ -217,17 +217,17 @@ export interface MemoryEntryInput {
 export interface MemoryEntryResponse {
     readonly entry: MemoryNoteEntry;
 }
-export declare const memoryCreateEntryRoute: import("@jini-ai/http-kit").JsonRouteSpec<MemoryEntryInput, MemoryEntryResponse, MemoryHttpDeps>;
-export declare const memoryReadEntryRoute: import("@jini-ai/http-kit").JsonRouteSpec<string, MemoryEntryResponse, MemoryHttpDeps>;
+export declare const memoryCreateEntryRoute: import("@jini-ai/http-kit").JsonRouteSpec<MemoryEntryInput, MemoryEntryResponse, MemoryHttpDeps, undefined>;
+export declare const memoryReadEntryRoute: import("@jini-ai/http-kit").JsonRouteSpec<string, MemoryEntryResponse, MemoryHttpDeps, undefined>;
 interface MemoryUpdateEntryInput {
     readonly id: string;
     readonly input: MemoryEntryInput;
 }
-export declare const memoryUpdateEntryRoute: import("@jini-ai/http-kit").JsonRouteSpec<MemoryUpdateEntryInput, MemoryEntryResponse, MemoryHttpDeps>;
+export declare const memoryUpdateEntryRoute: import("@jini-ai/http-kit").JsonRouteSpec<MemoryUpdateEntryInput, MemoryEntryResponse, MemoryHttpDeps, undefined>;
 export interface MemoryDeleteEntryResponse {
     readonly ok: true;
 }
-export declare const memoryDeleteEntryRoute: import("@jini-ai/http-kit").JsonRouteSpec<string, MemoryDeleteEntryResponse, MemoryHttpDeps>;
+export declare const memoryDeleteEntryRoute: import("@jini-ai/http-kit").JsonRouteSpec<string, MemoryDeleteEntryResponse, MemoryHttpDeps, undefined>;
 /**
  * `GET /api/memory/events` — one SSE connection multiplexing three channels
  * (matching OD's own reasoning: "so the browser opens one connection instead

package/dist/http/remote-run-events.d.ts

@@ -54,8 +54,8 @@ export interface RemoteToolResultRequest {
 export interface RemoteRunEventResponse {
     readonly recorded: true;
 }
-export declare const remoteToolUseRoute: import("@jini-ai/http-kit").JsonRouteSpec<RemoteToolUseRequest, RemoteRunEventResponse, RemoteRunEventHttpDeps>;
-export declare const remoteToolResultRoute: import("@jini-ai/http-kit").JsonRouteSpec<RemoteToolResultRequest, RemoteRunEventResponse, RemoteRunEventHttpDeps>;
+export declare const remoteToolUseRoute: import("@jini-ai/http-kit").JsonRouteSpec<RemoteToolUseRequest, RemoteRunEventResponse, RemoteRunEventHttpDeps, undefined>;
+export declare const remoteToolResultRoute: import("@jini-ai/http-kit").JsonRouteSpec<RemoteToolResultRequest, RemoteRunEventResponse, RemoteRunEventHttpDeps, undefined>;
 /**
  * Mounts both remote-run-event routes on `app`, gated by {@link requireRemoteToolBridgeToken}.
  * Unlike `registerRunRoutes`/`registerDelegatedToolRoutes`, these routes do not use

package/dist/http/research.d.ts

@@ -37,7 +37,7 @@ interface ResearchSearchRequest {
     readonly query: string;
     readonly maxSources?: number;
 }
-export declare const researchSearchRoute: import("@jini-ai/http-kit").JsonRouteSpec<ResearchSearchRequest, ResearchSearchResponse, ResearchHttpDeps>;
+export declare const researchSearchRoute: import("@jini-ai/http-kit").JsonRouteSpec<ResearchSearchRequest, ResearchSearchResponse, ResearchHttpDeps, undefined>;
 /** Mounts `POST /api/research/search` on `app`. A pack's `http(app, services)` calls this directly. */
 export declare function registerResearchRoutes({ app, deps, adapter }: {
     readonly app: Express;

package/dist/http/route-manifest.js

@@ -31,7 +31,7 @@
 import { agentListRoute, agentRescanRoute } from './agents.js';
 import { delegatedToolExecuteRoute } from './delegated-tools.js';
 import { apiHealthRoute, apiReadyRoute, apiVersionInfoRoute, healthRoute, readyRoute, versionInfoRoute, } from './health.js';
-import { RUN_EVENTS_ROUTE_PATH, runCancelRoute, runListRoute, runStartRoute, runStatusRoute, } from './runs.js';
+import { RUN_EVENTS_ROUTE_PATH, runCancelRoute, runMessageRoute, runListRoute, runStartRoute, runStatusRoute, } from './runs.js';
 import { toolCatalogDescribeRoute, toolCatalogSearchRoute } from './tool-catalog.js';
 /**
  * Projects route specs onto `RouteRegistration`s, upper-casing the method so entries compare directly
@@ -52,7 +52,7 @@ function fromSpecs(...specs) {
 export const JINI_ROUTE_MANIFEST = {
     health: fromSpecs(healthRoute, apiHealthRoute, readyRoute, apiReadyRoute, versionInfoRoute, apiVersionInfoRoute),
     runs: [
-        ...fromSpecs(runStartRoute, runListRoute, runStatusRoute, runCancelRoute),
+        ...fromSpecs(runStartRoute, runListRoute, runStatusRoute, runCancelRoute, runMessageRoute),
         // Registered with a bare `app.get` rather than a route spec (by `registerRunRoutes` itself), so
         // it contributes its exported path constant instead of a copied literal.
         { method: 'GET', path: RUN_EVENTS_ROUTE_PATH },

package/dist/http/routines.d.ts

@@ -87,17 +87,17 @@ interface RoutineRunsQuery {
 export interface RoutineListResponse {
     readonly routines: readonly Routine[];
 }
-export declare const routineListRoute: import("@jini-ai/http-kit").JsonRouteSpec<void, RoutineListResponse, RoutineHttpDeps>;
+export declare const routineListRoute: import("@jini-ai/http-kit").JsonRouteSpec<void, RoutineListResponse, RoutineHttpDeps, undefined>;
 export interface RoutineResponse {
     readonly routine: Routine;
 }
-export declare const routineCreateRoute: import("@jini-ai/http-kit").JsonRouteSpec<RoutineCreateInput, RoutineResponse, RoutineHttpDeps>;
-export declare const routineGetRoute: import("@jini-ai/http-kit").JsonRouteSpec<string, RoutineResponse, RoutineHttpDeps>;
-export declare const routineUpdateRoute: import("@jini-ai/http-kit").JsonRouteSpec<RoutineUpdateRequest, RoutineResponse, RoutineHttpDeps>;
+export declare const routineCreateRoute: import("@jini-ai/http-kit").JsonRouteSpec<RoutineCreateInput, RoutineResponse, RoutineHttpDeps, undefined>;
+export declare const routineGetRoute: import("@jini-ai/http-kit").JsonRouteSpec<string, RoutineResponse, RoutineHttpDeps, undefined>;
+export declare const routineUpdateRoute: import("@jini-ai/http-kit").JsonRouteSpec<RoutineUpdateRequest, RoutineResponse, RoutineHttpDeps, undefined>;
 export interface RoutineDeleteResponse {
     readonly ok: true;
 }
-export declare const routineDeleteRoute: import("@jini-ai/http-kit").JsonRouteSpec<string, RoutineDeleteResponse, RoutineHttpDeps>;
+export declare const routineDeleteRoute: import("@jini-ai/http-kit").JsonRouteSpec<string, RoutineDeleteResponse, RoutineHttpDeps, undefined>;
 export interface RoutineRunNowResponse {
     readonly routine: Routine | null;
     readonly run: RoutineRun | null;
@@ -105,11 +105,11 @@ export interface RoutineRunNowResponse {
     readonly conversationId: string;
     readonly agentRunId: string;
 }
-export declare const routineRunNowRoute: import("@jini-ai/http-kit").JsonRouteSpec<string, RoutineRunNowResponse, RoutineHttpDeps>;
+export declare const routineRunNowRoute: import("@jini-ai/http-kit").JsonRouteSpec<string, RoutineRunNowResponse, RoutineHttpDeps, undefined>;
 export interface RoutineRunsResponse {
     readonly runs: readonly RoutineRun[];
 }
-export declare const routineRunsListRoute: import("@jini-ai/http-kit").JsonRouteSpec<RoutineRunsQuery, RoutineRunsResponse, RoutineHttpDeps>;
+export declare const routineRunsListRoute: import("@jini-ai/http-kit").JsonRouteSpec<RoutineRunsQuery, RoutineRunsResponse, RoutineHttpDeps, undefined>;
 /** Mounts every routine route on `app`. A pack's `http(app, services)` calls this directly. */
 export declare function registerRoutineRoutes({ app, deps, adapter }: {
     readonly app: Express;

package/dist/http/run-credentials.d.ts

@@ -48,7 +48,7 @@ export interface RunOwnershipRequired {
 /** Mount after authentication on routes with a runId parameter. Denial envelopes pass through intact.
  * @complexity O(1) adapter work plus the injected ownership lookup; no storage or identity defaults.
  */
-export declare function createRunOwnershipMiddleware({ authorize, principalHeaderName, isEventStream }: RunOwnershipRequired): RequestHandler;
+export declare function createRunOwnershipMiddleware({ authorize, principalHeaderName, isEventStream }: RunOwnershipRequired, _optional?: Record<string, never>): RequestHandler;
 export interface OwnedRunListRequired<Run> {
     readonly principalHeaderName: string;
     readonly listRuns: (required: Record<string, never>, optional: {
@@ -69,5 +69,5 @@ export interface OwnedRunListRequired<Run> {
  * Missing principals receive the existing 401 envelope before the list port is called.
  * @complexity O(n) policy filtering for n listed runs; O(1) adapter space excluding results.
  */
-export declare function createOwnedRunListHandler<Run>({ listRuns, filterOwnedRuns, principalHeaderName }: OwnedRunListRequired<Run>): RequestHandler;
+export declare function createOwnedRunListHandler<Run>({ listRuns, filterOwnedRuns, principalHeaderName }: OwnedRunListRequired<Run>, _optional?: Record<string, never>): RequestHandler;
 //# sourceMappingURL=run-credentials.d.ts.map

package/dist/http/run-credentials.js

@@ -27,7 +27,7 @@ export function createDaemonAuthMiddleware({ authorize, authorizationHeaderName
 /** Mount after authentication on routes with a runId parameter. Denial envelopes pass through intact.
  * @complexity O(1) adapter work plus the injected ownership lookup; no storage or identity defaults.
  */
-export function createRunOwnershipMiddleware({ authorize, principalHeaderName, isEventStream }) {
+export function createRunOwnershipMiddleware({ authorize, principalHeaderName, isEventStream }, _optional = {}) {
     return async (req, res, next) => {
         try {
             const decision = await authorize({ runId: req.params.runId || undefined, principalId: req.get(principalHeaderName) || undefined, eventStream: isEventStream({ path: req.path }) });
@@ -46,7 +46,7 @@ export function createRunOwnershipMiddleware({ authorize, principalHeaderName, i
  * Missing principals receive the existing 401 envelope before the list port is called.
  * @complexity O(n) policy filtering for n listed runs; O(1) adapter space excluding results.
  */
-export function createOwnedRunListHandler({ listRuns, filterOwnedRuns, principalHeaderName }) {
+export function createOwnedRunListHandler({ listRuns, filterOwnedRuns, principalHeaderName }, _optional = {}) {
     return async (req, res, next) => {
         try {
             const principalId = req.get(principalHeaderName) || undefined;

package/dist/http/runs.d.ts

@@ -1,6 +1,6 @@
 import type { Express } from 'express';
 import { type RunStatus } from '@jini-ai/protocol';
-import type { RunLifecycle } from '../index.js';
+import type { RunLifecycle, UserMessageDelivery } from '../index.js';
 import { type AdapterContext } from '@jini-ai/http-kit';
 import type { ServerResponse } from 'node:http';
 /**
@@ -34,6 +34,15 @@ export interface RunHttpDeps {
     readonly onStarted?: RunStartHandler;
     /** Host-owned sink for the real exception behind a generic `INTERNAL_ERROR` response (SEC-005). Defaults to `console.error`. */
     readonly onInternalError?: (context: RunInternalErrorContext) => void;
+    /**
+     * Delivers a message the human sent mid-run into that run's live agent — a host passes its
+     * `AgentExecutor.sendUserMessage`. Omitted, every such message reports `'unsupported'`, so the
+     * client falls back to interrupting the run and sending the text as the next turn.
+     */
+    readonly deliverUserMessage?: (input: {
+        readonly runId: string;
+        readonly text: string;
+    }) => UserMessageDelivery | Promise<UserMessageDelivery>;
 }
 export interface RunStartResponse {
     readonly run: RunStatus;
@@ -45,19 +54,35 @@ export interface RunStatusResponse {
 export interface RunCancelResponse {
     readonly run: RunStatus;
 }
+export interface RunMessageRequest {
+    readonly runId: string;
+    readonly text: string;
+}
+export interface RunMessageResponse {
+    readonly delivery: 'delivered';
+}
+/** Ceiling on one mid-run message, matching what a person can reasonably type or paste into a composer. */
+export declare const RUN_MESSAGE_MAX_CHARS = 100000;
 export interface RunListResponse {
     readonly runs: readonly RunStatus[];
 }
-export declare const runStartRoute: import("@jini-ai/http-kit").JsonRouteSpec<RunCreateRequest, RunStartResponse, RunHttpDeps>;
+export declare const runStartRoute: import("@jini-ai/http-kit").JsonRouteSpec<RunCreateRequest, RunStartResponse, RunHttpDeps, undefined>;
 /** `GET /api/runs` — lists runs, optionally scoped to a `contextRef` query parameter. */
 export declare const runListRoute: import("@jini-ai/http-kit").JsonRouteSpec<{
     contextRef?: string;
-}, RunListResponse, RunHttpDeps>;
-export declare const runStatusRoute: import("@jini-ai/http-kit").JsonRouteSpec<string, RunStatusResponse, RunHttpDeps>;
+}, RunListResponse, RunHttpDeps, undefined>;
+export declare const runStatusRoute: import("@jini-ai/http-kit").JsonRouteSpec<string, RunStatusResponse, RunHttpDeps, undefined>;
 export declare const runCancelRoute: import("@jini-ai/http-kit").JsonRouteSpec<{
     runId: string;
     reason?: string;
-}, RunCancelResponse, RunHttpDeps>;
+}, RunCancelResponse, RunHttpDeps, undefined>;
+/**
+ * `POST /api/runs/:runId/messages` — a message the human sent while the run is going. `202` when it
+ * reached the live agent; `409 CONFLICT` with `details.delivery` (`'unsupported'` or
+ * `'not-running'`) when it did not, which tells the client whether to interrupt the run and send the
+ * text as the next turn, or simply send it next because the run is already ending.
+ */
+export declare const runMessageRoute: import("@jini-ai/http-kit").JsonRouteSpec<RunMessageRequest, RunMessageResponse, RunHttpDeps, undefined>;
 /**
  * The core of `GET /api/runs/:runId/events` — canonical events as SSE, with Last-Event-ID
  * reconnect support. Takes `runId`/`afterCursor` already resolved by the caller. `res` is typed
@@ -82,7 +107,7 @@ export declare function registerRunEventStream({ app, deps }: {
     readonly app: Express;
     readonly deps: RunHttpDeps;
 }, _optional?: Record<string, never>): void;
-/** Mounts create/status/cancel JSON endpoints and the SSE event stream as one run transport. */
+/** Mounts create/status/cancel/message JSON endpoints and the SSE event stream as one run transport. */
 export declare function registerRunRoutes({ app, deps, adapter }: {
     readonly app: Express;
     readonly deps: RunHttpDeps;

package/dist/http/runs.js

@@ -57,6 +57,23 @@ function parseRunCreate(input) {
         }
     });
 }
+/** Ceiling on one mid-run message, matching what a person can reasonably type or paste into a composer. */
+export const RUN_MESSAGE_MAX_CHARS = 100_000;
+function parseRunMessage(input) {
+    const parsedRunId = parseRunId(input);
+    if (!parsedRunId.ok)
+        return parsedRunId;
+    if (!isRecord(input.body))
+        return err({ error: validationError({ message: 'body must be a JSON object' }) });
+    const text = optionalString(input.body, 'text');
+    if (text === undefined || text === null) {
+        return err({ error: validationError({ message: 'text must be a non-empty string' }, { issues: [{ path: 'text', message: 'required non-empty string' }] }) });
+    }
+    if (text.length > RUN_MESSAGE_MAX_CHARS) {
+        return err({ error: validationError({ message: `text must be at most ${RUN_MESSAGE_MAX_CHARS} characters` }, { issues: [{ path: 'text', message: 'too long' }] }) });
+    }
+    return ok({ value: { runId: parsedRunId.value, text } });
+}
 function parseRunList(input) {
     const value = input.query.contextRef;
     if (value === undefined)
@@ -121,6 +138,23 @@ export const runCancelRoute = defineJsonRoute({
         return ok({ value: { run: await deps.lifecycle.cancel(input) } });
     }
 }, { requireSameOrigin: true });
+/**
+ * `POST /api/runs/:runId/messages` — a message the human sent while the run is going. `202` when it
+ * reached the live agent; `409 CONFLICT` with `details.delivery` (`'unsupported'` or
+ * `'not-running'`) when it did not, which tells the client whether to interrupt the run and send the
+ * text as the next turn, or simply send it next because the run is already ending.
+ */
+export const runMessageRoute = defineJsonRoute({
+    method: 'post', path: '/api/runs/:runId/messages', parse: parseRunMessage, handle: async ({ input, deps }) => {
+        const run = await deps.lifecycle.get({ runId: input.runId });
+        if (run === undefined)
+            return err({ error: createApiError({ code: 'NOT_FOUND', message: `run "${input.runId}" was not found` }) });
+        const delivery = deps.deliverUserMessage ? await deps.deliverUserMessage({ runId: input.runId, text: input.text }) : 'unsupported';
+        if (delivery === 'delivered')
+            return ok({ value: { delivery } });
+        return err({ error: createApiError({ code: 'CONFLICT', message: `run "${input.runId}" did not take the message` }, { details: { delivery } }) });
+    }
+}, { requireSameOrigin: true, successStatus: 202 });
 function sendStreamFailure(res, kind) {
     if (kind.kind === 'unknown-run') {
         sendRawApiError({ res, status: 404, error: createApiError({ code: 'NOT_FOUND', message: 'run was not found' }) });
@@ -210,12 +244,13 @@ export function registerRunEventStream({ app, deps }, _optional = {}) {
         await handleRunEventStreamRequest({ res, runId, afterCursor: requestedAfterCursor(req), deps });
     });
 }
-/** Mounts create/status/cancel JSON endpoints and the SSE event stream as one run transport. */
+/** Mounts create/status/cancel/message JSON endpoints and the SSE event stream as one run transport. */
 export function registerRunRoutes({ app, deps, adapter }, _optional = {}) {
     mountJsonRoute({ app, spec: runStartRoute, deps, adapter });
     mountJsonRoute({ app, spec: runListRoute, deps, adapter });
     mountJsonRoute({ app, spec: runStatusRoute, deps, adapter });
     mountJsonRoute({ app, spec: runCancelRoute, deps, adapter });
+    mountJsonRoute({ app, spec: runMessageRoute, deps, adapter });
     registerRunEventStream({ app, deps });
 }
 //# sourceMappingURL=runs.js.map

package/dist/http/terminals.d.ts

@@ -35,14 +35,14 @@ export interface TerminalCreateRequest {
  * open-in route does, then authorizes+spawns the session through
  * `ToolExecutor.execute(..., 'terminal.create', ...)`.
  */
-export declare const terminalCreateRoute: import("@jini-ai/http-kit").JsonRouteSpec<TerminalCreateRequest, TerminalSessionInfo, TerminalsHttpDeps>;
+export declare const terminalCreateRoute: import("@jini-ai/http-kit").JsonRouteSpec<TerminalCreateRequest, TerminalSessionInfo, TerminalsHttpDeps, undefined>;
 export interface TerminalListResponse {
     readonly terminals: readonly TerminalSessionInfo[];
 }
 /** `GET /api/terminals` — sessions the calling principal owns, optionally narrowed by `resourceRef`. Never gated through `ToolExecutor` — a read scoped to the caller's own sessions, matching `runs.ts`'s `runListRoute` precedent. */
 export declare const terminalListRoute: import("@jini-ai/http-kit").JsonRouteSpec<{
     resourceRef?: string;
-}, TerminalListResponse, TerminalsHttpDeps>;
+}, TerminalListResponse, TerminalsHttpDeps, undefined>;
 export interface TerminalActionResponse {
     readonly ok: boolean;
     readonly terminal?: TerminalSessionInfo;
@@ -64,17 +64,17 @@ export declare function actionResultToApiResult({ result, notFoundMessage }: {
 export declare const terminalStdinRoute: import("@jini-ai/http-kit").JsonRouteSpec<{
     id: string;
     data: string;
-}, TerminalActionResponse, TerminalsHttpDeps>;
+}, TerminalActionResponse, TerminalsHttpDeps, undefined>;
 /** `POST /api/terminals/:id/resize` — resizes the session's pty. */
 export declare const terminalResizeRoute: import("@jini-ai/http-kit").JsonRouteSpec<{
     id: string;
     cols: number;
     rows: number;
-}, TerminalActionResponse, TerminalsHttpDeps>;
+}, TerminalActionResponse, TerminalsHttpDeps, undefined>;
 /** `POST /api/terminals/:id/kill` — sends `SIGTERM` to the session's pty. */
-export declare const terminalKillRoute: import("@jini-ai/http-kit").JsonRouteSpec<string, TerminalActionResponse, TerminalsHttpDeps>;
+export declare const terminalKillRoute: import("@jini-ai/http-kit").JsonRouteSpec<string, TerminalActionResponse, TerminalsHttpDeps, undefined>;
 /** `DELETE /api/terminals/:id` — alias for `kill`, matching OD's dual `POST .../kill` / `DELETE` routes. */
-export declare const terminalDeleteRoute: import("@jini-ai/http-kit").JsonRouteSpec<string, TerminalActionResponse, TerminalsHttpDeps>;
+export declare const terminalDeleteRoute: import("@jini-ai/http-kit").JsonRouteSpec<string, TerminalActionResponse, TerminalsHttpDeps, undefined>;
 /** The one method {@link createDeferredEndGate} needs from `sse.ts`'s channel — narrowed so the gate is unit-testable against a bare fake, not a real `SseChannel`. */
 interface DeferredEndChannel {
     end(): void;

package/dist/http/tool-catalog.d.ts

@@ -52,7 +52,7 @@ export declare const toolCatalogSearchRoute: import("@jini-ai/http-kit").JsonRou
     limit: number;
 }, {
     hits: readonly ToolCatalogSearchHit[];
-}, ToolCatalogHttpDeps>;
+}, ToolCatalogHttpDeps, undefined>;
 /**
  * `GET /api/tools/:id` — full descriptor (schema included), paid for only once a candidate survives
  * search.
@@ -68,7 +68,7 @@ export declare const toolCatalogSearchRoute: import("@jini-ai/http-kit").JsonRou
  */
 export declare const toolCatalogDescribeRoute: import("@jini-ai/http-kit").JsonRouteSpec<{
     id: string;
-}, ToolCatalogEntry, ToolCatalogHttpDeps>;
+}, ToolCatalogEntry, ToolCatalogHttpDeps, undefined>;
 /** Mounts both tool-catalog routes on `app`. A pack's `http({ app, services })` calls this directly. */
 export declare function registerToolCatalogRoutes({ app, deps, adapter }: {
     readonly app: Express;

package/dist/http/xai.d.ts

@@ -45,7 +45,7 @@ export interface XaiOauthStartResponse {
         readonly port: number;
     };
 }
-export declare const xaiOauthStartRoute: import("@jini-ai/http-kit").JsonRouteSpec<void, XaiOauthStartResponse, XaiHttpDeps>;
+export declare const xaiOauthStartRoute: import("@jini-ai/http-kit").JsonRouteSpec<void, XaiOauthStartResponse, XaiHttpDeps, undefined>;
 export interface XaiOkResponse {
     readonly ok: true;
 }
@@ -53,8 +53,8 @@ interface XaiOauthCompleteRequest {
     readonly state: string;
     readonly code: string;
 }
-export declare const xaiOauthCompleteRoute: import("@jini-ai/http-kit").JsonRouteSpec<XaiOauthCompleteRequest, XaiOkResponse, XaiHttpDeps>;
-export declare const xaiOauthCancelRoute: import("@jini-ai/http-kit").JsonRouteSpec<void, XaiOkResponse, XaiHttpDeps>;
+export declare const xaiOauthCompleteRoute: import("@jini-ai/http-kit").JsonRouteSpec<XaiOauthCompleteRequest, XaiOkResponse, XaiHttpDeps, undefined>;
+export declare const xaiOauthCancelRoute: import("@jini-ai/http-kit").JsonRouteSpec<void, XaiOkResponse, XaiHttpDeps, undefined>;
 export interface XaiAuthStatusResponse {
     readonly connected: boolean;
     readonly expiresAt: number | null;
@@ -62,8 +62,8 @@ export interface XaiAuthStatusResponse {
     readonly savedAt: number | null;
     readonly listening: boolean;
 }
-export declare const xaiAuthStatusRoute: import("@jini-ai/http-kit").JsonRouteSpec<void, XaiAuthStatusResponse, XaiHttpDeps>;
-export declare const xaiOauthDisconnectRoute: import("@jini-ai/http-kit").JsonRouteSpec<void, XaiOkResponse, XaiHttpDeps>;
+export declare const xaiAuthStatusRoute: import("@jini-ai/http-kit").JsonRouteSpec<void, XaiAuthStatusResponse, XaiHttpDeps, undefined>;
+export declare const xaiOauthDisconnectRoute: import("@jini-ai/http-kit").JsonRouteSpec<void, XaiOkResponse, XaiHttpDeps, undefined>;
 interface XaiSearchRequest {
     readonly query: string;
     readonly allowedXHandles?: readonly string[];
@@ -79,7 +79,7 @@ export interface XaiSearchResponse {
     readonly citations: readonly string[];
     readonly model: string;
 }
-export declare const xaiSearchRoute: import("@jini-ai/http-kit").JsonRouteSpec<XaiSearchRequest, XaiSearchResponse, XaiHttpDeps>;
+export declare const xaiSearchRoute: import("@jini-ai/http-kit").JsonRouteSpec<XaiSearchRequest, XaiSearchResponse, XaiHttpDeps, undefined>;
 /** Mounts every xAI route on `app`. A pack's `http(app, services)` calls this directly. */
 export declare function registerXaiRoutes({ app, deps, adapter }: {
     readonly app: Express;