dominds 1.4.2 → 1.5.1

package/dist/apps-host/host.js

@@ -13,6 +13,200 @@ const dynamicImport = new Function('specifier', 'return import(specifier)');
 function isRecord(v) {
     return typeof v === 'object' && v !== null && !Array.isArray(v);
 }
+function isJsonPrimitive(value) {
+    return (typeof value === 'string' ||
+        typeof value === 'number' ||
+        typeof value === 'boolean' ||
+        value === null);
+}
+function isJsonValue(value) {
+    if (isJsonPrimitive(value))
+        return true;
+    if (Array.isArray(value))
+        return value.every((item) => isJsonValue(item));
+    if (!isRecord(value))
+        return false;
+    return Object.values(value).every((item) => isJsonValue(item));
+}
+function isToolCallOutput(value) {
+    if (typeof value === 'string')
+        return true;
+    if (!isRecord(value))
+        return false;
+    if (typeof value['content'] !== 'string')
+        return false;
+    const contentItems = value['contentItems'];
+    return contentItems === undefined || Array.isArray(contentItems);
+}
+function parseReminderRequest(value) {
+    if (!isRecord(value))
+        throw new Error('Invalid app tool reminder request: expected object');
+    const kind = value['kind'];
+    const ownerRef = value['ownerRef'];
+    if (typeof ownerRef !== 'string' || ownerRef.trim() === '') {
+        throw new Error('Invalid app tool reminder request: ownerRef required');
+    }
+    if (kind === 'delete') {
+        const meta = value['meta'];
+        if (meta !== undefined && !isJsonValue(meta)) {
+            throw new Error('Invalid app tool reminder request: delete.meta must be JSON-serializable');
+        }
+        return { kind: 'delete', ownerRef, meta };
+    }
+    if (kind === 'upsert') {
+        const content = value['content'];
+        if (typeof content !== 'string') {
+            throw new Error('Invalid app tool reminder request: upsert.content must be string');
+        }
+        const meta = value['meta'];
+        if (meta !== undefined && !isJsonValue(meta)) {
+            throw new Error('Invalid app tool reminder request: upsert.meta must be JSON-serializable');
+        }
+        const positionRaw = value['position'];
+        const position = positionRaw === undefined
+            ? undefined
+            : typeof positionRaw === 'number' && Number.isFinite(positionRaw)
+                ? Math.floor(positionRaw)
+                : null;
+        if (position === null) {
+            throw new Error('Invalid app tool reminder request: upsert.position must be finite number');
+        }
+        const echobackRaw = value['echoback'];
+        const echoback = echobackRaw === undefined ? undefined : typeof echobackRaw === 'boolean' ? echobackRaw : null;
+        if (echoback === null) {
+            throw new Error('Invalid app tool reminder request: upsert.echoback must be boolean');
+        }
+        return { kind: 'upsert', ownerRef, content, meta, position, echoback };
+    }
+    throw new Error(`Invalid app tool reminder request kind: ${String(kind)}`);
+}
+function parseDialogTargetRef(value) {
+    if (!isRecord(value))
+        throw new Error('Invalid dialog reminder target: expected object');
+    const dialogId = value['dialogId'];
+    if (typeof dialogId === 'string' && dialogId.trim() !== '') {
+        return { dialogId };
+    }
+    const agentId = value['agentId'];
+    if (typeof agentId !== 'string' || agentId.trim() === '') {
+        throw new Error('Invalid dialog reminder target: agentId required when dialogId is absent');
+    }
+    const rootDialogIdRaw = value['rootDialogId'];
+    const rootDialogId = rootDialogIdRaw === undefined
+        ? undefined
+        : typeof rootDialogIdRaw === 'string' && rootDialogIdRaw.trim() !== ''
+            ? rootDialogIdRaw
+            : null;
+    if (rootDialogId === null) {
+        throw new Error('Invalid dialog reminder target: rootDialogId must be non-empty string');
+    }
+    const sessionSlugRaw = value['sessionSlug'];
+    const sessionSlug = sessionSlugRaw === undefined
+        ? undefined
+        : typeof sessionSlugRaw === 'string' && sessionSlugRaw.trim() !== ''
+            ? sessionSlugRaw
+            : null;
+    if (sessionSlug === null) {
+        throw new Error('Invalid dialog reminder target: sessionSlug must be non-empty string');
+    }
+    return { agentId, rootDialogId, sessionSlug };
+}
+function parseDialogReminderRequestBatch(value) {
+    if (!isRecord(value))
+        throw new Error('Invalid dialog reminder request batch: expected object');
+    const reminderRequestsRaw = value['reminderRequests'];
+    if (!Array.isArray(reminderRequestsRaw)) {
+        throw new Error('Invalid dialog reminder request batch: reminderRequests must be an array');
+    }
+    return {
+        target: parseDialogTargetRef(value['target']),
+        reminderRequests: reminderRequestsRaw.map((request) => parseReminderRequest(request)),
+    };
+}
+function isReminderState(value) {
+    if (!isRecord(value))
+        return false;
+    if (typeof value['content'] !== 'string')
+        return false;
+    const meta = value['meta'];
+    if (meta !== undefined && !isJsonValue(meta))
+        return false;
+    const echoback = value['echoback'];
+    return echoback === undefined || typeof echoback === 'boolean';
+}
+function isReminderApplyResult(value) {
+    if (!isRecord(value))
+        return false;
+    const treatment = value['treatment'];
+    if (treatment === 'noop')
+        return true;
+    if (treatment === 'add') {
+        const position = value['position'];
+        return (isReminderState(value['reminder']) &&
+            (position === undefined || (typeof position === 'number' && Number.isFinite(position))));
+    }
+    if (treatment === 'update') {
+        return (typeof value['ownedIndex'] === 'number' &&
+            Number.isFinite(value['ownedIndex']) &&
+            isReminderState(value['reminder']));
+    }
+    if (treatment === 'delete') {
+        return typeof value['ownedIndex'] === 'number' && Number.isFinite(value['ownedIndex']);
+    }
+    return false;
+}
+function isReminderUpdateResult(value) {
+    if (!isRecord(value))
+        return false;
+    const treatment = value['treatment'];
+    if (treatment === 'drop' || treatment === 'keep') {
+        return true;
+    }
+    if (treatment !== 'update')
+        return false;
+    if (typeof value['updatedContent'] !== 'string')
+        return false;
+    const updatedMeta = value['updatedMeta'];
+    return updatedMeta === undefined || isJsonValue(updatedMeta);
+}
+function isChatMessage(value) {
+    if (!isRecord(value))
+        return false;
+    if (typeof value['type'] !== 'string')
+        return false;
+    if (typeof value['role'] !== 'string')
+        return false;
+    return true;
+}
+function normalizeToolResult(value) {
+    if (isToolCallOutput(value)) {
+        return { output: value };
+    }
+    if (!isRecord(value)) {
+        throw new Error('Invalid app tool result: expected ToolCallOutput or structured object');
+    }
+    const output = value['output'];
+    if (!isToolCallOutput(output)) {
+        throw new Error('Invalid app tool result: output must be ToolCallOutput');
+    }
+    const reminderRequestsRaw = value['reminderRequests'];
+    if (reminderRequestsRaw !== undefined && !Array.isArray(reminderRequestsRaw)) {
+        throw new Error('Invalid app tool result: reminderRequests must be an array');
+    }
+    const dialogReminderRequestsRaw = value['dialogReminderRequests'];
+    if (dialogReminderRequestsRaw !== undefined && !Array.isArray(dialogReminderRequestsRaw)) {
+        throw new Error('Invalid app tool result: dialogReminderRequests must be an array');
+    }
+    return {
+        output,
+        reminderRequests: reminderRequestsRaw === undefined
+            ? undefined
+            : reminderRequestsRaw.map((request) => parseReminderRequest(request)),
+        dialogReminderRequests: dialogReminderRequestsRaw === undefined
+            ? undefined
+            : dialogReminderRequestsRaw.map((batch) => parseDialogReminderRequestBatch(batch)),
+    };
+}
 function send(msg) {
     if (typeof process.send !== 'function') {
         throw new Error(`apps-host: process.send is not available; must be started with child_process.fork (msg=${JSON.stringify(msg)})`);
@@ -22,6 +216,10 @@ function send(msg) {
 const runningApps = new Map();
 const toolHandlers = new Map();
 const runControlHandlers = new Map();
+const reminderOwnerHandlers = new Map();
+function buildReminderOwnerHandlerKey(appId, ownerRef) {
+    return `${appId}::${ownerRef}`;
+}
 function pickExportedFactory(mod, exportName, moduleAbs) {
     if (isRecord(mod) && typeof mod[exportName] === 'function') {
         return mod[exportName];
@@ -51,6 +249,10 @@ function validateHostInstance(host, appId) {
     if (runControls !== undefined && !isRecord(runControls)) {
         throw new Error(`Invalid app host instance for '${appId}': runControls must be an object`);
     }
+    const reminderOwners = host['reminderOwners'];
+    if (reminderOwners !== undefined && !isRecord(reminderOwners)) {
+        throw new Error(`Invalid app host instance for '${appId}': reminderOwners must be an object`);
+    }
     const toolFns = tools;
     for (const [name, fn] of Object.entries(toolFns)) {
         if (typeof fn !== 'function') {
@@ -65,6 +267,23 @@ function validateHostInstance(host, appId) {
             }
         }
     }
+    if (reminderOwners !== undefined) {
+        const reminderOwnerFns = reminderOwners;
+        for (const [ownerRef, handler] of Object.entries(reminderOwnerFns)) {
+            if (!isRecord(handler)) {
+                throw new Error(`Invalid app host instance for '${appId}': reminderOwners['${ownerRef}'] must be an object`);
+            }
+            if (typeof handler['apply'] !== 'function') {
+                throw new Error(`Invalid app host instance for '${appId}': reminderOwners['${ownerRef}'].apply must be a function`);
+            }
+            if (typeof handler['updateReminder'] !== 'function') {
+                throw new Error(`Invalid app host instance for '${appId}': reminderOwners['${ownerRef}'].updateReminder must be a function`);
+            }
+            if (typeof handler['renderReminder'] !== 'function') {
+                throw new Error(`Invalid app host instance for '${appId}': reminderOwners['${ownerRef}'].renderReminder must be a function`);
+            }
+        }
+    }
     return host;
 }
 function isValidRunControlResult(result) {
@@ -113,6 +332,15 @@ async function initOnce(msg) {
                 runControlHandlers.set(controlId, { appId, fn });
             }
         }
+        if (host.reminderOwners) {
+            for (const [ownerRef, fn] of Object.entries(host.reminderOwners)) {
+                const handlerKey = buildReminderOwnerHandlerKey(appId, ownerRef);
+                if (reminderOwnerHandlers.has(handlerKey)) {
+                    throw new Error(`apps-host: duplicate reminder owner '${ownerRef}' for app '${appId}'`);
+                }
+                reminderOwnerHandlers.set(handlerKey, { appId, ownerRef, fn });
+            }
+        }
         let frontend = null;
         if (app.installJson.frontend) {
             if (!host.start) {
@@ -182,8 +410,15 @@ process.on('message', (raw) => {
                     return;
                 }
                 try {
-                    const output = await found.fn(msg.args, msg.ctx);
-                    send({ type: 'tool_result', callId: msg.callId, ok: true, output });
+                    const result = normalizeToolResult(await found.fn(msg.args, msg.ctx));
+                    send({
+                        type: 'tool_result',
+                        callId: msg.callId,
+                        ok: true,
+                        output: result.output,
+                        reminderRequests: result.reminderRequests,
+                        dialogReminderRequests: result.dialogReminderRequests,
+                    });
                 }
                 catch (err) {
                     send({
@@ -229,6 +464,108 @@ process.on('message', (raw) => {
                 }
                 return;
             }
+            case 'reminder_apply': {
+                const found = reminderOwnerHandlers.get(buildReminderOwnerHandlerKey(msg.appId, msg.ownerRef));
+                if (!found) {
+                    send({
+                        type: 'reminder_apply_result',
+                        callId: msg.callId,
+                        ok: false,
+                        errorText: `Unknown reminder owner: ${msg.appId}/${msg.ownerRef}`,
+                    });
+                    return;
+                }
+                try {
+                    const result = await found.fn.apply(msg.request, msg.ctx);
+                    if (!isReminderApplyResult(result)) {
+                        send({
+                            type: 'reminder_apply_result',
+                            callId: msg.callId,
+                            ok: false,
+                            errorText: `Invalid reminder apply result shape: ${msg.appId}/${msg.ownerRef}`,
+                        });
+                        return;
+                    }
+                    send({ type: 'reminder_apply_result', callId: msg.callId, ok: true, result });
+                }
+                catch (err) {
+                    send({
+                        type: 'reminder_apply_result',
+                        callId: msg.callId,
+                        ok: false,
+                        errorText: err instanceof Error ? err.message : String(err),
+                    });
+                }
+                return;
+            }
+            case 'reminder_update': {
+                const found = reminderOwnerHandlers.get(buildReminderOwnerHandlerKey(msg.appId, msg.ownerRef));
+                if (!found) {
+                    send({
+                        type: 'reminder_update_result',
+                        callId: msg.callId,
+                        ok: false,
+                        errorText: `Unknown reminder owner: ${msg.appId}/${msg.ownerRef}`,
+                    });
+                    return;
+                }
+                try {
+                    const result = await found.fn.updateReminder(msg.ctx);
+                    if (!isReminderUpdateResult(result)) {
+                        send({
+                            type: 'reminder_update_result',
+                            callId: msg.callId,
+                            ok: false,
+                            errorText: `Invalid reminder update result shape: ${msg.appId}/${msg.ownerRef}`,
+                        });
+                        return;
+                    }
+                    send({ type: 'reminder_update_result', callId: msg.callId, ok: true, result });
+                }
+                catch (err) {
+                    send({
+                        type: 'reminder_update_result',
+                        callId: msg.callId,
+                        ok: false,
+                        errorText: err instanceof Error ? err.message : String(err),
+                    });
+                }
+                return;
+            }
+            case 'reminder_render': {
+                const found = reminderOwnerHandlers.get(buildReminderOwnerHandlerKey(msg.appId, msg.ownerRef));
+                if (!found) {
+                    send({
+                        type: 'reminder_render_result',
+                        callId: msg.callId,
+                        ok: false,
+                        errorText: `Unknown reminder owner: ${msg.appId}/${msg.ownerRef}`,
+                    });
+                    return;
+                }
+                try {
+                    const message = await found.fn.renderReminder(msg.ctx);
+                    if (!isChatMessage(message)) {
+                        send({
+                            type: 'reminder_render_result',
+                            callId: msg.callId,
+                            ok: false,
+                            errorText: `Invalid reminder render result shape: ${msg.appId}/${msg.ownerRef}`,
+                        });
+                        return;
+                    }
+                    send({ type: 'reminder_render_result', callId: msg.callId, ok: true, message });
+                }
+                catch (err) {
+                    send({
+                        type: 'reminder_render_result',
+                        callId: msg.callId,
+                        ok: false,
+                        errorText: err instanceof Error ? err.message : String(err),
+                    });
+                }
+                return;
+            }
             case 'shutdown':
                 await shutdownAll();
                 process.exit(0);