@jsonstudio/llms 0.6.2172 → 0.6.3214

package/dist/conversion/hub/process/chat-process-clock-reminders.js

@@ -0,0 +1,104 @@
+import { readRuntimeMetadata } from '../../runtime-metadata.js';
+import { clearClockSession, resolveClockConfig, startClockDaemonIfNeeded } from '../../../servertool/clock/task-store.js';
+import { logClock } from '../../../servertool/clock/log.js';
+import { resolveClockSessionScope } from '../../../servertool/clock/session-scope.js';
+import { applyHubOperations } from '../ops/operations.js';
+import { buildClockStandardToolsOperations } from './chat-process-clock-tools.js';
+import { reserveClockDueReminderForRequest, scheduleClockReminderDirectiveMessages } from './chat-process-clock-reminder-orchestration.js';
+import { buildClockReminderMessages, buildClockReminderMetadata, buildDueReminderUserMessage } from './chat-process-clock-reminder-finalize.js';
+import { resolveClockReminderTimeTagLine } from './chat-process-clock-reminder-time-tag.js';
+import { extractClockReminderDirectives } from './chat-process-clock-reminder-directives.js';
+import { isClientInjectReady } from './client-inject-readiness.js';
+import { resolveClockReminderFlowPlanWithNative } from '../../../router/virtual-router/engine-selection/native-chat-process-clock-reminders-semantics.js';
+function resolveSessionIdForClock(metadata, request) {
+    const requestMetadata = request.metadata && typeof request.metadata === 'object' && !Array.isArray(request.metadata)
+        ? request.metadata
+        : null;
+    return resolveClockSessionScope(metadata, requestMetadata);
+}
+export async function maybeInjectClockRemindersAndApplyDirectives(request, metadata, requestId) {
+    if (!isClientInjectReady(metadata)) {
+        return request;
+    }
+    const rt = readRuntimeMetadata(metadata);
+    const flowPlan = resolveClockReminderFlowPlanWithNative(rt);
+    // Do not inject reminders or apply clock directives during internal servertool followup hops.
+    if (flowPlan.skipForServerToolFollowup) {
+        return request;
+    }
+    const rawConfig = rt?.clock;
+    const clockConfig = resolveClockConfig(rawConfig);
+    if (!clockConfig) {
+        return request;
+    }
+    try {
+        await startClockDaemonIfNeeded(clockConfig);
+    }
+    catch {
+        // best-effort
+    }
+    const sessionId = resolveSessionIdForClock(metadata, request);
+    const messages = Array.isArray(request.messages) ? request.messages : [];
+    // 1) Apply <**clock:clear**> and <**clock:{...}**> marker extraction (latest user message only).
+    const { hadClear, clockScheduleDirectives, baseMessages } = extractClockReminderDirectives(messages);
+    if (hadClear) {
+        if (sessionId) {
+            try {
+                await clearClockSession(sessionId);
+                logClock('cleared', { sessionId });
+            }
+            catch {
+                // best-effort: user directive should not crash request
+            }
+        }
+        // Continue: still inject per-request time tag (but skip due reminders).
+    }
+    // 2) Apply private schedule directives: <**clock:{time,message}**>
+    // Convert to actual clock scheduling and append synthetic tool_call/tool_result messages
+    // so downstream model sees canonical tool semantics.
+    const markerToolMessages = await scheduleClockReminderDirectiveMessages({
+        clockScheduleDirectives,
+        sessionId,
+        requestId,
+        clockConfig
+    });
+    // 3) Inject due reminders as a user message + attach reservation for response-side commit.
+    const { reservation, dueInjectText } = await reserveClockDueReminderForRequest({
+        hadClear,
+        sessionId,
+        requestId,
+        clockConfig
+    });
+    const dueUserMessage = buildDueReminderUserMessage(reservation, dueInjectText);
+    // 4) When we have due tasks, ensure a standard tool set is present (best-effort).
+    let nextRequest = request;
+    if (dueUserMessage) {
+        const ensureToolsOps = buildClockStandardToolsOperations();
+        nextRequest = applyHubOperations(nextRequest, ensureToolsOps);
+    }
+    // 5) Per-request time injection (user time tag or paired clock.get tool result).
+    const timeTagLine = await resolveClockReminderTimeTagLine();
+    const withReservationMetadata = buildClockReminderMetadata({
+        nextRequest,
+        metadata,
+        dueUserMessage,
+        reservation
+    });
+    // Always inject time via user-role content to keep the tag visible without adding
+    // extra tool-call semantics that may distract the model.
+    //
+    // IMPORTANT: do not append an extra trailing user message, otherwise the Virtual Router
+    // sees `latestMessageFromUser=true` and will force "thinking:user-input" even during
+    // tool followups (last message role=tool), which breaks `coding/search/tools` routing.
+    const timeInjectedMessages = buildClockReminderMessages({
+        baseMessages,
+        markerToolMessages,
+        dueUserMessage,
+        timeTagLine
+    });
+    return {
+        ...nextRequest,
+        messages: timeInjectedMessages,
+        metadata: withReservationMetadata
+    };
+}

