@jsonstudio/llms 0.6.2172 → 0.6.2979

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

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

@@ -0,0 +1,104 @@
+import { readRuntimeMetadata } from '../../shared/runtime-metadata.js';
+import { clearClockSession, resolveClockConfig, startClockDaemonIfNeeded } from '../../../servertool/clock/task-store.js';
+import { logClock } from '../../../servertool/clock/log.js';
+import { resolveClockSessionScope } from '../../../servertool/clock/session-scope.js';
+import { applyHubOperations } from '../ops/operations.js';
+import { buildClockStandardToolsOperations } from './chat-process-clock-tools.js';
+import { reserveClockDueReminderForRequest, scheduleClockReminderDirectiveMessages } from './chat-process-clock-reminder-orchestration.js';
+import { buildClockReminderMessages, buildClockReminderMetadata, buildDueReminderUserMessage } from './chat-process-clock-reminder-finalize.js';
+import { resolveClockReminderTimeTagLine } from './chat-process-clock-reminder-time-tag.js';
+import { extractClockReminderDirectives } from './chat-process-clock-reminder-directives.js';
+import { isClientInjectReady } from './client-inject-readiness.js';
+import { resolveClockReminderFlowPlanWithNative } from '../../../router/virtual-router/engine-selection/native-chat-process-clock-reminders-semantics.js';
+function resolveSessionIdForClock(metadata, request) {
+    const requestMetadata = request.metadata && typeof request.metadata === 'object' && !Array.isArray(request.metadata)
+        ? request.metadata
+        : null;
+    return resolveClockSessionScope(metadata, requestMetadata);
+}
+export async function maybeInjectClockRemindersAndApplyDirectives(request, metadata, requestId) {
+    if (!isClientInjectReady(metadata)) {
+        return request;
+    }
+    const rt = readRuntimeMetadata(metadata);
+    const flowPlan = resolveClockReminderFlowPlanWithNative(rt);
+    // Do not inject reminders or apply clock directives during internal servertool followup hops.
+    if (flowPlan.skipForServerToolFollowup) {
+        return request;
+    }
+    const rawConfig = rt?.clock;
+    const clockConfig = resolveClockConfig(rawConfig);
+    if (!clockConfig) {
+        return request;
+    }
+    try {
+        await startClockDaemonIfNeeded(clockConfig);
+    }
+    catch {
+        // best-effort
+    }
+    const sessionId = resolveSessionIdForClock(metadata, request);
+    const messages = Array.isArray(request.messages) ? request.messages : [];
+    // 1) Apply <**clock:clear**> and <**clock:{...}**> marker extraction (latest user message only).
+    const { hadClear, clockScheduleDirectives, baseMessages } = extractClockReminderDirectives(messages);
+    if (hadClear) {
+        if (sessionId) {
+            try {
+                await clearClockSession(sessionId);
+                logClock('cleared', { sessionId });
+            }
+            catch {
+                // best-effort: user directive should not crash request
+            }
+        }
+        // Continue: still inject per-request time tag (but skip due reminders).
+    }
+    // 2) Apply private schedule directives: <**clock:{time,message}**>
+    // Convert to actual clock scheduling and append synthetic tool_call/tool_result messages
+    // so downstream model sees canonical tool semantics.
+    const markerToolMessages = await scheduleClockReminderDirectiveMessages({
+        clockScheduleDirectives,
+        sessionId,
+        requestId,
+        clockConfig
+    });
+    // 3) Inject due reminders as a user message + attach reservation for response-side commit.
+    const { reservation, dueInjectText } = await reserveClockDueReminderForRequest({
+        hadClear,
+        sessionId,
+        requestId,
+        clockConfig
+    });
+    const dueUserMessage = buildDueReminderUserMessage(reservation, dueInjectText);
+    // 4) When we have due tasks, ensure a standard tool set is present (best-effort).
+    let nextRequest = request;
+    if (dueUserMessage) {
+        const ensureToolsOps = buildClockStandardToolsOperations();
+        nextRequest = applyHubOperations(nextRequest, ensureToolsOps);
+    }
+    // 5) Per-request time injection (user time tag or paired clock.get tool result).
+    const timeTagLine = await resolveClockReminderTimeTagLine();
+    const withReservationMetadata = buildClockReminderMetadata({
+        nextRequest,
+        metadata,
+        dueUserMessage,
+        reservation
+    });
+    // Always inject time via user-role content to keep the tag visible without adding
+    // extra tool-call semantics that may distract the model.
+    //
+    // IMPORTANT: do not append an extra trailing user message, otherwise the Virtual Router
+    // sees `latestMessageFromUser=true` and will force "thinking:user-input" even during
+    // tool followups (last message role=tool), which breaks `coding/search/tools` routing.
+    const timeInjectedMessages = buildClockReminderMessages({
+        baseMessages,
+        markerToolMessages,
+        dueUserMessage,
+        timeTagLine
+    });
+    return {
+        ...nextRequest,
+        messages: timeInjectedMessages,
+        metadata: withReservationMetadata
+    };
+}

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

@@ -0,0 +1,3 @@
+import type { HubOperation } from '../ops/operations.js';
+export declare function buildClockToolAppendOperations(hasSessionId: boolean): HubOperation[];
+export declare function buildClockStandardToolAppendOperations(): HubOperation[];