@jsonstudio/rcc 0.90.323 → 0.90.364

package/vendor/@jsonstudio/llms/dist/conversion/hub/pipelines/outbound.js

@@ -0,0 +1,59 @@
+import { normalizeProviderProtocolTokenWithNative } from '../../../router/virtual-router/engine-selection/native-hub-pipeline-req-inbound-semantics.js';
+function recordStage(recorder, stage, payload) {
+    if (!recorder)
+        return;
+    try {
+        recorder.record(stage, payload);
+    }
+    catch {
+        /* ignore recorder errors */
+    }
+}
+export async function runOutboundPipeline(options) {
+    const { chat, context, plan, stageRecorder } = options;
+    if (!plan)
+        throw new Error('Outbound plan is required');
+    normalizeProviderProtocolTokenWithNative(plan.protocol || context.providerProtocol);
+    if (plan.passthrough?.mode === 'protocol') {
+        if (!plan.passthrough.factory) {
+            throw new Error('Outbound passthrough requires factory');
+        }
+        const payload = await plan.passthrough.factory(chat, context);
+        recordStage(stageRecorder, 'outbound_passthrough', payload);
+        return payload;
+    }
+    if (!Array.isArray(plan.stages) || plan.stages.length === 0) {
+        throw new Error('Outbound plan must declare stages or passthrough');
+    }
+    let formatEnvelope;
+    let finalPayload;
+    for (const stage of plan.stages) {
+        switch (stage) {
+            case 'semantic_map_from_chat': {
+                if (!plan.semanticMapper) {
+                    throw new Error('semantic_map_from_chat stage requires semantic mapper');
+                }
+                formatEnvelope = await plan.semanticMapper.fromChat(chat, context);
+                recordStage(stageRecorder, 'semantic_map_from_chat', formatEnvelope);
+                break;
+            }
+            case 'format_build': {
+                if (!plan.formatAdapter) {
+                    throw new Error('format_build stage requires format adapter');
+                }
+                if (!formatEnvelope) {
+                    throw new Error('format_build stage requires semantic_map_from_chat result');
+                }
+                finalPayload = await plan.formatAdapter.buildResponse(formatEnvelope, context);
+                recordStage(stageRecorder, 'format_build', finalPayload);
+                break;
+            }
+            default:
+                throw new Error(`Unknown outbound stage: ${stage}`);
+        }
+    }
+    if (finalPayload === undefined) {
+        throw new Error('Outbound pipeline did not produce payload');
+    }
+    return finalPayload;
+}

package/vendor/@jsonstudio/llms/dist/conversion/hub/policy/policy-engine.d.ts

@@ -0,0 +1,48 @@
+import type { JsonObject } from '../types/json.js';
+import type { StageRecorder } from '../format-adapters/index.js';
+export type HubPolicyMode = 'off' | 'observe' | 'enforce';
+export interface HubPolicyConfig {
+    mode?: HubPolicyMode;
+    /**
+     * Optional: sampling rate in [0, 1]. When provided, observation is best-effort
+     * and may skip recording for some requests.
+     */
+    sampleRate?: number;
+}
+export interface PolicyObservation {
+    phase: 'client_inbound' | 'provider_outbound' | 'provider_inbound' | 'client_outbound';
+    providerProtocol: string;
+    violations: Array<{
+        code: 'unexpected_wrapper' | 'unexpected_field';
+        path: string;
+        detail?: string;
+    }>;
+    summary: {
+        totalViolations: number;
+        unexpectedFieldCount: number;
+    };
+}
+export interface ProviderOutboundPolicyApplyResult {
+    payload: JsonObject;
+    changed: boolean;
+    removedTopLevelKeys: string[];
+    flattenedWrappers: string[];
+}
+export declare function setHubPolicyRuntimePolicy(policy?: HubPolicyConfig): void;
+export declare function recordHubPolicyObservation(options: {
+    policy?: HubPolicyConfig;
+    phase?: PolicyObservation['phase'];
+    providerProtocol: string;
+    compatibilityProfile?: string;
+    payload: JsonObject;
+    stageRecorder?: StageRecorder;
+    requestId?: string;
+}): void;
+export declare function applyHubProviderOutboundPolicy(options: {
+    policy?: HubPolicyConfig;
+    providerProtocol: string;
+    compatibilityProfile?: string;
+    payload: JsonObject;
+    stageRecorder?: StageRecorder;
+    requestId?: string;
+}): JsonObject;