package/dist/conversion/hub/process/chat-process-clock-tool-schemas.d.ts

@@ -0,0 +1,3 @@
+import type { HubOperation } from '../ops/operations.js';
+export declare function buildClockToolAppendOperations(hasSessionId: boolean): HubOperation[];
+export declare function buildClockStandardToolAppendOperations(): HubOperation[];

package/dist/conversion/hub/process/chat-process-clock-tool-schemas.js

@@ -0,0 +1,233 @@
+import { buildClockStandardToolAppendOperationsWithNative, buildClockToolAppendOperationsWithNative } from '../../../router/virtual-router/engine-selection/native-chat-process-clock-tool-schema-semantics.js';
+const CLOCK_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. If waiting longer than 2 minutes is required, use action="schedule" immediately.'
+        },
+        items: {
+            type: 'array',
+            description: 'For schedule/update: list of reminder payloads. update uses items[0] as patch source.',
+            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 that states the exact action to execute on wake-up (no vague placeholders).'
+                    },
+                    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.'
+                    }
+                },
+                required: ['dueAt', 'task', 'tool', 'arguments'],
+                additionalProperties: false
+            }
+        },
+        taskId: {
+            type: 'string',
+            description: 'For cancel/update: target taskId.'
+        }
+    },
+    required: ['action', 'items', 'taskId'],
+    additionalProperties: false
+};
+const CLOCK_TOOL = {
+    type: 'function',
+    function: {
+        name: 'clock',
+        description: 'Time + Alarm for this session. If waiting longer than 2 minutes is required, MUST call clock.schedule now (never promise to wait without scheduling). Format example: {"action":"schedule","items":[{"dueAt":"<ISO8601>","task":"<exact follow-up action>","tool":"<tool-name-or-empty>","arguments":"<json-string-or-{}>"}],"taskId":""}. Use get/schedule/update/list/cancel/clear. Scheduled reminders are injected into future requests.',
+        parameters: CLOCK_PARAMETERS,
+        strict: true
+    }
+};
+const CLOCK_STANDARD_TOOLS = [
+    {
+        type: 'function',
+        function: {
+            name: 'clock',
+            description: 'Time + Alarm for this session. If waiting longer than 2 minutes is required, call clock.schedule now. Format example: {"action":"schedule","items":[{"dueAt":"<ISO8601>","task":"<exact follow-up action>","tool":"<tool-name-or-empty>","arguments":"<json-string-or-{}>"}],"taskId":""}. Use schedule/update/list/cancel/clear.',
+            parameters: {
+                type: 'object',
+                properties: {
+                    action: {
+                        type: 'string',
+                        enum: ['get', 'schedule', 'update', 'list', 'cancel', 'clear']
+                    },
+                    items: {
+                        type: 'array',
+                        items: {
+                            type: 'object',
+                            properties: {
+                                dueAt: { type: 'string' },
+                                task: { type: 'string' },
+                                tool: { type: 'string' },
+                                arguments: { type: 'string' }
+                            },
+                            required: ['dueAt', 'task', 'tool', 'arguments'],
+                            additionalProperties: false
+                        }
+                    },
+                    taskId: { type: 'string' }
+                },
+                required: ['action', 'items', 'taskId'],
+                additionalProperties: false
+            }
+        }
+    },
+    {
+        type: 'function',
+        function: {
+            name: 'shell',
+            description: 'Runs a shell command and returns its output.',
+            parameters: {
+                type: 'object',
+                properties: {
+                    command: { oneOf: [{ type: 'string' }, { type: 'array', items: { type: 'string' } }] },
+                    workdir: { type: 'string' }
+                },
+                required: ['command'],
+                additionalProperties: false
+            }
+        }
+    },
+    {
+        type: 'function',
+        function: {
+            name: 'exec_command',
+            description: 'Execute a command in a PTY and return output.',
+            parameters: {
+                type: 'object',
+                properties: {
+                    cmd: { type: 'string' },
+                    workdir: { type: 'string' },
+                    timeout_ms: { type: 'number' },
+                    max_output_tokens: { type: 'number' },
+                    yield_time_ms: { type: 'number' }
+                },
+                required: ['cmd'],
+                additionalProperties: false
+            }
+        }
+    },
+    {
+        type: 'function',
+        function: {
+            name: 'apply_patch',
+            description: 'Apply a patch to repository files.',
+            parameters: {
+                type: 'object',
+                properties: {
+                    patch: { type: 'string' }
+                },
+                required: ['patch'],
+                additionalProperties: false
+            }
+        }
+    },
+    {
+        type: 'function',
+        function: {
+            name: 'update_plan',
+            description: 'Update the task plan.',
+            parameters: {
+                type: 'object',
+                properties: {
+                    explanation: { type: 'string' },
+                    plan: {
+                        type: 'array',
+                        items: {
+                            type: 'object',
+                            properties: {
+                                step: { type: 'string' },
+                                status: { type: 'string' }
+                            },
+                            required: ['step', 'status'],
+                            additionalProperties: false
+                        }
+                    }
+                },
+                required: ['plan'],
+                additionalProperties: false
+            }
+        }
+    },
+    {
+        type: 'function',
+        function: {
+            name: 'view_image',
+            description: 'View a local image by file path.',
+            parameters: {
+                type: 'object',
+                properties: {
+                    path: { type: 'string' }
+                },
+                required: ['path'],
+                additionalProperties: false
+            }
+        }
+    },
+    {
+        type: 'function',
+        function: {
+            name: 'list_mcp_resources',
+            description: 'List resources exposed by MCP servers.',
+            parameters: {
+                type: 'object',
+                properties: {
+                    server: { type: 'string' },
+                    filter: { type: 'string' },
+                    root: { type: 'string' }
+                },
+                additionalProperties: false
+            }
+        }
+    },
+    {
+        type: 'function',
+        function: {
+            name: 'list_mcp_resource_templates',
+            description: 'List resource templates exposed by MCP servers.',
+            parameters: {
+                type: 'object',
+                properties: {
+                    server: { type: 'string' },
+                    cursor: { type: 'string' }
+                },
+                additionalProperties: false
+            }
+        }
+    },
+    {
+        type: 'function',
+        function: {
+            name: 'read_mcp_resource',
+            description: 'Read a specific MCP resource by { server, uri }.',
+            parameters: {
+                type: 'object',
+                properties: {
+                    server: { type: 'string' },
+                    uri: { type: 'string' }
+                },
+                required: ['server', 'uri'],
+                additionalProperties: false
+            }
+        }
+    }
+];
+export function buildClockToolAppendOperations(hasSessionId) {
+    return buildClockToolAppendOperationsWithNative(hasSessionId, CLOCK_TOOL);
+}
+export function buildClockStandardToolAppendOperations() {
+    return buildClockStandardToolAppendOperationsWithNative(CLOCK_STANDARD_TOOLS);
+}

