@jini-ai/daemon 0.3.8 → 0.5.0

package/dist/close-status.js

@@ -1,11 +1,11 @@
 /**
  * Pure run-close classification and inactivity-timeout helpers, generalized
  * from OD's `apps/daemon/src/runtimes/chat-run-lifecycle.ts`
- * (`arch/server-startserver-endgame` branch — see `source-map.md`). The
+ * (`arch/server-startserver-endgame` branch — see `archived provenance ledger`). The
  * origin file mixes a generic close-status decision tree with several
  * OD/ACP-vendor-specific escape hatches (forced-shutdown-but-actually-clean
  * heuristics for a specific agent-CLI protocol, artifact-quiet-period
- * nuance). Only the generic skeleton is kept here — see `source-map.md` for
+ * nuance). Only the generic skeleton is kept here — see `archived provenance ledger` for
  * the itemized list of what was dropped and why.
  */
 /**
@@ -20,7 +20,8 @@
  * @complexity O(1).
  * @overallScore 100/100
  */
-export function classifyRunCloseStatus(input) {
+export function classifyRunCloseStatus(requiredArgs, optionalArgs = {}) {
+    const input = { ...requiredArgs, ...optionalArgs };
     if (input.cancelRequested) {
         return 'cancelled';
     }
@@ -43,7 +44,8 @@ export function classifyRunCloseStatus(input) {
  * @complexity O(1).
  * @overallScore 100/100
  */
-export function resolveTimeoutMs(input) {
+export function resolveTimeoutMs(requiredArgs, optionalArgs = {}) {
+    const input = { ...requiredArgs, ...optionalArgs };
     const env = input.env ?? (typeof process !== 'undefined' ? process.env : {});
     const rawFromEnv = input.envVar ? env[input.envVar] : undefined;
     const fromEnv = rawFromEnv !== undefined ? Number(rawFromEnv) : undefined;
@@ -58,7 +60,7 @@ export function resolveTimeoutMs(input) {
  * `onTimeout` callback is where that would plug in).
  *
  * @param input.timeoutMs - Milliseconds of inactivity before `onTimeout` fires.
- * @param input.onTimeout - Fired at most once per watchdog instance.
+ * @param input.onTimeout - Fired once per armed timeout window; later activity can start a new window until cancellation.
  * @returns A handle to reset (`noteActivity`) or permanently disarm (`cancel`) the timer.
  * @remarks Side effect: starts a `setTimeout` immediately and calls
  * `.unref()` on it (when available) so a bare watchdog never keeps a Node
@@ -66,25 +68,35 @@ export function resolveTimeoutMs(input) {
  * @complexity O(1) per call.
  * @overallScore 100/100
  */
-export function createInactivityWatchdog(input) {
-    let timer;
+export function createInactivityWatchdog(input, { scheduler } = {}) {
+    const timers = scheduler ?? {
+        schedule({ delayMs, callback }) {
+            const timer = setTimeout(callback, delayMs);
+            if (typeof timer.unref === 'function')
+                timer.unref();
+            return () => clearTimeout(timer);
+        },
+    };
+    let cancelTimer;
+    // Terminal cancellation must survive activity arriving from an already-queued callback.
+    let cancelled = false;
     const arm = () => {
-        if (timer) {
-            clearTimeout(timer);
-        }
-        timer = setTimeout(input.onTimeout, input.timeoutMs);
-        if (typeof timer.unref === 'function') {
-            timer.unref();
-        }
+        if (cancelled)
+            return;
+        cancelTimer?.();
+        cancelTimer = timers.schedule({
+            delayMs: input.timeoutMs,
+            callback: () => { if (!cancelled)
+                input.onTimeout(); },
+        });
     };
     arm();
     return {
         noteActivity: arm,
-        cancel: () => {
-            if (timer) {
-                clearTimeout(timer);
-                timer = undefined;
-            }
+        cancel: (_args) => {
+            cancelled = true;
+            cancelTimer?.();
+            cancelTimer = undefined;
         },
     };
 }

package/dist/continuation/continuation-transport.d.ts

@@ -37,5 +37,7 @@ export type ContinuationTransport = 'mcp-callback' | 'stdin-injection' | 'none';
  * @complexity O(1).
  * @overallScore 100/100
  */
-export declare function resolveContinuationTransport(def: RuntimeAgentDef): ContinuationTransport;
+export declare function resolveContinuationTransport({ def }: {
+    readonly def: RuntimeAgentDef;
+}): ContinuationTransport;
 //# sourceMappingURL=continuation-transport.d.ts.map

package/dist/continuation/continuation-transport.js

@@ -8,7 +8,7 @@
  * @complexity O(1).
  * @overallScore 100/100
  */
-export function resolveContinuationTransport(def) {
+export function resolveContinuationTransport({ def }) {
     if (def.externalMcpInjection !== undefined)
         return 'mcp-callback';
     if (def.promptInputFormat === 'stream-json' && def.promptViaStdin === true)

package/dist/continuation/journal.d.ts

@@ -14,17 +14,22 @@
  * would either leak raw, potentially untrusted agent bytes into the public
  * run-event stream or force widening `RunProtocolEvent` itself. A caller
  * supplies its own `EventLog` instance here — reusing the exact same port
- * type and, for a durable deployment, the exact same `@jini-ai/sqlite` adapter
+ * type and, for a durable deployment, the exact same `@jini-ai/daemon/store/event-log/sqlite` adapter
  * — so the journal gets the identical durability/replay guarantees without
  * touching the run-protocol vocabulary at all.
  */
 import type { JournalEntry } from '@jini-ai/protocol';
 import type { EventLog } from '../event-log.js';
 export interface RunByteJournal {
-    /** Durably appends one journal entry for `runId`. Never rejects into caller code — see {@link createRunByteJournal}. */
-    record(runId: string, entry: JournalEntry): Promise<void>;
+    /** Durably appends one journal entry for `runId`. Propagates append failures so the driver can report journal durability loss; see {@link createRunByteJournal}. */
+    record(args: {
+        readonly runId: string;
+        readonly entry: JournalEntry;
+    }): Promise<void>;
     /** Replays every journal entry recorded for `runId`, oldest first. */
-    read(runId: string): Promise<readonly JournalEntry[]>;
+    read(args: {
+        readonly runId: string;
+    }): Promise<readonly JournalEntry[]>;
 }
 /**
  * Creates a `RunByteJournal` over the given `EventLog` instance.
@@ -33,5 +38,7 @@ export interface RunByteJournal {
  * @complexity Both methods are exactly as expensive as the underlying `EventLog`'s `append`/`replay`.
  * @overallScore 100/100
  */
-export declare function createRunByteJournal(eventLog: EventLog): RunByteJournal;
+export declare function createRunByteJournal({ eventLog }: {
+    readonly eventLog: EventLog;
+}): RunByteJournal;
 //# sourceMappingURL=journal.d.ts.map

package/dist/continuation/journal.js

@@ -7,13 +7,13 @@ const JOURNAL_EVENT_NAME = 'journal';
  * @complexity Both methods are exactly as expensive as the underlying `EventLog`'s `append`/`replay`.
  * @overallScore 100/100
  */
-export function createRunByteJournal(eventLog) {
+export function createRunByteJournal({ eventLog }) {
     return {
-        async record(runId, entry) {
+        async record({ runId, entry }) {
             await eventLog.append({ runId, event: JOURNAL_EVENT_NAME, data: entry });
         },
-        async read(runId) {
-            const replay = await eventLog.replay(runId, null);
+        async read({ runId }) {
+            const replay = await eventLog.replay({ runId: runId, afterCursor: null });
             if (replay.kind !== 'ok')
                 return [];
             return replay.entries.map((entry) => entry.data);

package/dist/continuation/run-scoped-context-store.d.ts

@@ -38,7 +38,9 @@ import type { RunLifecycle } from '../run-lifecycle.js';
  */
 export declare class RunContextNotBoundError extends Error {
     readonly runId: string;
-    constructor(runId: string);
+    constructor({ runId }: {
+        readonly runId: string;
+    });
 }
 export interface RunScopedContextStore<T> {
     /**
@@ -46,15 +48,22 @@ export interface RunScopedContextStore<T> {
      * state. Binding the same `runId` twice replaces the value without adding a second eviction
      * subscription.
      */
-    bind(runId: string, value: T): void;
+    bind(args: {
+        readonly runId: string;
+        readonly value: T;
+    }): void;
     /**
      * The value bound for `runId`.
      * @throws {@link RunContextNotBoundError} when the run is unknown, already finished, or was never
      * bound. Never returns a default — see this module's doc on why fabricating one would be the bug.
      */
-    resolve(runId: string): T;
+    resolve(args: {
+        readonly runId: string;
+    }): T;
     /** Whether `runId` currently has a binding. For callers that need a check without a throw. */
-    has(runId: string): boolean;
+    has(args: {
+        readonly runId: string;
+    }): boolean;
     /** Live binding count. Exists so a host (or a test) can assert the map actually drains. */
     readonly size: number;
 }

package/dist/continuation/run-scoped-context-store.js

@@ -6,7 +6,7 @@
  */
 export class RunContextNotBoundError extends Error {
     runId;
-    constructor(runId) {
+    constructor({ runId }) {
         super(`no context is bound for run "${runId}"`);
         this.runId = runId;
         this.name = 'RunContextNotBoundError';
@@ -25,7 +25,7 @@ export class RunContextNotBoundError extends Error {
 export function createRunScopedContextStore(options) {
     const values = new Map();
     return {
-        bind(runId, value) {
+        bind({ runId, value }) {
             // Re-binding replaces the value but must not subscribe twice: each subscription is a retained
             // promise callback, and one eviction is all a run can need.
             const alreadyTracked = values.has(runId);
@@ -38,14 +38,14 @@ export function createRunScopedContextStore(options) {
             // `then(evict, evict)`, not `.finally(evict)`: a rejecting `waitForTerminal` would leave
             // `.finally`'s returned promise rejected, and nothing awaits it — an unhandled rejection that
             // could take the process down. Either outcome means the run is over, so both evict.
-            void options.lifecycle.waitForTerminal(runId).then(evict, evict);
+            void options.lifecycle.waitForTerminal({ runId: runId }).then(evict, evict);
         },
-        resolve(runId) {
+        resolve({ runId }) {
             if (!values.has(runId))
-                throw new RunContextNotBoundError(runId);
+                throw new RunContextNotBoundError({ runId: runId });
             return values.get(runId);
         },
-        has(runId) {
+        has({ runId }) {
             return values.has(runId);
         },
         get size() {

package/dist/continuation/run-start-handler.d.ts

@@ -44,7 +44,7 @@ export interface ResolvedRunInput {
      * has an auto-approve flag (`bypassPermissions` / `--yolo` / `--dangerously-skip-permissions`) uses
      * it by default when this is absent. So a host that had been passing `'restricted'` to
      * `AgentExecutor.run()` by hand and then adopted `createDefaultRunStartHandler` would silently have
-     * started auto-approving every action — a security regression wearing the clothes of a refactor.
+     * started auto-approving every action — the historical security regression this field prevented.
      * This field is what makes that host's existing posture expressible through the default handler.
      */
     readonly permissionMode?: 'bypass' | 'restricted';

package/dist/continuation/run-start-handler.js

@@ -21,22 +21,9 @@ export function createDefaultRunStartHandler(options) {
             ...(context.request.agentId !== undefined ? { agentId: context.request.agentId } : {}),
         });
         // Each optional field is spread only when present, never passed as an explicit `undefined`:
-        // `AgentExecutor.run()` distinguishes absent from undefined for `permissionMode` in particular,
-        // where absent means "use the def's own auto-approve default".
-        await options.agentExecutor.run({
-            runId: context.run.id,
-            agentId: resolved.agentId,
-            prompt: resolved.prompt,
-            cwd: resolved.cwd,
-            ...(resolved.env !== undefined ? { env: resolved.env } : {}),
-            ...(resolved.permissionMode !== undefined ? { permissionMode: resolved.permissionMode } : {}),
-            ...(resolved.model !== undefined ? { model: resolved.model } : {}),
-            ...(resolved.reasoning !== undefined ? { reasoning: resolved.reasoning } : {}),
-            ...(resolved.credentialEnv !== undefined ? { credentialEnv: resolved.credentialEnv } : {}),
-            ...(resolved.imagePaths !== undefined ? { imagePaths: resolved.imagePaths } : {}),
-            ...(resolved.extraAllowedDirs !== undefined ? { extraAllowedDirs: resolved.extraAllowedDirs } : {}),
-            ...(resolved.uploadRoot !== undefined ? { uploadRoot: resolved.uploadRoot } : {}),
-        });
+        // Keep absent optional fields absent on the runtime port; permission mode now defaults restricted,
+        // where absent now selects the daemon's fail-closed restricted default.
+        await options.agentExecutor.run({ runId: context.run.id, agentId: resolved.agentId, prompt: resolved.prompt, cwd: resolved.cwd }, { ...(resolved.env !== undefined ? { env: resolved.env } : {}), ...(resolved.permissionMode !== undefined ? { permissionMode: resolved.permissionMode } : {}), ...(resolved.model !== undefined ? { model: resolved.model } : {}), ...(resolved.reasoning !== undefined ? { reasoning: resolved.reasoning } : {}), ...(resolved.credentialEnv !== undefined ? { credentialEnv: resolved.credentialEnv } : {}), ...(resolved.imagePaths !== undefined ? { imagePaths: resolved.imagePaths } : {}), ...(resolved.extraAllowedDirs !== undefined ? { extraAllowedDirs: resolved.extraAllowedDirs } : {}), ...(resolved.uploadRoot !== undefined ? { uploadRoot: resolved.uploadRoot } : {}) });
     };
 }
 //# sourceMappingURL=run-start-handler.js.map

package/dist/delegated-tool-bridge.d.ts

@@ -37,20 +37,24 @@ export interface DelegatedToolBridge {
      * routing errors from `ToolExecutor` and are rethrown after their error
      * result is recorded.
      */
-    execute(invocation: DelegatedToolInvocation): Promise<ToolExecutionResult>;
+    execute(requiredArgs: Pick<DelegatedToolInvocation, "runId" | "toolUseId" | "toolId" | "principal" | "input">, optionalArgs?: Pick<DelegatedToolInvocation, "signal">): Promise<ToolExecutionResult>;
 }
 export interface CreateDelegatedToolBridgeOptions {
     readonly lifecycle: RunLifecycle;
     readonly toolExecutor: ToolExecutor;
 }
 /** Converts arbitrary registered-tool output into the string-bearing run protocol. */
-export declare function serializeDelegatedToolOutput(output: unknown): string;
+export declare function serializeDelegatedToolOutput({ output }: {
+    readonly output: unknown;
+}): string;
 /**
  * Maps a `ToolExecutionResult`'s status to the string a delegated-tool caller (this bridge, or
  * gap 3's stdin-tool-result injector in `agent-executor.ts`) reports back as the tool's visible
  * output/failure reason. Exported so both real callers share one mapping rather than drifting.
  */
-export declare function resultContent(result: ToolExecutionResult): string;
+export declare function resultContent({ result }: {
+    readonly result: ToolExecutionResult;
+}): string;
 /**
  * Creates the transport-neutral bridge used by future ACP-delegate, MCP, or
  * other host protocols. This module does not invent a server transport: a

package/dist/delegated-tool-bridge.js

@@ -30,7 +30,7 @@ function errorMessage(error) {
     return error instanceof Error ? error.message : String(error);
 }
 /** Converts arbitrary registered-tool output into the string-bearing run protocol. */
-export function serializeDelegatedToolOutput(output) {
+export function serializeDelegatedToolOutput({ output }) {
     if (typeof output === 'string')
         return output;
     if (output === undefined)
@@ -48,10 +48,10 @@ export function serializeDelegatedToolOutput(output) {
  * gap 3's stdin-tool-result injector in `agent-executor.ts`) reports back as the tool's visible
  * output/failure reason. Exported so both real callers share one mapping rather than drifting.
  */
-export function resultContent(result) {
+export function resultContent({ result }) {
     switch (result.status) {
         case 'completed':
-            return serializeDelegatedToolOutput(result.output);
+            return serializeDelegatedToolOutput({ output: result.output });
         case 'denied':
             return 'Tool execution denied by policy.';
         case 'confirmation-denied':
@@ -72,14 +72,15 @@ export function resultContent(result) {
  */
 export function createDelegatedToolBridge(options) {
     const { lifecycle, toolExecutor } = options;
-    async function execute(invocation) {
+    async function execute(requiredArgs, optionalArgs = {}) {
+        const invocation = { ...requiredArgs, ...optionalArgs };
         const { runId, toolUseId, toolId, principal, input } = invocation;
-        await lifecycle.emit(runId, {
-            event: 'agent',
-            data: { type: 'tool_use', id: toolUseId, name: toolId, input },
-        });
+        await lifecycle.emit({ runId: runId, input: {
+                event: 'agent',
+                data: { type: 'tool_use', id: toolUseId, name: toolId, input },
+            } });
         const controller = new AbortController();
-        const unsubscribeCancel = lifecycle.onCancelRequested(runId, () => controller.abort());
+        const unsubscribeCancel = lifecycle.onCancelRequested({ runId: runId, listener: () => controller.abort() });
         const abortFromTransport = () => controller.abort();
         if (invocation.signal) {
             if (invocation.signal.aborted)
@@ -138,11 +139,11 @@ export function createDelegatedToolBridge(options) {
                 type: emission.channel,
                 ...correlationFor(emission.channel, toolUseId),
             };
-            await lifecycle.emit(runId, { event: 'agent', data });
+            await lifecycle.emit({ runId: runId, input: { event: 'agent', data } });
         };
         try {
             try {
-                const executed = await toolExecutor.execute(principal, run, toolId, input, controller.signal, emitSurface);
+                const executed = await toolExecutor.execute({ principal: principal, run: run, toolId: toolId, input: input }, { signal: controller.signal, emitSurface: emitSurface });
                 settled = true;
                 // Recognized media blocks (images) are collected here purely to populate the sibling
                 // `media` field the `tool_result` event carries below, for a UI that wants to render one
@@ -157,7 +158,7 @@ export function createDelegatedToolBridge(options) {
                 // that the sibling `media` field was the only channel a caller needed — true for a UI
                 // reading the run's event stream, false for `@jini-ai/mcp`'s `execute_delegated_tool`, which
                 // hands the bridge's RETURN VALUE to the model with no access to that event stream at all.)
-                const { media } = extractResultMedia(executed.output);
+                const { media } = extractResultMedia({ output: executed.output });
                 // THE MODEL/HUMAN FORK. A tool call's return value is definitionally what the model
                 // receives, so a UI resource left inside it is model-visible context no matter what any
                 // downstream layer does — `@jini-ai/mcp`'s `okResult()` JSON.stringifies the whole result
@@ -167,34 +168,34 @@ export function createDelegatedToolBridge(options) {
                 // Whitelist, not blacklist: only block types known to be model-safe survive into `output`;
                 // everything else is withheld and emitted for the human. See `tool-result-surfaces.ts` for
                 // why that direction is load-bearing.
-                const { modelOutput, surfaces } = splitToolResultSurfaces(executed.output);
+                const { modelOutput, surfaces } = splitToolResultSurfaces({ output: executed.output });
                 const result = surfaces.length === 0 ? executed : { ...executed, output: modelOutput };
                 // Emitted BEFORE `tool_result` so the surface is on screen by the time the transcript shows
                 // the call completing — otherwise the human is asked to confirm something not yet visible.
                 for (const surface of surfaces) {
-                    await lifecycle.emit(runId, {
-                        event: 'agent',
-                        data: { type: MCP_UI_EVENT_TYPE, toolUseId, resource: surface },
-                    });
+                    await lifecycle.emit({ runId: runId, input: {
+                            event: 'agent',
+                            data: { type: MCP_UI_EVENT_TYPE, toolUseId, resource: surface },
+                        } });
                 }
-                await lifecycle.emit(runId, {
-                    event: 'agent',
-                    data: {
-                        type: 'tool_result',
-                        toolUseId,
-                        content: resultContent(result),
-                        ...(result.status === 'completed' ? {} : { isError: true }),
-                        ...(media.length > 0 ? { media } : {}),
-                    },
-                });
+                await lifecycle.emit({ runId: runId, input: {
+                        event: 'agent',
+                        data: {
+                            type: 'tool_result',
+                            toolUseId,
+                            content: resultContent({ result }),
+                            ...(result.status === 'completed' ? {} : { isError: true }),
+                            ...(media.length > 0 ? { media } : {}),
+                        },
+                    } });
                 return result;
             }
             catch (error) {
                 settled = true;
-                await lifecycle.emit(runId, {
-                    event: 'agent',
-                    data: { type: 'tool_result', toolUseId, content: errorMessage(error), isError: true },
-                });
+                await lifecycle.emit({ runId: runId, input: {
+                        event: 'agent',
+                        data: { type: 'tool_result', toolUseId, content: errorMessage(error), isError: true },
+                    } });
                 throw error;
             }
         }

package/dist/event-log.d.ts

@@ -14,27 +14,29 @@
  * JSONL tail file that nothing ever reads back for replay. Because the durable half lives outside
  * any port, a non-OD consumer that only wires the in-memory ring silently loses in-flight output
  * on a long-run reload. `EventLog` is the fix: a single, storage-agnostic port that any adapter
- * (this module's in-memory reference implementation, or `@jini-ai/sqlite`'s durable adapter)
+ * (this module's in-memory reference implementation, or `@jini-ai/daemon/store/event-log/sqlite`'s durable adapter)
  * can satisfy.
  */
-export type { EventLog, EventLogAppendInput, EventLogEntry, EventLogReplayResult, } from '@jini-ai/protocol';
+export type { EventLog, EventLogAppendInput, EventLogAppendOptions, EventLogEntry, EventLogReplayResult, } from '@jini-ai/protocol';
 import type { EventLog } from '@jini-ai/protocol';
 export interface InMemoryEventLogOptions {
     /**
      * Maximum entries retained per run before the oldest are evicted. Eviction is opt-in: if
      * omitted, retention is unbounded and nothing is ever silently dropped. Pass an explicit
-     * value only when bounded memory (or, for `@jini-ai/sqlite`, bounded disk) is a deliberate
+     * value only when bounded memory (or, for `@jini-ai/daemon/store/event-log/sqlite`, bounded disk) is a deliberate
      * choice — the caller then owns the tradeoff, rather than inheriting a hidden 2000-entry
      * cap OD's own in-memory ring happened to use.
      */
     readonly maxEntriesPerRun?: number;
+    /** Host clock; defaults to Date.now to preserve recorded timestamps. */
+    readonly now?: () => number;
 }
 /**
  * Reference `EventLog` implementation: a per-run FIFO array, optionally capped at
  * `maxEntriesPerRun` (opt-in — see {@link InMemoryEventLogOptions}), functionally a ring
  * buffer once a cap is set (oldest entries evicted once the cap is exceeded) without needing
  * an actual circular-index structure at this scale. This is the in-memory half only — no
- * durable copy — matching this task's scope (a real persistent adapter is `@jini-ai/sqlite`'s
+ * durable copy — matching this task's scope (a real persistent adapter is `@jini-ai/daemon/store/event-log/sqlite`'s
  * job).
  *
  * @param options.maxEntriesPerRun - Retention cap per run, see {@link InMemoryEventLogOptions}.
@@ -43,5 +45,5 @@ export interface InMemoryEventLogOptions {
  * splice, k = entries over cap, which is normally 1). `replay` is O(n) in
  * the number of retained entries for the run.
  */
-export declare function createInMemoryEventLog(options?: InMemoryEventLogOptions): EventLog;
+export declare function createInMemoryEventLog(_requiredArgs: Record<string, never>, options?: InMemoryEventLogOptions): EventLog;
 //# sourceMappingURL=event-log.d.ts.map

package/dist/event-log.js

@@ -3,7 +3,7 @@
  * `maxEntriesPerRun` (opt-in — see {@link InMemoryEventLogOptions}), functionally a ring
  * buffer once a cap is set (oldest entries evicted once the cap is exceeded) without needing
  * an actual circular-index structure at this scale. This is the in-memory half only — no
- * durable copy — matching this task's scope (a real persistent adapter is `@jini-ai/sqlite`'s
+ * durable copy — matching this task's scope (a real persistent adapter is `@jini-ai/daemon/store/event-log/sqlite`'s
  * job).
  *
  * @param options.maxEntriesPerRun - Retention cap per run, see {@link InMemoryEventLogOptions}.
@@ -12,8 +12,9 @@
  * splice, k = entries over cap, which is normally 1). `replay` is O(n) in
  * the number of retained entries for the run.
  */
-export function createInMemoryEventLog(options = {}) {
+export function createInMemoryEventLog(_requiredArgs, options = {}) {
     const maxEntriesPerRun = options.maxEntriesPerRun;
+    const now = options.now ?? Date.now;
     const runs = new Map();
     function getOrCreateRunLog(runId) {
         let runLog = runs.get(runId);
@@ -24,10 +25,10 @@ export function createInMemoryEventLog(options = {}) {
         return runLog;
     }
     return {
-        async append(input) {
+        async append(input, options = {}) {
             const runLog = getOrCreateRunLog(input.runId);
-            if (input.dedupeKey !== undefined) {
-                const existing = runLog.dedupeIndex.get(input.dedupeKey);
+            if (options.dedupeKey !== undefined) {
+                const existing = runLog.dedupeIndex.get(options.dedupeKey);
                 if (existing) {
                     return existing;
                 }
@@ -36,19 +37,19 @@ export function createInMemoryEventLog(options = {}) {
                 id: String(runLog.nextId),
                 event: input.event,
                 data: input.data,
-                recordedAt: Date.now(),
+                recordedAt: now(),
             };
             runLog.nextId += 1;
             runLog.entries.push(entry);
-            if (input.dedupeKey !== undefined) {
-                runLog.dedupeIndex.set(input.dedupeKey, entry);
+            if (options.dedupeKey !== undefined) {
+                runLog.dedupeIndex.set(options.dedupeKey, entry);
             }
             if (maxEntriesPerRun !== undefined && runLog.entries.length > maxEntriesPerRun) {
                 runLog.entries.splice(0, runLog.entries.length - maxEntriesPerRun);
             }
             return entry;
         },
-        async replay(runId, afterCursor) {
+        async replay({ runId, afterCursor }) {
             const runLog = runs.get(runId);
             if (!runLog) {
                 return { kind: 'unknown-run' };
@@ -80,10 +81,10 @@ export function createInMemoryEventLog(options = {}) {
                 entries: runLog.entries.filter((entry) => Number(entry.id) > afterCursorNum),
             };
         },
-        async listRunIds() {
+        async listRunIds(_requiredArgs) {
             return Array.from(runs.keys()).sort();
         },
-        async drop(runId) {
+        async drop({ runId }) {
             runs.delete(runId);
         },
     };

package/dist/frontend-capability-tools.d.ts

@@ -98,5 +98,5 @@ export interface CreateFrontendCapabilityRegistrationsOptions {
  *
  * @complexity O(n) in `capabilities`; each handler is O(1) plus the round trip to the surface.
  */
-export declare function createFrontendCapabilityRegistrations(options: CreateFrontendCapabilityRegistrationsOptions): readonly ToolRegistration[];
+export declare function createFrontendCapabilityRegistrations(requiredArgs: Pick<CreateFrontendCapabilityRegistrationsOptions, "registry" | "capabilities">, optionalArgs?: Pick<CreateFrontendCapabilityRegistrationsOptions, "policy" | "timeoutMs" | "maxOutputBytes">): readonly ToolRegistration[];
 //# sourceMappingURL=frontend-capability-tools.d.ts.map

package/dist/frontend-capability-tools.js

@@ -43,7 +43,8 @@ function toCapabilityInput(capabilityId, input) {
  *
  * @complexity O(n) in `capabilities`; each handler is O(1) plus the round trip to the surface.
  */
-export function createFrontendCapabilityRegistrations(options) {
+export function createFrontendCapabilityRegistrations(requiredArgs, optionalArgs = {}) {
+    const options = { ...requiredArgs, ...optionalArgs };
     const { registry, capabilities, policy = denyAllFrontendCapabilityPolicy, timeoutMs = DEFAULT_FRONTEND_CAPABILITY_TIMEOUT_MS, maxOutputBytes, } = options;
     return capabilities.map((capability) => ({
         descriptor: {
@@ -62,7 +63,7 @@ export function createFrontendCapabilityRegistrations(options) {
         policy,
         // `ctx.signal` is `ToolExecutor`'s own timeout/cancel signal, so the descriptor's `timeoutMs`
         // and a cancelled run both reach the pending invocation without this module owning a timer.
-        handler: async (ctx) => registry.invoke(ctx.run.id, capability.id, toCapabilityInput(capability.id, ctx.input), ctx.signal),
+        handler: async (ctx) => registry.invoke({ runId: ctx.run.id, capabilityId: capability.id, input: toCapabilityInput(capability.id, ctx.input) }, { signal: ctx.signal }),
     }));
 }
 //# sourceMappingURL=frontend-capability-tools.js.map