package/vendor/@jsonstudio/llms/dist/conversion/hub/policy/policy-engine.js

@@ -0,0 +1,269 @@
+import { resolveHubProtocolSpec } from './protocol-spec.js';
+import { normalizeProviderProtocolTokenWithNative } from '../../../router/virtual-router/engine-selection/native-hub-pipeline-req-inbound-semantics.js';
+let hubPolicyRuntime = undefined;
+export function setHubPolicyRuntimePolicy(policy) {
+    hubPolicyRuntime = policy;
+}
+function resolveEffectivePolicy(policy) {
+    return policy ?? hubPolicyRuntime;
+}
+function shouldSample(rate) {
+    if (rate === undefined)
+        return true;
+    if (!Number.isFinite(rate))
+        return true;
+    if (rate <= 0)
+        return false;
+    if (rate >= 1)
+        return true;
+    return Math.random() < rate;
+}
+function isJsonRecord(value) {
+    return Boolean(value) && typeof value === 'object' && !Array.isArray(value);
+}
+function hasGeminiCliRequestWrapper(payload) {
+    const request = payload.request;
+    if (!isJsonRecord(request)) {
+        return false;
+    }
+    const req = request;
+    return (Object.prototype.hasOwnProperty.call(req, 'contents') ||
+        Object.prototype.hasOwnProperty.call(req, 'systemInstruction') ||
+        Object.prototype.hasOwnProperty.call(req, 'tools') ||
+        Object.prototype.hasOwnProperty.call(req, 'toolConfig') ||
+        Object.prototype.hasOwnProperty.call(req, 'generationConfig') ||
+        Object.prototype.hasOwnProperty.call(req, 'safetySettings'));
+}
+function isGeminiCliPayload(payload) {
+    const record = payload;
+    return (typeof record.project === 'string' ||
+        typeof record.requestType === 'string' ||
+        typeof record.userAgent === 'string' ||
+        typeof record.requestId === 'string' ||
+        hasGeminiCliRequestWrapper(payload));
+}
+function normalizeHubProviderProtocol(providerProtocol) {
+    return normalizeProviderProtocolTokenWithNative(providerProtocol) ?? providerProtocol;
+}
+function extendGeminiAllowlistIfNeeded(providerProtocol, payload, allowedTopLevelKeys) {
+    if (providerProtocol !== 'gemini-chat') {
+        return allowedTopLevelKeys;
+    }
+    if (!isGeminiCliPayload(payload)) {
+        return allowedTopLevelKeys;
+    }
+    const extended = allowedTopLevelKeys ? new Set(allowedTopLevelKeys) : new Set();
+    extended.add('request');
+    extended.add('project');
+    extended.add('requestId');
+    extended.add('requestType');
+    extended.add('userAgent');
+    extended.add('action');
+    return extended;
+}
+function applyProviderOutboundPolicy(providerProtocol, payload) {
+    const removedTopLevelKeys = [];
+    const flattenedWrappers = [];
+    const spec = resolveHubProtocolSpec(providerProtocol);
+    if (!spec.providerOutbound.enforceEnabled) {
+        return {
+            payload,
+            changed: false,
+            removedTopLevelKeys,
+            flattenedWrappers
+        };
+    }
+    let out = payload;
+    const ensureOutClone = () => {
+        if (out === payload) {
+            out = { ...payload };
+        }
+    };
+    const allowedTopLevelKeys = Array.isArray(spec.providerOutbound.allowedTopLevelKeys) &&
+        spec.providerOutbound.allowedTopLevelKeys.length > 0 &&
+        spec.providerOutbound.enforceAllowedTopLevelKeys === true
+        ? new Set(spec.providerOutbound.allowedTopLevelKeys)
+        : undefined;
+    const isGeminiCli = providerProtocol === 'gemini-chat' && isGeminiCliPayload(payload);
+    const allowedTopLevelKeysResolved = extendGeminiAllowlistIfNeeded(providerProtocol, payload, allowedTopLevelKeys);
+    // Reserved/private keys must never be sent upstream.
+    for (const key of Object.keys(payload)) {
+        if (spec.providerOutbound.reservedKeyPrefixes.some((prefix) => key.startsWith(prefix))) {
+            ensureOutClone();
+            delete out[key];
+            removedTopLevelKeys.push(key);
+        }
+    }
+    // Flatten accidental wrappers that have caused upstream 400s.
+    for (const rule of spec.providerOutbound.flattenWrappers) {
+        const wrapperKey = rule.wrapperKey;
+        if (!wrapperKey || typeof wrapperKey !== 'string') {
+            continue;
+        }
+        if (isGeminiCli && wrapperKey === 'request') {
+            continue;
+        }
+        if (!isJsonRecord(out[wrapperKey])) {
+            continue;
+        }
+        ensureOutClone();
+        const inner = { ...out[wrapperKey] };
+        const alias = rule.aliasKeys || {};
+        for (const [from, to] of Object.entries(alias)) {
+            if (inner[to] === undefined && inner[from] !== undefined) {
+                inner[to] = inner[from];
+            }
+        }
+        const allow = Array.isArray(rule.allowKeys) ? new Set(rule.allowKeys) : null;
+        const onlyIfMissing = rule.onlyIfTargetMissing !== false;
+        for (const [key, value] of Object.entries(inner)) {
+            if (allow && !allow.has(key)) {
+                continue;
+            }
+            if (!onlyIfMissing || out[key] === undefined) {
+                out[key] = value;
+            }
+        }
+        delete out[wrapperKey];
+        flattenedWrappers.push(wrapperKey);
+    }
+    // Enforce protocol allowlist (top-level). Only runs when explicitly enabled
+    // for this protocol, and only after wrapper flatten so allowed fields are
+    // present at the correct level.
+    if (allowedTopLevelKeysResolved) {
+        for (const key of Object.keys(out)) {
+            if (allowedTopLevelKeysResolved.has(key))
+                continue;
+            ensureOutClone();
+            delete out[key];
+            removedTopLevelKeys.push(key);
+        }
+    }
+    return {
+        payload: out,
+        changed: out !== payload || removedTopLevelKeys.length > 0 || flattenedWrappers.length > 0,
+        removedTopLevelKeys,
+        flattenedWrappers
+    };
+}
+function observeProviderPayload(options) {
+    const violations = [];
+    // Observe-only: detect known layout anti-patterns and reserved keys.
+    // Do NOT modify payload here.
+    const spec = resolveHubProtocolSpec(options.providerProtocol);
+    const allowlistEnabled = options.phase === 'provider_outbound';
+    const isGeminiCli = options.providerProtocol === 'gemini-chat' && isGeminiCliPayload(options.payload);
+    const allowedTopLevelKeys = allowlistEnabled && Array.isArray(spec.providerOutbound.allowedTopLevelKeys)
+        ? new Set(spec.providerOutbound.allowedTopLevelKeys)
+        : undefined;
+    const allowedTopLevelKeysResolved = extendGeminiAllowlistIfNeeded(options.providerProtocol, options.payload, allowedTopLevelKeys);
+    for (const rule of spec.providerOutbound.forbidWrappers) {
+        if (rule.code !== 'forbid_wrapper') {
+            continue;
+        }
+        if (isGeminiCli && rule.path === 'request') {
+            continue;
+        }
+        if (rule.path in options.payload && isJsonRecord(options.payload[rule.path])) {
+            violations.push({
+                code: 'unexpected_wrapper',
+                path: rule.path,
+                detail: rule.detail
+            });
+        }
+    }
+    // Always record unknown private wrapper keys (best-effort, conservative).
+    for (const key of Object.keys(options.payload)) {
+        if (spec.providerOutbound.reservedKeyPrefixes.some((prefix) => key.startsWith(prefix))) {
+            violations.push({
+                code: 'unexpected_field',
+                path: key
+            });
+            continue;
+        }
+        if (allowedTopLevelKeysResolved && !allowedTopLevelKeysResolved.has(key)) {
+            violations.push({
+                code: 'unexpected_field',
+                path: key,
+                detail: `Top-level key is not in protocol allowlist: ${options.providerProtocol}`
+            });
+        }
+    }
+    const unexpectedFieldCount = violations.filter((v) => v.code === 'unexpected_field').length;
+    return {
+        phase: options.phase,
+        providerProtocol: options.providerProtocol,
+        violations,
+        summary: {
+            totalViolations: violations.length,
+            unexpectedFieldCount
+        }
+    };
+}
+export function recordHubPolicyObservation(options) {
+    if (!options.stageRecorder) {
+        return;
+    }
+    const effectivePolicy = resolveEffectivePolicy(options.policy);
+    const mode = effectivePolicy?.mode ?? 'off';
+    // Keep observing in enforce mode (best-effort) so operators can monitor
+    // violations while gradually turning enforcement on.
+    if (mode !== 'observe' && mode !== 'enforce') {
+        return;
+    }
+    const compatibilityProfile = typeof options.compatibilityProfile === 'string' ? options.compatibilityProfile.trim().toLowerCase() : '';
+    if (compatibilityProfile === 'chat:deepseek-web') {
+        return;
+    }
+    if (!shouldSample(effectivePolicy?.sampleRate)) {
+        return;
+    }
+    const normalizedProviderProtocol = normalizeHubProviderProtocol(options.providerProtocol);
+    try {
+        const phase = options.phase ?? 'provider_outbound';
+        const observation = observeProviderPayload({
+            phase,
+            providerProtocol: normalizedProviderProtocol,
+            payload: options.payload
+        });
+        if (observation.summary.totalViolations <= 0) {
+            return;
+        }
+        const stage = `hub_policy.observe.${phase}`;
+        options.stageRecorder.record(stage, {
+            requestId: options.requestId,
+            ...observation
+        });
+    }
+    catch {
+        // observe-only must never break the pipeline
+    }
+}
+export function applyHubProviderOutboundPolicy(options) {
+    const effectivePolicy = resolveEffectivePolicy(options.policy);
+    const mode = effectivePolicy?.mode ?? 'off';
+    if (mode !== 'enforce') {
+        return options.payload;
+    }
+    const normalizedProviderProtocol = normalizeHubProviderProtocol(options.providerProtocol);
+    const compatibilityProfile = typeof options.compatibilityProfile === 'string' ? options.compatibilityProfile.trim().toLowerCase() : '';
+    if (compatibilityProfile === 'chat:deepseek-web') {
+        return options.payload;
+    }
+    const result = applyProviderOutboundPolicy(normalizedProviderProtocol, options.payload);
+    if (!result.changed) {
+        return options.payload;
+    }
+    try {
+        options.stageRecorder?.record('hub_policy.enforce.provider_outbound', {
+            requestId: options.requestId,
+            providerProtocol: normalizedProviderProtocol,
+            removedTopLevelKeys: result.removedTopLevelKeys,
+            flattenedWrappers: result.flattenedWrappers
+        });
+    }
+    catch {
+        // policy enforcement recording must not break the pipeline
+    }
+    return result.payload;
+}

