@jsonstudio/llms 0.6.954 → 0.6.1164

package/dist/servertool/clock/daemon.js

@@ -0,0 +1,79 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import { readSessionDirEnv, resolveClockDir } from './paths.js';
+import { cleanExpiredTasks, coerceState, nowMs } from './state.js';
+import { readJsonFile, writeJsonFileAtomic } from './io.js';
+let daemonStarted = false;
+let daemonTimer;
+let daemonConfig;
+export async function startClockDaemonIfNeeded(config) {
+    if (daemonStarted) {
+        return;
+    }
+    const sessionDir = readSessionDirEnv();
+    if (!sessionDir) {
+        return;
+    }
+    daemonStarted = true;
+    daemonConfig = config;
+    const tickOnce = async () => {
+        const effective = daemonConfig;
+        if (!effective)
+            return;
+        const base = readSessionDirEnv();
+        if (!base)
+            return;
+        const dir = resolveClockDir(base);
+        try {
+            const entries = await fs.readdir(dir, { withFileTypes: true });
+            const at = nowMs();
+            for (const entry of entries) {
+                if (!entry.isFile())
+                    continue;
+                if (!entry.name.endsWith('.json'))
+                    continue;
+                const filePath = path.join(dir, entry.name);
+                try {
+                    const raw = await readJsonFile(filePath);
+                    const sessionId = entry.name.slice(0, -'.json'.length);
+                    const state = coerceState(raw, sessionId);
+                    const cleaned = cleanExpiredTasks(state.tasks, effective, at);
+                    if (!cleaned.length) {
+                        await fs.rm(filePath, { force: true });
+                        continue;
+                    }
+                    if (cleaned.length !== state.tasks.length) {
+                        const next = {
+                            ...state,
+                            tasks: cleaned,
+                            updatedAtMs: at
+                        };
+                        await writeJsonFileAtomic(filePath, next);
+                    }
+                }
+                catch {
+                    // best-effort: ignore per-file errors
+                }
+            }
+        }
+        catch {
+            // best-effort: ignore global scan errors
+        }
+    };
+    // Startup scan (best-effort).
+    void tickOnce();
+    if (config.tickMs > 0) {
+        daemonTimer = setInterval(() => {
+            void tickOnce();
+        }, config.tickMs);
+        daemonTimer.unref?.();
+    }
+}
+export async function stopClockDaemonForTests() {
+    if (daemonTimer) {
+        clearInterval(daemonTimer);
+        daemonTimer = undefined;
+    }
+    daemonStarted = false;
+    daemonConfig = undefined;
+}

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

@@ -0,0 +1,2 @@
+export declare function readJsonFile(filePath: string): Promise<unknown>;
+export declare function writeJsonFileAtomic(filePath: string, value: unknown): Promise<void>;

package/dist/servertool/clock/io.js

@@ -0,0 +1,13 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+export async function readJsonFile(filePath) {
+    const buf = await fs.readFile(filePath);
+    return JSON.parse(buf.toString('utf8'));
+}
+export async function writeJsonFileAtomic(filePath, value) {
+    const dir = path.dirname(filePath);
+    const tmp = path.join(dir, `.tmp_${path.basename(filePath)}_${process.pid}_${Date.now()}_${Math.random().toString(16).slice(2)}`);
+    const payload = JSON.stringify(value, null, 2);
+    await fs.writeFile(tmp, payload, 'utf8');
+    await fs.rename(tmp, filePath);
+}

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

@@ -0,0 +1,4 @@
+export declare function readSessionDirEnv(): string;
+export declare function resolveClockDir(sessionDir: string): string;
+export declare function resolveClockStateFile(sessionDir: string, sessionId: string): string | null;
+export declare function ensureDir(dir: string): Promise<void>;

package/dist/servertool/clock/paths.js

@@ -0,0 +1,25 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+export function readSessionDirEnv() {
+    return String(process.env.ROUTECODEX_SESSION_DIR || '').trim();
+}
+function sanitizeSegment(value) {
+    return String(value || '')
+        .trim()
+        .replace(/[^a-zA-Z0-9_.-]/g, '_')
+        .replace(/_+/g, '_')
+        .replace(/^_+|_+$/g, '');
+}
+export function resolveClockDir(sessionDir) {
+    return path.join(sessionDir, 'clock');
+}
+export function resolveClockStateFile(sessionDir, sessionId) {
+    const safe = sanitizeSegment(sessionId);
+    if (!safe) {
+        return null;
+    }
+    return path.join(resolveClockDir(sessionDir), `${safe}.json`);
+}
+export async function ensureDir(dir) {
+    await fs.mkdir(dir, { recursive: true });
+}

