@jsonstudio/rcc 0.90.876 → 0.90.1270

package/dist/modules/llmswitch/bridge/state-integrations.js

@@ -5,6 +5,37 @@
  * clock task store compatibility wrappers.
  */
 import { importCoreDist, requireCoreDist } from './module-loader.js';
+const NON_BLOCKING_LOG_THROTTLE_MS = 60_000;
+const nonBlockingLogState = new Map();
+function formatUnknownError(error) {
+    if (error instanceof Error) {
+        return error.stack || `${error.name}: ${error.message}`;
+    }
+    try {
+        return JSON.stringify(error);
+    }
+    catch {
+        return String(error ?? 'unknown');
+    }
+}
+function logStateIntegrationsNonBlocking(stage, error, details) {
+    const now = Date.now();
+    const last = nonBlockingLogState.get(stage) ?? 0;
+    if (now - last < NON_BLOCKING_LOG_THROTTLE_MS) {
+        return;
+    }
+    nonBlockingLogState.set(stage, now);
+    try {
+        const detailSuffix = details && Object.keys(details).length > 0 ? ` details=${JSON.stringify(details)}` : '';
+        console.warn(`[llmswitch-bridge.state-integrations] ${stage} failed (non-blocking): ${formatUnknownError(error)}${detailSuffix}`);
+    }
+    catch {
+        // Never throw from non-blocking logging.
+    }
+}
+const NOOP_STATS_CENTER = {
+    recordProviderUsage: () => { }
+};
 let cachedStickySessionStore = undefined;
 function getStickySessionStoreExports() {
     if (cachedStickySessionStore !== undefined) {
@@ -13,7 +44,8 @@ function getStickySessionStoreExports() {
     try {
         cachedStickySessionStore = requireCoreDist('router/virtual-router/sticky-session-store');
     }
-    catch {
+    catch (error) {
+        logStateIntegrationsNonBlocking('sticky_session_store.load', error);
         cachedStickySessionStore = null;
     }
     return cachedStickySessionStore;
@@ -22,25 +54,81 @@ export function loadRoutingInstructionStateSync(key) {
     const mod = getStickySessionStoreExports();
     const fn = mod?.loadRoutingInstructionStateSync;
     if (typeof fn !== 'function') {
+        if (mod) {
+            logStateIntegrationsNonBlocking('sticky_session_store.load_state.api_unavailable', 'loadRoutingInstructionStateSync not available');
+        }
+        return null;
+    }
+    try {
+        return fn(key);
+    }
+    catch (error) {
+        logStateIntegrationsNonBlocking('sticky_session_store.load_state.invoke', error, { key });
         return null;
     }
-    return fn(key);
 }
 export function saveRoutingInstructionStateAsync(key, state) {
     const mod = getStickySessionStoreExports();
     const fn = mod?.saveRoutingInstructionStateAsync;
     if (typeof fn !== 'function') {
+        if (mod) {
+            logStateIntegrationsNonBlocking('sticky_session_store.save_async.api_unavailable', 'saveRoutingInstructionStateAsync not available');
+        }
         return;
     }
-    fn(key, state);
+    try {
+        fn(key, state);
+    }
+    catch (error) {
+        logStateIntegrationsNonBlocking('sticky_session_store.save_async.invoke', error, { key });
+    }
 }
 export function saveRoutingInstructionStateSync(key, state) {
     const mod = getStickySessionStoreExports();
     const fn = mod?.saveRoutingInstructionStateSync;
     if (typeof fn !== 'function') {
+        if (mod) {
+            logStateIntegrationsNonBlocking('sticky_session_store.save_sync.api_unavailable', 'saveRoutingInstructionStateSync not available');
+        }
         return;
     }
-    fn(key, state);
+    try {
+        fn(key, state);
+    }
+    catch (error) {
+        logStateIntegrationsNonBlocking('sticky_session_store.save_sync.invoke', error, { key });
+    }
+}
+let cachedReasoningStopStateModule = undefined;
+function getReasoningStopStateExports() {
+    if (cachedReasoningStopStateModule !== undefined) {
+        return cachedReasoningStopStateModule;
+    }
+    try {
+        cachedReasoningStopStateModule = requireCoreDist('servertool/handlers/reasoning-stop-state');
+    }
+    catch (error) {
+        logStateIntegrationsNonBlocking('reasoning_stop_state.load', error);
+        cachedReasoningStopStateModule = null;
+    }
+    return cachedReasoningStopStateModule;
+}
+export function syncReasoningStopModeFromRequest(adapterContext, fallbackMode = 'off') {
+    const mod = getReasoningStopStateExports();
+    const fn = mod?.syncReasoningStopModeFromRequest;
+    if (typeof fn !== 'function') {
+        if (mod) {
+            logStateIntegrationsNonBlocking('reasoning_stop_state.sync_mode.api_unavailable', 'syncReasoningStopModeFromRequest not available', { fallbackMode });
+        }
+        return fallbackMode;
+    }
+    try {
+        return fn(adapterContext, fallbackMode);
+    }
+    catch (error) {
+        logStateIntegrationsNonBlocking('reasoning_stop_state.sync_mode.invoke', error, { fallbackMode });
+        return fallbackMode;
+    }
 }
 let cachedSessionIdentifiersModule = undefined;
 function getSessionIdentifiersModule() {
@@ -50,7 +138,8 @@ function getSessionIdentifiersModule() {
     try {
         cachedSessionIdentifiersModule = requireCoreDist('conversion/hub/pipeline/session-identifiers');
     }
-    catch {
+    catch (error) {
+        logStateIntegrationsNonBlocking('session_identifiers.load', error);
         cachedSessionIdentifiersModule = null;
     }
     return cachedSessionIdentifiersModule;
@@ -59,12 +148,16 @@ export function extractSessionIdentifiersFromMetadata(meta) {
     const mod = getSessionIdentifiersModule();
     const fn = mod?.extractSessionIdentifiersFromMetadata;
     if (typeof fn !== 'function') {
+        if (mod) {
+            logStateIntegrationsNonBlocking('session_identifiers.extract.api_unavailable', 'extractSessionIdentifiersFromMetadata not available');
+        }
         return {};
     }
     try {
         return fn(meta);
     }
-    catch {
+    catch (error) {
+        logStateIntegrationsNonBlocking('session_identifiers.extract.invoke', error);
         return {};
     }
 }
@@ -74,7 +167,7 @@ export function getStatsCenterSafe() {
         return cachedStatsCenter;
     }
     if (cachedStatsCenter === null) {
-        return { recordProviderUsage: () => { } };
+        return NOOP_STATS_CENTER;
     }
     try {
         const mod = requireCoreDist('telemetry/stats-center');
@@ -84,12 +177,13 @@ export function getStatsCenterSafe() {
             cachedStatsCenter = center;
             return center;
         }
+        logStateIntegrationsNonBlocking('stats_center.api_unavailable', 'getStatsCenter not available');
     }
-    catch {
-        // fall through
+    catch (error) {
+        logStateIntegrationsNonBlocking('stats_center.load', error);
     }
     cachedStatsCenter = null;
-    return { recordProviderUsage: () => { } };
+    return NOOP_STATS_CENTER;
 }
 export function getLlmsStatsSnapshot() {
     try {
@@ -99,7 +193,8 @@ export function getLlmsStatsSnapshot() {
         const snap = center && typeof center === 'object' ? center.getSnapshot : null;
         return typeof snap === 'function' ? snap.call(center) : null;
     }
-    catch {
+    catch (error) {
+        logStateIntegrationsNonBlocking('stats_center.snapshot', error);
         return null;
     }
 }
@@ -114,8 +209,8 @@ async function tryLoadClockTaskStoreModule() {
     try {
         return await importCoreDist('servertool/clock/task-store');
     }
-    catch {
-        // fallback to legacy split exports
+    catch (error) {
+        logStateIntegrationsNonBlocking('clock_task_store.load.primary', error);
     }
     try {
         const [tasksModule, configModule] = await Promise.all([
@@ -124,7 +219,8 @@ async function tryLoadClockTaskStoreModule() {
         ]);
         return { ...tasksModule, resolveClockConfig: configModule.resolveClockConfig };
     }
-    catch {
+    catch (error) {
+        logStateIntegrationsNonBlocking('clock_task_store.load.legacy', error);
         return null;
     }
 }
@@ -154,7 +250,8 @@ async function tryLoadHeartbeatTaskStoreModule() {
     try {
         return await importCoreDist('servertool/heartbeat/task-store');
     }
-    catch {
+    catch (error) {
+        logStateIntegrationsNonBlocking('heartbeat_task_store.load', error);
         return null;
     }
 }
@@ -184,12 +281,17 @@ async function getHeartbeatTaskStoreModuleSafe() {
 export async function resolveClockConfigSnapshot(input) {
     const mod = await getClockTaskStoreModuleSafe();
     const fn = mod?.resolveClockConfig;
-    if (typeof fn !== 'function')
+    if (typeof fn !== 'function') {
+        if (mod) {
+            logStateIntegrationsNonBlocking('clock_task_store.resolve_config.api_unavailable', 'resolveClockConfig not available');
+        }
         return null;
+    }
     try {
         return fn(input) ?? null;
     }
-    catch {
+    catch (error) {
+        logStateIntegrationsNonBlocking('clock_task_store.resolve_config.invoke', error);
         return null;
     }
 }
@@ -197,13 +299,17 @@ export async function setClockRuntimeHooksSnapshot(hooks) {
     const mod = await getClockTaskStoreModuleSafe();
     const fn = mod?.setClockRuntimeHooks;
     if (typeof fn !== 'function') {
+        if (mod) {
+            logStateIntegrationsNonBlocking('clock_task_store.set_runtime_hooks.api_unavailable', 'setClockRuntimeHooks not available');
+        }
         return false;
     }
     try {
         await fn(hooks);
         return true;
     }
-    catch {
+    catch (error) {
+        logStateIntegrationsNonBlocking('clock_task_store.set_runtime_hooks.invoke', error);
         return false;
     }
 }
@@ -211,140 +317,202 @@ export async function startClockDaemonIfNeededSnapshot(config) {
     const mod = await getClockTaskStoreModuleSafe();
     const fn = mod?.startClockDaemonIfNeeded;
     if (typeof fn !== 'function') {
+        if (mod) {
+            logStateIntegrationsNonBlocking('clock_task_store.start_daemon.api_unavailable', 'startClockDaemonIfNeeded not available');
+        }
         return false;
     }
     try {
         await fn(config);
         return true;
     }
-    catch {
+    catch (error) {
+        logStateIntegrationsNonBlocking('clock_task_store.start_daemon.invoke', error);
         return false;
     }
 }
 export async function reserveClockDueTasks(args) {
     const mod = await getClockTaskStoreModuleSafe();
     const fn = mod?.reserveDueTasksForRequest;
-    if (typeof fn !== 'function')
+    if (typeof fn !== 'function') {
+        if (mod) {
+            logStateIntegrationsNonBlocking('clock_task_store.reserve_due_tasks.api_unavailable', 'reserveDueTasksForRequest not available');
+        }
         return { reservation: null };
+    }
     try {
         return await fn(args);
     }
-    catch {
+    catch (error) {
+        logStateIntegrationsNonBlocking('clock_task_store.reserve_due_tasks.invoke', error, {
+            sessionId: args.sessionId,
+            requestId: args.requestId
+        });
         return { reservation: null };
     }
 }
 export async function commitClockDueReservation(args) {
     const mod = await getClockTaskStoreModuleSafe();
     const fn = mod?.commitClockReservation;
-    if (typeof fn !== 'function')
+    if (typeof fn !== 'function') {
+        if (mod) {
+            logStateIntegrationsNonBlocking('clock_task_store.commit_reservation.api_unavailable', 'commitClockReservation not available');
+        }
         return;
+    }
     try {
         await fn(args.reservation, args.config);
     }
-    catch {
-        // best-effort only
+    catch (error) {
+        logStateIntegrationsNonBlocking('clock_task_store.commit_reservation.invoke', error);
     }
 }
 export async function listClockSessionIdsSnapshot() {
     const mod = await getClockTaskStoreModuleSafe();
     const fn = mod?.listClockSessionIds;
-    if (typeof fn !== 'function')
+    if (typeof fn !== 'function') {
+        if (mod) {
+            logStateIntegrationsNonBlocking('clock_task_store.list_session_ids.api_unavailable', 'listClockSessionIds not available');
+        }
         return [];
+    }
     try {
         const out = await fn();
         return Array.isArray(out)
             ? out.filter((item) => typeof item === 'string' && item.trim()).map((item) => item.trim())
             : [];
     }
-    catch {
+    catch (error) {
+        logStateIntegrationsNonBlocking('clock_task_store.list_session_ids.invoke', error);
         return [];
     }
 }
 export async function listClockTasksSnapshot(args) {
     const mod = await getClockTaskStoreModuleSafe();
     const fn = mod?.listClockTasks;
-    if (typeof fn !== 'function')
+    if (typeof fn !== 'function') {
+        if (mod) {
+            logStateIntegrationsNonBlocking('clock_task_store.list_tasks.api_unavailable', 'listClockTasks not available');
+        }
         return [];
+    }
     try {
         const out = await fn(args.sessionId, args.config);
         return Array.isArray(out) ? out : [];
     }
-    catch {
+    catch (error) {
+        logStateIntegrationsNonBlocking('clock_task_store.list_tasks.invoke', error, { sessionId: args.sessionId });
         return [];
     }
 }
 export async function scheduleClockTasksSnapshot(args) {
     const mod = await getClockTaskStoreModuleSafe();
     const fn = mod?.scheduleClockTasks;
-    if (typeof fn !== 'function')
+    if (typeof fn !== 'function') {
+        if (mod) {
+            logStateIntegrationsNonBlocking('clock_task_store.schedule_tasks.api_unavailable', 'scheduleClockTasks not available');
+        }
         return [];
+    }
     try {
         const out = await fn(args.sessionId, Array.isArray(args.items) ? args.items : [], args.config);
         return Array.isArray(out) ? out : [];
     }
-    catch {
+    catch (error) {
+        logStateIntegrationsNonBlocking('clock_task_store.schedule_tasks.invoke', error, { sessionId: args.sessionId });
         return [];
     }
 }
 export async function updateClockTaskSnapshot(args) {
     const mod = await getClockTaskStoreModuleSafe();
     const fn = mod?.updateClockTask;
-    if (typeof fn !== 'function')
+    if (typeof fn !== 'function') {
+        if (mod) {
+            logStateIntegrationsNonBlocking('clock_task_store.update_task.api_unavailable', 'updateClockTask not available');
+        }
         return null;
+    }
     try {
         return await fn(args.sessionId, args.taskId, args.patch, args.config);
     }
-    catch {
+    catch (error) {
+        logStateIntegrationsNonBlocking('clock_task_store.update_task.invoke', error, {
+            sessionId: args.sessionId,
+            taskId: args.taskId
+        });
         return null;
     }
 }
 export async function cancelClockTaskSnapshot(args) {
     const mod = await getClockTaskStoreModuleSafe();
     const fn = mod?.cancelClockTask;
-    if (typeof fn !== 'function')
+    if (typeof fn !== 'function') {
+        if (mod) {
+            logStateIntegrationsNonBlocking('clock_task_store.cancel_task.api_unavailable', 'cancelClockTask not available');
+        }
         return false;
+    }
     try {
         return Boolean(await fn(args.sessionId, args.taskId, args.config));
     }
-    catch {
+    catch (error) {
+        logStateIntegrationsNonBlocking('clock_task_store.cancel_task.invoke', error, {
+            sessionId: args.sessionId,
+            taskId: args.taskId
+        });
         return false;
     }
 }
 export async function clearClockTasksSnapshot(args) {
     const mod = await getClockTaskStoreModuleSafe();
     const fn = mod?.clearClockTasks;
-    if (typeof fn !== 'function')
+    if (typeof fn !== 'function') {
+        if (mod) {
+            logStateIntegrationsNonBlocking('clock_task_store.clear_tasks.api_unavailable', 'clearClockTasks not available');
+        }
         return 0;
+    }
     try {
         const removed = await fn(args.sessionId, args.config);
         return Number.isFinite(Number(removed)) ? Math.max(0, Math.floor(Number(removed))) : 0;
     }
-    catch {
+    catch (error) {
+        logStateIntegrationsNonBlocking('clock_task_store.clear_tasks.invoke', error, { sessionId: args.sessionId });
         return 0;
     }
 }
 export async function resolveHeartbeatConfigSnapshot(input) {
     const mod = await getHeartbeatTaskStoreModuleSafe();
     const fn = mod?.resolveHeartbeatConfig;
-    if (typeof fn !== 'function')
+    if (typeof fn !== 'function') {
+        if (mod) {
+            logStateIntegrationsNonBlocking('heartbeat_task_store.resolve_config.api_unavailable', 'resolveHeartbeatConfig not available');
+        }
         return null;
+    }
     try {
         return fn(input) ?? null;
     }
-    catch {
+    catch (error) {
+        logStateIntegrationsNonBlocking('heartbeat_task_store.resolve_config.invoke', error);
         return null;
     }
 }
 export async function buildHeartbeatInjectTextSnapshot() {
     const mod = await getHeartbeatTaskStoreModuleSafe();
     const fn = mod?.buildHeartbeatInjectText;
-    if (typeof fn !== 'function')
+    if (typeof fn !== 'function') {
+        if (mod) {
+            logStateIntegrationsNonBlocking('heartbeat_task_store.build_inject_text.api_unavailable', 'buildHeartbeatInjectText not available');
+        }
         return null;
+    }
     try {
         const text = fn();
         return typeof text === 'string' && text.trim() ? text : null;
     }
-    catch {
+    catch (error) {
+        logStateIntegrationsNonBlocking('heartbeat_task_store.build_inject_text.invoke', error);
         return null;
     }
 }
@@ -352,13 +520,17 @@ export async function setHeartbeatRuntimeHooksSnapshot(hooks) {
     const mod = await getHeartbeatTaskStoreModuleSafe();
     const fn = mod?.setHeartbeatRuntimeHooks;
     if (typeof fn !== 'function') {
+        if (mod) {
+            logStateIntegrationsNonBlocking('heartbeat_task_store.set_runtime_hooks.api_unavailable', 'setHeartbeatRuntimeHooks not available');
+        }
         return false;
     }
     try {
         await fn(hooks);
         return true;
     }
-    catch {
+    catch (error) {
+        logStateIntegrationsNonBlocking('heartbeat_task_store.set_runtime_hooks.invoke', error);
         return false;
     }
 }
@@ -366,46 +538,64 @@ export async function startHeartbeatDaemonIfNeededSnapshot(config) {
     const mod = await getHeartbeatTaskStoreModuleSafe();
     const fn = mod?.startHeartbeatDaemonIfNeeded;
     if (typeof fn !== 'function') {
+        if (mod) {
+            logStateIntegrationsNonBlocking('heartbeat_task_store.start_daemon.api_unavailable', 'startHeartbeatDaemonIfNeeded not available');
+        }
         return false;
     }
     try {
         await fn(config);
         return true;
     }
-    catch {
+    catch (error) {
+        logStateIntegrationsNonBlocking('heartbeat_task_store.start_daemon.invoke', error);
         return false;
     }
 }
 export async function loadHeartbeatStateSnapshot(tmuxSessionId) {
     const mod = await getHeartbeatTaskStoreModuleSafe();
     const fn = mod?.loadHeartbeatState;
-    if (typeof fn !== 'function')
+    if (typeof fn !== 'function') {
+        if (mod) {
+            logStateIntegrationsNonBlocking('heartbeat_task_store.load_state.api_unavailable', 'loadHeartbeatState not available');
+        }
         return null;
+    }
     try {
         return await fn(tmuxSessionId);
     }
-    catch {
+    catch (error) {
+        logStateIntegrationsNonBlocking('heartbeat_task_store.load_state.invoke', error, { tmuxSessionId });
         return null;
     }
 }
 export async function listHeartbeatStatesSnapshot() {
     const mod = await getHeartbeatTaskStoreModuleSafe();
     const fn = mod?.listHeartbeatStates;
-    if (typeof fn !== 'function')
+    if (typeof fn !== 'function') {
+        if (mod) {
+            logStateIntegrationsNonBlocking('heartbeat_task_store.list_states.api_unavailable', 'listHeartbeatStates not available');
+        }
         return [];
+    }
     try {
         const out = await fn();
         return Array.isArray(out) ? out : [];
     }
-    catch {
+    catch (error) {
+        logStateIntegrationsNonBlocking('heartbeat_task_store.list_states.invoke', error);
         return [];
     }
 }
 export async function setHeartbeatEnabledSnapshot(args) {
     const mod = await getHeartbeatTaskStoreModuleSafe();
     const fn = mod?.setHeartbeatEnabled;
-    if (typeof fn !== 'function')
+    if (typeof fn !== 'function') {
+        if (mod) {
+            logStateIntegrationsNonBlocking('heartbeat_task_store.set_enabled.api_unavailable', 'setHeartbeatEnabled not available');
+        }
         return null;
+    }
     try {
         return await fn(args.tmuxSessionId, args.enabled, {
             ...(typeof args.intervalMs === 'number' ? { intervalMs: args.intervalMs } : {}),
@@ -415,7 +605,11 @@ export async function setHeartbeatEnabledSnapshot(args) {
             ...(args.details && typeof args.details === 'object' ? { details: args.details } : {})
         });
     }
-    catch {
+    catch (error) {
+        logStateIntegrationsNonBlocking('heartbeat_task_store.set_enabled.invoke', error, {
+            tmuxSessionId: args.tmuxSessionId,
+            enabled: args.enabled
+        });
         return null;
     }
 }
@@ -423,13 +617,19 @@ export async function listHeartbeatHistorySnapshot(args) {
     const mod = await getHeartbeatTaskStoreModuleSafe();
     const fn = mod?.listHeartbeatHistory;
     if (typeof fn !== 'function') {
+        if (mod) {
+            logStateIntegrationsNonBlocking('heartbeat_task_store.list_history.api_unavailable', 'listHeartbeatHistory not available');
+        }
         return [];
     }
     try {
         const out = await fn(args);
         return Array.isArray(out) ? out : [];
     }
-    catch {
+    catch (error) {
+        logStateIntegrationsNonBlocking('heartbeat_task_store.list_history.invoke', error, {
+            tmuxSessionId: args.tmuxSessionId
+        });
         return [];
     }
 }
@@ -437,12 +637,20 @@ export async function appendHeartbeatHistoryEventSnapshot(input) {
     const mod = await getHeartbeatTaskStoreModuleSafe();
     const fn = mod?.appendHeartbeatHistoryEvent;
     if (typeof fn !== 'function') {
+        if (mod) {
+            logStateIntegrationsNonBlocking('heartbeat_task_store.append_history_event.api_unavailable', 'appendHeartbeatHistoryEvent not available');
+        }
         return false;
     }
     try {
         return Boolean(await fn(input));
     }
-    catch {
+    catch (error) {
+        logStateIntegrationsNonBlocking('heartbeat_task_store.append_history_event.invoke', error, {
+            tmuxSessionId: input.tmuxSessionId,
+            source: input.source,
+            action: input.action
+        });
         return false;
     }
 }
@@ -450,13 +658,17 @@ export async function runHeartbeatDaemonTickSnapshot() {
     const mod = await getHeartbeatTaskStoreModuleSafe();
     const fn = mod?.runHeartbeatDaemonTickForTests;
     if (typeof fn !== 'function') {
+        if (mod) {
+            logStateIntegrationsNonBlocking('heartbeat_task_store.run_tick.api_unavailable', 'runHeartbeatDaemonTickForTests not available');
+        }
         return false;
     }
     try {
         await fn();
         return true;
     }
-    catch {
+    catch (error) {
+        logStateIntegrationsNonBlocking('heartbeat_task_store.run_tick.invoke', error);
         return false;
     }
 }