package/vendor/@jsonstudio/llms/dist/conversion/hub/policy/protocol-spec.d.ts

@@ -0,0 +1,75 @@
+export type HubProviderProtocol = 'openai-chat' | 'openai-responses' | 'anthropic-messages' | 'gemini-chat';
+export interface ProviderOutboundLayoutRule {
+    code: 'forbid_wrapper';
+    path: string;
+    detail: string;
+}
+export interface ProviderOutboundWrapperFlattenRule {
+    wrapperKey: string;
+    /**
+     * When provided, only these keys from the wrapper are merged into top-level.
+     * When omitted, all keys are eligible.
+     */
+    allowKeys?: string[];
+    /**
+     * Key remap inside wrapper prior to merging (e.g. max_tokens -> max_output_tokens).
+     */
+    aliasKeys?: Record<string, string>;
+    /**
+     * Merge strategy: only write to target when top-level key is undefined.
+     */
+    onlyIfTargetMissing?: boolean;
+}
+export interface ProviderOutboundPolicySpec {
+    /**
+     * Whether provider outbound enforcement is enabled for this protocol.
+     * Keep this false for protocols not yet migrated, to avoid behavior changes.
+     */
+    enforceEnabled: boolean;
+    /**
+     * Provider outbound payload allowlist (top-level keys), used for observation
+     * to detect drift.
+     */
+    allowedTopLevelKeys?: readonly string[];
+    /**
+     * When enabled, provider outbound payload will drop any top-level keys not
+     * present in allowedTopLevelKeys (after wrapper flatten).
+     *
+     * Keep this configurable for progressive rollout, but Phase 1 completion
+     * requires enabling it for all protocols.
+     */
+    enforceAllowedTopLevelKeys?: boolean;
+    /**
+     * Reserved/private key prefixes that must not be sent upstream.
+     * (Enforced only when enforceEnabled=true.)
+     */
+    reservedKeyPrefixes: string[];
+    /**
+     * Wrappers that should not exist in provider outbound payload.
+     * observe: treat as violations; enforce: flatten/remove when configured.
+     */
+    forbidWrappers: ProviderOutboundLayoutRule[];
+    /**
+     * Best-effort fix for known wrapper anti-patterns by flattening into top-level.
+     * (Applied only when enforceEnabled=true.)
+     */
+    flattenWrappers: ProviderOutboundWrapperFlattenRule[];
+}
+export type ToolDefinitionFormat = 'openai' | 'anthropic' | 'gemini';
+export type ProviderOutboundHistoryCarrier = 'messages' | 'input';
+export interface ToolSurfaceSpec {
+    expectedToolFormat: ToolDefinitionFormat;
+    /**
+     * For OpenAI protocols, tool call/result history may be carried in either
+     * chat `messages[]` or responses `input[]`. This spec describes the expected
+     * carrier so toolSurface can normalize or at least record diffs.
+     */
+    expectedHistoryCarrier?: ProviderOutboundHistoryCarrier;
+}
+export interface ProtocolSpec {
+    id: HubProviderProtocol;
+    providerOutbound: ProviderOutboundPolicySpec;
+    toolSurface: ToolSurfaceSpec;
+}
+export declare const HUB_PROTOCOL_SPECS: Record<HubProviderProtocol, ProtocolSpec>;
+export declare function resolveHubProtocolSpec(protocol: string): ProtocolSpec;