package/dist/servertool/clock/session-store.d.ts

@@ -0,0 +1,3 @@
+import type { ClockConfigSnapshot, ClockSessionState } from './types.js';
+export declare function loadClockSessionState(sessionId: string, config: ClockConfigSnapshot): Promise<ClockSessionState>;
+export declare function clearClockSession(sessionId: string): Promise<void>;

package/dist/servertool/clock/session-store.js

@@ -0,0 +1,56 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import { ensureDir, readSessionDirEnv, resolveClockStateFile } from './paths.js';
+import { buildEmptyState, cleanExpiredTasks, coerceState, nowMs } from './state.js';
+import { readJsonFile, writeJsonFileAtomic } from './io.js';
+export async function loadClockSessionState(sessionId, config) {
+    const sessionDir = readSessionDirEnv();
+    if (!sessionDir) {
+        return buildEmptyState(sessionId);
+    }
+    const filePath = resolveClockStateFile(sessionDir, sessionId);
+    if (!filePath) {
+        return buildEmptyState(sessionId);
+    }
+    try {
+        const raw = await readJsonFile(filePath);
+        const state = coerceState(raw, sessionId);
+        const at = nowMs();
+        const cleaned = cleanExpiredTasks(state.tasks, config, at);
+        if (cleaned.length !== state.tasks.length) {
+            const next = { ...state, tasks: cleaned, updatedAtMs: at };
+            if (!next.tasks.length) {
+                await fs.rm(filePath, { force: true });
+            }
+            else {
+                await ensureDir(path.dirname(filePath));
+                await writeJsonFileAtomic(filePath, next);
+            }
+            return next;
+        }
+        return state;
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error ?? 'unknown');
+        if (message.includes('ENOENT')) {
+            return buildEmptyState(sessionId);
+        }
+        return buildEmptyState(sessionId);
+    }
+}
+export async function clearClockSession(sessionId) {
+    const sessionDir = readSessionDirEnv();
+    if (!sessionDir) {
+        return;
+    }
+    const filePath = resolveClockStateFile(sessionDir, sessionId);
+    if (!filePath) {
+        return;
+    }
+    try {
+        await fs.rm(filePath, { force: true });
+    }
+    catch {
+        // ignore
+    }
+}

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

@@ -0,0 +1,5 @@
+import type { ClockConfigSnapshot, ClockSessionState, ClockTask } from './types.js';
+export declare function nowMs(): number;
+export declare function buildEmptyState(sessionId: string): ClockSessionState;
+export declare function coerceState(raw: unknown, sessionId: string): ClockSessionState;
+export declare function cleanExpiredTasks(tasks: ClockTask[], config: ClockConfigSnapshot, atMs: number): ClockTask[];

package/dist/servertool/clock/state.js

@@ -0,0 +1,62 @@
+export function nowMs() {
+    return Date.now();
+}
+export function buildEmptyState(sessionId) {
+    const t = nowMs();
+    return { version: 1, sessionId, tasks: [], updatedAtMs: t };
+}
+export function coerceState(raw, sessionId) {
+    if (!raw || typeof raw !== 'object' || Array.isArray(raw)) {
+        return buildEmptyState(sessionId);
+    }
+    const record = raw;
+    const tasksRaw = Array.isArray(record.tasks) ? record.tasks : [];
+    const tasks = [];
+    for (const entry of tasksRaw) {
+        if (!entry || typeof entry !== 'object' || Array.isArray(entry))
+            continue;
+        const e = entry;
+        const taskId = typeof e.taskId === 'string' ? e.taskId.trim() : '';
+        const dueAtMs = typeof e.dueAtMs === 'number' && Number.isFinite(e.dueAtMs) ? Math.floor(e.dueAtMs) : NaN;
+        const createdAtMs = typeof e.createdAtMs === 'number' && Number.isFinite(e.createdAtMs) ? Math.floor(e.createdAtMs) : NaN;
+        const updatedAtMs = typeof e.updatedAtMs === 'number' && Number.isFinite(e.updatedAtMs) ? Math.floor(e.updatedAtMs) : NaN;
+        const task = typeof e.task === 'string' ? e.task.trim() : '';
+        if (!taskId || !task || !Number.isFinite(dueAtMs) || !Number.isFinite(createdAtMs) || !Number.isFinite(updatedAtMs)) {
+            continue;
+        }
+        const tool = typeof e.tool === 'string' && e.tool.trim() ? e.tool.trim() : undefined;
+        const args = e.arguments && typeof e.arguments === 'object' && !Array.isArray(e.arguments)
+            ? e.arguments
+            : undefined;
+        const deliveredAtMs = typeof e.deliveredAtMs === 'number' && Number.isFinite(e.deliveredAtMs) ? Math.floor(e.deliveredAtMs) : undefined;
+        const deliveryCount = typeof e.deliveryCount === 'number' && Number.isFinite(e.deliveryCount) ? Math.max(0, Math.floor(e.deliveryCount)) : 0;
+        tasks.push({
+            taskId,
+            sessionId,
+            dueAtMs,
+            createdAtMs,
+            updatedAtMs,
+            task,
+            ...(tool ? { tool } : {}),
+            ...(args ? { arguments: args } : {}),
+            ...(deliveredAtMs !== undefined ? { deliveredAtMs } : {}),
+            deliveryCount
+        });
+    }
+    const updatedAtMs = typeof record.updatedAtMs === 'number' && Number.isFinite(record.updatedAtMs) ? Math.floor(record.updatedAtMs) : nowMs();
+    return { version: 1, sessionId, tasks, updatedAtMs };
+}
+export function cleanExpiredTasks(tasks, config, atMs) {
+    const out = [];
+    for (const task of tasks) {
+        if (!task || typeof task !== 'object')
+            continue;
+        if (!Number.isFinite(task.dueAtMs))
+            continue;
+        if (atMs > task.dueAtMs + config.retentionMs) {
+            continue;
+        }
+        out.push(task);
+    }
+    return out;
+}