package/dist/conversion/hub/process/chat-process-clock-tools.d.ts

@@ -0,0 +1,6 @@
+import type { HubOperation } from '../ops/operations.js';
+export declare function buildClockOperations(metadata: Record<string, unknown>): HubOperation[];
+export declare function buildClockOperationsWithPlan(metadata: Record<string, unknown>, precomputedPlan?: {
+    shouldInject: boolean;
+}): HubOperation[];
+export declare function buildClockStandardToolsOperations(): HubOperation[];

package/dist/conversion/hub/process/chat-process-clock-tools.js

@@ -0,0 +1,41 @@
+import { readRuntimeMetadata } from '../../runtime-metadata.js';
+import { logClock } from '../../../servertool/clock/log.js';
+import { buildClockStandardToolAppendOperations, buildClockToolAppendOperations } from './chat-process-clock-tool-schemas.js';
+import { planChatClockOperationsWithNative } from '../../../router/virtual-router/engine-selection/native-chat-process-servertool-orchestration-semantics.js';
+import { isClientInjectReady } from './client-inject-readiness.js';
+function readString(value) {
+    return typeof value === 'string' && value.trim() ? value.trim() : undefined;
+}
+export function buildClockOperations(metadata) {
+    if (!isClientInjectReady(metadata)) {
+        return [];
+    }
+    const rt = (readRuntimeMetadata(metadata) ?? {});
+    const rawConfig = rt?.clock;
+    const plan = planChatClockOperationsWithNative(rt);
+    if (!plan.shouldInject) {
+        return [];
+    }
+    const sessionId = readString(metadata.sessionId);
+    const hasSessionId = Boolean(sessionId && sessionId.trim());
+    logClock('inject_schema', { hasSessionId });
+    return buildClockToolAppendOperations(hasSessionId);
+}
+export function buildClockOperationsWithPlan(metadata, precomputedPlan) {
+    if (!isClientInjectReady(metadata)) {
+        return [];
+    }
+    if (!precomputedPlan) {
+        return buildClockOperations(metadata);
+    }
+    if (!precomputedPlan.shouldInject) {
+        return [];
+    }
+    const sessionId = readString(metadata.sessionId);
+    const hasSessionId = Boolean(sessionId && sessionId.trim());
+    logClock('inject_schema', { hasSessionId });
+    return buildClockToolAppendOperations(hasSessionId);
+}
+export function buildClockStandardToolsOperations() {
+    return buildClockStandardToolAppendOperations();
+}

