@jsonstudio/llms 0.6.1739 → 0.6.1890

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

@@ -1,9 +1,10 @@
 import { registerServerToolHandler } from '../registry.js';
 import { extractCapturedChatSeed } from './followup-request-builder.js';
 import { readRuntimeMetadata } from '../../conversion/shared/runtime-metadata.js';
-import { findNextUndeliveredDueAtMs, listClockTasks, resolveClockConfig, startClockDaemonIfNeeded } from '../clock/task-store.js';
+import { findNextUndeliveredDueAtMs, listClockTasks, reserveDueTasksForRequest, resolveClockConfig, startClockDaemonIfNeeded } from '../clock/task-store.js';
 import { nowMs } from '../clock/state.js';
 import { logClock } from '../clock/log.js';
+import { isStopEligibleForServerTool } from '../stop-gateway-context.js';
 const FLOW_ID = 'clock_hold_flow';
 function resolveClientConnectionState(value) {
     if (!value || typeof value !== 'object' || Array.isArray(value)) {
@@ -20,7 +21,14 @@ function clientWantsStreaming(adapterContext) {
         return false;
     }
     const record = adapterContext;
-    if (record.stream === true) {
+    if (record.stream === true ||
+        record.inboundStream === true ||
+        record.outboundStream === true ||
+        record.clientStream === true) {
+        return true;
+    }
+    const streamingHint = typeof record.streamingHint === 'string' ? record.streamingHint.trim().toLowerCase() : '';
+    if (streamingHint === 'force') {
         return true;
     }
     const clientHeaders = record.clientHeaders;
@@ -32,50 +40,6 @@ function clientWantsStreaming(adapterContext) {
     }
     return false;
 }
-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;
@@ -103,7 +67,7 @@ async function sleep(ms) {
 const handler = async (ctx) => {
     const record = ctx.adapterContext;
     // Only trigger on stop/length completion (no tool calls).
-    if (!isStopFinishReason(ctx.base)) {
+    if (!isStopEligibleForServerTool(ctx.base, ctx.adapterContext)) {
         return null;
     }
     // When client already disconnected, skip holding.
@@ -147,33 +111,47 @@ const handler = async (ctx) => {
     }
     // Wait until the "due window" is reached (now >= dueAt - dueWindowMs).
     const thresholdMs = nextDueAtMs - clockConfig.dueWindowMs;
-    // Important: if we're already inside the due window, do NOT auto-followup in the current request
-    // (prevents same-request loops; the reminder will be injected on the next request).
-    if (at >= thresholdMs) {
-        return null;
-    }
-    const remainingMs = thresholdMs - at;
-    if (clockConfig.holdMaxMs >= 0 && remainingMs > clockConfig.holdMaxMs) {
-        return null;
-    }
-    logClock('hold_start', { sessionId, nextDueAtMs, thresholdMs });
-    while (nowMs() < thresholdMs) {
-        const state = resolveClientConnectionState(ctx.adapterContext.clientConnectionState);
-        if (state?.disconnected === true) {
-            return null;
-        }
-        const remaining = thresholdMs - nowMs();
-        await sleep(computeHoldSleepMs(remaining));
-        // Best-effort: if tasks were cleared/cancelled while holding, stop holding.
+    const inDueWindow = at >= thresholdMs;
+    if (inDueWindow) {
         try {
-            const refreshed = await listClockTasks(sessionId, clockConfig);
-            const refreshedNext = findNextUndeliveredDueAtMs(refreshed, nowMs());
-            if (!refreshedNext) {
+            const probe = await reserveDueTasksForRequest({
+                reservationId: `${ctx.requestId}:clock_auto_probe`,
+                sessionId,
+                config: clockConfig,
+                requestId: ctx.requestId
+            });
+            if (!probe.reservation || !Array.isArray(probe.reservation.taskIds) || probe.reservation.taskIds.length === 0) {
                 return null;
             }
         }
         catch {
-            // ignore refresh errors; keep holding
+            return null;
+        }
+    }
+    else {
+        const remainingMs = thresholdMs - at;
+        if (clockConfig.holdMaxMs >= 0 && remainingMs > clockConfig.holdMaxMs) {
+            return null;
+        }
+        logClock('hold_start', { sessionId, nextDueAtMs, thresholdMs });
+        while (nowMs() < thresholdMs) {
+            const state = resolveClientConnectionState(ctx.adapterContext.clientConnectionState);
+            if (state?.disconnected === true) {
+                return null;
+            }
+            const remaining = thresholdMs - nowMs();
+            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, nowMs());
+                if (!refreshedNext) {
+                    return null;
+                }
+            }
+            catch {
+                // ignore refresh errors; keep holding
+            }
         }
     }
     return {
@@ -191,10 +169,15 @@ const handler = async (ctx) => {
                             { op: 'append_user_text', text: 'continue' }
                         ]
                     },
-                    metadata: (connectionState ? { clientConnectionState: connectionState } : {})
+                    metadata: {
+                        ...(connectionState ? { clientConnectionState: connectionState } : {}),
+                        __rt: {
+                            clockFollowupInjectReminders: true
+                        }
+                    }
                 }
             }
         })
     };
 };