package/vendor/@jsonstudio/llms/dist/conversion/hub/policy/protocol-spec.js

@@ -0,0 +1,27 @@
+import { ANTHROPIC_ALLOWED_FIELDS, ANTHROPIC_PARAMETERS_WRAPPER_ALLOW_KEYS, GEMINI_ALLOWED_FIELDS, OPENAI_CHAT_ALLOWED_FIELDS, OPENAI_CHAT_PARAMETERS_WRAPPER_ALLOW_KEYS, OPENAI_RESPONSES_ALLOWED_FIELDS, OPENAI_RESPONSES_PARAMETERS_WRAPPER_ALLOW_KEYS } from '../../protocol-field-allowlists.js';
+import { resolveHubProtocolSpecWithNative } from '../../../router/virtual-router/engine-selection/native-hub-bridge-policy-semantics.js';
+const ALLOWLISTS = {
+    openaiChatAllowedFields: OPENAI_CHAT_ALLOWED_FIELDS,
+    openaiChatParametersWrapperAllowKeys: OPENAI_CHAT_PARAMETERS_WRAPPER_ALLOW_KEYS,
+    openaiResponsesAllowedFields: OPENAI_RESPONSES_ALLOWED_FIELDS,
+    openaiResponsesParametersWrapperAllowKeys: OPENAI_RESPONSES_PARAMETERS_WRAPPER_ALLOW_KEYS,
+    anthropicAllowedFields: ANTHROPIC_ALLOWED_FIELDS,
+    anthropicParametersWrapperAllowKeys: ANTHROPIC_PARAMETERS_WRAPPER_ALLOW_KEYS,
+    geminiAllowedFields: GEMINI_ALLOWED_FIELDS
+};
+function buildSpec(protocol) {
+    return resolveHubProtocolSpecWithNative({
+        protocol,
+        allowlists: ALLOWLISTS
+    });
+}
+export const HUB_PROTOCOL_SPECS = {
+    'openai-chat': buildSpec('openai-chat'),
+    'openai-responses': buildSpec('openai-responses'),
+    'anthropic-messages': buildSpec('anthropic-messages'),
+    'gemini-chat': buildSpec('gemini-chat')
+};
+export function resolveHubProtocolSpec(protocol) {
+    const normalized = (protocol || '').trim().toLowerCase();
+    return HUB_PROTOCOL_SPECS[normalized] ?? HUB_PROTOCOL_SPECS['openai-chat'];
+}