package/dist/conversion/hub/process/chat-process-continue-execution.d.ts

@@ -0,0 +1,11 @@
+import { type NativeContinueExecutionPlan } from '../../../router/virtual-router/engine-selection/native-chat-process-servertool-orchestration-semantics.js';
+import type { HubOperation } from '../ops/operations.js';
+import type { StandardizedRequest } from '../types/standardized.js';
+type ContinueExecutionBuildOptions = {
+    hasActiveStopMessage?: boolean;
+    precomputedPlan?: NativeContinueExecutionPlan;
+};
+export declare function buildContinueExecutionOperations(metadata: Record<string, unknown>, options?: ContinueExecutionBuildOptions): HubOperation[];
+export declare function injectContinueExecutionDirectiveIntoUserMessage(request: StandardizedRequest, metadata: Record<string, unknown>): StandardizedRequest;
+export declare function resolveHasActiveStopMessageForContinueExecution(metadata: Record<string, unknown>): boolean;
+export {};

package/dist/conversion/hub/process/chat-process-continue-execution.js

@@ -0,0 +1,82 @@
+import { readRuntimeMetadata } from '../../runtime-metadata.js';
+import { loadRoutingInstructionStateSync } from '../../../router/virtual-router/sticky-session-store.js';
+import { logContinueExecution } from '../../../servertool/continue-execution/log.js';
+import { buildContinueExecutionOperationsWithNative, injectContinueExecutionDirectiveWithNative, planContinueExecutionOperationsWithNative, resolveHasActiveStopMessageForContinueExecutionWithNative, resolveStopMessageSessionScopeWithNative } from '../../../router/virtual-router/engine-selection/native-chat-process-servertool-orchestration-semantics.js';
+import { isClientInjectReady } from './client-inject-readiness.js';
+const CONTINUE_EXECUTION_INJECTION_MARKER = '[routecodex:continue_execution_injection]';
+const CONTINUE_EXECUTION_INJECTION_TEXT = '继续执行';
+export function buildContinueExecutionOperations(metadata, options) {
+    const rt = (readRuntimeMetadata(metadata) ?? {});
+    const sessionId = readString(metadata.sessionId);
+    const hasSessionId = Boolean(sessionId && sessionId.trim());
+    if (!isClientInjectReady(metadata)) {
+        logContinueExecution('skip_schema_due_client_inject_unready', { hasSessionId });
+        return [];
+    }
+    const hasActiveStopMessage = options && typeof options.hasActiveStopMessage === 'boolean'
+        ? options.hasActiveStopMessage
+        : hasActiveStopMessageStateForContinueExecution(metadata);
+    const plan = options?.precomputedPlan ??
+        planContinueExecutionOperationsWithNative(rt, hasActiveStopMessage);
+    const operations = buildContinueExecutionOperationsWithNative(Boolean(plan.shouldInject));
+    if (operations.length === 0) {
+        if (hasActiveStopMessage) {
+            logContinueExecution('skip_schema_due_stopmessage', { hasSessionId });
+        }
+        return [];
+    }
+    logContinueExecution('inject_schema', { hasSessionId });
+    return operations;
+}
+export function injectContinueExecutionDirectiveIntoUserMessage(request, metadata) {
+    const rt = (readRuntimeMetadata(metadata) ?? {});
+    if (!isClientInjectReady(metadata)) {
+        return request;
+    }
+    if (rt?.serverToolFollowup === true) {
+        return request;
+    }
+    if (hasActiveStopMessageStateForContinueExecution(metadata)) {
+        const sessionId = readString(metadata.sessionId);
+        const hasSessionId = Boolean(sessionId && sessionId.trim());
+        logContinueExecution('skip_user_directive_due_stopmessage', { hasSessionId });
+        return request;
+    }
+    const messages = Array.isArray(request.messages) ? request.messages : [];
+    if (messages.length === 0) {
+        return request;
+    }
+    const injected = injectContinueExecutionDirectiveWithNative(messages, CONTINUE_EXECUTION_INJECTION_MARKER, CONTINUE_EXECUTION_INJECTION_TEXT);
+    if (!injected.changed) {
+        return request;
+    }
+    const sessionId = readString(metadata.sessionId);
+    const hasSessionId = Boolean(sessionId && sessionId.trim());
+    logContinueExecution('inject_user_directive', { hasSessionId });
+    return {
+        ...request,
+        messages: injected.messages
+    };
+}
+function hasActiveStopMessageStateForContinueExecution(metadata) {
+    const rt = (readRuntimeMetadata(metadata) ?? {});
+    const runtimeState = rt?.stopMessageState;
+    const persistedState = resolvePersistedStopMessageState(metadata);
+    return resolveHasActiveStopMessageForContinueExecutionWithNative(runtimeState, persistedState);
+}
+export function resolveHasActiveStopMessageForContinueExecution(metadata) {
+    return hasActiveStopMessageStateForContinueExecution(metadata);
+}
+function resolvePersistedStopMessageState(metadata) {
+    const sessionScope = resolveStopMessageSessionScope(metadata);
+    if (!sessionScope) {
+        return undefined;
+    }
+    return loadRoutingInstructionStateSync(sessionScope);
+}
+function resolveStopMessageSessionScope(metadata) {
+    return resolveStopMessageSessionScopeWithNative(metadata);
+}
+function readString(value) {
+    return typeof value === 'string' ? value : undefined;
+}

