@jini-ai/daemon 0.5.2 → 0.5.4

package/dist/http/attachments.d.ts

@@ -147,7 +147,8 @@ export interface AttachmentStore {
         readonly runId: string;
     }, _optional?: Record<string, never>) => Promise<StoredAttachment | undefined>;
     /**
-     * Lists every still-unclaimed attachment registered with `ownerId` — the discovery counterpart to
+     * Lists unclaimed attachments registered with `ownerId`, plus attachments claimed by optional
+     * `runId` when supplied — the discovery counterpart to
      * `resolveForRun`'s single-lookup: a caller that does not yet hold a specific ref at all (an
      * attachment uploaded in an earlier turn, never named in this run's prompt) has no id to look up
      * with `resolveForRun` in the first place. This is what makes that attachment findable.
@@ -164,12 +165,18 @@ export interface AttachmentStore {
      *   attachment from before this method existed) is excluded from every caller's results, never
      *   just "unscoped" — this method is not callable with `ownerId: undefined`, so there is no input
      *   that could accidentally match an ownerless record;
-     * - a claimed attachment is excluded outright, whether or not this caller's own `runId` claimed
-     *   it, so this method can never be used to re-discover something already handed to a run — the
-     *   same "runs, not listings, are the reach here" boundary `resolveForRun` draws for a single ref.
+     * - a claimed attachment is excluded unless the host supplies that exact claiming `runId` in
+     *   the optional argument. Hosts must derive ownerId/runId from authenticated execution context,
+     *   never tool input. Run startup claims ALL message attachments before tools execute; including
+     *   that run's claims keeps image, video and generic file discovery available after delivery.
+     *   Owner matching remains mandatory even for the matching run. Without runId, the original
+     *   unclaimed-only behavior is unchanged. Listing never claims, releases, or reads a file; callers
+     *   still use `resolveForRun` for integrity-checked bytes/promotion.
      *
      * What this does NOT scope by: batch, conversation, or run — none of those are recorded on an
-     * `AttachmentRecord` today. Two different conversations run by the SAME `ownerId` will each see
+     * `AttachmentRecord` today (except run ownership once claimed). Hosts restricting discovery to
+     * an accepted message must also intersect these summaries with that message's refs. Without that
+     * intersection, two different conversations run by the SAME `ownerId` will each see
      * the other's pending attachments through this method. A host for whom that is too wide needs a
      * finer-grained id than `ownerId` to pass into `register()` — this method does not itself assume
      * `ownerId` means "one admin account" rather than "one conversation, one composer, one browser
@@ -184,7 +191,9 @@ export interface AttachmentStore {
      */
     listPendingForOwner: ({ ownerId }: {
         readonly ownerId: string;
-    }, _optional?: Record<string, never>) => Promise<PendingAttachmentSummary[]>;
+    }, optional?: {
+        readonly runId?: string;
+    }) => Promise<PendingAttachmentSummary[]>;
     /** Deletes the named still-unclaimed uploads, then the batch directory if it is now empty. */
     deleteUnclaimed: ({ batchId, paths }: {
         readonly batchId: string;
@@ -265,7 +274,7 @@ export interface AttachmentRecord {
     ownerId?: string;
 }
 /**
- * What `listPendingForOwner` hands back for one still-unclaimed attachment: enough for a caller to
+ * What `listPendingForOwner` hands back for an unclaimed or same-run claimed attachment: enough for a caller to
  * show a person what is waiting, and to name it again (`ref`) to `claim()`/`resolveForRun`.
  */
 export interface PendingAttachmentSummary {

package/dist/http/attachments.js

@@ -835,12 +835,13 @@ export async function createDiskAttachmentStore(requiredArgs, optionalArgs = {})
             }
             return { path: record.filePath, name: record.name, kind: record.kind, size: record.size };
         },
-        async listPendingForOwner({ ownerId }, _optional = {}) {
+        async listPendingForOwner({ ownerId }, { runId } = {}) {
             return [...records.values()]
                 // `record.ownerId !== undefined` first, short-circuiting before the comparison: this is
                 // what makes an ownerless record excluded rather than accidentally matched by a falsy-ish
                 // `ownerId` argument — see this method's own doc on why that must never be a wildcard.
-                .filter((record) => record.claimedRunId === undefined && record.ownerId !== undefined && record.ownerId === ownerId)
+                .filter((record) => record.ownerId !== undefined && record.ownerId === ownerId
+                && (record.claimedRunId === undefined || (runId !== undefined && record.claimedRunId === runId)))
                 .sort((a, b) => a.createdAt - b.createdAt)
                 .map((record) => ({ ref: record.id, name: record.name, kind: record.kind, size: record.size, createdAt: record.createdAt }));
         },

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

@@ -62,7 +62,7 @@ export declare const componentCatalogSearchRoute: import("@jini-ai/http-kit").Js
     limit: number;
 }, {
     hits: readonly ComponentCatalogSearchHit[];
-}, ComponentCatalogHttpDeps>;
+}, ComponentCatalogHttpDeps, undefined>;
 /**
  * `GET /api/components/:id` — full descriptor (propsSchema included). An unknown id is 404,
  * matching `tool-catalog.ts`'s describe route.
@@ -74,7 +74,7 @@ export declare const componentCatalogSearchRoute: import("@jini-ai/http-kit").Js
  */
 export declare const componentCatalogDescribeRoute: import("@jini-ai/http-kit").JsonRouteSpec<{
     id: string;
-}, ComponentCatalogEntry, ComponentCatalogHttpDeps>;
+}, ComponentCatalogEntry, ComponentCatalogHttpDeps, undefined>;
 /** Mounts both component-catalog routes on `app`. A pack's `http(app, services)` calls this directly. */
 export declare function registerComponentCatalogRoutes({ app, deps, adapter }: {
     readonly app: Express;

package/dist/http/connectors.d.ts

@@ -140,10 +140,10 @@ export interface ConnectorsAuthVerifyResponse {
 export interface ConnectorsOkResponse {
     readonly ok: true;
 }
-export declare const connectorsAuthSignUpRoute: import("@jini-ai/http-kit").JsonRouteSpec<AuthCredentials, ConnectorsAuthUserResponse, ConnectorsHttpDeps>;
-export declare const connectorsAuthSignInRoute: import("@jini-ai/http-kit").JsonRouteSpec<AuthCredentials, ConnectorsAuthSessionResponse, ConnectorsHttpDeps>;
-export declare const connectorsAuthSignOutRoute: import("@jini-ai/http-kit").JsonRouteSpec<string, ConnectorsOkResponse, ConnectorsHttpDeps>;
-export declare const connectorsAuthSessionRoute: import("@jini-ai/http-kit").JsonRouteSpec<string, ConnectorsAuthVerifyResponse, ConnectorsHttpDeps>;
+export declare const connectorsAuthSignUpRoute: import("@jini-ai/http-kit").JsonRouteSpec<AuthCredentials, ConnectorsAuthUserResponse, ConnectorsHttpDeps, undefined>;
+export declare const connectorsAuthSignInRoute: import("@jini-ai/http-kit").JsonRouteSpec<AuthCredentials, ConnectorsAuthSessionResponse, ConnectorsHttpDeps, undefined>;
+export declare const connectorsAuthSignOutRoute: import("@jini-ai/http-kit").JsonRouteSpec<string, ConnectorsOkResponse, ConnectorsHttpDeps, undefined>;
+export declare const connectorsAuthSessionRoute: import("@jini-ai/http-kit").JsonRouteSpec<string, ConnectorsAuthVerifyResponse, ConnectorsHttpDeps, undefined>;
 interface StoragePutRequest {
     readonly key: string;
     readonly dataBase64: string;
@@ -158,16 +158,16 @@ export interface ConnectorsStorageGetResponse {
 export interface ConnectorsStorageListResponse {
     readonly objects: readonly StorageObjectMeta[];
 }
-export declare const connectorsStoragePutRoute: import("@jini-ai/http-kit").JsonRouteSpec<StoragePutRequest, ConnectorsStorageMetaResponse, ConnectorsHttpDeps>;
-export declare const connectorsStorageGetRoute: import("@jini-ai/http-kit").JsonRouteSpec<string, ConnectorsStorageGetResponse, ConnectorsHttpDeps>;
-export declare const connectorsStorageDeleteRoute: import("@jini-ai/http-kit").JsonRouteSpec<string, ConnectorsOkResponse, ConnectorsHttpDeps>;
-export declare const connectorsStorageListRoute: import("@jini-ai/http-kit").JsonRouteSpec<string | undefined, ConnectorsStorageListResponse, ConnectorsHttpDeps>;
+export declare const connectorsStoragePutRoute: import("@jini-ai/http-kit").JsonRouteSpec<StoragePutRequest, ConnectorsStorageMetaResponse, ConnectorsHttpDeps, undefined>;
+export declare const connectorsStorageGetRoute: import("@jini-ai/http-kit").JsonRouteSpec<string, ConnectorsStorageGetResponse, ConnectorsHttpDeps, undefined>;
+export declare const connectorsStorageDeleteRoute: import("@jini-ai/http-kit").JsonRouteSpec<string, ConnectorsOkResponse, ConnectorsHttpDeps, undefined>;
+export declare const connectorsStorageListRoute: import("@jini-ai/http-kit").JsonRouteSpec<string | undefined, ConnectorsStorageListResponse, ConnectorsHttpDeps, undefined>;
 export interface ConnectorsChargeResponse {
     readonly charge: Charge;
 }
-export declare const connectorsPaymentsChargeRoute: import("@jini-ai/http-kit").JsonRouteSpec<ChargeInput, ConnectorsChargeResponse, ConnectorsHttpDeps>;
-export declare const connectorsPaymentsGetRoute: import("@jini-ai/http-kit").JsonRouteSpec<string, ConnectorsChargeResponse, ConnectorsHttpDeps>;
-export declare const connectorsPaymentsRefundRoute: import("@jini-ai/http-kit").JsonRouteSpec<string, ConnectorsChargeResponse, ConnectorsHttpDeps>;
+export declare const connectorsPaymentsChargeRoute: import("@jini-ai/http-kit").JsonRouteSpec<ChargeInput, ConnectorsChargeResponse, ConnectorsHttpDeps, undefined>;
+export declare const connectorsPaymentsGetRoute: import("@jini-ai/http-kit").JsonRouteSpec<string, ConnectorsChargeResponse, ConnectorsHttpDeps, undefined>;
+export declare const connectorsPaymentsRefundRoute: import("@jini-ai/http-kit").JsonRouteSpec<string, ConnectorsChargeResponse, ConnectorsHttpDeps, undefined>;
 interface DbInsertRequest {
     readonly collection: string;
     readonly record: DbRecord;
@@ -189,16 +189,16 @@ export interface ConnectorsDbRecordResponse {
 export interface ConnectorsDbQueryResponse {
     readonly records: readonly DbRecord[];
 }
-export declare const connectorsDbInsertRoute: import("@jini-ai/http-kit").JsonRouteSpec<DbInsertRequest, ConnectorsDbRecordResponse, ConnectorsHttpDeps>;
-export declare const connectorsDbGetRoute: import("@jini-ai/http-kit").JsonRouteSpec<DbCollectionIdParams, ConnectorsDbRecordResponse, ConnectorsHttpDeps>;
-export declare const connectorsDbUpdateRoute: import("@jini-ai/http-kit").JsonRouteSpec<DbUpdateRequest, ConnectorsDbRecordResponse, ConnectorsHttpDeps>;
-export declare const connectorsDbDeleteRoute: import("@jini-ai/http-kit").JsonRouteSpec<DbCollectionIdParams, ConnectorsOkResponse, ConnectorsHttpDeps>;
-export declare const connectorsDbQueryRoute: import("@jini-ai/http-kit").JsonRouteSpec<DbQueryRequest, ConnectorsDbQueryResponse, ConnectorsHttpDeps>;
+export declare const connectorsDbInsertRoute: import("@jini-ai/http-kit").JsonRouteSpec<DbInsertRequest, ConnectorsDbRecordResponse, ConnectorsHttpDeps, undefined>;
+export declare const connectorsDbGetRoute: import("@jini-ai/http-kit").JsonRouteSpec<DbCollectionIdParams, ConnectorsDbRecordResponse, ConnectorsHttpDeps, undefined>;
+export declare const connectorsDbUpdateRoute: import("@jini-ai/http-kit").JsonRouteSpec<DbUpdateRequest, ConnectorsDbRecordResponse, ConnectorsHttpDeps, undefined>;
+export declare const connectorsDbDeleteRoute: import("@jini-ai/http-kit").JsonRouteSpec<DbCollectionIdParams, ConnectorsOkResponse, ConnectorsHttpDeps, undefined>;
+export declare const connectorsDbQueryRoute: import("@jini-ai/http-kit").JsonRouteSpec<DbQueryRequest, ConnectorsDbQueryResponse, ConnectorsHttpDeps, undefined>;
 interface RealtimePublishRequest {
     readonly channel: string;
     readonly event: unknown;
 }
-export declare const connectorsRealtimePublishRoute: import("@jini-ai/http-kit").JsonRouteSpec<RealtimePublishRequest, ConnectorsOkResponse, ConnectorsHttpDeps>;
+export declare const connectorsRealtimePublishRoute: import("@jini-ai/http-kit").JsonRouteSpec<RealtimePublishRequest, ConnectorsOkResponse, ConnectorsHttpDeps, undefined>;
 /** Mounts every connectors route on `app`. A pack's `http(app, services)` calls this directly. */
 export declare function registerConnectorsRoutes({ app, deps, adapter }: {
     readonly app: Express;

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/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/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

@@ -48,16 +48,16 @@ export interface RunCancelResponse {
 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>;
 /**
  * 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

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;