@jsonstudio/llms 0.6.954 → 0.6.1172

package/dist/servertool/handlers/clock.js

@@ -0,0 +1,197 @@
+import { registerServerToolHandler } from '../registry.js';
+import { cloneJson } from '../server-side-tools.js';
+import { extractCapturedChatSeed } from './followup-request-builder.js';
+import { cancelClockTask, clearClockTasks, listClockTasks, normalizeClockConfig, parseDueAtMs, scheduleClockTasks, startClockDaemonIfNeeded } from '../clock/task-store.js';
+const FLOW_ID = 'clock_flow';
+function parseToolArguments(toolCall) {
+    if (!toolCall.arguments || typeof toolCall.arguments !== 'string') {
+        return {};
+    }
+    try {
+        const parsed = JSON.parse(toolCall.arguments);
+        return parsed && typeof parsed === 'object' && !Array.isArray(parsed) ? parsed : {};
+    }
+    catch {
+        return {};
+    }
+}
+function resolveSessionId(adapterContext) {
+    if (!adapterContext || typeof adapterContext !== 'object' || Array.isArray(adapterContext)) {
+        return null;
+    }
+    const sessionId = typeof adapterContext.sessionId === 'string' ? String(adapterContext.sessionId).trim() : '';
+    return sessionId || null;
+}
+function injectClockToolOutput(base, toolCall, content) {
+    const cloned = cloneJson(base);
+    const existingOutputs = Array.isArray(cloned.tool_outputs)
+        ? cloned.tool_outputs
+        : [];
+    let payloadText;
+    if (typeof content === 'string') {
+        payloadText = content;
+    }
+    else {
+        try {
+            payloadText = JSON.stringify(content ?? {});
+        }
+        catch {
+            payloadText = String(content ?? '');
+        }
+    }
+    cloned.tool_outputs = [
+        ...existingOutputs,
+        {
+            tool_call_id: toolCall.id,
+            name: 'clock',
+            content: payloadText
+        }
+    ];
+    return cloned;
+}
+function asPlainObject(value) {
+    if (value && typeof value === 'object' && !Array.isArray(value)) {
+        return value;
+    }
+    return null;
+}
+function normalizeAction(value) {
+    const raw = typeof value === 'string' ? value.trim().toLowerCase() : '';
+    if (raw === 'list' || raw === 'cancel' || raw === 'clear' || raw === 'schedule') {
+        return raw;
+    }
+    return 'schedule';
+}
+function toIso(ms) {
+    try {
+        return new Date(ms).toISOString();
+    }
+    catch {
+        return new Date(0).toISOString();
+    }
+}
+function normalizeScheduleItems(parsed) {
+    const itemsRaw = parsed.items;
+    if (!Array.isArray(itemsRaw) || itemsRaw.length === 0) {
+        return { ok: false, items: [], message: 'clock.schedule requires items: [{ dueAt, task, tool?, arguments? }]' };
+    }
+    const items = [];
+    for (const entry of itemsRaw) {
+        const rec = asPlainObject(entry);
+        if (!rec) {
+            return { ok: false, items: [], message: 'clock.schedule items must be objects' };
+        }
+        const dueAtMs = parseDueAtMs(rec.dueAt);
+        if (!dueAtMs) {
+            return { ok: false, items: [], message: 'clock.schedule dueAt must be an ISO8601 string' };
+        }
+        const task = typeof rec.task === 'string' ? rec.task.trim() : '';
+        if (!task) {
+            return { ok: false, items: [], message: 'clock.schedule task must be a non-empty string' };
+        }
+        const tool = typeof rec.tool === 'string' && rec.tool.trim().length ? rec.tool.trim() : undefined;
+        const argsObj = rec.arguments && typeof rec.arguments === 'object' && !Array.isArray(rec.arguments)
+            ? cloneJson(rec.arguments)
+            : undefined;
+        items.push({
+            dueAtMs,
+            task,
+            ...(tool ? { tool } : {}),
+            ...(argsObj ? { arguments: argsObj } : {})
+        });
+    }
+    return { ok: true, items };
+}
+function mapTaskForTool(t) {
+    return {
+        taskId: t.taskId,
+        dueAt: toIso(t.dueAtMs),
+        task: t.task,
+        ...(t.tool ? { tool: t.tool } : {}),
+        ...(t.arguments ? { arguments: t.arguments } : {}),
+        ...(typeof t.deliveredAtMs === 'number' ? { deliveredAt: toIso(t.deliveredAtMs) } : {}),
+        deliveryCount: t.deliveryCount
+    };
+}
+const handler = async (ctx) => {
+    const toolCall = ctx.toolCall;
+    if (!toolCall || toolCall.name !== 'clock') {
+        return null;
+    }
+    const clockConfig = normalizeClockConfig(ctx.adapterContext.clock);
+    const sessionId = resolveSessionId(ctx.adapterContext);
+    const parsedArgs = parseToolArguments(toolCall);
+    const action = normalizeAction(parsedArgs.action);
+    const respond = (payload) => {
+        return {
+            flowId: FLOW_ID,
+            finalize: async () => {
+                const patched = injectClockToolOutput(ctx.base, toolCall, payload);
+                const seed = extractCapturedChatSeed(ctx.adapterContext?.capturedChatRequest);
+                const canFollowup = Boolean(seed);
+                return {
+                    chatResponse: patched,
+                    execution: {
+                        flowId: FLOW_ID,
+                        ...(canFollowup
+                            ? {
+                                followup: {
+                                    requestIdSuffix: ':clock_followup',
+                                    entryEndpoint: ctx.entryEndpoint,
+                                    injection: {
+                                        ops: [
+                                            { op: 'append_assistant_message', required: true },
+                                            { op: 'append_tool_messages_from_tool_outputs', required: true }
+                                        ]
+                                    }
+                                }
+                            }
+                            : {})
+                    }
+                };
+            }
+        };
+    };
+    if (!clockConfig) {
+        return respond({
+            ok: false,
+            action,
+            message: 'clock tool is not enabled (virtualrouter.clock.enabled=true required).'
+        });
+    }
+    await startClockDaemonIfNeeded(clockConfig);
+    if (!sessionId) {
+        return respond({
+            ok: false,
+            action,
+            message: 'clock requires sessionId (x-session-id header or metadata.sessionId).'
+        });
+    }
+    if (action === 'list') {
+        const items = await listClockTasks(sessionId, clockConfig);
+        return respond({ ok: true, action, items: items.map(mapTaskForTool) });
+    }
+    if (action === 'clear') {
+        const removedCount = await clearClockTasks(sessionId, clockConfig);
+        return respond({ ok: true, action, removedCount });
+    }
+    if (action === 'cancel') {
+        const taskId = typeof parsedArgs.taskId === 'string' ? parsedArgs.taskId.trim() : '';
+        if (!taskId) {
+            return respond({ ok: false, action, message: 'clock.cancel requires taskId' });
+        }
+        const removed = await cancelClockTask(sessionId, taskId, clockConfig);
+        return respond({ ok: true, action, removed: removed ? taskId : null });
+    }
+    const normalized = normalizeScheduleItems(parsedArgs);
+    if (!normalized.ok) {
+        return respond({ ok: false, action, message: normalized.message ?? 'invalid schedule items' });
+    }
+    const scheduled = await scheduleClockTasks(sessionId, normalized.items, clockConfig);
+    return respond({
+        ok: true,
+        action,
+        scheduled: scheduled.map(mapTaskForTool)
+    });
+};
+registerServerToolHandler('clock', handler);