package/vendor/@jsonstudio/llms/dist/conversion/hub/process/chat-process-anthropic-alias.d.ts

@@ -0,0 +1,2 @@
+import type { StandardizedRequest } from '../types/standardized.js';
+export declare function applyAnthropicToolAliasSemantics(request: StandardizedRequest, entryEndpoint: string): StandardizedRequest;

package/vendor/@jsonstudio/llms/dist/conversion/hub/process/chat-process-anthropic-alias.js

@@ -0,0 +1,36 @@
+import { isJsonObject } from '../types/json.js';
+import { buildAnthropicToolAliasMapWithNative } from '../../../router/virtual-router/engine-selection/native-chat-process-governance-semantics.js';
+export function applyAnthropicToolAliasSemantics(request, entryEndpoint) {
+    try {
+        const endpoint = typeof entryEndpoint === 'string' ? entryEndpoint.trim().toLowerCase() : '';
+        if (!endpoint.includes('/v1/messages')) {
+            return request;
+        }
+        request.semantics = asObjectRecord(request.semantics);
+        const semantics = request.semantics;
+        const semanticsTools = asObjectRecord(semantics.tools);
+        semantics.tools = semanticsTools;
+        const hasAlias = isJsonObject(semanticsTools.toolNameAliasMap) ||
+            isJsonObject(semanticsTools.toolAliasMap);
+        if (hasAlias) {
+            return request;
+        }
+        const sourceTools = Array.isArray(semanticsTools.clientToolsRaw) && semanticsTools.clientToolsRaw.length
+            ? semanticsTools.clientToolsRaw
+            : request.tools;
+        const aliasMap = buildAnthropicToolAliasMapWithNative(sourceTools);
+        if (aliasMap) {
+            semanticsTools.toolNameAliasMap = aliasMap;
+        }
+    }
+    catch {
+        // best-effort: alias-map propagation must never block request handling
+    }
+    return request;
+}
+function asObjectRecord(value) {
+    if (value && typeof value === 'object' && !Array.isArray(value)) {
+        return value;
+    }
+    return {};
+}