-registerServerToolHandler('clock_auto', handler, { trigger: 'auto' });
+registerServerToolHandler('clock_auto', handler, { trigger: 'auto', hook: { phase: 'post', priority: 50 } });

package/dist/servertool/handlers/clock.js

@@ -2,11 +2,27 @@ import { registerServerToolHandler } from '../registry.js';
 import { cloneJson } from '../server-side-tools.js';
 import { extractCapturedChatSeed } from './followup-request-builder.js';
 import { ensureRuntimeMetadata, readRuntimeMetadata } from '../../conversion/shared/runtime-metadata.js';
-import { cancelClockTask, clearClockTasks, listClockTasks, resolveClockConfig, parseDueAtMs, scheduleClockTasks, startClockDaemonIfNeeded } from '../clock/task-store.js';
+import { cancelClockTask, clearClockTasks, listClockTasks, resolveClockConfig, parseDueAtMs, scheduleClockTasks, startClockDaemonIfNeeded, updateClockTask } from '../clock/task-store.js';
 import { getClockTimeSnapshot } from '../clock/ntp.js';
 import { nowMs } from '../clock/state.js';
 import { logClock } from '../clock/log.js';
 const FLOW_ID = 'clock_flow';
+let fallbackClockToolCallSeq = 0;
+function ensureClockToolCall(toolCall, requestId) {
+    if (!toolCall || toolCall.name !== 'clock') {
+        return null;
+    }
+    const existingId = typeof toolCall.id === 'string' ? toolCall.id.trim() : '';
+    if (existingId) {
+        return toolCall;
+    }
+    fallbackClockToolCallSeq += 1;
+    const reqToken = String(requestId || 'req').replace(/[^a-zA-Z0-9_-]+/g, '_') || 'req';
+    return {
+        ...toolCall,
+        id: `call_clock_fallback_${reqToken}_${fallbackClockToolCallSeq}`
+    };
+}
 function extractAssistantMessageFromChatLike(chatResponse) {
     if (!chatResponse || typeof chatResponse !== 'object') {
         return null;
@@ -112,7 +128,7 @@ function asPlainObject(value) {
 }
 function normalizeAction(value) {
     const raw = typeof value === 'string' ? value.trim().toLowerCase() : '';
-    if (raw === 'get' || raw === 'list' || raw === 'cancel' || raw === 'clear' || raw === 'schedule') {
+    if (raw === 'get' || raw === 'list' || raw === 'cancel' || raw === 'clear' || raw === 'schedule' || raw === 'update') {
         return raw;
     }
     return 'schedule';
@@ -125,6 +141,58 @@ function toIso(ms) {
         return new Date(0).toISOString();
     }
 }
+function parseRecurrenceKind(raw) {
+    const value = typeof raw === 'string' ? raw.trim().toLowerCase() : '';
+    if (!value) {
+        return undefined;
+    }
+    if (value === 'daily' || value === 'day') {
+        return 'daily';
+    }
+    if (value === 'weekly' || value === 'week') {
+        return 'weekly';
+    }
+    if (value === 'interval' || value === 'every_minutes' || value === 'every-minutes' || value === 'everyminutes') {
+        return 'interval';
+    }
+    return undefined;
+}
+function parseRecurrenceFromRecord(record) {
+    const recurrenceRaw = record.recurrence ?? record.repeat ?? record.cycle;
+    const maxRunsRaw = Number(record.maxRuns ?? (recurrenceRaw && typeof recurrenceRaw === 'object' && !Array.isArray(recurrenceRaw)
+        ? recurrenceRaw.maxRuns
+        : undefined));
+    if (recurrenceRaw === undefined || recurrenceRaw === null || recurrenceRaw === false) {
+        return {};
+    }
+    let kind;
+    let everyMinutesRaw;
+    if (typeof recurrenceRaw === 'string') {
+        kind = parseRecurrenceKind(recurrenceRaw);
+        everyMinutesRaw = record.everyMinutes;
+    }
+    else if (recurrenceRaw && typeof recurrenceRaw === 'object' && !Array.isArray(recurrenceRaw)) {
+        const recurrenceRecord = recurrenceRaw;
+        kind = parseRecurrenceKind(recurrenceRecord.kind ?? recurrenceRecord.type ?? recurrenceRecord.mode ?? recurrenceRecord.every);
+        everyMinutesRaw = recurrenceRecord.everyMinutes ?? recurrenceRecord.minutes ?? record.everyMinutes;
+    }
+    if (!kind) {
+        return { message: 'clock.schedule recurrence kind must be daily|weekly|interval' };
+    }
+    const maxRuns = Number.isFinite(maxRunsRaw) ? Math.floor(maxRunsRaw) : NaN;
+    if (!Number.isFinite(maxRuns) || maxRuns <= 0) {
+        return { message: 'clock.schedule recurring task requires maxRuns >= 1' };
+    }
+    if (kind === 'interval') {
+        const everyMinutesNum = Number(everyMinutesRaw);
+        const everyMinutes = Number.isFinite(everyMinutesNum) ? Math.floor(everyMinutesNum) : NaN;
+        if (!Number.isFinite(everyMinutes) || everyMinutes <= 0) {
+            return { message: 'clock.schedule interval recurrence requires everyMinutes >= 1' };
+        }
+        return { recurrence: { kind: 'interval', maxRuns, everyMinutes } };
+    }
+    return { recurrence: { kind, maxRuns } };
+}
 function normalizeScheduleItems(parsed) {
     const itemsRaw = parsed.items;
     if (!Array.isArray(itemsRaw) || itemsRaw.length === 0) {
@@ -161,16 +229,33 @@ function normalizeScheduleItems(parsed) {
             }
             return undefined;
         })();
+        const recurrenceParsed = parseRecurrenceFromRecord(rec);
+        if (recurrenceParsed.message) {
+            return { ok: false, items: [], message: recurrenceParsed.message };
+        }
         items.push({
             dueAtMs,
             task,
             ...(tool ? { tool } : {}),
-            ...(argsObj ? { arguments: argsObj } : {})
+            ...(argsObj ? { arguments: argsObj } : {}),
+            ...(recurrenceParsed.recurrence ? { recurrence: recurrenceParsed.recurrence } : {})
         });
     }
     return { ok: true, items };
 }
 function mapTaskForTool(t) {
+    const recurrence = t.recurrence && typeof t.recurrence === 'object'
+        ? {
+            kind: t.recurrence.kind,
+            maxRuns: t.recurrence.maxRuns,
+            ...(t.recurrence.kind === 'interval' && typeof t.recurrence.everyMinutes === 'number'
+                ? { everyMinutes: t.recurrence.everyMinutes }
+                : {})
+        }
+        : undefined;
+    const remainingRuns = recurrence
+        ? Math.max(0, Math.floor(Number(recurrence.maxRuns) || 0) - Math.max(0, Math.floor(Number(t.deliveryCount) || 0)))
+        : undefined;
     return {
         taskId: t.taskId,
         dueAt: toIso(t.dueAtMs),
@@ -178,12 +263,14 @@ function mapTaskForTool(t) {
         ...(t.tool ? { tool: t.tool } : {}),
         ...(t.arguments ? { arguments: t.arguments } : {}),
         ...(typeof t.deliveredAtMs === 'number' ? { deliveredAt: toIso(t.deliveredAtMs) } : {}),
-        deliveryCount: t.deliveryCount
+        deliveryCount: t.deliveryCount,
+        ...(recurrence ? { recurrence } : {}),
+        ...(typeof remainingRuns === 'number' ? { remainingRuns } : {})
     };
 }
 const handler = async (ctx) => {
-    const toolCall = ctx.toolCall;
-    if (!toolCall || toolCall.name !== 'clock') {
+    const toolCall = ensureClockToolCall(ctx.toolCall, ctx.requestId);
+    if (!toolCall) {
         return null;
     }
     const rt = readRuntimeMetadata(ctx.adapterContext);
@@ -324,6 +411,34 @@ const handler = async (ctx) => {
         logClock('cancel', { sessionId, taskId, removed });
         return respond({ ok: true, action, removed: removed ? taskId : null });
     }
+    if (action === 'update') {
+        const taskId = typeof parsedArgs.taskId === 'string' ? parsedArgs.taskId.trim() : '';
+        if (!taskId) {
+            logClock('update_invalid', { sessionId, action, reason: 'missing_task_id' });
+            return respond({ ok: false, action, message: 'clock.update requires taskId' });
+        }
+        const normalized = normalizeScheduleItems(parsedArgs);
+        if (!normalized.ok || normalized.items.length < 1) {
+            logClock('update_invalid', { sessionId, action, message: normalized.message ?? 'invalid update payload' });
+            return respond({ ok: false, action, message: normalized.message ?? 'clock.update requires items[0] with dueAt/task' });
+        }
+        const item = normalized.items[0];
+        const patch = {
+            dueAtMs: item.dueAtMs,
+            task: item.task,
+            resetDelivery: true,
+            ...(item.tool ? { tool: item.tool } : {}),
+            ...(item.arguments ? { arguments: item.arguments } : {}),
+            ...(item.recurrence ? { recurrence: item.recurrence } : {})
+        };
+        const updated = await updateClockTask(sessionId, taskId, patch, clockConfig);
+        if (!updated) {
+            logClock('update_miss', { sessionId, taskId });
+            return respond({ ok: false, action, message: 'clock.update failed: task not found or patch invalid' });
+        }
+        logClock('update', { sessionId, taskId });
+        return respond({ ok: true, action, updated: mapTaskForTool(updated) });
+    }
     const normalized = normalizeScheduleItems(parsedArgs);
     if (!normalized.ok) {
         logClock('schedule_invalid', { sessionId, message: normalized.message ?? 'invalid schedule items' });

package/dist/servertool/handlers/continue-execution.d.ts

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

package/dist/servertool/handlers/continue-execution.js

@@ -0,0 +1,91 @@
+import { registerServerToolHandler } from '../registry.js';
+import { cloneJson } from '../server-side-tools.js';
+const FLOW_ID = 'continue_execution_flow';
+const TOOL_NAME = 'continue_execution';
+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 injectToolOutput(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: TOOL_NAME,
+            content: payloadText
+        }
+    ];
+    return cloned;
+}
+function normalizeReason(parsed) {
+    const candidate = (typeof parsed.reason === 'string' ? parsed.reason : '') ||
+        (typeof parsed.note === 'string' ? parsed.note : '') ||
+        (typeof parsed.message === 'string' ? parsed.message : '');
+    return candidate.trim();
+}
+const handler = async (ctx) => {
+    const toolCall = ctx.toolCall;
+    if (!toolCall || toolCall.name !== TOOL_NAME) {
+        return null;
+    }
+    const parsed = parseToolArguments(toolCall);
+    const reason = normalizeReason(parsed);
+    const followupText = '继续执行当前任务，不要中断到总结/汇报。仅在任务真正完成后再给最终总结。该工具用于避免打断会话并提高执行效率。';
+    return {
+        flowId: FLOW_ID,
+        finalize: async () => {
+            const patched = injectToolOutput(ctx.base, toolCall, {
+                ok: true,
+                executed: true,
+                noop: true,
+                action: 'continue_execution',
+                ...(reason ? { reason } : {}),
+                message: 'No-op acknowledged. Continue execution without pausing for status summaries or ending turn early. If you were about to stop/end_turn, emit continue_execution first; server auto-followup keeps execution moving.'
+            });
+            return {
+                chatResponse: patched,
+                execution: {
+                    flowId: FLOW_ID,
+                    followup: {
+                        requestIdSuffix: ':continue_execution_followup',
+                        entryEndpoint: ctx.entryEndpoint,
+                        injection: {
+                            ops: [
+                                { op: 'preserve_tools' },
+                                { op: 'ensure_standard_tools' },
+                                { op: 'append_assistant_message', required: true },
+                                { op: 'append_tool_messages_from_tool_outputs', required: true },
+                                { op: 'append_user_text', text: followupText }
+                            ]
+                        }
+                    }
+                }
+            };
+        }
+    };
+};
+registerServerToolHandler(TOOL_NAME, handler);

package/dist/servertool/handlers/followup-request-builder.js

@@ -327,6 +327,19 @@ function buildStandardFollowupTools() {
                 }
             }
         },
+        {
+            type: 'function',
+            function: {
+                name: 'continue_execution',
+                description: 'No-op control tool. Use this before summaries or before ending the turn. If you are about to return stop/end_turn, emit continue_execution first instead of ending directly. Keep it lightweight; server auto-followup continues execution.',
+                parameters: {
+                    type: 'object',
+                    properties: {},
+                    required: [],
+                    additionalProperties: false
+                }
+            }
+        },
         {
             type: 'function',
             function: {

package/dist/servertool/handlers/gemini-empty-reply-continue.js

@@ -99,7 +99,7 @@ const handler = async (ctx) => {
         })
     };
 };
