@jsonstudio/rcc 0.90.323 → 0.90.364

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

@@ -0,0 +1,108 @@
+import { analyzeChatProcessMedia, stripChatProcessHistoricalImages, } from "../../../router/virtual-router/engine-selection/native-router-hotpath.js";
+export function stripHistoricalImageAttachments(messages) {
+    if (!Array.isArray(messages) || !messages.length) {
+        return messages;
+    }
+    const placeholderText = "[Image omitted]";
+    const stripped = stripChatProcessHistoricalImages(messages, placeholderText);
+    if (stripped.changed !== true || !Array.isArray(stripped.messages)) {
+        return messages;
+    }
+    return stripped.messages;
+}
+const INLINE_MEDIA_DATA_RE = /data:(image|video)\/[a-z0-9.+-]+;base64,[a-z0-9+/=\s]+/i;
+function isVisualToolMessage(message) {
+    if (!message || typeof message !== "object") {
+        return false;
+    }
+    if (message.role !== "tool") {
+        return false;
+    }
+    const name = typeof message.name === "string" ? message.name.trim().toLowerCase() : "";
+    if (name === "view_image") {
+        return true;
+    }
+    const content = typeof message.content === "string" ? message.content : "";
+    return INLINE_MEDIA_DATA_RE.test(content);
+}
+export function stripHistoricalVisualToolOutputs(messages) {
+    if (!Array.isArray(messages) || messages.length === 0) {
+        return messages;
+    }
+    let changed = false;
+    const next = messages.map((message) => {
+        if (!isVisualToolMessage(message)) {
+            return message;
+        }
+        const content = typeof message.content === "string" ? message.content : "";
+        if (!INLINE_MEDIA_DATA_RE.test(content)) {
+            return message;
+        }
+        changed = true;
+        return {
+            ...message,
+            content: "[Image omitted]",
+        };
+    });
+    return changed ? next : messages;
+}
+export function containsImageAttachment(messages) {
+    if (!Array.isArray(messages) || !messages.length) {
+        return false;
+    }
+    return analyzeChatProcessMedia(messages).containsCurrentTurnImage === true;
+}
+export function repairIncompleteToolCalls(messages) {
+    if (!Array.isArray(messages) || messages.length === 0) {
+        return messages;
+    }
+    const toolCallIdsWithResponse = new Set();
+    for (let i = messages.length - 1; i >= 0; i--) {
+        const msg = messages[i];
+        if (msg?.role === "tool" && typeof msg.tool_call_id === "string") {
+            toolCallIdsWithResponse.add(msg.tool_call_id);
+        }
+    }
+    const result = [];
+    let changed = false;
+    for (const msg of messages) {
+        if (msg?.role === "assistant" && Array.isArray(msg.tool_calls)) {
+            const completeToolCalls = [];
+            const missingToolCallIds = [];
+            for (const tc of msg.tool_calls) {
+                const tcId = typeof tc?.id === "string" ? tc.id : "";
+                if (tcId && toolCallIdsWithResponse.has(tcId)) {
+                    completeToolCalls.push(tc);
+                }
+                else if (tcId) {
+                    missingToolCallIds.push(tcId);
+                }
+            }
+            if (missingToolCallIds.length > 0) {
+                changed = true;
+                const repaired = {
+                    ...msg,
+                    tool_calls: completeToolCalls.length > 0 ? completeToolCalls : undefined,
+                };
+                if (!repaired.tool_calls) {
+                    delete repaired.tool_calls;
+                }
+                result.push(repaired);
+                for (const missingId of missingToolCallIds) {
+                    result.push({
+                        role: "tool",
+                        tool_call_id: missingId,
+                        content: '{"status":"tool_call_repaired_orphaned_tool_call"}',
+                    });
+                }
+            }
+            else {
+                result.push(msg);
+            }
+        }
+        else {
+            result.push(msg);
+        }
+    }
+    return changed ? result : messages;
+}

package/vendor/@jsonstudio/llms/dist/conversion/hub/process/chat-process-node-result.d.ts

