@jsonstudio/llms 0.6.2172 → 0.6.2979

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 '../../shared/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 '../../shared/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 {};

package/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/dist/conversion/hub/process/chat-process-media.d.ts

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

package/dist/conversion/hub/process/chat-process-media.js

@@ -0,0 +1,18 @@
+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;
+}
+export function containsImageAttachment(messages) {
+    if (!Array.isArray(messages) || !messages.length) {
+        return false;
+    }
+    return analyzeChatProcessMedia(messages).containsCurrentTurnImage === true;
+}

package/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/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/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 {};