@jsonstudio/llms 0.6.2172 → 0.6.3214

package/dist/conversion/hub/policy/protocol-spec.js

@@ -1,155 +1,27 @@
-import { ANTHROPIC_ALLOWED_FIELDS, ANTHROPIC_PARAMETERS_WRAPPER_ALLOW_KEYS, GEMINI_ALLOWED_FIELDS, OPENAI_CHAT_ALLOWED_FIELDS, OPENAI_CHAT_PARAMETERS_WRAPPER_ALLOW_KEYS, OPENAI_RESPONSES_ALLOWED_FIELDS, OPENAI_RESPONSES_PARAMETERS_WRAPPER_ALLOW_KEYS } from '../../shared/protocol-field-allowlists.js';
-const RESPONSES_SPEC = {
-    id: 'openai-responses',
-    providerOutbound: {
-        enforceEnabled: true,
-        allowedTopLevelKeys: OPENAI_RESPONSES_ALLOWED_FIELDS,
-        enforceAllowedTopLevelKeys: true,
-        forbidWrappers: [
-            {
-                code: 'forbid_wrapper',
-                path: 'parameters',
-                detail: 'Responses provider payload must not contain a top-level parameters wrapper (expects flattened fields).'
-            },
-            {
-                code: 'forbid_wrapper',
-                path: 'request',
-                detail: 'Responses provider payload must not contain a nested request wrapper.'
-            }
-        ],
-        reservedKeyPrefixes: ['__', '_'],
-        flattenWrappers: [
-            {
-                wrapperKey: 'request',
-                onlyIfTargetMissing: true
-            },
-            {
-                wrapperKey: 'parameters',
-                onlyIfTargetMissing: true,
-                aliasKeys: {
-                    max_tokens: 'max_output_tokens'
-                },
-                allowKeys: [...OPENAI_RESPONSES_PARAMETERS_WRAPPER_ALLOW_KEYS]
-            }
-        ]
-    },
-    toolSurface: {
-        expectedToolFormat: 'openai',
-        expectedHistoryCarrier: 'input'
-    }
-};
-const DEFAULT_SPEC = {
-    id: 'openai-chat',
-    providerOutbound: {
-        enforceEnabled: true,
-        allowedTopLevelKeys: OPENAI_CHAT_ALLOWED_FIELDS,
-        enforceAllowedTopLevelKeys: true,
-        forbidWrappers: [
-            {
-                code: 'forbid_wrapper',
-                path: 'parameters',
-                detail: 'OpenAI Chat provider payload must not contain a top-level parameters wrapper (expects flattened fields).'
-            },
-            {
-                code: 'forbid_wrapper',
-                path: 'request',
-                detail: 'OpenAI Chat provider payload must not contain a nested request wrapper.'
-            }
-        ],
-        reservedKeyPrefixes: ['__', '_'],
-        flattenWrappers: [
-            {
-                wrapperKey: 'request',
-                onlyIfTargetMissing: true
-            },
-            {
-                wrapperKey: 'parameters',
-                onlyIfTargetMissing: true,
-                aliasKeys: {
-                    max_output_tokens: 'max_tokens'
-                },
-                allowKeys: [...OPENAI_CHAT_PARAMETERS_WRAPPER_ALLOW_KEYS]
-            }
-        ]
-    },
-    toolSurface: {
-        expectedToolFormat: 'openai',
-        expectedHistoryCarrier: 'messages'
-    }
+import { ANTHROPIC_ALLOWED_FIELDS, ANTHROPIC_PARAMETERS_WRAPPER_ALLOW_KEYS, GEMINI_ALLOWED_FIELDS, OPENAI_CHAT_ALLOWED_FIELDS, OPENAI_CHAT_PARAMETERS_WRAPPER_ALLOW_KEYS, OPENAI_RESPONSES_ALLOWED_FIELDS, OPENAI_RESPONSES_PARAMETERS_WRAPPER_ALLOW_KEYS } from '../../protocol-field-allowlists.js';
+import { resolveHubProtocolSpecWithNative } from '../../../router/virtual-router/engine-selection/native-hub-bridge-policy-semantics.js';
+const ALLOWLISTS = {
+    openaiChatAllowedFields: OPENAI_CHAT_ALLOWED_FIELDS,
+    openaiChatParametersWrapperAllowKeys: OPENAI_CHAT_PARAMETERS_WRAPPER_ALLOW_KEYS,
+    openaiResponsesAllowedFields: OPENAI_RESPONSES_ALLOWED_FIELDS,
+    openaiResponsesParametersWrapperAllowKeys: OPENAI_RESPONSES_PARAMETERS_WRAPPER_ALLOW_KEYS,
+    anthropicAllowedFields: ANTHROPIC_ALLOWED_FIELDS,
+    anthropicParametersWrapperAllowKeys: ANTHROPIC_PARAMETERS_WRAPPER_ALLOW_KEYS,
+    geminiAllowedFields: GEMINI_ALLOWED_FIELDS
 };
+function buildSpec(protocol) {
+    return resolveHubProtocolSpecWithNative({
+        protocol,
+        allowlists: ALLOWLISTS
+    });
+}
 export const HUB_PROTOCOL_SPECS = {
-    'openai-chat': DEFAULT_SPEC,
-    'openai-responses': RESPONSES_SPEC,
-    'anthropic-messages': {
-        id: 'anthropic-messages',
-        providerOutbound: {
-            enforceEnabled: true,
-            allowedTopLevelKeys: ANTHROPIC_ALLOWED_FIELDS,
-            enforceAllowedTopLevelKeys: true,
-            forbidWrappers: [
-                {
-                    code: 'forbid_wrapper',
-                    path: 'parameters',
-                    detail: 'Anthropic Messages provider payload must not contain a top-level parameters wrapper.'
-                },
-                {
-                    code: 'forbid_wrapper',
-                    path: 'request',
-                    detail: 'Anthropic Messages provider payload must not contain a nested request wrapper.'
-                }
-            ],
-            reservedKeyPrefixes: ['__', '_'],
-            flattenWrappers: [
-                {
-                    wrapperKey: 'request',
-                    onlyIfTargetMissing: true
-                },
-                {
-                    wrapperKey: 'parameters',
-                    onlyIfTargetMissing: true,
-                    aliasKeys: {
-                        max_output_tokens: 'max_tokens'
-                    },
-                    allowKeys: [...ANTHROPIC_PARAMETERS_WRAPPER_ALLOW_KEYS]
-                }
-            ]
-        },
-        toolSurface: {
-            expectedToolFormat: 'anthropic'
-        }
-    },
-    'gemini-chat': {
-        id: 'gemini-chat',
-        providerOutbound: {
-            enforceEnabled: true,
-            allowedTopLevelKeys: GEMINI_ALLOWED_FIELDS,
-            enforceAllowedTopLevelKeys: true,
-            forbidWrappers: [
-                {
-                    code: 'forbid_wrapper',
-                    path: 'parameters',
-                    detail: 'Gemini provider payload must not contain a top-level parameters wrapper.'
-                },
-                {
-                    code: 'forbid_wrapper',
-                    path: 'request',
-                    detail: 'Gemini provider payload must not contain a nested request wrapper.'
-                }
-            ],
-            reservedKeyPrefixes: ['__', '_'],
-            flattenWrappers: [
-                {
-                    wrapperKey: 'request',
-                    onlyIfTargetMissing: true
-                }
-            ]
-        },
-        toolSurface: {
-            expectedToolFormat: 'gemini'
-        }
-    }
+    'openai-chat': buildSpec('openai-chat'),
+    'openai-responses': buildSpec('openai-responses'),
+    'anthropic-messages': buildSpec('anthropic-messages'),
+    'gemini-chat': buildSpec('gemini-chat')
 };
 export function resolveHubProtocolSpec(protocol) {
     const normalized = (protocol || '').trim().toLowerCase();
-    return HUB_PROTOCOL_SPECS[normalized] ?? DEFAULT_SPEC;
+    return HUB_PROTOCOL_SPECS[normalized] ?? HUB_PROTOCOL_SPECS['openai-chat'];
 }

package/dist/conversion/hub/process/chat-process-anthropic-alias.d.ts

@@ -0,0 +1,2 @@
+import type { StandardizedRequest } from '../types/standardized.js';
+export declare function applyAnthropicToolAliasSemantics(request: StandardizedRequest, entryEndpoint: string): StandardizedRequest;

package/dist/conversion/hub/process/chat-process-anthropic-alias.js

@@ -0,0 +1,36 @@
+import { isJsonObject } from '../types/json.js';
+import { buildAnthropicToolAliasMapWithNative } from '../../../router/virtual-router/engine-selection/native-chat-process-governance-semantics.js';
+export function applyAnthropicToolAliasSemantics(request, entryEndpoint) {
+    try {
+        const endpoint = typeof entryEndpoint === 'string' ? entryEndpoint.trim().toLowerCase() : '';
+        if (!endpoint.includes('/v1/messages')) {
+            return request;
+        }
+        request.semantics = asObjectRecord(request.semantics);
+        const semantics = request.semantics;
+        const semanticsTools = asObjectRecord(semantics.tools);
+        semantics.tools = semanticsTools;
+        const hasAlias = isJsonObject(semanticsTools.toolNameAliasMap) ||
+            isJsonObject(semanticsTools.toolAliasMap);
+        if (hasAlias) {
+            return request;
+        }
+        const sourceTools = Array.isArray(semanticsTools.clientToolsRaw) && semanticsTools.clientToolsRaw.length
+            ? semanticsTools.clientToolsRaw
+            : request.tools;
+        const aliasMap = buildAnthropicToolAliasMapWithNative(sourceTools);
+        if (aliasMap) {
+            semanticsTools.toolNameAliasMap = aliasMap;
+        }
+    }
+    catch {
+        // best-effort: alias-map propagation must never block request handling
+    }
+    return request;
+}
+function asObjectRecord(value) {
+    if (value && typeof value === 'object' && !Array.isArray(value)) {
+        return value;
+    }
+    return {};
+}

package/dist/conversion/hub/process/chat-process-clock-directive-parser.d.ts

@@ -0,0 +1,5 @@
+import { type ClockScheduleDirectiveCandidate } from '../../../router/virtual-router/engine-selection/native-chat-process-clock-directive-parser.js';
+import type { ClockScheduleDirective } from './chat-process-clock-directives.js';
+export declare function hydrateClockScheduleDirectiveCandidate(candidate: ClockScheduleDirectiveCandidate): ClockScheduleDirective | null;
+export declare function parseClockScheduleDirectiveCandidatePayload(payload: string): ClockScheduleDirectiveCandidate | null;
+export declare function parseClockScheduleDirectivePayload(payload: string): ClockScheduleDirective | null;

package/dist/conversion/hub/process/chat-process-clock-directive-parser.js

@@ -0,0 +1,48 @@
+import { parseDueAtMs } from '../../../servertool/clock/task-store.js';
+import { parseClockScheduleDirectiveCandidateWithNative } from '../../../router/virtual-router/engine-selection/native-chat-process-clock-directive-parser.js';
+function normalizeRecurrence(recurrence) {
+    if (!recurrence) {
+        return undefined;
+    }
+    if (recurrence.kind === 'interval') {
+        if (typeof recurrence.everyMinutes !== 'number' || recurrence.everyMinutes <= 0) {
+            return undefined;
+        }
+        return {
+            kind: 'interval',
+            maxRuns: Math.floor(recurrence.maxRuns),
+            everyMinutes: Math.floor(recurrence.everyMinutes)
+        };
+    }
+    return {
+        kind: recurrence.kind,
+        maxRuns: Math.floor(recurrence.maxRuns)
+    };
+}
+export function hydrateClockScheduleDirectiveCandidate(candidate) {
+    const dueAtMs = parseDueAtMs(candidate.dueAt);
+    if (!dueAtMs || !candidate.task) {
+        return null;
+    }
+    const recurrence = normalizeRecurrence(candidate.recurrence);
+    if (candidate.recurrence && !recurrence) {
+        return null;
+    }
+    return {
+        dueAtMs,
+        dueAt: new Date(dueAtMs).toISOString(),
+        task: candidate.task,
+        ...(recurrence ? { recurrence } : {})
+    };
+}
+export function parseClockScheduleDirectiveCandidatePayload(payload) {
+    const raw = String(payload || '').trim();
+    return parseClockScheduleDirectiveCandidateWithNative(raw);
+}
+export function parseClockScheduleDirectivePayload(payload) {
+    const candidate = parseClockScheduleDirectiveCandidatePayload(payload);
+    if (!candidate) {
+        return null;
+    }
+    return hydrateClockScheduleDirectiveCandidate(candidate);
+}

package/dist/conversion/hub/process/chat-process-clock-directives.d.ts

@@ -0,0 +1,24 @@
+import type { StandardizedMessage } from '../types/standardized.js';
+import type { ClockTaskRecurrence } from '../../../servertool/clock/task-store.js';
+export type ClockScheduleDirective = {
+    dueAtMs: number;
+    dueAt: string;
+    task: string;
+    recurrence?: ClockTaskRecurrence;
+};
+export declare function stripClockClearDirectiveFromText(text: string): {
+    hadClear: boolean;
+    next: string;
+};
+export declare function extractClockScheduleDirectivesFromText(text: string): {
+    directives: ClockScheduleDirective[];
+    next: string;
+};
+export declare function extractClockScheduleDirectivesFromContent(content: StandardizedMessage['content']): {
+    directives: ClockScheduleDirective[];
+    next: StandardizedMessage['content'];
+};
+export declare function stripClockClearDirectiveFromContent(content: StandardizedMessage['content']): {
+    hadClear: boolean;
+    next: StandardizedMessage['content'];
+};

package/dist/conversion/hub/process/chat-process-clock-directives.js

@@ -0,0 +1,98 @@
+import { stripClockClearDirectiveText } from '../../../router/virtual-router/engine-selection/native-router-hotpath.js';
+import { extractClockScheduleDirectiveTextPartsWithNative } from '../../../router/virtual-router/engine-selection/native-chat-process-clock-directive-parser.js';
+import { hydrateClockScheduleDirectiveCandidate } from './chat-process-clock-directive-parser.js';
+export function stripClockClearDirectiveFromText(text) {
+    const analysis = stripClockClearDirectiveText(String(text || ''));
+    return {
+        hadClear: analysis.hadClear,
+        next: analysis.next
+    };
+}
+export function extractClockScheduleDirectivesFromText(text) {
+    const raw = String(text || '');
+    const parts = extractClockScheduleDirectiveTextPartsWithNative(raw);
+    const directives = [];
+    const nextParts = [];
+    for (const part of parts) {
+        if (part.kind === 'text') {
+            nextParts.push(part.text);
+            continue;
+        }
+        const parsed = part.candidate ? hydrateClockScheduleDirectiveCandidate(part.candidate) : null;
+        if (!parsed) {
+            nextParts.push(part.full);
+            continue;
+        }
+        directives.push(parsed);
+    }
+    return {
+        directives,
+        next: nextParts.join('').replace(/\n{3,}/g, '\n\n').trim()
+    };
+}
+export function extractClockScheduleDirectivesFromContent(content) {
+    if (typeof content === 'string') {
+        const result = extractClockScheduleDirectivesFromText(content);
+        return { directives: result.directives, next: result.next };
+    }
+    if (Array.isArray(content)) {
+        const directives = [];
+        const next = content.map((part) => {
+            if (typeof part === 'string') {
+                const result = extractClockScheduleDirectivesFromText(part);
+                if (result.directives.length) {
+                    directives.push(...result.directives);
+                }
+                return result.next;
+            }
+            if (part && typeof part === 'object' && !Array.isArray(part)) {
+                const block = part;
+                const text = typeof block.text === 'string' ? block.text : undefined;
+                if (!text) {
+                    return part;
+                }
+                const result = extractClockScheduleDirectivesFromText(text);
+                if (result.directives.length) {
+                    directives.push(...result.directives);
+                }
+                return { ...block, text: result.next };
+            }
+            return part;
+        });
+        return { directives, next };
+    }
+    return { directives: [], next: content };
+}
+export function stripClockClearDirectiveFromContent(content) {
+    if (typeof content === 'string') {
+        const { hadClear, next } = stripClockClearDirectiveFromText(content);
+        return { hadClear, next };
+    }
+    if (Array.isArray(content)) {
+        let hadClear = false;
+        const next = content.map((part) => {
+            if (typeof part === 'string') {
+                const stripped = stripClockClearDirectiveFromText(part);
+                if (stripped.hadClear) {
+                    hadClear = true;
+                }
+                return stripped.next;
+            }
+            if (part && typeof part === 'object' && !Array.isArray(part)) {
+                const block = part;
+                const text = typeof block.text === 'string' ? block.text : undefined;
+                if (!text) {
+                    return part;
+                }
+                const stripped = stripClockClearDirectiveFromText(text);
+                if (stripped.hadClear) {
+                    hadClear = true;
+                }
+                return { ...block, text: stripped.next };
+            }
+            return part;
+        });
+        return { hadClear, next };
+    }
+    return { hadClear: false, next: content };
+}

package/dist/conversion/hub/process/chat-process-clock-reminder-directives.d.ts

@@ -0,0 +1,8 @@
+import type { StandardizedMessage } from '../types/standardized.js';
+import { type ClockScheduleDirective } from './chat-process-clock-directives.js';
+export interface ClockReminderDirectiveExtraction {
+    hadClear: boolean;
+    clockScheduleDirectives: ClockScheduleDirective[];
+    baseMessages: StandardizedMessage[];
+}
+export declare function extractClockReminderDirectives(messages: StandardizedMessage[]): ClockReminderDirectiveExtraction;

package/dist/conversion/hub/process/chat-process-clock-reminder-directives.js

@@ -0,0 +1,42 @@
+import { findLastUserMessageIndex } from './chat-process-clock-reminder-messages.js';
+import { extractClockReminderDirectivesWithNative } from '../../../router/virtual-router/engine-selection/native-chat-process-clock-reminder-directives.js';
+import { hydrateClockScheduleDirectiveCandidate } from './chat-process-clock-directive-parser.js';
+function resolveDirectivesFromCandidates(candidates) {
+    const directives = [];
+    let hasInvalid = false;
+    for (const candidate of candidates) {
+        const parsed = hydrateClockScheduleDirectiveCandidate(candidate);
+        if (parsed) {
+            directives.push(parsed);
+        }
+        else {
+            hasInvalid = true;
+        }
+    }
+    return { directives, hasInvalid };
+}
+function mergeResolvedBaseMessagesPreservingReferences(original, resolvedBaseMessages) {
+    const lastUserIdx = findLastUserMessageIndex(original);
+    const merged = original.slice();
+    if (lastUserIdx >= 0) {
+        const current = original[lastUserIdx];
+        const resolved = resolvedBaseMessages[lastUserIdx];
+        if (current && resolved) {
+            merged[lastUserIdx] = { ...current, content: resolved.content };
+        }
+    }
+    return merged;
+}
+export function extractClockReminderDirectives(messages) {
+    const resolved = extractClockReminderDirectivesWithNative(messages);
+    const resolvedDirectives = resolveDirectivesFromCandidates(resolved.directiveCandidates);
+    const hasInvalidCandidate = resolvedDirectives.hasInvalid;
+    const shouldKeepOriginalMessages = hasInvalidCandidate;
+    return {
+        hadClear: shouldKeepOriginalMessages ? false : resolved.hadClear,
+        clockScheduleDirectives: shouldKeepOriginalMessages ? [] : resolvedDirectives.directives,
+        baseMessages: shouldKeepOriginalMessages
+            ? messages
+            : mergeResolvedBaseMessagesPreservingReferences(messages, resolved.baseMessages)
+    };
+}

package/dist/conversion/hub/process/chat-process-clock-reminder-finalize.d.ts

@@ -0,0 +1,14 @@
+import type { StandardizedMessage, StandardizedRequest } from '../types/standardized.js';
+export declare function buildDueReminderUserMessage(reservation: unknown, dueInjectText: string): StandardizedMessage | null;
+export declare function buildClockReminderMetadata(options: {
+    nextRequest: StandardizedRequest;
+    metadata: Record<string, unknown>;
+    dueUserMessage: StandardizedMessage | null;
+    reservation: unknown;
+}): StandardizedRequest['metadata'];
+export declare function buildClockReminderMessages(options: {
+    baseMessages: StandardizedMessage[];
+    markerToolMessages: StandardizedMessage[];
+    dueUserMessage: StandardizedMessage | null;
+    timeTagLine: string;
+}): StandardizedMessage[];

package/dist/conversion/hub/process/chat-process-clock-reminder-finalize.js

@@ -0,0 +1,10 @@
+import { buildClockReminderMessagesWithNative, buildClockReminderMetadataWithNative, buildDueReminderUserMessageWithNative } from '../../../router/virtual-router/engine-selection/native-chat-process-clock-reminder-semantics.js';
+export function buildDueReminderUserMessage(reservation, dueInjectText) {
+    return buildDueReminderUserMessageWithNative(reservation, dueInjectText);
+}
+export function buildClockReminderMetadata(options) {
+    return buildClockReminderMetadataWithNative(options.nextRequest.metadata, options.metadata, options.dueUserMessage, options.reservation);
+}
+export function buildClockReminderMessages(options) {
+    return buildClockReminderMessagesWithNative(options.baseMessages, options.markerToolMessages, options.dueUserMessage, options.timeTagLine);
+}

package/dist/conversion/hub/process/chat-process-clock-reminder-messages.d.ts

@@ -0,0 +1,5 @@
+import type { StandardizedMessage } from '../types/standardized.js';
+import type { ClockScheduleDirective } from './chat-process-clock-directives.js';
+export declare function buildClockMarkerScheduleMessages(requestId: string, markerIndex: number, marker: ClockScheduleDirective, payload: Record<string, unknown>): StandardizedMessage[];
+export declare function findLastUserMessageIndex(messages: StandardizedMessage[]): number;
+export declare function injectTimeTagIntoMessages(messages: StandardizedMessage[], timeTagLine: string): StandardizedMessage[];

package/dist/conversion/hub/process/chat-process-clock-reminder-messages.js

@@ -0,0 +1,10 @@
+import { buildClockMarkerScheduleMessagesWithNative, findLastUserMessageIndexWithNative, injectTimeTagIntoMessagesWithNative } from '../../../router/virtual-router/engine-selection/native-chat-process-clock-reminder-semantics.js';
+export function buildClockMarkerScheduleMessages(requestId, markerIndex, marker, payload) {
+    return buildClockMarkerScheduleMessagesWithNative(requestId, markerIndex, marker, payload);
+}
+export function findLastUserMessageIndex(messages) {
+    return findLastUserMessageIndexWithNative(messages);
+}
+export function injectTimeTagIntoMessages(messages, timeTagLine) {
+    return injectTimeTagIntoMessagesWithNative(messages, timeTagLine);
+}

package/dist/conversion/hub/process/chat-process-clock-reminder-orchestration.d.ts

@@ -0,0 +1,30 @@
+import { logClock } from '../../../servertool/clock/log.js';
+import { reserveDueTasksForRequest, scheduleClockTasks, type ClockConfigSnapshot, type ClockReservation } from '../../../servertool/clock/task-store.js';
+import type { StandardizedMessage } from '../types/standardized.js';
+import type { ClockScheduleDirective } from './chat-process-clock-directives.js';
+import { buildClockMarkerScheduleMessages } from './chat-process-clock-reminder-messages.js';
+type ClockReminderSchedulingDeps = {
+    nowFn?: () => number;
+    logClockFn?: typeof logClock;
+    scheduleClockTasksFn?: typeof scheduleClockTasks;
+    buildClockMarkerScheduleMessagesFn?: typeof buildClockMarkerScheduleMessages;
+};
+type ClockReminderReservationDeps = {
+    reserveDueTasksForRequestFn?: typeof reserveDueTasksForRequest;
+};
+export declare function scheduleClockReminderDirectiveMessages(options: {
+    clockScheduleDirectives: ClockScheduleDirective[];
+    sessionId: string | null;
+    requestId: string;
+    clockConfig: ClockConfigSnapshot;
+}, deps?: ClockReminderSchedulingDeps): Promise<StandardizedMessage[]>;
+export declare function reserveClockDueReminderForRequest(options: {
+    hadClear: boolean;
+    sessionId: string | null;
+    requestId: string;
+    clockConfig: ClockConfigSnapshot;
+}, deps?: ClockReminderReservationDeps): Promise<{
+    reservation: ClockReservation | null;
+    dueInjectText: string;
+}>;
+export {};

package/dist/conversion/hub/process/chat-process-clock-reminder-orchestration.js

@@ -0,0 +1,68 @@
+import { logClock } from '../../../servertool/clock/log.js';
+import { reserveDueTasksForRequest, scheduleClockTasks } from '../../../servertool/clock/task-store.js';
+import { buildClockMarkerScheduleMessages } from './chat-process-clock-reminder-messages.js';
+import { buildGuardedClockScheduleItemWithNative, normalizeDueInjectTextWithNative, shouldReserveClockDueReminderWithNative } from '../../../router/virtual-router/engine-selection/native-chat-process-clock-reminder-orchestration-semantics.js';
+export async function scheduleClockReminderDirectiveMessages(options, deps = {}) {
+    const nowFn = deps.nowFn ?? Date.now;
+    const logClockFn = deps.logClockFn ?? logClock;
+    const scheduleClockTasksFn = deps.scheduleClockTasksFn ?? scheduleClockTasks;
+    const buildMessagesFn = deps.buildClockMarkerScheduleMessagesFn ?? buildClockMarkerScheduleMessages;
+    let markerToolMessages = [];
+    for (let index = 0; index < options.clockScheduleDirectives.length; index += 1) {
+        const marker = options.clockScheduleDirectives[index];
+        const now = nowFn();
+        const guardedItem = buildGuardedClockScheduleItemWithNative(marker, options.requestId, Number(options.clockConfig.dueWindowMs), Number(now));
+        if (!options.sessionId) {
+            markerToolMessages = markerToolMessages.concat(buildMessagesFn(options.requestId, index, marker, {
+                ok: false,
+                action: 'schedule',
+                message: 'clock requires tmux session scope (clientTmuxSessionId/tmuxSessionId).'
+            }));
+            continue;
+        }
+        try {
+            const scheduled = await scheduleClockTasksFn(options.sessionId, [guardedItem], options.clockConfig);
+            markerToolMessages = markerToolMessages.concat(buildMessagesFn(options.requestId, index, marker, {
+                ok: true,
+                action: 'schedule',
+                scheduled: scheduled.map((entry) => ({
+                    taskId: entry.taskId,
+                    dueAt: new Date(entry.dueAtMs).toISOString(),
+                    task: entry.task,
+                    deliveryCount: entry.deliveryCount
+                }))
+            }));
+            logClockFn('schedule', { sessionId: options.sessionId, count: scheduled.length, source: 'marker' });
+        }
+        catch (error) {
+            markerToolMessages = markerToolMessages.concat(buildMessagesFn(options.requestId, index, marker, {
+                ok: false,
+                action: 'schedule',
+                message: `clock.schedule failed: ${error instanceof Error ? error.message : String(error ?? 'unknown')}`
+            }));
+        }
+    }
+    return markerToolMessages;
+}
+export async function reserveClockDueReminderForRequest(options, deps = {}) {
+    const shouldReserve = shouldReserveClockDueReminderWithNative(options.hadClear, options.sessionId);
+    if (!shouldReserve) {
+        return { reservation: null, dueInjectText: '' };
+    }
+    const reserveDueTasksForRequestFn = deps.reserveDueTasksForRequestFn ?? reserveDueTasksForRequest;
+    try {
+        const reserved = await reserveDueTasksForRequestFn({
+            reservationId: `${options.requestId}:clock`,
+            sessionId: options.sessionId,
+            config: options.clockConfig,
+            requestId: options.requestId
+        });
+        return {
+            reservation: reserved.reservation,
+            dueInjectText: normalizeDueInjectTextWithNative(reserved.injectText)
+        };
+    }
+    catch {
+        return { reservation: null, dueInjectText: '' };
+    }
+}

package/dist/conversion/hub/process/chat-process-clock-reminder-time-tag.d.ts

@@ -0,0 +1,9 @@
+import { buildTimeTagLine, getClockTimeSnapshot } from '../../../servertool/clock/ntp.js';
+export declare const CLOCK_TIME_TAG_FALLBACK_LINE = "[Time/Date]: utc=`1970-01-01T00:00:00.000Z` local=`1970-01-01 00:00:00.000 +00:00` tz=`unknown` nowMs=`0` ntpOffsetMs=`0`";
+type ClockReminderTimeTagDeps = {
+    getClockTimeSnapshotFn?: typeof getClockTimeSnapshot;
+    buildTimeTagLineFn?: typeof buildTimeTagLine;
+    fallbackLine?: string;
+};
+export declare function resolveClockReminderTimeTagLine(deps?: ClockReminderTimeTagDeps): Promise<string>;
+export {};

package/dist/conversion/hub/process/chat-process-clock-reminder-time-tag.js

@@ -0,0 +1,18 @@
+import { buildTimeTagLine, getClockTimeSnapshot } from '../../../servertool/clock/ntp.js';
+import { resolveClockTimeTagFallbackLineWithNative } from '../../../router/virtual-router/engine-selection/native-chat-process-clock-reminder-time-tag-semantics.js';
+export const CLOCK_TIME_TAG_FALLBACK_LINE = '[Time/Date]: utc=`1970-01-01T00:00:00.000Z` local=`1970-01-01 00:00:00.000 +00:00` tz=`unknown` nowMs=`0` ntpOffsetMs=`0`';
+export async function resolveClockReminderTimeTagLine(deps = {}) {
+    const getClockTimeSnapshotFn = deps.getClockTimeSnapshotFn ?? getClockTimeSnapshot;
+    const buildTimeTagLineFn = deps.buildTimeTagLineFn ?? buildTimeTagLine;
+    const fallbackLine = resolveClockTimeTagFallbackLineWithNative(deps.fallbackLine, CLOCK_TIME_TAG_FALLBACK_LINE);
+    try {
+        const snapshot = await getClockTimeSnapshotFn();
+        if (snapshot) {
+            return buildTimeTagLineFn(snapshot);
+        }
+    }
+    catch {
+        // best-effort
+    }
+    return fallbackLine;
+}

package/dist/conversion/hub/process/chat-process-clock-reminders.d.ts

@@ -0,0 +1,2 @@
+import type { StandardizedRequest } from '../types/standardized.js';
+export declare function maybeInjectClockRemindersAndApplyDirectives(request: StandardizedRequest, metadata: Record<string, unknown>, requestId: string): Promise<StandardizedRequest>;