@@ -0,0 +1,23 @@
+import type { ProcessedRequest, StandardizedRequest } from '../types/standardized.js';
+import type { JsonObject } from '../types/json.js';
+export interface HubProcessNodeResult {
+    success: boolean;
+    metadata: {
+        node: string;
+        executionTime: number;
+        startTime: number;
+        endTime: number;
+        dataProcessed?: {
+            messages: number;
+            tools: number;
+        };
+    };
+    error?: {
+        code?: string;
+        message: string;
+        details?: JsonObject;
+    };
+}
+export declare function buildProcessedRequest(request: StandardizedRequest): ProcessedRequest;
+export declare function buildSuccessResult(startTime: number, processedRequest: ProcessedRequest): HubProcessNodeResult;
+export declare function buildErrorResult(startTime: number, error: unknown): HubProcessNodeResult;

package/vendor/@jsonstudio/llms/dist/conversion/hub/process/chat-process-node-result.js

@@ -0,0 +1,24 @@
+import { applyChatProcessedRequestWithNative, buildChatNodeResultMetadataWithNative } from '../../../router/virtual-router/engine-selection/native-chat-process-node-result-semantics.js';
+export function buildProcessedRequest(request) {
+    const timestamp = Date.now();
+    return applyChatProcessedRequestWithNative(request, timestamp);
+}
+export function buildSuccessResult(startTime, processedRequest) {
+    const endTime = Date.now();
+    const metadata = buildChatNodeResultMetadataWithNative(startTime, endTime, processedRequest.messages.length, processedRequest.tools?.length ?? 0, true);
+    return {
+        success: true,
+        metadata: metadata
+    };
+}
+export function buildErrorResult(startTime, error) {
+    const endTime = Date.now();
+    const metadata = buildChatNodeResultMetadataWithNative(startTime, endTime, 0, 0, false);
+    return {
+        success: false,
+        metadata: metadata,
+        error: {
+            message: error instanceof Error ? error.message : String(error)
+        }
+    };
+}

package/vendor/@jsonstudio/llms/dist/conversion/hub/process/chat-process-pending-tool-sync.d.ts

@@ -0,0 +1,14 @@
+import type { StandardizedMessage, StandardizedRequest } from '../types/standardized.js';
+type PendingToolSyncDeps = {
+    loadPendingServerToolInjectionFn?: (sessionId: string) => Promise<{
+        afterToolCallIds?: unknown;
+        messages?: unknown;
+    } | null>;
+    clearPendingServerToolInjectionFn?: (sessionId: string) => Promise<void>;
+    analyzePendingToolSyncFn?: (messages: StandardizedMessage[], afterToolCallIds: string[]) => {
+        ready: boolean;
+        insertAt: number;
+    };
+};
+export declare function maybeInjectPendingServerToolResultsAfterClientTools(request: StandardizedRequest, metadata: Record<string, unknown>, deps?: PendingToolSyncDeps): Promise<StandardizedRequest>;
+export {};

package/vendor/@jsonstudio/llms/dist/conversion/hub/process/chat-process-pending-tool-sync.js

@@ -0,0 +1,52 @@
+import { clearPendingServerToolInjection, loadPendingServerToolInjection } from '../../../servertool/pending-session.js';
+import { analyzePendingToolSync } from '../../../router/virtual-router/engine-selection/native-router-hotpath.js';
+function readString(value) {
+    return typeof value === 'string' ? value : undefined;
+}
+function resolveSessionIdForPending(metadata, request) {
+    const candidate = readString(metadata.sessionId) ?? readString(request.metadata?.sessionId);
+    return candidate && candidate.trim() ? candidate.trim() : null;
+}
+export async function maybeInjectPendingServerToolResultsAfterClientTools(request, metadata, deps = {}) {
+    const loadFn = deps.loadPendingServerToolInjectionFn ?? loadPendingServerToolInjection;
+    const clearFn = deps.clearPendingServerToolInjectionFn ?? clearPendingServerToolInjection;
+    const analyzeFn = deps.analyzePendingToolSyncFn ?? analyzePendingToolSync;
+    const sessionId = resolveSessionIdForPending(metadata, request);
+    if (!sessionId) {
+        return request;
+    }
+    const pending = await loadFn(sessionId);
+    if (!pending) {
+        return request;
+    }
+    const afterIds = Array.isArray(pending.afterToolCallIds)
+        ? pending.afterToolCallIds
+            .filter((id) => typeof id === 'string')
+            .map((id) => id.trim())
+            .filter((id) => id.length > 0)
+        : [];
+    if (!afterIds.length) {
+        return request;
+    }
+    const messages = Array.isArray(request.messages) ? request.messages : [];
+    const analysis = analyzeFn(messages, afterIds);
+    if (!analysis.ready) {
+        return request;
+    }
+    if (analysis.insertAt < 0) {
+        return request;
+    }
+    const inject = Array.isArray(pending.messages) ? pending.messages : [];
+    if (!inject.length) {
+        return request;
+    }
+    const nextMessages = messages.slice();
+    nextMessages.splice(analysis.insertAt + 1, 0, ...inject);
+    try {
+        await clearFn(sessionId);
+    }
+    catch {
+        // best-effort
+    }
+    return { ...request, messages: nextMessages };
+}