package/vendor/@jsonstudio/llms/dist/conversion/hub/process/chat-process-clock-directive-parser.d.ts

@@ -0,0 +1,5 @@
+import { type ClockScheduleDirectiveCandidate } from '../../../router/virtual-router/engine-selection/native-chat-process-clock-directive-parser.js';
+import type { ClockScheduleDirective } from './chat-process-clock-directives.js';
+export declare function hydrateClockScheduleDirectiveCandidate(candidate: ClockScheduleDirectiveCandidate): ClockScheduleDirective | null;
+export declare function parseClockScheduleDirectiveCandidatePayload(payload: string): ClockScheduleDirectiveCandidate | null;
+export declare function parseClockScheduleDirectivePayload(payload: string): ClockScheduleDirective | null;

package/vendor/@jsonstudio/llms/dist/conversion/hub/process/chat-process-clock-directive-parser.js

@@ -0,0 +1,56 @@
+import { parseDueAtMs } from '../../../servertool/clock/task-store.js';
+import { normalizeQuietHours } from '../../../servertool/clock/recurrence.js';
+import { parseClockScheduleDirectiveCandidateWithNative } from '../../../router/virtual-router/engine-selection/native-chat-process-clock-directive-parser.js';
+function normalizeRecurrence(recurrence) {
+    if (!recurrence) {
+        return undefined;
+    }
+    const quietHours = normalizeQuietHours(recurrence.quietHours);
+    if (recurrence.kind === 'interval') {
+        if (typeof recurrence.everyMinutes !== 'number' || recurrence.everyMinutes <= 0) {
+            return undefined;
+        }
+        return {
+            kind: 'interval',
+            everyMinutes: Math.floor(recurrence.everyMinutes),
+            ...(typeof recurrence.maxRuns === 'number' && recurrence.maxRuns > 0
+                ? { maxRuns: Math.floor(recurrence.maxRuns) }
+                : {}),
+            ...(quietHours ? { quietHours } : {})
+        };
+    }
+    return {
+        kind: recurrence.kind,
+        ...(typeof recurrence.maxRuns === 'number' && recurrence.maxRuns > 0
+            ? { maxRuns: Math.floor(recurrence.maxRuns) }
+            : {}),
+        ...(quietHours ? { quietHours } : {})
+    };
+}
+export function hydrateClockScheduleDirectiveCandidate(candidate) {
+    const dueAtMs = parseDueAtMs(candidate.dueAt);
+    if (!dueAtMs || !candidate.task) {
+        return null;
+    }
+    const recurrence = normalizeRecurrence(candidate.recurrence);
+    if (candidate.recurrence && !recurrence) {
+        return null;
+    }
+    return {
+        dueAtMs,
+        dueAt: new Date(dueAtMs).toISOString(),
+        task: candidate.task,
+        ...(recurrence ? { recurrence } : {})
+    };
+}
+export function parseClockScheduleDirectiveCandidatePayload(payload) {
+    const raw = String(payload || '').trim();
+    return parseClockScheduleDirectiveCandidateWithNative(raw);
+}
+export function parseClockScheduleDirectivePayload(payload) {
+    const candidate = parseClockScheduleDirectiveCandidatePayload(payload);
+    if (!candidate) {
+        return null;
+    }
+    return hydrateClockScheduleDirectiveCandidate(candidate);
+}

package/vendor/@jsonstudio/llms/dist/conversion/hub/process/chat-process-clock-directives.d.ts

@@ -0,0 +1,24 @@
+import type { StandardizedMessage } from '../types/standardized.js';
+import type { ClockTaskRecurrence } from '../../../servertool/clock/task-store.js';
+export type ClockScheduleDirective = {
+    dueAtMs: number;
+    dueAt: string;
+    task: string;
+    recurrence?: ClockTaskRecurrence;
+};
+export declare function stripClockClearDirectiveFromText(text: string): {
+    hadClear: boolean;
+    next: string;
+};
+export declare function extractClockScheduleDirectivesFromText(text: string): {
+    directives: ClockScheduleDirective[];
+    next: string;
+};
+export declare function extractClockScheduleDirectivesFromContent(content: StandardizedMessage['content']): {
+    directives: ClockScheduleDirective[];
+    next: StandardizedMessage['content'];
+};
+export declare function stripClockClearDirectiveFromContent(content: StandardizedMessage['content']): {
+    hadClear: boolean;
+    next: StandardizedMessage['content'];
+};