package/dist/servertool/clock/task-store.d.ts

@@ -0,0 +1,5 @@
+export type { ClockConfigSnapshot, ClockReservation, ClockScheduleItem, ClockSessionState, ClockTask } from './types.js';
+export { normalizeClockConfig } from './config.js';
+export { startClockDaemonIfNeeded, stopClockDaemonForTests } from './daemon.js';
+export { loadClockSessionState, clearClockSession } from './session-store.js';
+export { cancelClockTask, clearClockTasks, commitClockReservation, findNextUndeliveredDueAtMs, listClockTasks, parseDueAtMs, reserveDueTasksForRequest, scheduleClockTasks, selectDueUndeliveredTasks } from './tasks.js';

package/dist/servertool/clock/task-store.js

@@ -0,0 +1,4 @@
+export { normalizeClockConfig } from './config.js';
+export { startClockDaemonIfNeeded, stopClockDaemonForTests } from './daemon.js';
+export { loadClockSessionState, clearClockSession } from './session-store.js';
+export { cancelClockTask, clearClockTasks, commitClockReservation, findNextUndeliveredDueAtMs, listClockTasks, parseDueAtMs, reserveDueTasksForRequest, scheduleClockTasks, selectDueUndeliveredTasks } from './tasks.js';

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

@@ -0,0 +1,17 @@
+import type { ClockConfigSnapshot, ClockReservation, ClockScheduleItem, ClockTask } from './types.js';
+export declare function parseDueAtMs(value: unknown): number | null;
+export declare function listClockTasks(sessionId: string, config: ClockConfigSnapshot): Promise<ClockTask[]>;
+export declare function scheduleClockTasks(sessionId: string, items: ClockScheduleItem[], config: ClockConfigSnapshot): Promise<ClockTask[]>;
+export declare function cancelClockTask(sessionId: string, taskId: string, config: ClockConfigSnapshot): Promise<boolean>;
+export declare function clearClockTasks(sessionId: string, config: ClockConfigSnapshot): Promise<number>;
+export declare function selectDueUndeliveredTasks(tasks: ClockTask[], config: ClockConfigSnapshot, atMs: number): ClockTask[];
+export declare function findNextUndeliveredDueAtMs(tasks: ClockTask[], atMs: number): number | null;
+export declare function reserveDueTasksForRequest(args: {
+    reservationId: string;
+    sessionId: string;
+    config: ClockConfigSnapshot;
+}): Promise<{
+    reservation: ClockReservation | null;
+    injectText?: string;
+}>;
+export declare function commitClockReservation(reservation: ClockReservation, config: ClockConfigSnapshot): Promise<void>;

package/dist/servertool/clock/tasks.js

