dominds 1.4.2 → 1.5.1

package/dist/apps/runtime.js

@@ -1,10 +1,20 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getAppsHostClient = getAppsHostClient;
 exports.shutdownAppsRuntime = shutdownAppsRuntime;
 exports.registerEnabledAppsToolProxies = registerEnabledAppsToolProxies;
 exports.initAppsRuntime = initAppsRuntime;
+const crypto_1 = require("crypto");
+const promises_1 = __importDefault(require("fs/promises"));
+const path_1 = __importDefault(require("path"));
+const dialog_1 = require("../dialog");
+const dialog_global_registry_1 = require("../dialog-global-registry");
+const dialog_instance_registry_1 = require("../dialog-instance-registry");
 const log_1 = require("../log");
+const app_reminders_1 = require("../tools/app-reminders");
 const registry_1 = require("../tools/registry");
 const client_1 = require("../apps-host/client");
 const dialog_run_controls_1 = require("./dialog-run-controls");
@@ -12,20 +22,133 @@ const enabled_apps_1 = require("./enabled-apps");
 const problems_1 = require("./problems");
 const log = (0, log_1.createLogger)('apps-runtime');
 let appsHostClient = null;
-const proxyRegisteredAppIds = new Set();
+let hostedAppsSignature = null;
+let appsRuntimeConfig = null;
+let refreshQueue = Promise.resolve();
+const registeredAppArtifactsById = new Map();
+function resolveRootDialogFor(dlg) {
+    if (dlg instanceof dialog_1.RootDialog) {
+        return dlg;
+    }
+    if (dlg instanceof dialog_1.SubDialog) {
+        return dlg.rootDialog;
+    }
+    throw new Error(`Unsupported dialog type for app runtime: ${dlg.constructor.name}`);
+}
+async function ensureRootDialogLoaded(rootId) {
+    const existing = dialog_global_registry_1.globalDialogRegistry.get(rootId);
+    if (existing) {
+        await existing.loadSubdialogRegistry();
+        await existing.loadPendingSubdialogsFromPersistence();
+        return existing;
+    }
+    return await (0, dialog_instance_registry_1.getOrRestoreRootDialog)(rootId, 'running');
+}
+async function ensureDialogLoadedBySelfId(rootDialog, dialogSelfId) {
+    if (dialogSelfId === rootDialog.id.rootId) {
+        return rootDialog;
+    }
+    const existing = rootDialog.lookupDialog(dialogSelfId);
+    if (existing) {
+        return existing;
+    }
+    return await (0, dialog_instance_registry_1.ensureDialogLoaded)(rootDialog, new dialog_1.DialogID(dialogSelfId, rootDialog.id.rootId), 'running');
+}
+function describeTarget(target) {
+    if ('dialogId' in target) {
+        return `dialogId=${target.dialogId}`;
+    }
+    const parts = [`agentId=${target.agentId}`];
+    if (target.rootDialogId) {
+        parts.push(`rootDialogId=${target.rootDialogId}`);
+    }
+    if (target.sessionSlug) {
+        parts.push(`sessionSlug=${target.sessionSlug}`);
+    }
+    return parts.join(' ');
+}
+async function resolveTargetDialog(sourceDlg, target) {
+    const sourceRoot = resolveRootDialogFor(sourceDlg);
+    if ('dialogId' in target) {
+        const matches = [];
+        const seenDialogKeys = new Set();
+        const pushMatch = (dialog) => {
+            if (!dialog)
+                return;
+            const key = dialog.id.valueOf();
+            if (seenDialogKeys.has(key))
+                return;
+            seenDialogKeys.add(key);
+            matches.push(dialog);
+        };
+        pushMatch(await ensureDialogLoadedBySelfId(sourceRoot, target.dialogId));
+        for (const loadedRoot of dialog_global_registry_1.globalDialogRegistry.getAll()) {
+            pushMatch(await ensureDialogLoadedBySelfId(loadedRoot, target.dialogId));
+        }
+        if (target.dialogId !== sourceRoot.id.rootId) {
+            pushMatch(await ensureRootDialogLoaded(target.dialogId));
+        }
+        if (matches.length === 1) {
+            return matches[0];
+        }
+        if (matches.length === 0) {
+            throw new Error(`dialog reminder target not found (${describeTarget(target)})`);
+        }
+        throw new Error(`dialog reminder target is ambiguous (${describeTarget(target)})`);
+    }
+    const targetRootId = target.rootDialogId ?? sourceRoot.id.rootId;
+    const targetRoot = targetRootId === sourceRoot.id.rootId ? sourceRoot : await ensureRootDialogLoaded(targetRootId);
+    if (!targetRoot) {
+        throw new Error(`dialog reminder target root not found (${describeTarget(target)})`);
+    }
+    await targetRoot.loadSubdialogRegistry();
+    await targetRoot.loadPendingSubdialogsFromPersistence();
+    if (target.sessionSlug) {
+        const subdialog = targetRoot.lookupSubdialog(target.agentId, target.sessionSlug);
+        if (!subdialog) {
+            throw new Error(`dialog reminder target not found (${describeTarget(target)})`);
+        }
+        return subdialog;
+    }
+    const matches = targetRoot.getAllDialogs().filter((dialog) => dialog.agentId === target.agentId);
+    if (matches.length === 1) {
+        return matches[0];
+    }
+    if (matches.length === 0) {
+        throw new Error(`dialog reminder target not found (${describeTarget(target)})`);
+    }
+    throw new Error(`dialog reminder target is ambiguous (${describeTarget(target)})`);
+}
+async function applyDialogReminderRequestBatches(sourceDlg, appId, dialogReminderRequests) {
+    for (const batch of dialogReminderRequests) {
+        if (batch.reminderRequests.length === 0) {
+            continue;
+        }
+        const targetDlg = await resolveTargetDialog(sourceDlg, batch.target);
+        await (0, app_reminders_1.applyAppReminderRequests)(targetDlg, {
+            appId,
+            reminderRequests: batch.reminderRequests,
+            resolveHostClient: getAppsHostClient,
+        });
+    }
+}
 function getAppsHostClient() {
     if (!appsHostClient) {
         throw new Error('Apps host is not initialized');
     }
     return appsHostClient;
 }