package/vendor/@jsonstudio/llms/dist/conversion/hub/process/chat-process-post-governed-normalization.d.ts

@@ -0,0 +1,8 @@
+import type { StandardizedRequest } from '../types/standardized.js';
+interface PostGovernedNormalizationOptions {
+    request: StandardizedRequest;
+    metadata: Record<string, unknown>;
+    originalEndpoint?: string;
+}
+export declare function applyPostGovernedNormalization(options: PostGovernedNormalizationOptions): Promise<StandardizedRequest>;
+export {};

package/vendor/@jsonstudio/llms/dist/conversion/hub/process/chat-process-post-governed-normalization.js

@@ -0,0 +1,16 @@
+import { normalizeApplyPatchToolCallsOnRequest } from '../../shared/tool-governor.js';
+import { containsImageAttachment, stripHistoricalImageAttachments } from './chat-process-media.js';
+import { maybeInjectPendingServerToolResultsAfterClientTools } from './chat-process-pending-tool-sync.js';
+import { buildImageAttachmentMetadataWithNative } from '../../../router/virtual-router/engine-selection/native-chat-process-post-governed-normalization-semantics.js';
+export async function applyPostGovernedNormalization(options) {
+    let request = {
+        ...options.request,
+        messages: stripHistoricalImageAttachments(options.request.messages)
+    };
+    request = normalizeApplyPatchToolCallsOnRequest(request);
+    request = await maybeInjectPendingServerToolResultsAfterClientTools(request, options.metadata);
+    if (containsImageAttachment(request.messages)) {
+        request.metadata = buildImageAttachmentMetadataWithNative(request.metadata, options.originalEndpoint ?? '/v1/chat/completions');
+    }
+    return request;
+}

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

@@ -0,0 +1,2 @@
+import type { HubOperation } from '../ops/operations.js';
+export declare function buildReviewOperations(metadata: Record<string, unknown>): HubOperation[];

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

@@ -0,0 +1,8 @@
+import { buildReviewOperationsWithNative } from '../../../router/virtual-router/engine-selection/native-chat-process-servertool-orchestration-semantics.js';
+import { isClientInjectReady } from './client-inject-readiness.js';
+export function buildReviewOperations(metadata) {
+    if (!isClientInjectReady(metadata)) {
+        return [];
+    }
+    return buildReviewOperationsWithNative(metadata);
+}

package/vendor/@jsonstudio/llms/dist/conversion/hub/process/chat-process-servertool-orchestration.d.ts

@@ -0,0 +1,8 @@
+import type { StandardizedRequest } from '../types/standardized.js';
+interface ServerToolOrchestrationOptions {
+    request: StandardizedRequest;
+    metadata: Record<string, unknown>;
+    requestId: string;
+}
+export declare function applyServerToolOrchestration(options: ServerToolOrchestrationOptions): Promise<StandardizedRequest>;
+export {};

package/vendor/@jsonstudio/llms/dist/conversion/hub/process/chat-process-servertool-orchestration.js