package/dist/conversion/hub/process/chat-process-governance-context.d.ts

@@ -0,0 +1,15 @@
+import type { StandardizedRequest } from '../types/standardized.js';
+interface GovernanceContextSource {
+    entryEndpoint: string;
+    metadata: Record<string, unknown>;
+}
+export interface ResolvedGovernanceContext {
+    entryEndpoint: string;
+    metadata: Record<string, unknown>;
+    providerProtocol: string;
+    metadataToolHints: unknown;
+    inboundStreamIntent: boolean;
+    rawRequestBody?: Record<string, unknown>;
+}
+export declare function resolveGovernanceContext(request: StandardizedRequest, context: GovernanceContextSource): ResolvedGovernanceContext;
+export {};

package/dist/conversion/hub/process/chat-process-governance-context.js

@@ -0,0 +1,7 @@
+import { resolveGovernanceContextWithNative } from '../../../router/virtual-router/engine-selection/native-chat-process-governance-semantics.js';
+export function resolveGovernanceContext(request, context) {
+    const nativeResolved = resolveGovernanceContextWithNative(request, context);
+    return {
+        ...nativeResolved
+    };
+}

package/dist/conversion/hub/process/chat-process-governance-finalize.d.ts

@@ -0,0 +1,16 @@
+import type { StandardizedRequest } from '../types/standardized.js';
+export interface ToolGovernanceLike {
+    governRequest(request: StandardizedRequest, providerProtocol: string): {
+        request: StandardizedRequest;
+        summary: {
+            applied?: boolean;
+        };
+    };
+}
+interface GovernanceFinalizeOptions {
+    request: StandardizedRequest;
+    providerProtocol: string;
+    governanceEngine: ToolGovernanceLike;
+}
+export declare function finalizeGovernedRequest(options: GovernanceFinalizeOptions): StandardizedRequest;
+export {};

