@jsonstudio/rcc 0.90.352 → 0.90.367

package/vendor/llmswitch-core/dist/servertool/followup-shadow.d.ts

@@ -0,0 +1,16 @@
+import type { StageRecorder } from '../conversion/hub/format-adapters/index.js';
+import type { JsonObject } from '../conversion/hub/types/json.js';
+export type HubFollowupMode = 'off' | 'shadow' | 'enforce';
+export interface HubFollowupConfig {
+    mode: HubFollowupMode;
+    sampleRate?: number;
+}
+export declare function resolveHubFollowupConfigFromEnv(): HubFollowupConfig;
+export declare function applyHubFollowupPolicyShadow(args: {
+    config?: HubFollowupConfig;
+    requestId?: string;
+    entryEndpoint?: string;
+    flowId?: string;
+    payload: JsonObject;
+    stageRecorder?: StageRecorder;
+}): JsonObject;

package/vendor/llmswitch-core/dist/servertool/followup-shadow.js

@@ -0,0 +1,145 @@
+import { isJsonObject, jsonClone } from '../conversion/hub/types/json.js';
+function clampSampleRate(value) {
+    const num = typeof value === 'number' && Number.isFinite(value) ? value : 1;
+    if (num <= 0)
+        return 0;
+    if (num >= 1)
+        return 1;
+    return num;
+}
+function fnv1a32(input) {
+    let hash = 0x811c9dc5;
+    for (let i = 0; i < input.length; i++) {
+        hash ^= input.charCodeAt(i);
+        hash = (hash * 0x01000193) >>> 0;
+    }
+    return hash >>> 0;
+}
+function shouldSample(config, requestId) {
+    const rate = clampSampleRate(config.sampleRate);
+    if (rate <= 0)
+        return false;
+    if (rate >= 1)
+        return true;
+    const key = typeof requestId === 'string' && requestId.trim().length ? requestId.trim() : 'no_request_id';
+    const bucket = fnv1a32(key) / 0xffffffff;
+    return bucket < rate;
+}
+function readMode(raw) {
+    const normalized = raw.trim().toLowerCase();
+    if (!normalized)
+        return null;
+    if (normalized === 'off' || normalized === '0' || normalized === 'false')
+        return 'off';
+    if (normalized === 'shadow')
+        return 'shadow';
+    if (normalized === 'enforce')
+        return 'enforce';
+    return null;
+}
+export function resolveHubFollowupConfigFromEnv() {
+    const raw = String(process.env.ROUTECODEX_HUB_FOLLOWUP_MODE || '').trim();
+    const mode = readMode(raw) ?? 'off';
+    const sampleRateRaw = String(process.env.ROUTECODEX_HUB_FOLLOWUP_SAMPLE_RATE || '').trim();
+    const sampleRate = sampleRateRaw ? Number(sampleRateRaw) : undefined;
+    return {
+        mode,
+        ...(Number.isFinite(sampleRate) ? { sampleRate } : {})
+    };
+}
+function dropKeyByPrefix(root, prefixes) {
+    for (const key of Object.keys(root)) {
+        if (prefixes.some((p) => key.startsWith(p))) {
+            try {
+                delete root[key];
+            }
+            catch {
+                root[key] = undefined;
+            }
+        }
+    }
+}
+function normalizeFollowupPayload(payload) {
+    const out = jsonClone(payload);
+    const record = out;
+    // Followup requests must be non-streaming and must not carry route hints.
+    if (record.stream !== undefined) {
+        record.stream = false;
+    }
+    if (record.routeHint !== undefined) {
+        delete record.routeHint;
+    }
+    if (record.route_hint !== undefined) {
+        delete record.route_hint;
+    }
+    // Remove internal/private carriers from the body (metadata belongs to request metadata, not body).
+    dropKeyByPrefix(record, ['__']);
+    const parameters = record.parameters;
+    if (isJsonObject(parameters)) {
+        const params = parameters;
+        if (params.stream !== undefined) {
+            delete params.stream;
+        }
+    }
+    return out;
+}
+function diffPayloads(baseline, candidate, p = '<root>') {
+    if (Object.is(baseline, candidate))
+        return [];
+    if (typeof baseline !== typeof candidate)
+        return [{ path: p, baseline, candidate }];
+    if (Array.isArray(baseline) && Array.isArray(candidate)) {
+        const max = Math.max(baseline.length, candidate.length);
+        const diffs = [];
+        for (let i = 0; i < max; i += 1) {
+            diffs.push(...diffPayloads(baseline[i], candidate[i], `${p}[${i}]`));
+        }
+        return diffs;
+    }
+    if (baseline && typeof baseline === 'object' && candidate && typeof candidate === 'object') {
+        const a = baseline;
+        const b = candidate;
+        const keys = new Set([...Object.keys(a), ...Object.keys(b)]);
+        const diffs = [];
+        for (const key of keys) {
+            const next = p === '<root>' ? key : `${p}.${key}`;
+            if (!(key in b))
+                diffs.push({ path: next, baseline: a[key], candidate: undefined });
+            else if (!(key in a))
+                diffs.push({ path: next, baseline: undefined, candidate: b[key] });
+            else
+                diffs.push(...diffPayloads(a[key], b[key], next));
+        }
+        return diffs;
+    }
+    return [{ path: p, baseline, candidate }];
+}
+export function applyHubFollowupPolicyShadow(args) {
+    const cfg = args.config ?? resolveHubFollowupConfigFromEnv();
+    if (!cfg || cfg.mode === 'off') {
+        return args.payload;
+    }
+    if (!shouldSample(cfg, args.requestId)) {
+        return args.payload;
+    }
+    const candidate = normalizeFollowupPayload(args.payload);
+    const diffs = diffPayloads(args.payload, candidate);
+    if (diffs.length > 0) {
+        const stage = `hub_followup.${cfg.mode}.payload`;
+        args.stageRecorder?.record(stage, {
+            kind: 'hub_followup_payload_shadow',
+            requestId: args.requestId,
+            entryEndpoint: args.entryEndpoint,
+            flowId: args.flowId,
+            diffCount: diffs.length,
+            diffPaths: diffs.slice(0, 50).map((d) => d.path),
+            diffHead: diffs.slice(0, 50).map((d) => ({ path: d.path, baseline: d.baseline, candidate: d.candidate })),
+            baseline: jsonClone(args.payload),
+            candidate: jsonClone(candidate)
+        });
+    }
+    if (cfg.mode === 'enforce') {
+        return candidate;
+    }
+    return args.payload;
+}