@@ -0,0 +1,22 @@
+import { applyHubOperations } from '../ops/operations.js';
+import { buildContinueExecutionOperations, resolveHasActiveStopMessageForContinueExecution } from './chat-process-continue-execution.js';
+import { buildWebSearchOperations } from './chat-process-web-search.js';
+import { buildClockOperationsWithPlan } from './chat-process-clock-tools.js';
+import { buildReviewOperations } from './chat-process-review.js';
+import { maybeInjectClockRemindersAndApplyDirectives } from './chat-process-clock-reminders.js';
+import { readRuntimeMetadata } from '../../runtime-metadata.js';
+import { tryPlanChatServerToolBundleWithNative } from '../../../router/virtual-router/engine-selection/native-chat-process-servertool-orchestration-semantics.js';
+export async function applyServerToolOrchestration(options) {
+    let request = options.request;
+    const runtimeMetadata = (readRuntimeMetadata(options.metadata) ?? {});
+    const hasActiveStopMessage = resolveHasActiveStopMessageForContinueExecution(options.metadata);
+    const nativeBundle = tryPlanChatServerToolBundleWithNative(request, runtimeMetadata, hasActiveStopMessage);
+    request = applyHubOperations(request, buildWebSearchOperations(request, options.metadata, nativeBundle?.webSearch));
+    request = applyHubOperations(request, buildClockOperationsWithPlan(options.metadata, nativeBundle?.clock));
+    request = applyHubOperations(request, buildContinueExecutionOperations(options.metadata, {
+        hasActiveStopMessage,
+        precomputedPlan: nativeBundle?.continueExecution
+    }));
+    request = applyHubOperations(request, buildReviewOperations(options.metadata));
+    return maybeInjectClockRemindersAndApplyDirectives(request, options.metadata, options.requestId);
+}

package/vendor/@jsonstudio/llms/dist/conversion/hub/process/chat-process-session-usage.d.ts

@@ -0,0 +1,7 @@
+import type { AdapterContext } from '../types/chat-envelope.js';
+import type { ProcessedRequest, StandardizedRequest } from '../types/standardized.js';
+export declare function estimateSessionBoundTokens(request: StandardizedRequest | ProcessedRequest, metadata: Record<string, unknown> | undefined): number | undefined;
+export declare function saveChatProcessSessionActualUsage(options: {
+    context: AdapterContext;
+    usage: Record<string, unknown> | undefined;
+}): void;

package/vendor/@jsonstudio/llms/dist/conversion/hub/process/chat-process-session-usage.js

