@jsonstudio/rcc 0.90.367 → 0.90.429

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

@@ -1,98 +0,0 @@
-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/vendor/llmswitch-core/dist/conversion/hub/process/chat-process-clock-reminder-directives.d.ts

@@ -1,8 +0,0 @@
-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/vendor/llmswitch-core/dist/conversion/hub/process/chat-process-clock-reminder-directives.js

@@ -1,42 +0,0 @@
-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/vendor/llmswitch-core/dist/conversion/hub/process/chat-process-clock-reminder-finalize.d.ts

@@ -1,14 +0,0 @@
-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/vendor/llmswitch-core/dist/conversion/hub/process/chat-process-clock-reminder-finalize.js

@@ -1,10 +0,0 @@
-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/vendor/llmswitch-core/dist/conversion/hub/process/chat-process-clock-reminder-messages.d.ts

@@ -1,5 +0,0 @@
-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/vendor/llmswitch-core/dist/conversion/hub/process/chat-process-clock-reminder-messages.js

@@ -1,10 +0,0 @@
-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/vendor/llmswitch-core/dist/conversion/hub/process/chat-process-clock-reminder-orchestration.d.ts

@@ -1,30 +0,0 @@
-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/vendor/llmswitch-core/dist/conversion/hub/process/chat-process-clock-reminder-orchestration.js

@@ -1,68 +0,0 @@
-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/vendor/llmswitch-core/dist/conversion/hub/process/chat-process-clock-reminder-time-tag.d.ts

@@ -1,9 +0,0 @@
-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/vendor/llmswitch-core/dist/conversion/hub/process/chat-process-clock-reminder-time-tag.js

@@ -1,18 +0,0 @@
-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/vendor/llmswitch-core/dist/conversion/hub/process/chat-process-clock-reminders.d.ts

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

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

@@ -1,104 +0,0 @@
-import { readRuntimeMetadata } from '../../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/vendor/llmswitch-core/dist/conversion/hub/process/chat-process-clock-tool-schemas.d.ts

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