@jsonstudio/llms 0.6.2172 → 0.6.2979

package/dist/router/virtual-router/engine-selection/alias-selection.js

@@ -1,3 +1,4 @@
+import { pinAliasQueueWithNative, resolveAliasSelectionStrategyWithNative } from './native-virtual-router-alias-selection-semantics.js';
 // Default provider-level strategy table.
 // This is a data-only default; callers can override via `loadBalancing.aliasSelection.providers`.
 export const DEFAULT_PROVIDER_ALIAS_SELECTION = {
@@ -5,21 +6,7 @@ export const DEFAULT_PROVIDER_ALIAS_SELECTION = {
     antigravity: 'sticky-queue'
 };
 export function resolveAliasSelectionStrategy(providerId, cfg) {
-    if (!providerId)
-        return 'none';
-    if (cfg?.enabled === false)
-        return 'none';
-    const overrides = cfg?.providers ?? {};
-    const override = overrides[providerId];
-    if (override === 'none' || override === 'sticky-queue') {
-        return override;
-    }
-    const def = cfg?.defaultStrategy;
-    if (def === 'none' || def === 'sticky-queue') {
-        return def;
-    }
-    const table = DEFAULT_PROVIDER_ALIAS_SELECTION[providerId];
-    return table ?? 'none';
+    return resolveAliasSelectionStrategyWithNative(providerId, cfg);
 }
 export function pinCandidatesByAliasQueue(opts) {
     const { queueStore, providerId, modelId, candidates, orderedTargets, excludedProviderKeys, aliasOfKey, modelIdOfKey, availabilityCheck } = opts;
@@ -56,49 +43,51 @@ export function pinCandidatesByAliasQueue(opts) {
         modelIdOfKey,
         allowedAliases: new Set(aliasBuckets.keys())
     });
-    let queue = mergeAliasQueue(queueStore.get(queueKey) ?? [], desiredOrder);
-    // If this is a retry attempt and the previous alias was excluded, rotate it to the tail.
-    if (excludedProviderKeys && excludedProviderKeys.size) {
-        const excludedAliases = [];
-        for (const ex of excludedProviderKeys) {
-            if (!ex || typeof ex !== 'string')
-                continue;
-            if (!ex.startsWith(`${providerId}.`))
-                continue;
-            const exModel = modelIdOfKey(ex);
-            if (!exModel || exModel !== modelId)
-                continue;
-            const exAlias = aliasOfKey(ex);
-            if (exAlias)
-                excludedAliases.push(exAlias);
-        }
-        if (excludedAliases.length) {
-            queue = rotateQueueToTail(queue, excludedAliases);
-        }
+    const excludedAliases = collectExcludedAliases({
+        excludedProviderKeys,
+        providerId,
+        modelId,
+        aliasOfKey,
+        modelIdOfKey
+    });
+    const availabilityByAlias = buildAliasAvailabilityMap(aliasBuckets, availabilityCheck);
+    const resolved = pinAliasQueueWithNative({
+        queue: queueStore.get(queueKey) ?? [],
+        desiredOrder,
+        excludedAliases,
+        aliasBuckets: Object.fromEntries(aliasBuckets.entries()),
+        candidateOrder: candidates,
+        availabilityByAlias: Object.fromEntries(availabilityByAlias.entries())
+    });
+    queueStore.set(queueKey, resolved.queue);
+    return resolved.selectedCandidates.length ? resolved.selectedCandidates : null;
+}
+function collectExcludedAliases(opts) {
+    const { excludedProviderKeys, providerId, modelId, aliasOfKey, modelIdOfKey } = opts;
+    if (!excludedProviderKeys || excludedProviderKeys.size === 0) {
+        return [];
     }
-    // Ensure the head alias points to an available candidate; otherwise rotate until we find one.
-    if (queue.length) {
-        for (let i = 0; i < queue.length; i += 1) {
-            const head = queue[0];
-            const keys = aliasBuckets.get(head) ?? [];
-            const hasAvailable = keys.some((key) => availabilityCheck(key));
-            if (hasAvailable) {
-                break;
-            }
-            queue = rotateQueueToTail(queue, [head]);
-        }
+    const excludedAliases = [];
+    for (const ex of excludedProviderKeys) {
+        if (!ex || typeof ex !== 'string')
+            continue;
+        if (!ex.startsWith(`${providerId}.`))
+            continue;
+        const exModel = modelIdOfKey(ex);
+        if (!exModel || exModel !== modelId)
+            continue;
+        const exAlias = aliasOfKey(ex);
+        if (exAlias)
+            excludedAliases.push(exAlias);
     }
-    // Persist queue updates (even if unchanged, ensure first-time init is stored).
-    queueStore.set(queueKey, queue);
-    const selectedAlias = queue[0];
-    if (!selectedAlias)
-        return null;
-    const selectedKeys = aliasBuckets.get(selectedAlias) ?? [];
-    if (!selectedKeys.length)
-        return null;
-    // Preserve original candidate order.
-    const selectedSet = new Set(selectedKeys);
-    return candidates.filter((key) => selectedSet.has(key));
+    return excludedAliases;
+}
+function buildAliasAvailabilityMap(aliasBuckets, availabilityCheck) {
+    const out = new Map();
+    for (const [alias, keys] of aliasBuckets.entries()) {
+        out.set(alias, keys.some((key) => availabilityCheck(key)));
+    }
+    return out;
 }
 function resolveAliasOrderFromTargets(opts) {
     const { orderedTargets, providerId, modelId, aliasOfKey, modelIdOfKey, allowedAliases } = opts;
@@ -127,30 +116,3 @@ function resolveAliasOrderFromTargets(opts) {
     }
     return out;
 }
-function mergeAliasQueue(existing, desired) {
-    if (!Array.isArray(existing) || existing.length === 0) {
-        return [...desired];
-    }
-    const desiredSet = new Set(desired);
-    const merged = existing.filter((a) => desiredSet.has(a));
-    const mergedSet = new Set(merged);
-    for (const a of desired) {
-        if (!mergedSet.has(a))
-            merged.push(a);
-    }
-    return merged;
-}
-function rotateQueueToTail(queue, aliases) {
-    if (!Array.isArray(queue) || queue.length < 2)
-        return queue;
-    if (!Array.isArray(aliases) || aliases.length === 0)
-        return queue;
-    const toMove = new Set(aliases);
-    const kept = queue.filter((a) => !toMove.has(a));
-    const moved = [];
-    for (const a of queue) {
-        if (toMove.has(a) && !moved.includes(a))
-            moved.push(a);
-    }
-    return [...kept, ...moved];
-}

package/dist/router/virtual-router/engine-selection/key-parsing.js

@@ -1,22 +1,15 @@
+import { analyzeProviderKey } from './native-router-hotpath.js';
+function parseProviderKey(providerKey) {
+    return analyzeProviderKey(providerKey);
+}
 export function extractProviderId(providerKey) {
-    const firstDot = providerKey.indexOf('.');
-    if (firstDot <= 0)
-        return null;
-    return providerKey.substring(0, firstDot);
+    return parseProviderKey(providerKey).providerId;
 }
 export function extractKeyAlias(providerKey) {
-    // Provider keys are logically: <providerId>.<alias>.<modelId>
-    //
-    // NOTE: modelId can contain dots (e.g. "gpt-5.2"), so we must not assume `split('.')` length === 3.
-    const firstDot = providerKey.indexOf('.');
-    if (firstDot <= 0)
-        return null;
-    const secondDot = providerKey.indexOf('.', firstDot + 1);
-    if (secondDot <= firstDot + 1)
-        return null;
-    const alias = providerKey.substring(firstDot + 1, secondDot);
-    if (!alias)
+    const alias = parseProviderKey(providerKey).alias;
+    if (!alias) {
         return null;
+    }
     return normalizeAliasDescriptor(alias);
 }
 export function normalizeAliasDescriptor(alias) {
@@ -26,14 +19,7 @@ export function normalizeAliasDescriptor(alias) {
     return alias;
 }
 export function extractKeyIndex(providerKey) {
-    const parts = providerKey.split('.');
-    if (parts.length === 2) {
-        const index = parseInt(parts[1], 10);
-        if (!isNaN(index) && index > 0) {
-            return index;
-        }
-    }
-    return undefined;
+    return parseProviderKey(providerKey).keyIndex;
 }
 export function getProviderModelId(providerKey, providerRegistry) {
     const profile = providerRegistry.get(providerKey);

package/dist/router/virtual-router/engine-selection/native-chat-process-clock-directive-parser.d.ts

@@ -0,0 +1,20 @@
+export type ClockDirectiveRecurrenceCandidate = {
+    kind: 'daily' | 'weekly' | 'interval';
+    maxRuns: number;
+    everyMinutes?: number;
+};
+export type ClockScheduleDirectiveCandidate = {
+    dueAt: string;
+    task: string;
+    recurrence?: ClockDirectiveRecurrenceCandidate;
+};
+export type ClockDirectiveTextPart = {
+    kind: 'text';
+    text: string;
+} | {
+    kind: 'directive';
+    full: string;
+    candidate?: ClockScheduleDirectiveCandidate;
+};
+export declare function parseClockScheduleDirectiveCandidateWithNative(payload: string): ClockScheduleDirectiveCandidate | null;
+export declare function extractClockScheduleDirectiveTextPartsWithNative(text: string): ClockDirectiveTextPart[];

package/dist/router/virtual-router/engine-selection/native-chat-process-clock-directive-parser.js

@@ -0,0 +1,163 @@
+import { isNativeDisabledByEnv, makeNativeRequiredError } from './native-router-hotpath-policy.js';
+import { loadNativeRouterHotpathBindingForInternalUse } from './native-router-hotpath.js';
+function parsePositiveInt(value) {
+    const parsed = Number(value);
+    if (!Number.isFinite(parsed)) {
+        return undefined;
+    }
+    const floored = Math.floor(parsed);
+    return floored > 0 ? floored : undefined;
+}
+function parseRecurrence(value) {
+    if (!value || typeof value !== 'object' || Array.isArray(value)) {
+        return undefined;
+    }
+    const row = value;
+    const kind = typeof row.kind === 'string' ? row.kind.trim().toLowerCase() : '';
+    if (kind !== 'daily' && kind !== 'weekly' && kind !== 'interval') {
+        return undefined;
+    }
+    const maxRuns = parsePositiveInt(row.maxRuns);
+    if (!maxRuns) {
+        return undefined;
+    }
+    if (kind === 'interval') {
+        const everyMinutes = parsePositiveInt(row.everyMinutes);
+        if (!everyMinutes) {
+            return undefined;
+        }
+        return { kind, maxRuns, everyMinutes };
+    }
+    return { kind, maxRuns };
+}
+function parseCandidateRow(value) {
+    if (!value || typeof value !== 'object' || Array.isArray(value)) {
+        return null;
+    }
+    const row = value;
+    const dueAt = typeof row.dueAt === 'string' ? row.dueAt.trim() : '';
+    const task = typeof row.task === 'string' ? row.task.trim() : '';
+    if (!dueAt || !task) {
+        return null;
+    }
+    const recurrence = parseRecurrence(row.recurrence);
+    if (row.recurrence !== undefined && !recurrence) {
+        return null;
+    }
+    return recurrence ? { dueAt, task, recurrence } : { dueAt, task };
+}
+function parseNativeCandidatePayload(raw) {
+    try {
+        return parseCandidateRow(JSON.parse(raw));
+    }
+    catch {
+        return null;
+    }
+}
+function parseNativeTextPart(value) {
+    if (!value || typeof value !== 'object' || Array.isArray(value)) {
+        return null;
+    }
+    const row = value;
+    const kind = typeof row.kind === 'string' ? row.kind.trim().toLowerCase() : '';
+    if (kind === 'text') {
+        const text = typeof row.text === 'string' ? row.text : '';
+        return { kind: 'text', text };
+    }
+    if (kind !== 'directive') {
+        return null;
+    }
+    const full = typeof row.full === 'string' ? row.full : '';
+    if (!full) {
+        return null;
+    }
+    const candidateRaw = row.candidate;
+    if (candidateRaw === undefined || candidateRaw === null) {
+        return { kind: 'directive', full };
+    }
+    const candidate = parseCandidateRow(candidateRaw);
+    if (!candidate) {
+        return null;
+    }
+    return { kind: 'directive', full, candidate };
+}
+function parseNativeTextPartsPayload(raw) {
+    try {
+        const parsed = JSON.parse(raw);
+        if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) {
+            return null;
+        }
+        const row = parsed;
+        const partsRaw = Array.isArray(row.parts) ? row.parts : null;
+        if (!partsRaw) {
+            return null;
+        }
+        const parts = [];
+        for (const item of partsRaw) {
+            const part = parseNativeTextPart(item);
+            if (!part) {
+                return null;
+            }
+            parts.push(part);
+        }
+        return parts;
+    }
+    catch {
+        return null;
+    }
+}
+function toErrorReason(error) {
+    return error instanceof Error ? error.message : String(error ?? 'unknown');
+}
+function requireNativeFunction(capability, exportName) {
+    if (isNativeDisabledByEnv()) {
+        throw makeNativeRequiredError(capability, 'native disabled');
+    }
+    const binding = loadNativeRouterHotpathBindingForInternalUse();
+    const fn = binding?.[exportName];
+    if (typeof fn !== 'function') {
+        throw makeNativeRequiredError(capability);
+    }
+    return fn;
+}
+export function parseClockScheduleDirectiveCandidateWithNative(payload) {
+    const capability = 'parseClockScheduleDirectiveCandidateJson';
+    const fn = requireNativeFunction(capability, capability);
+    let raw;
+    try {
+        raw = fn(payload);
+    }
+    catch (error) {
+        throw makeNativeRequiredError(capability, toErrorReason(error));
+    }
+    if (typeof raw !== 'string' || !raw) {
+        throw makeNativeRequiredError(capability, 'empty result');
+    }
+    if (raw.trim() === 'null') {
+        return null;
+    }
+    const parsed = parseNativeCandidatePayload(raw);
+    if (!parsed) {
+        throw makeNativeRequiredError(capability, 'invalid payload');
+    }
+    return parsed;
+}
+export function extractClockScheduleDirectiveTextPartsWithNative(text) {
+    const capability = 'extractClockScheduleDirectiveTextPartsJson';
+    const fn = requireNativeFunction(capability, capability);
+    let raw;
+    try {
+        raw = fn(String(text || ''));
+    }
+    catch (error) {
+        throw makeNativeRequiredError(capability, toErrorReason(error));
+    }
+    if (typeof raw !== 'string' || !raw) {
+        throw makeNativeRequiredError(capability, 'empty result');
+    }
+    const parsed = parseNativeTextPartsPayload(raw);
+    if (!parsed) {
+        throw makeNativeRequiredError(capability, 'invalid payload');
+    }
+    return parsed;
+}

package/dist/router/virtual-router/engine-selection/native-chat-process-clock-reminder-directives.d.ts

@@ -0,0 +1,7 @@
+import type { ClockScheduleDirectiveCandidate } from './native-chat-process-clock-directive-parser.js';
+export type NativeClockReminderDirectiveExtractionPayload = {
+    hadClear: boolean;
+    directiveCandidates: ClockScheduleDirectiveCandidate[];
+    baseMessages: unknown[];
+};
+export declare function extractClockReminderDirectivesWithNative(messages: unknown[]): NativeClockReminderDirectiveExtractionPayload;

package/dist/router/virtual-router/engine-selection/native-chat-process-clock-reminder-directives.js

@@ -0,0 +1,103 @@
+import { failNativeRequired, isNativeDisabledByEnv } from './native-router-hotpath-policy.js';
+import { loadNativeRouterHotpathBindingForInternalUse } from './native-router-hotpath.js';
+function parseCandidate(value) {
+    if (!value || typeof value !== 'object' || Array.isArray(value)) {
+        return null;
+    }
+    const row = value;
+    const dueAt = typeof row.dueAt === 'string' ? row.dueAt.trim() : '';
+    const task = typeof row.task === 'string' ? row.task.trim() : '';
+    if (!dueAt || !task) {
+        return null;
+    }
+    const recurrenceRaw = row.recurrence;
+    if (recurrenceRaw === undefined || recurrenceRaw === null) {
+        return { dueAt, task };
+    }
+    if (!recurrenceRaw || typeof recurrenceRaw !== 'object' || Array.isArray(recurrenceRaw)) {
+        return null;
+    }
+    const recurrence = recurrenceRaw;
+    const kind = typeof recurrence.kind === 'string' ? recurrence.kind.trim() : '';
+    const maxRuns = Number(recurrence.maxRuns);
+    if (!Number.isFinite(maxRuns) || Math.floor(maxRuns) <= 0) {
+        return null;
+    }
+    if (kind !== 'daily' && kind !== 'weekly' && kind !== 'interval') {
+        return null;
+    }
+    if (kind === 'interval') {
+        const everyMinutes = Number(recurrence.everyMinutes);
+        if (!Number.isFinite(everyMinutes) || Math.floor(everyMinutes) <= 0) {
+            return null;
+        }
+        return {
+            dueAt,
+            task,
+            recurrence: {
+                kind,
+                maxRuns: Math.floor(maxRuns),
+                everyMinutes: Math.floor(everyMinutes)
+            }
+        };
+    }
+    return {
+        dueAt,
+        task,
+        recurrence: {
+            kind,
+            maxRuns: Math.floor(maxRuns)
+        }
+    };
+}
+function parsePayload(raw) {
+    try {
+        const parsed = JSON.parse(raw);
+        if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) {
+            return null;
+        }
+        const row = parsed;
+        const hadClear = row.hadClear === true;
+        const baseMessages = Array.isArray(row.baseMessages) ? row.baseMessages : null;
+        const directiveCandidatesRaw = Array.isArray(row.directiveCandidates) ? row.directiveCandidates : null;
+        if (!baseMessages || !directiveCandidatesRaw) {
+            return null;
+        }
+        const directiveCandidates = [];
+        for (const entry of directiveCandidatesRaw) {
+            const candidate = parseCandidate(entry);
+            if (!candidate) {
+                return null;
+            }
+            directiveCandidates.push(candidate);
+        }
+        return { hadClear, directiveCandidates, baseMessages };
+    }
+    catch {
+        return null;
+    }
+}
+export function extractClockReminderDirectivesWithNative(messages) {
+    const capability = 'extractClockReminderDirectivesJson';
+    const fail = (reason) => failNativeRequired(capability, reason);
+    if (isNativeDisabledByEnv()) {
+        return fail('native disabled');
+    }
+    const binding = loadNativeRouterHotpathBindingForInternalUse();
+    const fn = binding?.extractClockReminderDirectivesJson;
+    if (typeof fn !== 'function') {
+        return fail();
+    }
+    try {
+        const raw = fn(JSON.stringify(messages));
+        if (typeof raw !== 'string' || !raw) {
+            return fail('empty result');
+        }
+        const parsed = parsePayload(raw);
+        return parsed ?? fail('invalid payload');
+    }
+    catch (error) {
+        const reason = error instanceof Error ? error.message : String(error ?? 'unknown');
+        return fail(reason);
+    }
+}

package/dist/router/virtual-router/engine-selection/native-chat-process-clock-reminder-orchestration-semantics.d.ts

@@ -0,0 +1,10 @@
+export type NativeGuardedClockScheduleItem = {
+    dueAtMs: number;
+    setBy?: string;
+    task: string;
+    recurrence?: unknown;
+    notBeforeRequestId?: string;
+};
+export declare function buildGuardedClockScheduleItemWithNative(marker: unknown, requestId: string, dueWindowMs: number, nowMs: number): NativeGuardedClockScheduleItem;
+export declare function normalizeDueInjectTextWithNative(value: unknown): string;
+export declare function shouldReserveClockDueReminderWithNative(hadClear: boolean, sessionId: string | null): boolean;

package/dist/router/virtual-router/engine-selection/native-chat-process-clock-reminder-orchestration-semantics.js

@@ -0,0 +1,110 @@
+import { failNativeRequired, isNativeDisabledByEnv } from './native-router-hotpath-policy.js';
+import { loadNativeRouterHotpathBindingForInternalUse } from './native-router-hotpath.js';
+function parseGuardedItem(raw) {
+    try {
+        const parsed = JSON.parse(raw);
+        if (parsed === null) {
+            return null;
+        }
+        if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) {
+            return null;
+        }
+        const row = parsed;
+        const dueAtMs = Number(row.dueAtMs);
+        const setBy = typeof row.setBy === 'string' ? row.setBy : '';
+        const task = typeof row.task === 'string' ? row.task : '';
+        if (!Number.isFinite(dueAtMs) || !task.trim()) {
+            return null;
+        }
+        const notBeforeRequestId = typeof row.notBeforeRequestId === 'string' && row.notBeforeRequestId.trim()
+            ? row.notBeforeRequestId
+            : undefined;
+        return {
+            dueAtMs: Math.floor(dueAtMs),
+            ...(setBy.trim() ? { setBy } : {}),
+            task,
+            ...(row.recurrence !== undefined ? { recurrence: row.recurrence } : {}),
+            ...(notBeforeRequestId ? { notBeforeRequestId } : {})
+        };
+    }
+    catch {
+        return null;
+    }
+}
+function parseJsonString(raw) {
+    try {
+        const parsed = JSON.parse(raw);
+        return typeof parsed === 'string' ? parsed : null;
+    }
+    catch {
+        return null;
+    }
+}
+export function buildGuardedClockScheduleItemWithNative(marker, requestId, dueWindowMs, nowMs) {
+    const capability = 'buildGuardedClockScheduleItemJson';
+    const fail = (reason) => failNativeRequired(capability, reason);
+    if (isNativeDisabledByEnv()) {
+        return fail('native disabled');
+    }
+    const binding = loadNativeRouterHotpathBindingForInternalUse();
+    const fn = binding?.buildGuardedClockScheduleItemJson;
+    if (typeof fn !== 'function') {
+        return fail();
+    }
+    try {
+        const raw = fn(JSON.stringify(marker ?? null), String(requestId || ''), Number.isFinite(dueWindowMs) ? dueWindowMs : 0, Number.isFinite(nowMs) ? nowMs : 0);
+        if (typeof raw !== 'string' || !raw) {
+            return fail('empty result');
+        }
+        const parsed = parseGuardedItem(raw);
+        return parsed ?? fail('invalid payload');
+    }
+    catch (error) {
+        const reason = error instanceof Error ? error.message : String(error ?? 'unknown');
+        return fail(reason);
+    }
+}
+export function normalizeDueInjectTextWithNative(value) {
+    const capability = 'normalizeDueInjectTextJson';
+    const fail = (reason) => failNativeRequired(capability, reason);
+    if (isNativeDisabledByEnv()) {
+        return fail('native disabled');
+    }
+    const binding = loadNativeRouterHotpathBindingForInternalUse();
+    const fn = binding?.normalizeDueInjectTextJson;
+    if (typeof fn !== 'function') {
+        return fail();
+    }
+    try {
+        const raw = fn(JSON.stringify(value ?? null));
+        if (typeof raw !== 'string' || !raw) {
+            return fail('empty result');
+        }
+        const parsed = parseJsonString(raw);
+        return parsed ?? fail('invalid payload');
+    }
+    catch (error) {
+        const reason = error instanceof Error ? error.message : String(error ?? 'unknown');
+        return fail(reason);
+    }
+}
+export function shouldReserveClockDueReminderWithNative(hadClear, sessionId) {
+    const capability = 'shouldReserveClockDueReminderJson';
+    const fail = (reason) => failNativeRequired(capability, reason);
+    if (isNativeDisabledByEnv()) {
+        return fail('native disabled');
+    }
+    const binding = loadNativeRouterHotpathBindingForInternalUse();
+    const fn = binding?.shouldReserveClockDueReminderJson;
+    if (typeof fn !== 'function') {
+        return fail();
+    }
+    try {
+        const raw = fn(hadClear === true, String(sessionId ?? ''));
+        return raw === true;
+    }
+    catch (error) {
+        const reason = error instanceof Error ? error.message : String(error ?? 'unknown');
+        return fail(reason);
+    }
+}

package/dist/router/virtual-router/engine-selection/native-chat-process-clock-reminder-semantics.d.ts

@@ -0,0 +1,8 @@
+export declare function resolveClockConfigWithNative(raw: unknown, rawIsUndefined: boolean): Record<string, unknown> | null;
+export declare function resolveClockSessionScopeWithNative(primary: Record<string, unknown> | null | undefined, fallback: Record<string, unknown> | null | undefined): string | null;
+export declare function buildClockMarkerScheduleMessagesWithNative(requestId: string, markerIndex: number, marker: Record<string, unknown>, payload: Record<string, unknown>): unknown[];
+export declare function findLastUserMessageIndexWithNative(messages: unknown[]): number;
+export declare function injectTimeTagIntoMessagesWithNative(messages: unknown[], timeTagLine: string): unknown[];
+export declare function buildDueReminderUserMessageWithNative(reservation: unknown, dueInjectText: string): unknown;
+export declare function buildClockReminderMetadataWithNative(nextRequestMetadata: unknown, metadata: Record<string, unknown>, dueUserMessage: unknown, reservation: unknown): Record<string, unknown>;
+export declare function buildClockReminderMessagesWithNative(baseMessages: unknown[], markerToolMessages: unknown[], dueUserMessage: unknown, timeTagLine: string): unknown[];