@@ -0,0 +1,147 @@
+import { loadRoutingInstructionStateSync, saveRoutingInstructionStateSync } from '../../../router/virtual-router/sticky-session-store.js';
+import { countRequestTokens } from '../../../router/virtual-router/token-counter.js';
+function createEmptyRoutingInstructionState() {
+    return {
+        allowedProviders: new Set(),
+        disabledProviders: new Set(),
+        disabledKeys: new Map(),
+        disabledModels: new Map()
+    };
+}
+function resolveSessionUsageScope(record) {
+    const sessionId = typeof record?.sessionId === 'string' ? record.sessionId.trim() : '';
+    if (sessionId) {
+        return `session:${sessionId}`;
+    }
+    const conversationId = typeof record?.conversationId === 'string' ? record.conversationId.trim() : '';
+    if (conversationId) {
+        return `conversation:${conversationId}`;
+    }
+    return undefined;
+}
+function loadState(scope) {
+    try {
+        return loadRoutingInstructionStateSync(scope);
+    }
+    catch {
+        return null;
+    }
+}
+function readRoundedToken(value) {
+    if (typeof value !== 'number' || !Number.isFinite(value)) {
+        return undefined;
+    }
+    const rounded = Math.round(value);
+    return rounded > 0 ? rounded : undefined;
+}
+function buildSnapshot(scope, state) {
+    if (!state) {
+        return null;
+    }
+    const totalTokens = readRoundedToken(state.chatProcessLastTotalTokens);
+    const inputTokens = readRoundedToken(state.chatProcessLastInputTokens);
+    const messageCount = readRoundedToken(state.chatProcessLastMessageCount);
+    const updatedAtMs = readRoundedToken(state.chatProcessLastUpdatedAt);
+    if (totalTokens === undefined && inputTokens === undefined) {
+        return null;
+    }
+    return {
+        scope,
+        ...(totalTokens !== undefined ? { totalTokens } : {}),
+        ...(inputTokens !== undefined ? { inputTokens } : {}),
+        ...(messageCount !== undefined ? { messageCount } : {}),
+        ...(updatedAtMs !== undefined ? { updatedAtMs } : {})
+    };
+}
+function normalizeUsage(usage) {
+    if (!usage || typeof usage !== 'object') {
+        return null;
+    }
+    const inputTokens = readRoundedToken(usage.input_tokens ??
+        usage.prompt_tokens ??
+        usage.inputTokens ??
+        usage.promptTokens ??
+        usage.request_tokens ??
+        usage.requestTokens);
+    const outputTokens = readRoundedToken(usage.output_tokens ??
+        usage.completion_tokens ??
+        usage.outputTokens ??
+        usage.completionTokens ??
+        usage.response_tokens ??
+        usage.responseTokens);
+    const totalTokens = readRoundedToken(usage.total_tokens ??
+        usage.totalTokens ??
+        ((inputTokens ?? 0) + (outputTokens ?? 0) > 0
+            ? (inputTokens ?? 0) + (outputTokens ?? 0)
+            : undefined));
+    if (totalTokens === undefined && inputTokens === undefined) {
+        return null;
+    }
+    return {
+        ...(inputTokens !== undefined ? { inputTokens } : {}),
+        ...(outputTokens !== undefined ? { outputTokens } : {}),
+        ...(totalTokens !== undefined ? { totalTokens } : {})
+    };
+}
+function estimateDeltaTokens(request, previousMessageCount) {
+    const messages = Array.isArray(request.messages) ? request.messages : [];
+    if (previousMessageCount < 0 || previousMessageCount > messages.length) {
+        return undefined;
+    }
+    const appendedMessages = messages.slice(previousMessageCount);
+    if (appendedMessages.length === 0) {
+        return 0;
+    }
+    return countRequestTokens({
+        model: request.model,
+        messages: appendedMessages,
+        parameters: {},
+        metadata: { originalEndpoint: request.metadata?.originalEndpoint ?? '/v1/chat/completions' }
+    });
+}
+export function estimateSessionBoundTokens(request, metadata) {
+    const scope = resolveSessionUsageScope(metadata);
+    if (!scope) {
+        return undefined;
+    }
+    const snapshot = buildSnapshot(scope, loadState(scope));
+    if (!snapshot) {
+        return undefined;
+    }
+    const previousTotal = snapshot.totalTokens ?? snapshot.inputTokens;
+    const previousMessageCount = snapshot.messageCount;
+    if (previousTotal === undefined || previousMessageCount === undefined) {
+        return undefined;
+    }
+    const deltaTokens = estimateDeltaTokens(request, previousMessageCount);
+    if (deltaTokens === undefined) {
+        return undefined;
+    }
+    return Math.max(1, Math.round(previousTotal + deltaTokens));
+}
+export function saveChatProcessSessionActualUsage(options) {
+    const scope = resolveSessionUsageScope(options.context);
+    if (!scope) {
+        return;
+    }
+    const normalizedUsage = normalizeUsage(options.usage);
+    if (!normalizedUsage) {
+        return;
+    }
+    const capturedChatRequest = options.context.capturedChatRequest;
+    const messageCount = Array.isArray(capturedChatRequest?.messages)
+        ? (capturedChatRequest.messages ?? []).length
+        : undefined;
+    const state = loadState(scope) ?? createEmptyRoutingInstructionState();
+    if (normalizedUsage.totalTokens !== undefined) {
+        state.chatProcessLastTotalTokens = normalizedUsage.totalTokens;
+    }
+    if (normalizedUsage.inputTokens !== undefined) {
+        state.chatProcessLastInputTokens = normalizedUsage.inputTokens;
+    }
+    if (typeof messageCount === 'number' && Number.isFinite(messageCount)) {
+        state.chatProcessLastMessageCount = Math.max(0, Math.round(messageCount));
+    }
+    state.chatProcessLastUpdatedAt = Date.now();
+    saveRoutingInstructionStateSync(scope, state);
+}

package/vendor/@jsonstudio/llms/dist/conversion/hub/process/chat-process-tool-normalization.d.ts

@@ -0,0 +1,2 @@
+import type { StandardizedTool } from '../types/standardized.js';
+export declare function castGovernedTools(tools: unknown): StandardizedTool[] | undefined;

package/vendor/@jsonstudio/llms/dist/conversion/hub/process/chat-process-tool-normalization.js

@@ -0,0 +1,4 @@
+import { castGovernedToolsWithNative } from '../../../router/virtual-router/engine-selection/native-chat-process-governance-semantics.js';
+export function castGovernedTools(tools) {
+    return castGovernedToolsWithNative(tools);
+}

