@jsonstudio/llms 0.6.938 → 0.6.1164

package/dist/servertool/handlers/clock-auto.js

@@ -0,0 +1,160 @@
+import { registerServerToolHandler } from '../registry.js';
+import { extractCapturedChatSeed } from './followup-request-builder.js';
+import { findNextUndeliveredDueAtMs, listClockTasks, normalizeClockConfig, startClockDaemonIfNeeded } from '../clock/task-store.js';
+const FLOW_ID = 'clock_hold_flow';
+function resolveClientConnectionState(value) {
+    if (!value || typeof value !== 'object' || Array.isArray(value)) {
+        return null;
+    }
+    const record = value;
+    if (typeof record.disconnected !== 'boolean') {
+        return null;
+    }
+    return { disconnected: record.disconnected };
+}
+function isStopFinishReason(base) {
+    if (!base || typeof base !== 'object' || Array.isArray(base)) {
+        return false;
+    }
+    const payload = base;
+    const choicesRaw = payload.choices;
+    if (Array.isArray(choicesRaw) && choicesRaw.length) {
+        const first = choicesRaw[0];
+        if (!first || typeof first !== 'object' || Array.isArray(first)) {
+            return false;
+        }
+        const finishReasonRaw = first.finish_reason;
+        const finishReason = typeof finishReasonRaw === 'string' && finishReasonRaw.trim()
+            ? finishReasonRaw.trim().toLowerCase()
+            : '';
+        if (!finishReason || finishReason === 'tool_calls') {
+            return false;
+        }
+        if (finishReason !== 'stop' && finishReason !== 'length') {
+            return false;
+        }
+        const message = first.message &&
+            typeof first.message === 'object' &&
+            !Array.isArray(first.message)
+            ? first.message
+            : null;
+        if (!message) {
+            return false;
+        }
+        const toolCalls = Array.isArray(message.tool_calls) ? message.tool_calls : [];
+        if (toolCalls.length > 0) {
+            return false;
+        }
+        return true;
+    }
+    const statusRaw = typeof payload.status === 'string' ? payload.status.trim().toLowerCase() : '';
+    if (statusRaw && statusRaw !== 'completed') {
+        return false;
+    }
+    if (payload.required_action && typeof payload.required_action === 'object') {
+        return false;
+    }
+    return true;
+}
+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 computeHoldSleepMs(remainingMs) {
+    if (remainingMs <= 0)
+        return 0;
+    if (remainingMs > 10 * 60_000)
+        return 30_000;
+    if (remainingMs > 60_000)
+        return 10_000;
+    if (remainingMs > 10_000)
+        return 1_000;
+    return 200;
+}
+async function sleep(ms) {
+    if (!Number.isFinite(ms) || ms <= 0) {
+        return;
+    }
+    await new Promise((resolve) => setTimeout(resolve, ms));
+}
+const handler = async (ctx) => {
+    const record = ctx.adapterContext;
+    // Only trigger on stop/length completion (no tool calls).
+    if (!isStopFinishReason(ctx.base)) {
+        return null;
+    }
+    // When client already disconnected, skip holding.
+    const connectionState = resolveClientConnectionState(record.clientConnectionState);
+    if (connectionState?.disconnected === true) {
+        return null;
+    }
+    const clientDisconnectedRaw = record.clientDisconnected;
+    if (clientDisconnectedRaw === true ||
+        (typeof clientDisconnectedRaw === 'string' && clientDisconnectedRaw.trim().toLowerCase() === 'true')) {
+        return null;
+    }
+    const clockConfig = normalizeClockConfig(record.clock);
+    if (!clockConfig) {
+        return null;
+    }
+    await startClockDaemonIfNeeded(clockConfig);
+    const sessionId = resolveSessionId(ctx.adapterContext);
+    if (!sessionId) {
+        return null;
+    }
+    const seed = extractCapturedChatSeed(record.capturedChatRequest);
+    if (!seed) {
+        return null;
+    }
+    const tasks = await listClockTasks(sessionId, clockConfig);
+    const at = Date.now();
+    const nextDueAtMs = findNextUndeliveredDueAtMs(tasks, at);
+    if (!nextDueAtMs) {
+        return null;
+    }
+    // Wait until the "due window" is reached (now >= dueAt - dueWindowMs).
+    const thresholdMs = nextDueAtMs - clockConfig.dueWindowMs;
+    while (Date.now() < thresholdMs) {
+        const state = resolveClientConnectionState(ctx.adapterContext.clientConnectionState);
+        if (state?.disconnected === true) {
+            return null;
+        }
+        const remaining = thresholdMs - Date.now();
+        await sleep(computeHoldSleepMs(remaining));
+        // Best-effort: if tasks were cleared/cancelled while holding, stop holding.
+        try {
+            const refreshed = await listClockTasks(sessionId, clockConfig);
+            const refreshedNext = findNextUndeliveredDueAtMs(refreshed, Date.now());
+            if (!refreshedNext) {
+                return null;
+            }
+        }
+        catch {
+            // ignore refresh errors; keep holding
+        }
+    }
+    return {
+        flowId: FLOW_ID,
+        finalize: async () => ({
+            chatResponse: ctx.base,
+            execution: {
+                flowId: FLOW_ID,
+                followup: {
+                    requestIdSuffix: ':clock_hold_followup',
+                    entryEndpoint: ctx.entryEndpoint,
+                    injection: {
+                        ops: [
+                            { op: 'append_assistant_message', required: false },
+                            { op: 'append_user_text', text: 'continue' }
+                        ]
+                    },
+                    metadata: (connectionState ? { clientConnectionState: connectionState } : {})
+                }
+            }
+        })
+    };
+};
+registerServerToolHandler('clock_auto', handler, { trigger: 'auto' });

package/dist/servertool/handlers/clock.d.ts

@@ -0,0 +1 @@
+export {};

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);