@@ -0,0 +1,221 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import crypto from 'node:crypto';
+import { ensureDir, readSessionDirEnv, resolveClockStateFile } from './paths.js';
+import { cleanExpiredTasks, nowMs } from './state.js';
+import { writeJsonFileAtomic } from './io.js';
+import { clearClockSession, loadClockSessionState } from './session-store.js';
+function safeJson(value) {
+    try {
+        return JSON.stringify(value ?? {});
+    }
+    catch {
+        return '{}';
+    }
+}
+function safeQuoted(text) {
+    const normalized = String(text ?? '');
+    const escaped = normalized.replace(/\"/g, '\\"');
+    return `"${escaped}"`;
+}
+function buildTaskId() {
+    try {
+        return crypto.randomUUID();
+    }
+    catch {
+        return `task_${Math.random().toString(16).slice(2)}_${Date.now()}`;
+    }
+}
+export function parseDueAtMs(value) {
+    if (typeof value !== 'string')
+        return null;
+    const t = value.trim();
+    if (!t)
+        return null;
+    const ms = Date.parse(t);
+    if (!Number.isFinite(ms))
+        return null;
+    return ms;
+}
+export async function listClockTasks(sessionId, config) {
+    const state = await loadClockSessionState(sessionId, config);
+    return state.tasks.slice();
+}
+export async function scheduleClockTasks(sessionId, items, config) {
+    const sessionDir = readSessionDirEnv();
+    if (!sessionDir) {
+        throw new Error('clock: missing ROUTECODEX_SESSION_DIR');
+    }
+    const filePath = resolveClockStateFile(sessionDir, sessionId);
+    if (!filePath) {
+        throw new Error('clock: invalid sessionId');
+    }
+    await ensureDir(path.dirname(filePath));
+    const at = nowMs();
+    const existing = await loadClockSessionState(sessionId, config);
+    const cleaned = cleanExpiredTasks(existing.tasks, config, at);
+    const scheduled = [];
+    for (const item of items) {
+        const text = typeof item.task === 'string' ? item.task.trim() : '';
+        const dueAtMs = item.dueAtMs;
+        if (!text || !Number.isFinite(dueAtMs)) {
+            continue;
+        }
+        const taskId = buildTaskId();
+        scheduled.push({
+            taskId,
+            sessionId,
+            dueAtMs: Math.floor(dueAtMs),
+            createdAtMs: at,
+            updatedAtMs: at,
+            task: text,
+            ...(item.tool ? { tool: item.tool } : {}),
+            ...(item.arguments ? { arguments: item.arguments } : {}),
+            deliveryCount: 0
+        });
+    }
+    const nextTasks = cleanExpiredTasks([...cleaned, ...scheduled], config, at);
+    const next = {
+        version: 1,
+        sessionId,
+        tasks: nextTasks,
+        updatedAtMs: at
+    };
+    if (!next.tasks.length) {
+        await fs.rm(filePath, { force: true });
+    }
+    else {
+        await writeJsonFileAtomic(filePath, next);
+    }
+    return scheduled;
+}
+export async function cancelClockTask(sessionId, taskId, config) {
+    const sessionDir = readSessionDirEnv();
+    if (!sessionDir) {
+        throw new Error('clock: missing ROUTECODEX_SESSION_DIR');
+    }
+    const filePath = resolveClockStateFile(sessionDir, sessionId);
+    if (!filePath) {
+        throw new Error('clock: invalid sessionId');
+    }
+    await ensureDir(path.dirname(filePath));
+    const at = nowMs();
+    const state = await loadClockSessionState(sessionId, config);
+    const cleaned = cleanExpiredTasks(state.tasks, config, at);
+    const nextTasks = cleaned.filter((t) => t.taskId !== taskId);
+    const removed = nextTasks.length !== cleaned.length;
+    const next = { version: 1, sessionId, tasks: nextTasks, updatedAtMs: at };
+    if (!next.tasks.length) {
+        await fs.rm(filePath, { force: true });
+    }
+    else {
+        await writeJsonFileAtomic(filePath, next);
+    }
+    return removed;
+}
+export async function clearClockTasks(sessionId, config) {
+    const items = await listClockTasks(sessionId, config);
+    await clearClockSession(sessionId);
+    return items.length;
+}
+export function selectDueUndeliveredTasks(tasks, config, atMs) {
+    const due = [];
+    for (const task of tasks) {
+        if (!task || typeof task !== 'object')
+            continue;
+        if (task.deliveredAtMs !== undefined)
+            continue;
+        if (!Number.isFinite(task.dueAtMs))
+            continue;
+        if (atMs < task.dueAtMs - config.dueWindowMs)
+            continue;
+        if (atMs > task.dueAtMs + config.retentionMs)
+            continue;
+        due.push(task);
+    }
+    due.sort((a, b) => a.dueAtMs - b.dueAtMs);
+    return due;
+}
+export function findNextUndeliveredDueAtMs(tasks, atMs) {
+    let next = null;
+    for (const task of tasks) {
+        if (!task || typeof task !== 'object')
+            continue;
+        if (task.deliveredAtMs !== undefined)
+            continue;
+        if (!Number.isFinite(task.dueAtMs))
+            continue;
+        if (task.dueAtMs < atMs) {
+            // keep past due tasks as "next" too (will be due immediately)
+        }
+        if (next === null || task.dueAtMs < next) {
+            next = task.dueAtMs;
+        }
+    }
+    return next;
+}
+export async function reserveDueTasksForRequest(args) {
+    const state = await loadClockSessionState(args.sessionId, args.config);
+    const at = nowMs();
+    const due = selectDueUndeliveredTasks(state.tasks, args.config, at);
+    if (!due.length) {
+        return { reservation: null };
+    }
+    const taskIds = due.map((t) => t.taskId);
+    const reservation = {
+        reservationId: args.reservationId,
+        sessionId: args.sessionId,
+        taskIds,
+        reservedAtMs: at
+    };
+    const injectText = due
+        .map((t) => {
+        const dueAtIso = new Date(t.dueAtMs).toISOString();
+        const toolLabel = t.tool ? ` tool=${t.tool}` : '';
+        const argsLabel = t.arguments ? ` args=${safeJson(t.arguments)}` : '';
+        return `[scheduled task:${safeQuoted(t.task)}${toolLabel}${argsLabel} dueAt=${dueAtIso}]`;
+    })
+        .join('\n');
+    return { reservation, injectText };
+}
+export async function commitClockReservation(reservation, config) {
+    const sessionDir = readSessionDirEnv();
+    if (!sessionDir) {
+        return;
+    }
+    const filePath = resolveClockStateFile(sessionDir, reservation.sessionId);
+    if (!filePath) {
+        return;
+    }
+    const at = nowMs();
+    const state = await loadClockSessionState(reservation.sessionId, config);
+    const cleaned = cleanExpiredTasks(state.tasks, config, at);
+    const reservedSet = new Set(reservation.taskIds);
+    let touched = false;
+    const nextTasks = cleaned.map((t) => {
+        if (!reservedSet.has(t.taskId)) {
+            return t;
+        }
+        if (t.deliveredAtMs !== undefined) {
+            return t;
+        }
+        touched = true;
+        return {
+            ...t,
+            deliveredAtMs: at,
+            deliveryCount: (typeof t.deliveryCount === 'number' ? t.deliveryCount : 0) + 1,
+            updatedAtMs: at
+        };
+    });
+    if (!touched) {
+        return;
+    }
+    const next = { version: 1, sessionId: reservation.sessionId, tasks: nextTasks, updatedAtMs: at };
+    await ensureDir(path.dirname(filePath));
+    if (!next.tasks.length) {
+        await fs.rm(filePath, { force: true });
+    }
+    else {
+        await writeJsonFileAtomic(filePath, next);
+    }
+}

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

@@ -0,0 +1,36 @@
+export type ClockTask = {
+    taskId: string;
+    sessionId: string;
+    dueAtMs: number;
+    createdAtMs: number;
+    updatedAtMs: number;
+    task: string;
+    tool?: string;
+    arguments?: Record<string, unknown>;
+    deliveredAtMs?: number;
+    deliveryCount: number;
+};
+export type ClockSessionState = {
+    version: 1;
+    sessionId: string;
+    tasks: ClockTask[];
+    updatedAtMs: number;
+};
+export type ClockReservation = {
+    reservationId: string;
+    sessionId: string;
+    taskIds: string[];
+    reservedAtMs: number;
+};
+export type ClockConfigSnapshot = {
+    enabled: boolean;
+    retentionMs: number;
+    dueWindowMs: number;
+    tickMs: number;
+};
+export type ClockScheduleItem = {
+    dueAtMs: number;
+    task: string;
+    tool?: string;
+    arguments?: Record<string, unknown>;
+};

package/dist/servertool/clock/types.js

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

package/dist/servertool/engine.d.ts

@@ -1,12 +1,14 @@
 import type { AdapterContext } from '../conversion/hub/types/chat-envelope.js';
 import type { JsonObject } from '../conversion/hub/types/json.js';
 import type { ProviderInvoker } from './types.js';
+import type { StageRecorder } from '../conversion/hub/format-adapters/index.js';
 export interface ServerToolOrchestrationOptions {
     chat: JsonObject;
     adapterContext: AdapterContext;
     requestId: string;
     entryEndpoint: string;
     providerProtocol: string;
+    stageRecorder?: StageRecorder;
     reenterPipeline?: (options: {
         entryEndpoint: string;
         requestId: string;