package/vendor/@jsonstudio/llms/dist/conversion/hub/process/chat-process-web-search-intent.d.ts

@@ -0,0 +1,12 @@
+import type { ChatSemantics } from '../types/chat-envelope.js';
+import type { StandardizedRequest } from '../types/standardized.js';
+export type WebSearchIntent = {
+    hasIntent: boolean;
+    googlePreferred: boolean;
+};
+export type WebSearchSemanticsHint = {
+    force?: boolean;
+    disable?: boolean;
+};
+export declare function extractWebSearchSemantics(semantics: ChatSemantics | undefined): WebSearchSemanticsHint | undefined;
+export declare function detectWebSearchIntent(request: StandardizedRequest): WebSearchIntent;

package/vendor/@jsonstudio/llms/dist/conversion/hub/process/chat-process-web-search-intent.js

@@ -0,0 +1,13 @@
+import { analyzeChatWebSearchIntent } from '../../../router/virtual-router/engine-selection/native-router-hotpath.js';
+import { extractWebSearchSemanticsHintWithNative } from '../../../router/virtual-router/engine-selection/native-chat-process-web-search-intent-semantics.js';
+export function extractWebSearchSemantics(semantics) {
+    return extractWebSearchSemanticsHintWithNative(semantics);
+}
+export function detectWebSearchIntent(request) {
+    const messages = Array.isArray(request.messages) ? request.messages : [];
+    const analysis = analyzeChatWebSearchIntent(messages);
+    return {
+        hasIntent: analysis.hasIntent === true,
+        googlePreferred: analysis.googlePreferred === true
+    };
+}

package/vendor/@jsonstudio/llms/dist/conversion/hub/process/chat-process-web-search-tool-schema.d.ts

@@ -0,0 +1,3 @@
+import type { VirtualRouterWebSearchConfig } from '../../../router/virtual-router/types.js';
+import type { HubOperation } from '../ops/operations.js';
+export declare function buildWebSearchToolAppendOperations(engines: Array<VirtualRouterWebSearchConfig['engines'][number]>): HubOperation[];

package/vendor/@jsonstudio/llms/dist/conversion/hub/process/chat-process-web-search-tool-schema.js

@@ -0,0 +1,4 @@
+import { buildWebSearchToolAppendOperationsWithNative } from '../../../router/virtual-router/engine-selection/native-chat-process-governance-semantics.js';
+export function buildWebSearchToolAppendOperations(engines) {
+    return buildWebSearchToolAppendOperationsWithNative(engines);
+}

package/vendor/@jsonstudio/llms/dist/conversion/hub/process/chat-process-web-search.d.ts

@@ -0,0 +1,8 @@
+import type { HubOperation } from '../ops/operations.js';
+import type { StandardizedRequest } from '../types/standardized.js';
+type WebSearchOperationPlan = {
+    shouldInject: boolean;
+    selectedEngineIndexes: number[];
+};
+export declare function buildWebSearchOperations(request: StandardizedRequest, metadata: Record<string, unknown>, precomputedPlan?: WebSearchOperationPlan): HubOperation[];
+export {};

package/vendor/@jsonstudio/llms/dist/conversion/hub/process/chat-process-web-search.js

@@ -0,0 +1,26 @@
+import { readRuntimeMetadata } from '../../runtime-metadata.js';
+import { buildWebSearchToolAppendOperations } from './chat-process-web-search-tool-schema.js';
+import { planChatWebSearchOperationsWithNative } from '../../../router/virtual-router/engine-selection/native-chat-process-servertool-orchestration-semantics.js';
+export function buildWebSearchOperations(request, metadata, precomputedPlan) {
+    const rt = (readRuntimeMetadata(metadata) ?? {});
+    const rawConfig = rt?.webSearch;
+    if (!rawConfig || !Array.isArray(rawConfig.engines) || rawConfig.engines.length === 0) {
+        return [];
+    }
+    const plan = precomputedPlan ??
+        planChatWebSearchOperationsWithNative(request, rt);
+    if (!plan.shouldInject || !plan.selectedEngineIndexes.length) {
+        return [];
+    }
+    const selectedEngines = selectEnginesByIndexes(rawConfig.engines, plan.selectedEngineIndexes);
+    if (!selectedEngines.length) {
+        return [];
+    }
+    return buildWebSearchToolAppendOperations(selectedEngines);
+}
+function selectEnginesByIndexes(engines, indexes) {
+    return indexes
+        .map((value) => (typeof value === 'number' && Number.isFinite(value) ? Math.floor(value) : -1))
+        .filter((value) => value >= 0 && value < engines.length)
+        .map((value) => engines[value]);
+}

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

