@jsonstudio/rcc 0.90.352 → 0.90.367

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

@@ -0,0 +1,280 @@
+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. 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 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.'
+                    },
+                    recurrence: {
+                        type: 'object',
+                        description: 'Optional recurrence. Omit recurrence for a one-time reminder. For finite interval loops use {"kind":"interval","everyMinutes":30,"maxRuns":10}. For infinite loops use {"kind":"interval","everyMinutes":30,"infinite":true}. quietHours is optional and uses local-time windows such as [{"start":"00:00","end":"07:00"}] to skip sub-daily cycles.',
+                        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: target taskId.'
+        }
+    },
+    required: ['action', 'items', 'taskId'],
+    additionalProperties: false
+};
+const CLOCK_TOOL = {
+    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, MUST call clock.schedule now (never promise to wait without scheduling). 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: one-time schedule item without recurrence; finite interval loop recurrence={"kind":"interval","everyMinutes":30,"maxRuns":10}; infinite interval loop recurrence={"kind":"interval","everyMinutes":30,"infinite":true,"quietHours":[{"start":"00:00","end":"07:00"}]}. 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. 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. 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 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' },
+                                recurrence: {
+                                    type: 'object',
+                                    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' }
+                },
+                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/vendor/llmswitch-core/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/vendor/llmswitch-core/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/vendor/llmswitch-core/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/vendor/llmswitch-core/dist/conversion/hub/process/chat-process-continue-execution.js

@@ -0,0 +1,83 @@
+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, isStopMessageStateActiveWithNative, 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) {
+    if (!isClientInjectReady(metadata)) {
+        return false;
+    }
+    const persistedState = resolvePersistedStopMessageState(metadata);
+    return isStopMessageStateActiveWithNative(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/vendor/llmswitch-core/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/vendor/llmswitch-core/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/vendor/llmswitch-core/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/vendor/llmswitch-core/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/vendor/llmswitch-core/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/vendor/llmswitch-core/dist/conversion/hub/process/chat-process-governance-orchestration.js

@@ -0,0 +1,49 @@
+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';
+import { resolveHasActiveStopMessageForContinueExecution } from './chat-process-continue-execution.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,
+        hasActiveStopMessageForContinueExecution: resolveHasActiveStopMessageForContinueExecution(context.metadata)
+    });
+    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/vendor/llmswitch-core/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/vendor/llmswitch-core/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/vendor/llmswitch-core/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/vendor/llmswitch-core/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/vendor/llmswitch-core/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 {};

package/vendor/llmswitch-core/dist/conversion/hub/process/chat-process-governed-merge.js

@@ -0,0 +1,11 @@
+import { castGovernedTools } from './chat-process-tool-normalization.js';
+import { applyGovernedMergeRequestWithNative } from '../../../router/virtual-router/engine-selection/native-chat-process-governance-semantics.js';
+export function buildGovernedMergedRequest(options) {
+    const { request, governed, inboundStreamIntent } = options;
+    const governanceTimestamp = Date.now();
+    const mergedBase = applyGovernedMergeRequestWithNative(request, governed, inboundStreamIntent, governanceTimestamp);
+    return {
+        ...mergedBase,
+        tools: governed.tools !== undefined ? castGovernedTools(governed.tools) : request.tools
+    };
+}

package/vendor/llmswitch-core/dist/conversion/hub/process/chat-process-media.d.ts

@@ -0,0 +1,5 @@
+import type { StandardizedMessage } from "../types/standardized.js";
+export declare function stripHistoricalImageAttachments(messages: StandardizedMessage[]): StandardizedMessage[];
+export declare function stripHistoricalVisualToolOutputs(messages: StandardizedMessage[]): StandardizedMessage[];
+export declare function containsImageAttachment(messages: StandardizedMessage[]): boolean;
+export declare function repairIncompleteToolCalls(messages: StandardizedMessage[]): StandardizedMessage[];