-async function shutdownAppsRuntime() {
+async function stopAppsHost() {
     const client = appsHostClient;
     if (!client)
         return;
     appsHostClient = null;
+    hostedAppsSignature = null;
     await client.shutdown();
 }
+async function shutdownAppsRuntime() {
+    await stopAppsHost();
+}
 function ensureNoDuplicateTool(toolName, appId) {
     const existing = (0, registry_1.getTool)(toolName);
     if (existing) {
@@ -47,84 +170,209 @@ function registerAppToolset(params) {
     (0, registry_1.registerToolset)(params.toolsetId, params.tools);
     (0, registry_1.setToolsetMeta)(params.toolsetId, { source: 'app', descriptionI18n: params.descriptionI18n });
 }
-function registerAppProxyToolsForEnabledApps(params) {
-    for (const app of params.enabledApps) {
-        if (proxyRegisteredAppIds.has(app.appId))
-            continue;
-        const toolsets = app.installJson.contributes?.toolsets ?? [];
-        for (const ts of toolsets) {
-            const tools = ts.tools.map((t) => ({
-                type: 'func',
-                name: t.name,
-                description: t.description,
-                descriptionI18n: t.descriptionI18n,
-                parameters: t.parameters,
-                call: async (dlg, caller, args) => {
-                    const host = getAppsHostClient();
-                    return await host.callTool(t.name, args, {
-                        dialogId: dlg.id.selfId,
-                        callerId: caller.id,
+function computeAppSignature(app) {
+    return JSON.stringify({
+        appId: app.appId,
+        runtimePort: app.runtimePort,
+        installJson: app.installJson,
+        hostSourceVersion: app.hostSourceVersion,
+    });
+}
+function computeHostedAppsSignature(enabledApps) {
+    return JSON.stringify(enabledApps.map((app) => ({
+        appId: app.appId,
+        runtimePort: app.runtimePort,
+        installJson: app.installJson,
+        hostSourceVersion: app.hostSourceVersion,
+    })));
+}
+async function computeHostSourceVersion(params) {
+    if (params.source.kind !== 'local') {
+        return null;
+    }
+    const host = params.installJson.host;
+    if (host.kind !== 'node_module') {
+        return null;
+    }
+    const moduleAbs = path_1.default.resolve(params.source.pathAbs, host.moduleRelPath);
+    try {
+        const content = await promises_1.default.readFile(moduleAbs);
+        const digest = (0, crypto_1.createHash)('sha256').update(content).digest('hex');
+        return `sha256:${digest}`;
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        return `unreadable:${moduleAbs}:${message}`;
+    }
+}
+function unregisterRegisteredAppArtifacts(appId) {
+    const registered = registeredAppArtifactsById.get(appId);
+    if (!registered) {
+        (0, app_reminders_1.unregisterAppReminderOwnersForApps)({ appIds: [appId] });
+        return;
+    }
+    for (const toolName of registered.toolNames) {
+        (0, registry_1.unregisterTool)(toolName);
+    }
+    for (const toolsetId of registered.toolsetIds) {
+        (0, registry_1.unregisterToolset)(toolsetId);
+    }
+    for (const controlId of registered.dialogRunControlIds) {
+        (0, dialog_run_controls_1.unregisterAppDialogRunControl)(controlId);
+    }
+    (0, app_reminders_1.unregisterAppReminderOwnersForApps)({ appIds: [appId] });
+    registeredAppArtifactsById.delete(appId);
+}
+async function ensureAppsHostReadyForToolCalls() {
+    const config = appsRuntimeConfig;
+    if (!config && !appsHostClient) {
+        throw new Error('Apps host is unavailable in the current runtime; start an interactive Dominds runtime first');
+    }
+    if (config) {
+        await registerEnabledAppsToolProxies({ rtwsRootAbs: config.rtwsRootAbs });
+    }
+    return getAppsHostClient();
+}
+function registerAppArtifacts(app) {
+    const toolNames = [];
+    const toolsetIds = [];
+    const dialogRunControlIds = [];
+    const toolsets = app.installJson.contributes?.toolsets ?? [];
+    for (const ts of toolsets) {
+        const tools = ts.tools.map((t) => ({
+            type: 'func',
+            name: t.name,
+            description: t.description,
+            descriptionI18n: t.descriptionI18n,
+            parameters: t.parameters,
+            call: async (dlg, caller, args) => {
+                const host = await ensureAppsHostReadyForToolCalls();
+                const result = await host.callTool(t.name, args, {
+                    dialogId: dlg.id.selfId,
+                    rootDialogId: dlg.id.rootId,
+                    agentId: dlg.agentId,
+                    sessionSlug: dlg instanceof dialog_1.SubDialog ? dlg.sessionSlug : undefined,
+                    callerId: caller.id,
+                });
+                if (Array.isArray(result.reminderRequests) && result.reminderRequests.length > 0) {
+                    await (0, app_reminders_1.applyAppReminderRequests)(dlg, {
+                        appId: app.appId,
+                        reminderRequests: result.reminderRequests,
+                        resolveHostClient: getAppsHostClient,
                     });
-                },
-            }));
-            registerAppToolset({
-                appId: app.appId,
-                toolsetId: ts.id,
-                tools,
-                descriptionI18n: ts.descriptionI18n,
-            });
-        }
-        proxyRegisteredAppIds.add(app.appId);
+                }
+                if (Array.isArray(result.dialogReminderRequests) &&
+                    result.dialogReminderRequests.length > 0) {
+                    await applyDialogReminderRequestBatches(dlg, app.appId, result.dialogReminderRequests);
+                }
+                return result.output;
+            },
+        }));
+        registerAppToolset({
+            appId: app.appId,
+            toolsetId: ts.id,
+            tools,
+            descriptionI18n: ts.descriptionI18n,
+        });
+        toolsetIds.push(ts.id);
+        toolNames.push(...tools.map((tool) => tool.name));
     }
+    const controls = app.installJson.contributes?.dialogRunControls ?? [];
+    for (const control of controls) {
+        (0, dialog_run_controls_1.registerAppDialogRunControl)({
+            id: control.id,
+            appId: app.appId,
+            descriptionI18n: control.descriptionI18n,
+        });
+        dialogRunControlIds.push(control.id);
+    }
+    (0, app_reminders_1.ensureAppReminderOwnersRegistered)({
+        enabledApps: [app],
+        resolveHostClient: getAppsHostClient,
+    });
+    registeredAppArtifactsById.set(app.appId, {
+        signature: computeAppSignature(app),
+        toolNames,
+        toolsetIds,
+        dialogRunControlIds,
+    });
 }
-function registerAppDialogRunControlsForEnabledApps(params) {
+function syncRegisteredAppArtifacts(params) {
+    const nextAppIds = new Set(params.enabledApps.map((app) => app.appId));
+    for (const appId of registeredAppArtifactsById.keys()) {
+        if (!nextAppIds.has(appId)) {
+            unregisterRegisteredAppArtifacts(appId);
+        }
+    }
     for (const app of params.enabledApps) {
-        const controls = app.installJson.contributes?.dialogRunControls ?? [];
-        for (const control of controls) {
-            (0, dialog_run_controls_1.registerAppDialogRunControl)({
-                id: control.id,
-                appId: app.appId,
-                descriptionI18n: control.descriptionI18n,
-            });
+        const nextSignature = computeAppSignature(app);
+        const existing = registeredAppArtifactsById.get(app.appId);
+        if (existing?.signature === nextSignature) {
+            continue;
+        }
+        if (existing) {
+            unregisterRegisteredAppArtifacts(app.appId);
         }
+        registerAppArtifacts(app);
     }
 }
-async function registerEnabledAppsToolProxies(params) {
-    const snapshot = await (0, enabled_apps_1.loadEnabledAppsSnapshot)({ rtwsRootAbs: params.rtwsRootAbs });
-    (0, problems_1.reconcileAppsResolutionIssuesToProblems)({ issues: snapshot.issues });
-    const enabledApps = snapshot.enabledApps.map((a) => ({
-        appId: a.id,
-        runtimePort: a.runtimePort,
-        installJson: a.installJson,
-    }));
-    if (enabledApps.length === 0)
+async function syncAppsHostToEnabledApps(params) {
+    const config = appsRuntimeConfig;
+    if (!config) {
         return;
-    registerAppProxyToolsForEnabledApps({ enabledApps });
-}
-async function initAppsRuntime(params) {
-    if (appsHostClient) {
-        throw new Error('Apps runtime already initialized');
     }
-    const snapshot = await (0, enabled_apps_1.loadEnabledAppsSnapshot)({ rtwsRootAbs: params.rtwsRootAbs });
-    (0, problems_1.reconcileAppsResolutionIssuesToProblems)({ issues: snapshot.issues });
-    const enabledApps = snapshot.enabledApps.map((a) => ({
-        appId: a.id,
-        runtimePort: a.runtimePort,
-        installJson: a.installJson,
-    }));
-    if (enabledApps.length === 0) {
-        log.info('No enabled apps');
+    const nextSignature = computeHostedAppsSignature(params.enabledApps);
+    if (params.enabledApps.length === 0) {
+        await stopAppsHost();
         return;
     }
-    // Register proxy tools first (fail fast on collisions) so team loading/validation can see toolsets.
-    registerAppProxyToolsForEnabledApps({ enabledApps });
-    // Register dialog run controls before websocket handlers start processing user drives.
-    registerAppDialogRunControlsForEnabledApps({ enabledApps });
-    log.info(`Starting apps-host (${enabledApps.length} enabled apps)`);
+    if (appsHostClient && hostedAppsSignature === nextSignature) {
+        return;
+    }
+    await stopAppsHost();
+    log.info(`Starting apps-host (${params.enabledApps.length} enabled apps)`);
     const { client } = await (0, client_1.startAppsHost)({
-        rtwsRootAbs: params.rtwsRootAbs,
-        kernel: params.kernel,
-        apps: enabledApps,
+        rtwsRootAbs: config.rtwsRootAbs,
+        kernel: config.kernel,
+        apps: params.enabledApps,
     });
     appsHostClient = client;
+    hostedAppsSignature = nextSignature;
+}
+async function refreshEnabledAppsRuntimeNow(params) {
+    const snapshot = await (0, enabled_apps_1.loadEnabledAppsSnapshot)({ rtwsRootAbs: params.rtwsRootAbs });
+    (0, problems_1.reconcileAppsResolutionIssuesToProblems)({ issues: snapshot.issues });
+    const enabledApps = await Promise.all(snapshot.enabledApps.map(async (app) => ({
+        appId: app.id,
+        runtimePort: app.runtimePort,
+        installJson: app.installJson,
+        hostSourceVersion: await computeHostSourceVersion({
+            source: app.source,
+            installJson: app.installJson,
+        }),
+    })));
+    syncRegisteredAppArtifacts({ enabledApps });
+    if (params.ensureHost) {
+        await syncAppsHostToEnabledApps({ enabledApps });
+    }
+}
+async function registerEnabledAppsToolProxies(params) {
+    const run = refreshQueue.then(() => refreshEnabledAppsRuntimeNow({
+        rtwsRootAbs: params.rtwsRootAbs,
+        ensureHost: appsRuntimeConfig !== null,
+    }));
+    refreshQueue = run.catch(() => undefined);
+    await run;
+}
+async function initAppsRuntime(params) {
+    appsRuntimeConfig = {
+        rtwsRootAbs: params.rtwsRootAbs,
+        kernel: params.kernel,
+    };
+    const run = refreshQueue.then(() => refreshEnabledAppsRuntimeNow({
+        rtwsRootAbs: params.rtwsRootAbs,
+        ensureHost: true,
+    }));
+    refreshQueue = run.catch(() => undefined);
+    await run;
 }

package/dist/apps-host/client.js

@@ -46,6 +46,24 @@ function parseMessageToKernel(v) {
             throw new Error('Invalid tool_result message: callId required');
         return v;
     }
+    if (type === 'reminder_apply_result') {
+        const callId = asString(v['callId']);
+        if (!callId)
+            throw new Error('Invalid reminder_apply_result message: callId required');
+        return v;
+    }
+    if (type === 'reminder_update_result') {
+        const callId = asString(v['callId']);
+        if (!callId)
+            throw new Error('Invalid reminder_update_result message: callId required');
+        return v;
+    }
+    if (type === 'reminder_render_result') {
+        const callId = asString(v['callId']);
+        if (!callId)
+            throw new Error('Invalid reminder_render_result message: callId required');
+        return v;
+    }
     if (type === 'run_control_result') {
         const callId = asString(v['callId']);
         if (!callId)
@@ -84,6 +102,9 @@ async function startAppsHost(params) {
     }
     const pendingTools = new Map();
     const pendingRunControls = new Map();
+    const pendingReminderApplies = new Map();
+    const pendingReminderUpdates = new Map();
+    const pendingReminderRenders = new Map();
     let ready = false;
     let readyMsg = null;
     let readyResolve = null;
@@ -106,6 +127,21 @@ async function startAppsHost(params) {
             p.reject(err);
         }
         pendingRunControls.clear();
+        for (const p of pendingReminderApplies.values()) {
+            clearTimeout(p.timeout);
+            p.reject(err);
+        }
+        pendingReminderApplies.clear();
+        for (const p of pendingReminderUpdates.values()) {
+            clearTimeout(p.timeout);
+            p.reject(err);
+        }
+        pendingReminderUpdates.clear();
+        for (const p of pendingReminderRenders.values()) {
+            clearTimeout(p.timeout);
+            p.reject(err);
+        }
+        pendingReminderRenders.clear();
     };
     child.on('exit', (code, signal) => {
         const err = new Error(`apps-host exited (code=${code ?? 'null'} signal=${signal ?? 'null'})`);
@@ -140,8 +176,13 @@ async function startAppsHost(params) {
                 }
                 pendingTools.delete(msg.callId);
                 clearTimeout(p.timeout);
-                if (msg.ok)
-                    p.resolve(msg.output);
+                if (msg.ok) {
+                    p.resolve({
+                        output: msg.output,
+                        reminderRequests: msg.reminderRequests,
+                        dialogReminderRequests: msg.dialogReminderRequests,
+                    });
+                }
                 else
                     p.reject(new Error(msg.errorText));
                 return;
@@ -158,6 +199,48 @@ async function startAppsHost(params) {
                     return;
                 }
                 p.resolve(msg.result);
+                return;
+            }
+            if (msg.type === 'reminder_apply_result') {
+                const p = pendingReminderApplies.get(msg.callId);
+                if (!p) {
+                    throw new Error(`Unexpected reminder_apply_result for unknown callId: ${msg.callId}`);
+                }
+                pendingReminderApplies.delete(msg.callId);
+                clearTimeout(p.timeout);
+                if (!msg.ok) {
+                    p.reject(new Error(msg.errorText));
+                    return;
+                }
+                p.resolve(msg.result);
+                return;
+            }
+            if (msg.type === 'reminder_update_result') {
+                const p = pendingReminderUpdates.get(msg.callId);
+                if (!p) {
+                    throw new Error(`Unexpected reminder_update_result for unknown callId: ${msg.callId}`);
+                }
+                pendingReminderUpdates.delete(msg.callId);
+                clearTimeout(p.timeout);
+                if (!msg.ok) {
+                    p.reject(new Error(msg.errorText));
+                    return;
+                }
+                p.resolve(msg.result);
+                return;
+            }
+            if (msg.type === 'reminder_render_result') {
+                const p = pendingReminderRenders.get(msg.callId);
+                if (!p) {
+                    throw new Error(`Unexpected reminder_render_result for unknown callId: ${msg.callId}`);
+                }
+                pendingReminderRenders.delete(msg.callId);
+                clearTimeout(p.timeout);
+                if (!msg.ok) {
+                    p.reject(new Error(msg.errorText));
+                    return;
+                }
+                p.resolve(msg.message);
             }
         }
         catch (err) {
@@ -210,6 +293,70 @@ async function startAppsHost(params) {
             child.send(msg);
         });
     };
+    const applyReminder = async (appId, ownerRef, request, ctx) => {
+        if (!ready) {
+            throw new Error(`apps-host is not ready yet (reminderOwner=${appId}/${ownerRef})`);
+        }
+        const callId = (0, crypto_1.randomUUID)();
+        const msg = {
+            type: 'reminder_apply',
+            callId,
+            appId,
+            ownerRef,
+            request,
+            ctx,
+        };
+        return await new Promise((resolve, reject) => {
+            const timeout = setTimeout(() => {
+                pendingReminderApplies.delete(callId);
+                reject(new Error(`apps-host reminder apply timed out: owner=${appId}/${ownerRef} callId=${callId}`));
+            }, 60000);
+            pendingReminderApplies.set(callId, { resolve, reject, timeout });
+            child.send(msg);
+        });
+    };
+    const updateReminder = async (appId, ownerRef, ctx) => {
+        if (!ready) {
+            throw new Error(`apps-host is not ready yet (reminderOwner=${appId}/${ownerRef})`);
+        }
+        const callId = (0, crypto_1.randomUUID)();
+        const msg = {
+            type: 'reminder_update',
+            callId,
+            appId,
+            ownerRef,
+            ctx,
+        };
+        return await new Promise((resolve, reject) => {
+            const timeout = setTimeout(() => {
+                pendingReminderUpdates.delete(callId);
+                reject(new Error(`apps-host reminder update timed out: owner=${appId}/${ownerRef} callId=${callId}`));
+            }, 60000);
+            pendingReminderUpdates.set(callId, { resolve, reject, timeout });
+            child.send(msg);
+        });
+    };
+    const renderReminder = async (appId, ownerRef, ctx) => {
+        if (!ready) {
+            throw new Error(`apps-host is not ready yet (reminderOwner=${appId}/${ownerRef})`);
+        }
+        const callId = (0, crypto_1.randomUUID)();
+        const msg = {
+            type: 'reminder_render',
+            callId,
+            appId,
+            ownerRef,
+            ctx,
+        };
+        return await new Promise((resolve, reject) => {
+            const timeout = setTimeout(() => {
+                pendingReminderRenders.delete(callId);
+                reject(new Error(`apps-host reminder render timed out: owner=${appId}/${ownerRef} callId=${callId}`));
+            }, 60000);
+            pendingReminderRenders.set(callId, { resolve, reject, timeout });
+            child.send(msg);
+        });
+    };
     const shutdown = async () => {
         try {
             child.send({ type: 'shutdown' });
@@ -222,5 +369,8 @@ async function startAppsHost(params) {
     if (!readyMsg) {
         throw new Error('apps-host: internal error (readyMsg missing after readyPromise resolved)');
     }
-    return { client: { callTool, applyRunControl, shutdown }, ready: readyResult };
+    return {
+        client: { callTool, applyRunControl, applyReminder, updateReminder, renderReminder, shutdown },
+        ready: readyResult,
+    };
 }