@jsonstudio/llms 0.6.2172 → 0.6.2979

package/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/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/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/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/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/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/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 '../../shared/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/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/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/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/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/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/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/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/dist/conversion/hub/process/chat-process-web-search.js

@@ -0,0 +1,26 @@
+import { readRuntimeMetadata } from '../../shared/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/dist/conversion/hub/process/chat-process.d.ts

@@ -1,5 +1,6 @@
 import type { ProcessedRequest, StandardizedRequest } from '../types/standardized.js';
-import type { JsonObject } from '../types/json.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;
@@ -11,22 +12,4 @@ export interface HubChatProcessResult {
     processedRequest?: ProcessedRequest;
     nodeResult: HubProcessNodeResult;
 }
-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 runHubChatProcess(options: HubChatProcessOptions): Promise<HubChatProcessResult>;