package/vendor/llmswitch-core/dist/servertool/handlers/antigravity-thought-signature-bootstrap.d.ts

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

package/vendor/llmswitch-core/dist/servertool/handlers/antigravity-thought-signature-bootstrap.js

@@ -0,0 +1,225 @@
+import { registerServerToolHandler } from '../registry.js';
+import { extractCapturedChatSeed } from './followup-request-builder.js';
+import { ensureRuntimeMetadata, readRuntimeMetadata } from '../../conversion/runtime-metadata.js';
+import { cloneJson } from '../server-side-tools.js';
+const FLOW_ID = 'antigravity_thought_signature_bootstrap';
+function readProviderKey(adapterContext) {
+    if (!adapterContext || typeof adapterContext !== 'object') {
+        return '';
+    }
+    const raw = adapterContext.providerKey ?? adapterContext.runtimeKey ?? adapterContext.providerId;
+    return typeof raw === 'string' ? raw.trim() : '';
+}
+function isAntigravityFamily(providerKey) {
+    const lowered = providerKey.toLowerCase();
+    return lowered.startsWith('antigravity.') || lowered.startsWith('gemini-cli.');
+}
+function readErrorInfo(base) {
+    const err = base.error;
+    if (!err || typeof err !== 'object' || Array.isArray(err)) {
+        return null;
+    }
+    const codeRaw = err.code;
+    const msgRaw = err.message;
+    const statusRaw = err.status ?? err.statusCode;
+    const code = typeof codeRaw === 'string' ? codeRaw.trim() : typeof codeRaw === 'number' ? String(codeRaw) : undefined;
+    const message = typeof msgRaw === 'string' ? msgRaw.trim() : undefined;
+    const status = typeof statusRaw === 'number' && Number.isFinite(statusRaw)
+        ? Math.floor(statusRaw)
+        : typeof code === 'string' && /^HTTP_\d{3}$/i.test(code)
+            ? Number(code.split('_')[1])
+            : typeof code === 'string' && /^\d{3}$/.test(code)
+                ? Number(code)
+                : undefined;
+    return { ...(status ? { status } : {}), ...(code ? { code } : {}), ...(message ? { message } : {}) };
+}
+function isSignatureInvalidError(error) {
+    const code = (error.code || '').toLowerCase();
+    if (code.includes('signature')) {
+        return true;
+    }
+    const msg = (error.message || '').toLowerCase();
+    return msg.includes('signature') && (msg.includes('invalid') || msg.includes('corrupt') || msg.includes('validator'));
+}
+function shouldTriggerBootstrap(error) {
+    // One-shot bootstrap trigger:
+    // - Always attempt once on 429 (may be quota OR signature validator; one-shot prevents loops).
+    // - Also attempt on 400 when we can confidently classify as signature invalid/missing.
+    if (error.status === 429)
+        return true;
+    if (error.status === 400 && isSignatureInvalidError(error))
+        return true;
+    return false;
+}
+function buildClockToolSchema() {
+    // Keep this schema aligned with docs/SERVERTOOL_CLOCK_DESIGN.md + chat-process injection.
+    return {
+        type: 'function',
+        function: {
+            name: 'clock',
+            description: 'Time + Alarm for this session. Mandatory workflow: before every new clock.schedule, call clock.list first; without a fresh list, new reminder creation is invalid. After listing, prefer clock.update over clock.schedule whenever an existing reminder can be edited. If two reminders would be within 5 minutes, merge or retime them instead of keeping near-duplicate alarms. Use clock.schedule for any blocking wait so work can continue non-blockingly and you will get an interrupt reminder later. If waiting 3 minutes or longer is required, call clock.schedule now (do not only promise to wait). Supports one-time reminders, finite interval loops, infinite interval loops, and local-time quietHours skip windows such as 00:00-07:00. You may set multiple reminders when they are meaningfully different. For complex reminders, write clock.md before waiting and read it first when reminded. Required clock.md template: ## 背景 / ## 当前阻塞点 / ## 下次提醒要做的第一步 / ## 不能忘的检查项. Examples: recurrence={"kind":"interval","everyMinutes":30,"maxRuns":10} or recurrence={"kind":"interval","everyMinutes":30,"infinite":true,"quietHours":[{"start":"00:00","end":"07:00"}]}. Use get/schedule/update/list/cancel/clear. Scheduled reminders will be injected into future requests.',
+            strict: true,
+            parameters: {
+                type: 'object',
+                properties: {
+                    action: {
+                        type: 'string',
+                        enum: ['get', 'schedule', 'update', 'list', 'cancel', 'clear'],
+                        description: 'Get current time, or schedule/update/list/cancel/clear session-scoped reminders. Mandatory rule: before every new clock.schedule, call clock.list first; without a fresh list, new reminder creation is invalid. After listing, prefer clock.update over clock.schedule whenever an existing reminder can be edited. If reminders end up within 5 minutes of each other, reconsider and merge or retime them. Use clock.schedule for blocking waits that should not stall execution. If waiting 3 minutes or longer is required, use action="schedule" immediately. For complex reminders, write the context into clock.md using this template: ## 背景 / ## 当前阻塞点 / ## 下次提醒要做的第一步 / ## 不能忘的检查项.'
+                    },
+                    items: {
+                        type: 'array',
+                        description: 'For schedule/update: list of reminders (update uses items[0]).',
+                        items: {
+                            type: 'object',
+                            properties: {
+                                dueAt: {
+                                    type: 'string',
+                                    description: 'ISO8601 datetime with timezone (e.g. 2026-01-21T20:30:00-08:00).'
+                                },
+                                task: {
+                                    type: 'string',
+                                    description: 'Reminder text (should include which tool to use and what to do).'
+                                },
+                                tool: {
+                                    type: 'string',
+                                    description: 'Optional suggested tool name (hint only).'
+                                },
+                                arguments: {
+                                    type: 'string',
+                                    description: 'Optional suggested tool arguments as a JSON string (hint only). Use "{}" when unsure.'
+                                },
+                                recurrence: {
+                                    type: 'object',
+                                    description: 'Optional recurrence. Omit for one-time reminders. Interval loops require everyMinutes. Use maxRuns for finite loops or infinite=true for endless loops. quietHours is optional and uses local-time windows such as [{"start":"00:00","end":"07:00"}].',
+                                    properties: {
+                                        kind: { type: 'string', enum: ['daily', 'weekly', 'interval'] },
+                                        maxRuns: { type: 'number' },
+                                        infinite: { type: 'boolean' },
+                                        everyMinutes: { type: 'number' },
+                                        quietHours: {
+                                            type: 'array',
+                                            items: {
+                                                type: 'object',
+                                                properties: {
+                                                    start: { type: 'string' },
+                                                    end: { type: 'string' }
+                                                },
+                                                required: ['start', 'end'],
+                                                additionalProperties: false
+                                            }
+                                        }
+                                    },
+                                    required: ['kind'],
+                                    additionalProperties: false
+                                }
+                            },
+                            required: ['dueAt', 'task', 'tool', 'arguments'],
+                            additionalProperties: false
+                        }
+                    },
+                    taskId: {
+                        type: 'string',
+                        description: 'For cancel/update: taskId to target.'
+                    }
+                },
+                required: ['action', 'items', 'taskId'],
+                additionalProperties: false
+            }
+        }
+    };
+}
+function ensureClockTool(tools) {
+    const list = Array.isArray(tools) ? cloneJson(tools) : [];
+    const hasClock = list.some((tool) => {
+        const fn = tool && typeof tool === 'object' && !Array.isArray(tool) ? tool.function : undefined;
+        const name = fn && typeof fn === 'object' && typeof fn.name === 'string' ? String(fn.name) : '';
+        return name.trim() === 'clock';
+    });
+    if (hasClock) {
+        return list;
+    }
+    return [...list, buildClockToolSchema()];
+}
+const BOOTSTRAP_USER_PROMPT = '请先调用 `clock` 工具并传入 `{\"action\":\"get\",\"items\":[],\"taskId\":\"\"}` 获取当前时间；' +
+    '得到工具返回后只需回复 `OK`（不要调用其它工具）。';
+const handler = async (ctx) => {
+    if (!ctx.capabilities.reenterPipeline) {
+        return null;
+    }
+    if (ctx.providerProtocol !== 'gemini-chat') {
+        return null;
+    }
+    const providerKey = readProviderKey(ctx.adapterContext);
+    if (!providerKey || !isAntigravityFamily(providerKey)) {
+        return null;
+    }
+    const rt = readRuntimeMetadata(ctx.adapterContext);
+    if (rt?.serverToolFollowup === true) {
+        return null;
+    }
+    if (rt?.antigravityThoughtSignatureBootstrapAttempted === true) {
+        return null;
+    }
+    const error = readErrorInfo(ctx.base);
+    if (!error || !shouldTriggerBootstrap(error)) {
+        return null;
+    }
+    const captured = ctx.adapterContext?.capturedChatRequest;
+    const seed = extractCapturedChatSeed(captured);
+    if (!seed) {
+        return null;
+    }
+    // Preflight bootstrap request:
+    // - Avoid any historical tool calls so Gemini can emit a fresh thoughtSignature.
+    // - Keep the FIRST user message identical to the original request to preserve derived session_id.
+    const originalMessages = Array.isArray(seed.messages) ? cloneJson(seed.messages) : [];
+    const firstUser = originalMessages.find((m) => {
+        const role = typeof m?.role === 'string' ? String(m.role).toLowerCase() : '';
+        return role === 'user';
+    });
+    if (!firstUser) {
+        return null;
+    }
+    const messages = [cloneJson(firstUser), { role: 'user', content: BOOTSTRAP_USER_PROMPT }];
+    const parameters = {
+        ...(seed.parameters && typeof seed.parameters === 'object' && !Array.isArray(seed.parameters)
+            ? cloneJson(seed.parameters)
+            : {})
+    };
+    // Gemini toolConfig forcing: request the model to emit a clock call first, before any other tools.
+    parameters.tool_config = {
+        functionCallingConfig: {
+            mode: 'ANY',
+            allowedFunctionNames: ['clock']
+        }
+    };
+    const followupPayload = {
+        ...(seed.model ? { model: seed.model } : {}),
+        messages,
+        tools: ensureClockTool([]),
+        ...(Object.keys(parameters).length ? { parameters } : {})
+    };
+    const followupMetadata = {
+        __shadowCompareForcedProviderKey: providerKey
+    };
+    const followupRt = ensureRuntimeMetadata(followupMetadata);
+    followupRt.antigravityThoughtSignatureBootstrap = true;
+    followupRt.antigravityThoughtSignatureBootstrapAttempted = true;
+    return {
+        flowId: FLOW_ID,
+        finalize: async () => ({
+            chatResponse: ctx.base,
+            execution: {
+                flowId: FLOW_ID,
+                followup: {
+                    requestIdSuffix: ':antigravity_ts_bootstrap',
+                    entryEndpoint: ctx.entryEndpoint,
+                    payload: followupPayload,
+                    metadata: followupMetadata
+                }
+            }
+        })
+    };
+};
+registerServerToolHandler(FLOW_ID, handler, { trigger: 'auto', hook: { phase: 'default', priority: 30 } });