-registerServerToolHandler('empty_reply_continue', handler, { trigger: 'auto' });
+registerServerToolHandler('empty_reply_continue', handler, { trigger: 'auto', hook: { phase: 'default', priority: 20 } });
 function decideEmptyReply(base) {
     // 1) OpenAI Chat shape
     const choices = Array.isArray(base.choices) ? base.choices : [];

package/dist/servertool/handlers/iflow-model-error-retry.js

@@ -69,7 +69,7 @@ const handler = async (ctx) => {
         })
     };
 };
-registerServerToolHandler('iflow_model_error_retry', handler, { trigger: 'auto' });
+registerServerToolHandler('iflow_model_error_retry', handler, { trigger: 'auto', hook: { phase: 'pre', priority: 10 } });
 function getCapturedRequest(adapterContext) {
     if (!adapterContext || typeof adapterContext !== 'object') {
         return null;

package/dist/servertool/handlers/recursive-detection-guard.js

@@ -332,4 +332,4 @@ const handler = async (ctx) => {
     sessionStates.set(sessionKey, state);
     return null;
 };
-registerServerToolHandler('recursive_detection_guard', handler, { trigger: 'auto' });
+registerServerToolHandler('recursive_detection_guard', handler, { trigger: 'auto', hook: { phase: 'pre', priority: 5 } });