package/dist/conversion/hub/process/chat-process-governance-finalize.js

@@ -0,0 +1,11 @@
+import { finalizeGovernedRequestWithNative } from '../../../router/virtual-router/engine-selection/native-chat-process-governance-semantics.js';
+export function finalizeGovernedRequest(options) {
+    const { request, providerProtocol, governanceEngine } = options;
+    const { request: sanitized, summary } = governanceEngine.governRequest(request, providerProtocol);
+    if (summary.applied !== true) {
+        return sanitized;
+    }
+    const finalized = finalizeGovernedRequestWithNative(sanitized, summary);
+    sanitized.metadata = finalized.metadata;
+    return sanitized;
+}

package/dist/conversion/hub/process/chat-process-governance-orchestration.d.ts

@@ -0,0 +1,9 @@
+import type { StandardizedRequest } from '../types/standardized.js';
+import type { ToolGovernanceLike } from './chat-process-governance-finalize.js';
+export interface GovernanceContext {
+    entryEndpoint: string;
+    requestId: string;
+    metadata: Record<string, unknown>;
+    rawPayload?: Record<string, unknown>;
+}
+export declare function applyRequestToolGovernance(request: StandardizedRequest, context: GovernanceContext, governanceEngine?: ToolGovernanceLike): Promise<StandardizedRequest>;

package/dist/conversion/hub/process/chat-process-governance-orchestration.js

@@ -0,0 +1,47 @@
+import { applyReqProcessToolGovernanceWithNative } from '../../../router/virtual-router/engine-selection/native-hub-pipeline-req-process-semantics.js';
+import { maybeInjectClockRemindersAndApplyDirectives } from './chat-process-clock-reminders.js';
+import { finalizeGovernedRequest } from './chat-process-governance-finalize.js';
+function isRecord(value) {
+    return !!value && typeof value === 'object' && !Array.isArray(value);
+}
+function parseGovernedRequest(value) {
+    const row = value;
+    if (!Array.isArray(row.messages)) {
+        throw new Error('native chat governance returned malformed request envelope');
+    }
+    const normalized = {
+        ...row,
+        parameters: isRecord(row.parameters) ? row.parameters : {},
+        metadata: isRecord(row.metadata) ? row.metadata : {}
+    };
+    return normalized;
+}
+function resolveProviderProtocol(context) {
+    const metadataProtocol = context.metadata.providerProtocol;
+    if (typeof metadataProtocol === 'string' && metadataProtocol) {
+        return metadataProtocol;
+    }
+    return context.entryEndpoint === '/v1/messages' ? 'anthropic-chat' : 'openai-chat';
+}
+export async function applyRequestToolGovernance(request, context, governanceEngine) {
+    if (!isRecord(request) || !Array.isArray(request.messages)) {
+        throw new Error('chat governance input request is invalid');
+    }
+    const nativeResult = applyReqProcessToolGovernanceWithNative({
+        request: request,
+        rawPayload: context.rawPayload ?? request,
+        metadata: context.metadata,
+        entryEndpoint: context.entryEndpoint,
+        requestId: context.requestId
+    });
+    const governedRequest = parseGovernedRequest(nativeResult.processedRequest);
+    const requestAfterInject = await maybeInjectClockRemindersAndApplyDirectives(governedRequest, context.metadata, context.requestId);
+    if (!governanceEngine) {
+        return requestAfterInject;
+    }
+    return finalizeGovernedRequest({
+        request: requestAfterInject,
+        providerProtocol: resolveProviderProtocol(context),
+        governanceEngine
+    });
+}