package/vendor/llmswitch-core/dist/servertool/handlers/apply-patch-guard.d.ts

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

package/vendor/llmswitch-core/dist/servertool/handlers/apply-patch-guard.js

@@ -0,0 +1,5 @@
+import { registerServerToolHandler } from '../registry.js';
+const handler = async (ctx) => {
+    return null;
+};
+registerServerToolHandler('apply_patch', handler);

package/vendor/llmswitch-core/dist/servertool/handlers/clock-auto.d.ts

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

package/vendor/llmswitch-core/dist/servertool/handlers/clock-auto.js

@@ -0,0 +1,177 @@
+import { registerServerToolHandler } from '../registry.js';
+import { extractCapturedChatSeed } from './followup-request-builder.js';
+import { readRuntimeMetadata } from '../../conversion/runtime-metadata.js';
+import { findNextUndeliveredDueAtMs, listClockTasks, reserveDueTasksForRequest, resolveClockConfig, startClockDaemonIfNeeded } from '../clock/task-store.js';
+import { nowMs } from '../clock/state.js';
+import { logClock } from '../clock/log.js';
+import { resolveClockSessionScope } from '../clock/session-scope.js';
+import { isStopEligibleForServerTool } from '../stop-gateway-context.js';
+const FLOW_ID = 'clock_hold_flow';
+function resolveClientConnectionState(value) {
+    if (!value || typeof value !== 'object' || Array.isArray(value)) {
+        return null;
+    }
+    const record = value;
+    if (typeof record.disconnected !== 'boolean') {
+        return null;
+    }
+    return { disconnected: record.disconnected };
+}
+function clientWantsStreaming(adapterContext) {
+    if (!adapterContext || typeof adapterContext !== 'object' || Array.isArray(adapterContext)) {
+        return false;
+    }
+    const record = adapterContext;
+    if (record.stream === true ||
+        record.inboundStream === true ||
+        record.outboundStream === true ||
+        record.clientStream === true) {
+        return true;
+    }
+    const streamingHint = typeof record.streamingHint === 'string' ? record.streamingHint.trim().toLowerCase() : '';
+    if (streamingHint === 'force') {
+        return true;
+    }
+    const clientHeaders = record.clientHeaders;
+    if (clientHeaders && typeof clientHeaders === 'object' && !Array.isArray(clientHeaders)) {
+        const accept = clientHeaders.accept;
+        if (typeof accept === 'string' && accept.toLowerCase().includes('text/event-stream')) {
+            return true;
+        }
+    }
+    return false;
+}
+function computeHoldSleepMs(remainingMs) {
+    if (remainingMs <= 0)
+        return 0;
+    if (remainingMs > 10 * 60_000)
+        return 30_000;
+    if (remainingMs > 60_000)
+        return 10_000;
+    if (remainingMs > 10_000)
+        return 1_000;
+    return 200;
+}
+async function sleep(ms) {
+    if (!Number.isFinite(ms) || ms <= 0) {
+        return;
+    }
+    await new Promise((resolve) => setTimeout(resolve, ms));
+}
+const handler = async (ctx) => {
+    const record = ctx.adapterContext;
+    // Only trigger on stop/length completion (no tool calls).
+    if (!isStopEligibleForServerTool(ctx.base, ctx.adapterContext)) {
+        return null;
+    }
+    // When client already disconnected, skip holding.
+    const connectionState = resolveClientConnectionState(record.clientConnectionState);
+    if (connectionState?.disconnected === true) {
+        return null;
+    }
+    const clientDisconnectedRaw = record.clientDisconnected;
+    if (clientDisconnectedRaw === true ||
+        (typeof clientDisconnectedRaw === 'string' && clientDisconnectedRaw.trim().toLowerCase() === 'true')) {
+        return null;
+    }
+    const rt = readRuntimeMetadata(ctx.adapterContext);
+    const sessionId = resolveClockSessionScope(ctx.adapterContext, rt);
+    if (!sessionId) {
+        return null;
+    }
+    // Default-enable clock when config is absent, but keep "explicitly disabled" honored.
+    const clockConfig = resolveClockConfig(rt?.clock);
+    if (!clockConfig) {
+        return null;
+    }
+    await startClockDaemonIfNeeded(clockConfig);
+    // IMPORTANT: clock hold requires a long-lived client connection.
+    // - Streaming/SSE clients: ok to hold (keepalive is handled by host SSE bridge).
+    // - Non-streaming/JSON clients: only hold when explicitly enabled via config,
+    //   and only within a small max window (holdMaxMs).
+    const wantsStream = clientWantsStreaming(ctx.adapterContext);
+    if (!wantsStream && clockConfig.holdNonStreaming !== true) {
+        return null;
+    }
+    const seed = extractCapturedChatSeed(record.capturedChatRequest);
+    if (!seed) {
+        return null;
+    }
+    const tasks = await listClockTasks(sessionId, clockConfig);
+    const at = nowMs();
+    const nextDueAtMs = findNextUndeliveredDueAtMs(tasks, at);
+    if (!nextDueAtMs) {
+        return null;
+    }
+    // Wait until the "due window" is reached (now >= dueAt - dueWindowMs).
+    const thresholdMs = nextDueAtMs - clockConfig.dueWindowMs;
+    const inDueWindow = at >= thresholdMs;
+    if (inDueWindow) {
+        try {
+            const probe = await reserveDueTasksForRequest({
+                reservationId: `${ctx.requestId}:clock_auto_probe`,
+                sessionId,
+                config: clockConfig,
+                requestId: ctx.requestId
+            });
+            if (!probe.reservation || !Array.isArray(probe.reservation.taskIds) || probe.reservation.taskIds.length === 0) {
+                return null;
+            }
+        }
+        catch {
+            return null;
+        }
+    }
+    else {
+        const remainingMs = thresholdMs - at;
+        if (clockConfig.holdMaxMs >= 0 && remainingMs > clockConfig.holdMaxMs) {
+            return null;
+        }
+        logClock('hold_start', { sessionId, nextDueAtMs, thresholdMs });
+        while (nowMs() < thresholdMs) {
+            const state = resolveClientConnectionState(ctx.adapterContext.clientConnectionState);
+            if (state?.disconnected === true) {
+                return null;
+            }
+            const remaining = thresholdMs - nowMs();
+            await sleep(computeHoldSleepMs(remaining));
+            // Best-effort: if tasks were cleared/cancelled while holding, stop holding.
+            try {
+                const refreshed = await listClockTasks(sessionId, clockConfig);
+                const refreshedNext = findNextUndeliveredDueAtMs(refreshed, nowMs());
+                if (!refreshedNext) {
+                    return null;
+                }
+            }
+            catch {
+                // ignore refresh errors; keep holding
+            }
+        }
+    }
+    return {
+        flowId: FLOW_ID,
+        finalize: async () => ({
+            chatResponse: ctx.base,
+            execution: {
+                flowId: FLOW_ID,
+                followup: {
+                    requestIdSuffix: ':clock_hold_followup',
+                    entryEndpoint: ctx.entryEndpoint,
+                    injection: {
+                        ops: [
+                            { op: 'append_assistant_message', required: false },
+                            { op: 'append_user_text', text: 'continue' }
+                        ]
+                    },
+                    metadata: {
+                        ...(connectionState ? { clientConnectionState: connectionState } : {}),
+                        __rt: {
+                            clockFollowupInjectReminders: true
+                        }
+                    }
+                }
+            }
+        })
+    };
+};
+registerServerToolHandler('clock_auto', handler, { trigger: 'auto', hook: { phase: 'post', priority: 50 } });

package/vendor/llmswitch-core/dist/servertool/handlers/clock.d.ts

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