@@ -0,0 +1,15 @@
+import type { ProcessedRequest, StandardizedRequest } from '../types/standardized.js';
+import type { HubProcessNodeResult } from './chat-process-node-result.js';
+export type { HubProcessNodeResult } from './chat-process-node-result.js';
+export interface HubChatProcessOptions {
+    request: StandardizedRequest;
+    requestId: string;
+    entryEndpoint: string;
+    rawPayload: Record<string, unknown>;
+    metadata: Record<string, unknown>;
+}
+export interface HubChatProcessResult {
+    processedRequest?: ProcessedRequest;
+    nodeResult: HubProcessNodeResult;
+}
+export declare function runHubChatProcess(options: HubChatProcessOptions): Promise<HubChatProcessResult>;

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

@@ -0,0 +1,27 @@
+import { buildErrorResult, buildProcessedRequest, buildSuccessResult } from './chat-process-node-result.js';
+import { applyRequestToolGovernance } from './chat-process-governance-orchestration.js';
+import { shouldRunHubChatProcessWithNative } from '../../../router/virtual-router/engine-selection/native-hub-pipeline-req-inbound-semantics.js';
+export async function runHubChatProcess(options) {
+    const startTime = Date.now();
+    try {
+        const shouldRunGovernance = shouldRunHubChatProcessWithNative(options.requestId, options.entryEndpoint);
+        const governed = shouldRunGovernance
+            ? await applyRequestToolGovernance(options.request, {
+                entryEndpoint: options.entryEndpoint,
+                requestId: options.requestId,
+                metadata: options.metadata,
+                rawPayload: options.rawPayload
+            })
+            : options.request;
+        const processedRequest = buildProcessedRequest(governed);
+        return {
+            processedRequest,
+            nodeResult: buildSuccessResult(startTime, processedRequest)
+        };
+    }
+    catch (error) {
+        return {
+            nodeResult: buildErrorResult(startTime, error)
+        };
+    }
+}

package/vendor/@jsonstudio/llms/dist/conversion/hub/process/client-inject-readiness.d.ts

@@ -0,0 +1 @@
+export declare function isClientInjectReady(metadata: Record<string, unknown>): boolean;

package/vendor/@jsonstudio/llms/dist/conversion/hub/process/client-inject-readiness.js

@@ -0,0 +1,4 @@
+import { resolveClientInjectReadyWithNative } from '../../../router/virtual-router/engine-selection/native-hub-pipeline-req-inbound-semantics.js';
+export function isClientInjectReady(metadata) {
+    return resolveClientInjectReadyWithNative(metadata);
+}

package/vendor/@jsonstudio/llms/dist/conversion/hub/registry.d.ts

@@ -0,0 +1,28 @@
+import type { InboundPlan, InboundPassthroughConfig, InboundStage } from './pipelines/inbound.js';
+import type { OutboundPlan, OutboundPassthroughConfig, OutboundStage } from './pipelines/outbound.js';
+import type { FormatAdapter, SemanticMapper } from './format-adapters/index.js';
+interface InboundPlanFactory {
+    protocol: string;
+    stages: InboundStage[];
+    passthrough?: InboundPassthroughConfig;
+    createFormatAdapter?: () => FormatAdapter;
+    createSemanticMapper?: () => SemanticMapper;
+}
+interface OutboundPlanFactory {
+    protocol: string;
+    stages: OutboundStage[];
+    passthrough?: OutboundPassthroughConfig;
+    createFormatAdapter?: () => FormatAdapter;
+    createSemanticMapper?: () => SemanticMapper;
+}
+export interface HubProtocolDefinition {
+    protocol: string;
+    inbound: InboundPlanFactory;
+    outbound: OutboundPlanFactory;
+}
+export declare const HUB_PROTOCOL_REGISTRY: Record<string, HubProtocolDefinition>;
+export declare function createProtocolPlans(protocol: string): {
+    inbound: InboundPlan;
+    outbound: OutboundPlan;
+};
+export {};