package/dist/conversion/hub/process/chat-process-governed-control-ops.d.ts

@@ -0,0 +1,8 @@
+import type { StandardizedRequest } from '../types/standardized.js';
+interface GovernedControlOpsOptions {
+    request: StandardizedRequest;
+    governed: Record<string, unknown>;
+    inboundStreamIntent: boolean;
+}
+export declare function applyGovernedControlOperations(options: GovernedControlOpsOptions): StandardizedRequest;
+export {};

package/dist/conversion/hub/process/chat-process-governed-control-ops.js

@@ -0,0 +1,5 @@
+import { applyGovernedControlOperationsWithNative } from '../../../router/virtual-router/engine-selection/native-chat-process-governance-semantics.js';
+export function applyGovernedControlOperations(options) {
+    const { request, governed, inboundStreamIntent } = options;
+    return applyGovernedControlOperationsWithNative(request, governed, inboundStreamIntent);
+}

package/dist/conversion/hub/process/chat-process-governed-filter-call.d.ts

@@ -0,0 +1,12 @@
+import type { StandardizedRequest } from '../types/standardized.js';
+interface GovernedFilterCallOptions {
+    request: StandardizedRequest;
+    entryEndpoint: string;
+    requestId: string;
+    providerProtocol: string;
+    inboundStreamIntent: boolean;
+    metadataToolHints: unknown;
+    rawRequestBody?: Record<string, unknown>;
+}
+export declare function runGovernedChatRequestFilters(options: GovernedFilterCallOptions): Promise<Record<string, unknown>>;
+export {};

package/dist/conversion/hub/process/chat-process-governed-filter-call.js

@@ -0,0 +1,18 @@
+import { runChatRequestToolFilters } from '../../shared/tool-filter-pipeline.js';
+import { buildGovernedFilterPayloadWithNative } from '../../../router/virtual-router/engine-selection/native-chat-process-governed-filter-semantics.js';
+export async function runGovernedChatRequestFilters(options) {
+    const { request } = options;
+    const shaped = buildGovernedFilterPayloadWithNative(request);
+    const governedPayload = await runChatRequestToolFilters(shaped, {
+        entryEndpoint: options.entryEndpoint,
+        requestId: options.requestId,
+        model: request.model,
+        profile: options.providerProtocol,
+        stream: options.inboundStreamIntent,
+        toolFilterHints: options.metadataToolHints,
+        rawPayload: options.rawRequestBody && typeof options.rawRequestBody === 'object'
+            ? options.rawRequestBody
+            : undefined
+    });
+    return governedPayload;
+}

package/dist/conversion/hub/process/chat-process-governed-merge.d.ts

@@ -0,0 +1,8 @@
+import type { StandardizedRequest } from '../types/standardized.js';
+interface GovernedMergeOptions {
+    request: StandardizedRequest;
+    governed: Record<string, unknown>;
+    inboundStreamIntent: boolean;
+}
+export declare function buildGovernedMergedRequest(options: GovernedMergeOptions): StandardizedRequest;
+export {};