@jsonstudio/llms 0.6.2172 → 0.6.3214

package/dist/router/virtual-router/sticky-session-store.js

@@ -3,10 +3,20 @@ import * as path from 'node:path';
 import os from 'node:os';
 import { serializeRoutingInstructionState, deserializeRoutingInstructionState } from './routing-instructions.js';
 const pendingWrites = new Map();
+export class StickySessionKeyMissingError extends Error {
+    key;
+    constructor(key, message) {
+        super(message);
+        this.key = key;
+        this.name = 'StickySessionKeyMissingError';
+    }
+}
 function isPersistentKey(key) {
     if (!key)
         return false;
-    return key.startsWith('session:') || key.startsWith('conversation:');
+    return key.startsWith('session:')
+        || key.startsWith('conversation:')
+        || key.startsWith('tmux:');
 }
 function resolveRoutecodexUserDir() {
     try {
@@ -77,7 +87,7 @@ function keyToFilename(key) {
     if (idx <= 0 || idx === key.length - 1) {
         return null;
     }
-    const scope = key.substring(0, idx); // "session" | "conversation"
+    const scope = key.substring(0, idx); // "session" | "conversation" | "tmux"
     const rawId = key.substring(idx + 1);
     const safeId = rawId.replace(/[^a-zA-Z0-9_.-]/g, '_');
     return `${scope}-${safeId}.json`;
@@ -91,91 +101,13 @@ function resolveSessionFilepaths(key) {
     if (!dir || !filename) {
         return [];
     }
-    const filepaths = [path.join(dir, filename)];
-    const fallbackDir = resolveSessionFallbackDir(dir);
-    if (fallbackDir) {
-        const fallbackPath = path.join(fallbackDir, filename);
-        if (!filepaths.includes(fallbackPath)) {
-            filepaths.push(fallbackPath);
-        }
-    }
-    return filepaths;
+    return [path.join(dir, filename)];
 }
 function resolveSessionLoadFilepaths(key) {
     if (!isPersistentKey(key)) {
         return [];
     }
-    const filepaths = resolveSessionFilepaths(key);
-    if (filepaths.length === 0) {
-        return [];
-    }
-    const dir = resolveSessionDir();
-    const filename = keyToFilename(key);
-    if (!dir || !filename) {
-        return filepaths;
-    }
-    const legacyFallbacks = resolveLegacyServerScopedFilepaths(dir, filename);
-    for (const candidate of legacyFallbacks) {
-        if (!filepaths.includes(candidate)) {
-            filepaths.push(candidate);
-        }
-    }
-    return filepaths;
-}
-function resolveLegacyServerScopedFilepaths(primaryDir, filename) {
-    try {
-        const normalizedPrimary = path.resolve(primaryDir);
-        const searchRoot = resolveSessionSearchRoot(normalizedPrimary);
-        if (!searchRoot) {
-            return [];
-        }
-        const currentDirName = path.dirname(normalizedPrimary) === searchRoot ? path.basename(normalizedPrimary) : '';
-        const entries = fs.readdirSync(searchRoot, { withFileTypes: true });
-        const candidates = [];
-        for (const entry of entries) {
-            if (!entry.isDirectory()) {
-                continue;
-            }
-            if (currentDirName && entry.name === currentDirName) {
-                continue;
-            }
-            const candidatePath = path.join(searchRoot, entry.name, filename);
-            try {
-                const stat = fs.statSync(candidatePath);
-                if (!stat.isFile()) {
-                    continue;
-                }
-                candidates.push({
-                    filepath: candidatePath,
-                    mtimeMs: Number.isFinite(stat.mtimeMs) ? stat.mtimeMs : 0
-                });
-            }
-            catch {
-                // ignore missing legacy files
-            }
-        }
-        candidates.sort((left, right) => right.mtimeMs - left.mtimeMs);
-        return candidates.map((entry) => entry.filepath);
-    }
-    catch {
-        return [];
-    }
-}
-function resolveSessionSearchRoot(sessionDir) {
-    try {
-        const normalized = path.resolve(sessionDir);
-        if (path.basename(normalized) === 'sessions') {
-            return normalized;
-        }
-        const parent = path.dirname(normalized);
-        if (path.basename(parent) === 'sessions') {
-            return parent;
-        }
-        return null;
-    }
-    catch {
-        return null;
-    }
+    return resolveSessionFilepaths(key);
 }
 function readPersistedStateFromFile(filepath) {
     try {
@@ -219,9 +151,14 @@ function readPersistedStateFromFile(filepath) {
     }
 }
 export function loadRoutingInstructionStateSync(key) {
+    if (!isPersistentKey(key)) {
+        const error = new StickySessionKeyMissingError(key, 'Sticky session key missing or invalid; failing fast per no-fallback policy');
+        throw error;
+    }
     const filepaths = resolveSessionLoadFilepaths(key);
     if (filepaths.length === 0) {
-        return null;
+        const error = new StickySessionKeyMissingError(key, 'Unable to resolve session file path for sticky key; failing fast per no-fallback policy');
+        throw error;
     }
     const writeTargets = resolveSessionFilepaths(key);
     for (const filepath of filepaths) {
@@ -278,6 +215,9 @@ export function saveRoutingInstructionStateAsync(key, state) {
     }
 }
 export function saveRoutingInstructionStateSync(key, state) {
+    if (!isPersistentKey(key)) {
+        return;
+    }
     const filepaths = resolveSessionFilepaths(key);
     if (filepaths.length === 0) {
         return;

package/dist/router/virtual-router/stop-message-file-resolver.d.ts

@@ -1 +1,2 @@
+export declare function isStopMessageFileReference(raw: string): boolean;
 export declare function resolveStopMessageText(raw: string): string;

package/dist/router/virtual-router/stop-message-file-resolver.js

@@ -41,6 +41,16 @@ function resolveStopMessageFilePath(raw) {
     }
     return abs;
 }
+export function isStopMessageFileReference(raw) {
+    let text = typeof raw === 'string' ? raw.trim() : '';
+    if (!text) {
+        return false;
+    }
+    if (text.startsWith('<') && text.endsWith('>') && text.length >= 3) {
+        text = text.slice(1, -1).trim();
+    }
+    return /^file:\/\//i.test(text);
+}
 export function resolveStopMessageText(raw) {
     const abs = resolveStopMessageFilePath(raw);
     if (!abs) {

package/dist/router/virtual-router/stop-message-state-sync.d.ts

@@ -1,5 +1,5 @@
 import type { RoutingInstructionState } from './routing-instructions.js';
-type StopMessageSubset = Pick<RoutingInstructionState, 'stopMessageSource' | 'stopMessageText' | 'stopMessageMaxRepeats' | 'stopMessageUsed' | 'stopMessageStage' | 'stopMessageStageMode' | 'stopMessageObservationHash' | 'stopMessageObservationStableCount' | 'stopMessageBdWorkState' | 'stopMessageAssignedIssueId' | 'stopMessageAssignedIssueSource' | 'stopMessageNoTaskSummaryUsed' | 'stopMessageUpdatedAt' | 'stopMessageLastUsedAt'>;
+type StopMessageSubset = Pick<RoutingInstructionState, 'stopMessageSource' | 'stopMessageText' | 'stopMessageMaxRepeats' | 'stopMessageUsed' | 'stopMessageStageMode' | 'stopMessageAiMode' | 'stopMessageAiSeedPrompt' | 'stopMessageAiHistory' | 'stopMessageUpdatedAt' | 'stopMessageLastUsedAt'>;
 /**
  * Decide whether we should overwrite in-memory stopMessage fields with persisted ones.
  *

package/dist/router/virtual-router/stop-message-state-sync.js

@@ -41,14 +41,10 @@ export function mergeStopMessageFromPersisted(existing, persisted) {
             stopMessageText: persisted.stopMessageText,
             stopMessageMaxRepeats: persisted.stopMessageMaxRepeats,
             stopMessageUsed: persisted.stopMessageUsed,
-            stopMessageStage: persisted.stopMessageStage,
             stopMessageStageMode: persisted.stopMessageStageMode,
-            stopMessageObservationHash: persisted.stopMessageObservationHash,
-            stopMessageObservationStableCount: persisted.stopMessageObservationStableCount,
-            stopMessageBdWorkState: persisted.stopMessageBdWorkState,
-            stopMessageAssignedIssueId: persisted.stopMessageAssignedIssueId,
-            stopMessageAssignedIssueSource: persisted.stopMessageAssignedIssueSource,
-            stopMessageNoTaskSummaryUsed: persisted.stopMessageNoTaskSummaryUsed,
+            stopMessageAiMode: persisted.stopMessageAiMode,
+            stopMessageAiSeedPrompt: persisted.stopMessageAiSeedPrompt,
+            stopMessageAiHistory: persisted.stopMessageAiHistory,
             stopMessageUpdatedAt: persisted.stopMessageUpdatedAt,
             stopMessageLastUsedAt: persisted.stopMessageLastUsedAt
         };

package/dist/router/virtual-router/token-counter.js

@@ -36,9 +36,6 @@ export function countRequestTokens(request) {
     if (request.parameters) {
         total += encodeText(JSON.stringify(request.parameters), encoder);
     }
-    if (request.metadata) {
-        total += encodeText(JSON.stringify(request.metadata), encoder);
-    }
     return total;
 }
 function countMessageTokens(message, encoder) {
@@ -50,15 +47,9 @@ function countMessageTokens(message, encoder) {
             total += encodeText(JSON.stringify(call ?? {}), encoder);
         }
     }
-    if (Array.isArray(message.metadata?.toolRuns)) {
-        total += encodeText(JSON.stringify(message.metadata?.toolRuns), encoder);
-    }
     if (message.name) {
         total += encodeText(message.name, encoder);
     }
-    if (message.metadata) {
-        total += encodeText(JSON.stringify(message.metadata), encoder);
-    }
     if (message.tool_call_id) {
         total += encodeText(message.tool_call_id, encoder);
     }

package/dist/router/virtual-router/tool-signals.js

@@ -33,7 +33,10 @@ const SEARCH_TOOL_EXACT = new Set([
     'glob_search',
     'grep_files',
     'code_search',
-    'lookup_symbol'
+    'lookup_symbol',
+    'list_files',
+    'list_directory',
+    'list_dir'
 ]);
 const READ_TOOL_KEYWORDS = ['read', 'view', 'download', 'open', 'show', 'fetch', 'inspect'];
 const WRITE_TOOL_KEYWORDS = ['write', 'patch', 'modify', 'edit', 'create', 'update', 'append', 'replace', 'save'];
@@ -54,7 +57,12 @@ const SHELL_SEARCH_COMMANDS = new Set([
     'find',
     'fd',
     'locate',
-    'codesearch'
+    'codesearch',
+    'ls',
+    'dir',
+    'tree',
+    'eza',
+    'exa'
 ]);
 const SHELL_REDIRECT_WRITE_BINARIES = new Set(['cat', 'printf', 'python', 'node', 'perl', 'ruby', 'php', 'bash', 'sh', 'zsh', 'echo']);
 const SHELL_WRAPPER_COMMANDS = new Set(['sudo', 'env', 'time', 'nice', 'nohup', 'command', 'stdbuf']);
@@ -356,7 +364,8 @@ function buildCommandSnippet(commandText) {
 function categorizeToolName(name) {
     const normalized = name.toLowerCase();
     if (SEARCH_TOOL_EXACT.has(normalized) ||
-        SEARCH_TOOL_KEYWORDS.some((keyword) => normalized.includes(keyword.toLowerCase()))) {
+        SEARCH_TOOL_KEYWORDS.some((keyword) => normalized.includes(keyword.toLowerCase())) ||
+        isListToolName(normalized)) {
         return 'search';
     }
     if (READ_TOOL_EXACT.has(normalized)) {
@@ -367,6 +376,15 @@ function categorizeToolName(name) {
     }
     return 'other';
 }
+function isListToolName(normalized) {
+    if (!normalized) {
+        return false;
+    }
+    if (normalized === 'list') {
+        return true;
+    }
+    return normalized.startsWith('list_') || normalized.startsWith('list-');
+}
 function classifyShellCommand(command) {
     if (!command) {
         return 'other';

package/dist/router/virtual-router/types.d.ts

@@ -60,6 +60,7 @@ export interface ProviderProfile {
     processMode?: 'chat' | 'passthrough';
     responsesConfig?: ResponsesProviderConfig;
     streaming?: StreamingPreference;
+    maxOutputTokens?: number;
     maxContextTokens?: number;
     deepseek?: DeepSeekCompatRuntimeOptions;
     /**
@@ -85,6 +86,8 @@ export interface ProviderRuntimeProfile {
     responsesConfig?: ResponsesProviderConfig;
     streaming?: StreamingPreference;
     modelStreaming?: Record<string, StreamingPreference>;
+    modelOutputTokens?: Record<string, number>;
+    defaultOutputTokens?: number;
     modelContextTokens?: Record<string, number>;
     defaultContextTokens?: number;
     maxContextTokens?: number;
@@ -370,6 +373,12 @@ export interface RouterMetadataInput {
     excludedProviderKeys?: string[];
     sessionId?: string;
     conversationId?: string;
+    clientTmuxSessionId?: string;
+    client_tmux_session_id?: string;
+    tmuxSessionId?: string;
+    tmux_session_id?: string;
+    stopMessageClientInjectSessionScope?: string;
+    stopMessageClientInjectScope?: string;
     responsesResume?: {
         previousRequestId?: string;
         restoredFromResponseId?: string;
@@ -426,6 +435,7 @@ export interface TargetMetadata {
     processMode?: 'chat' | 'passthrough';
     responsesConfig?: ResponsesProviderConfig;
     streaming?: StreamingPreference;
+    maxOutputTokens?: number;
     maxContextTokens?: number;
     deepseek?: DeepSeekCompatRuntimeOptions;
     /**
@@ -471,14 +481,10 @@ export interface StopMessageStateSnapshot {
     stopMessageUsed?: number;
     stopMessageUpdatedAt?: number;
     stopMessageLastUsedAt?: number;
-    stopMessageStage?: string;
     stopMessageStageMode?: 'on' | 'off' | 'auto';
-    stopMessageObservationHash?: string;
-    stopMessageObservationStableCount?: number;
-    stopMessageBdWorkState?: string;
-    stopMessageAssignedIssueId?: string;
-    stopMessageAssignedIssueSource?: 'in_progress' | 'ready' | 'open';
-    stopMessageNoTaskSummaryUsed?: boolean;
+    stopMessageAiMode?: 'on' | 'off';
+    stopMessageAiSeedPrompt?: string;
+    stopMessageAiHistory?: Array<Record<string, unknown>>;
 }
 export interface PreCommandStateSnapshot {
     preCommandScriptPath: string;

package/dist/servertool/clock/config.js

@@ -1,3 +1,4 @@
+import { resolveClockConfigWithNative } from '../../router/virtual-router/engine-selection/native-chat-process-clock-reminder-semantics.js';
 export const CLOCK_CONFIG_DEFAULTS = {
     retentionMs: 20 * 60_000,
     dueWindowMs: 0,
@@ -5,56 +6,30 @@ export const CLOCK_CONFIG_DEFAULTS = {
     holdNonStreaming: true,
     holdMaxMs: 60_000
 };
-function parseBooleanWithDefault(value, fallback) {
-    if (value === undefined) {
-        return fallback;
-    }
-    if (typeof value === 'boolean') {
-        return value;
-    }
-    if (typeof value === 'number') {
-        if (value === 1)
-            return true;
-        if (value === 0)
-            return false;
-        return fallback;
-    }
-    if (typeof value === 'string') {
-        const normalized = value.trim().toLowerCase();
-        if (normalized === 'true' || normalized === '1' || normalized === 'yes' || normalized === 'on') {
-            return true;
-        }
-        if (normalized === 'false' || normalized === '0' || normalized === 'no' || normalized === 'off') {
-            return false;
-        }
-    }
-    return fallback;
-}
-export function normalizeClockConfig(raw) {
-    if (!raw || typeof raw !== 'object' || Array.isArray(raw)) {
+function toClockConfigSnapshot(value) {
+    if (!value) {
         return null;
     }
-    const record = raw;
-    const enabled = record.enabled === true ||
-        (typeof record.enabled === 'string' && record.enabled.trim().toLowerCase() === 'true') ||
-        (typeof record.enabled === 'number' && record.enabled === 1);
-    if (!enabled) {
+    if (value.enabled !== true ||
+        typeof value.retentionMs !== 'number' ||
+        typeof value.dueWindowMs !== 'number' ||
+        typeof value.tickMs !== 'number' ||
+        typeof value.holdNonStreaming !== 'boolean' ||
+        typeof value.holdMaxMs !== 'number') {
         return null;
     }
-    const retentionMs = typeof record.retentionMs === 'number' && Number.isFinite(record.retentionMs) && record.retentionMs >= 0
-        ? Math.floor(record.retentionMs)
-        : CLOCK_CONFIG_DEFAULTS.retentionMs;
-    const dueWindowMs = typeof record.dueWindowMs === 'number' && Number.isFinite(record.dueWindowMs) && record.dueWindowMs >= 0
-        ? Math.floor(record.dueWindowMs)
-        : CLOCK_CONFIG_DEFAULTS.dueWindowMs;
-    const tickMs = typeof record.tickMs === 'number' && Number.isFinite(record.tickMs) && record.tickMs >= 0
-        ? Math.floor(record.tickMs)
-        : CLOCK_CONFIG_DEFAULTS.tickMs;
-    const holdNonStreaming = parseBooleanWithDefault(record.holdNonStreaming, CLOCK_CONFIG_DEFAULTS.holdNonStreaming);
-    const holdMaxMs = typeof record.holdMaxMs === 'number' && Number.isFinite(record.holdMaxMs) && record.holdMaxMs >= 0
-        ? Math.floor(record.holdMaxMs)
-        : CLOCK_CONFIG_DEFAULTS.holdMaxMs;
-    return { enabled: true, retentionMs, dueWindowMs, tickMs, holdNonStreaming, holdMaxMs };
+    return {
+        enabled: true,
+        retentionMs: value.retentionMs,
+        dueWindowMs: value.dueWindowMs,
+        tickMs: value.tickMs,
+        holdNonStreaming: value.holdNonStreaming,
+        holdMaxMs: value.holdMaxMs
+    };
+}
+export function normalizeClockConfig(raw) {
+    const resolved = resolveClockConfigWithNative(raw, false);
+    return toClockConfigSnapshot(resolved);
 }
 /**
  * Resolve the effective clock config for a request/session.
@@ -64,13 +39,10 @@ export function normalizeClockConfig(raw) {
  * - If the config is explicitly present but disabled/invalid -> return null.
  */
 export function resolveClockConfig(raw) {
-    const normalized = normalizeClockConfig(raw);
+    const resolved = resolveClockConfigWithNative(raw, raw === undefined);
+    const normalized = toClockConfigSnapshot(resolved);
     if (normalized) {
         return normalized;
     }
-    // Important: only default-enable when the config is absent, not when it's explicitly disabled.
-    if (raw === undefined) {
-        return normalizeClockConfig({ enabled: true });
-    }
     return null;
 }

package/dist/servertool/clock/io.js

@@ -6,6 +6,7 @@ export async function readJsonFile(filePath) {
 }
 export async function writeJsonFileAtomic(filePath, value) {
     const dir = path.dirname(filePath);
+    await fs.mkdir(dir, { recursive: true });
     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');

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

@@ -1,3 +1,3 @@
-export declare function buildClockSessionScopeFromDaemonId(daemonId: string): string;
-export declare function extractClockDaemonIdFromSessionScope(sessionScope: string): string | null;
+export declare function buildClockSessionScopeFromDaemonId(_daemonId: string): string;
+export declare function extractClockDaemonIdFromSessionScope(_sessionScope: string): string | null;
 export declare function resolveClockSessionScope(primary?: Record<string, unknown> | null, fallback?: Record<string, unknown> | null): string | null;

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

@@ -1,52 +1,41 @@
-const CLOCK_DAEMON_SESSION_PREFIX = 'clockd.';
-function readToken(value) {
-    return typeof value === 'string' && value.trim().length ? value.trim() : '';
+import { resolveClockSessionScopeWithNative } from '../../router/virtual-router/engine-selection/native-chat-process-clock-reminder-semantics.js';
+export function buildClockSessionScopeFromDaemonId(_daemonId) {
+    return '';
 }
-function readRecordToken(record, keys) {
-    if (!record) {
-        return '';
-    }
-    for (const key of keys) {
-        const value = readToken(record[key]);
-        if (value) {
-            return value;
-        }
+export function extractClockDaemonIdFromSessionScope(_sessionScope) {
+    return null;
+}
+function readToken(value) {
+    if (typeof value !== 'string') {
+        return null;
     }
-    return '';
+    const trimmed = value.trim();
+    return trimmed ? trimmed : null;
 }
-export function buildClockSessionScopeFromDaemonId(daemonId) {
-    const normalized = readToken(daemonId);
-    if (!normalized) {
-        return '';
+function readTmuxSessionId(record) {
+    if (!record || typeof record !== 'object') {
+        return null;
     }
-    return `${CLOCK_DAEMON_SESSION_PREFIX}${normalized}`;
+    return (readToken(record.tmuxSessionId) ||
+        readToken(record.tmux_session_id) ||
+        readToken(record.clientTmuxSessionId) ||
+        readToken(record.client_tmux_session_id));
 }
-export function extractClockDaemonIdFromSessionScope(sessionScope) {
-    const normalized = readToken(sessionScope);
-    if (!normalized.startsWith(CLOCK_DAEMON_SESSION_PREFIX)) {
+function readSessionId(record) {
+    if (!record || typeof record !== 'object') {
         return null;
     }
-    const daemonId = normalized.slice(CLOCK_DAEMON_SESSION_PREFIX.length).trim();
-    return daemonId || null;
+    return readToken(record.sessionId) || readToken(record.session_id) || readToken(record.conversationId) || readToken(record.conversation_id);
 }
 export function resolveClockSessionScope(primary, fallback) {
-    const daemonId = readRecordToken(primary, ['clockDaemonId', 'clockClientDaemonId', 'clock_daemon_id', 'clock_client_daemon_id']) ||
-        readRecordToken(fallback, ['clockDaemonId', 'clockClientDaemonId', 'clock_daemon_id', 'clock_client_daemon_id']);
-    if (daemonId) {
-        const daemonScope = buildClockSessionScopeFromDaemonId(daemonId);
-        if (daemonScope) {
-            return daemonScope;
-        }
+    const native = resolveClockSessionScopeWithNative(primary, fallback);
+    if (native && native.trim()) {
+        return native;
     }
-    const sessionId = readRecordToken(primary, ['sessionId', 'session_id']) ||
-        readRecordToken(fallback, ['sessionId', 'session_id']);
-    if (sessionId) {
-        return sessionId;
+    const tmuxSessionId = readTmuxSessionId(primary) || readTmuxSessionId(fallback);
+    if (tmuxSessionId) {
+        return `tmux:${tmuxSessionId}`;
     }
-    const conversationId = readRecordToken(primary, ['conversationId', 'conversation_id']) ||
-        readRecordToken(fallback, ['conversationId', 'conversation_id']);
-    if (conversationId) {
-        return conversationId;
-    }
-    return null;
+    const sessionId = readSessionId(primary) || readSessionId(fallback);
+    return sessionId || null;
 }

package/dist/servertool/engine.d.ts

@@ -19,6 +19,15 @@ export interface ServerToolOrchestrationOptions {
         __sse_responses?: unknown;
         format?: string;
     }>;
+    clientInjectDispatch?: (options: {
+        entryEndpoint: string;
+        requestId: string;
+        body?: JsonObject;
+        metadata?: JsonObject;
+    }) => Promise<{
+        ok: boolean;
+        reason?: string;
+    }>;
     providerInvoker?: ProviderInvoker;
 }
 export interface ServerToolOrchestrationResult {