@jsonstudio/llms 0.6.3409 → 0.6.3541

package/dist/router/virtual-router/engine-selection/native-shared-conversion-semantics.d.ts

@@ -28,6 +28,7 @@ export declare function mapChatToolsToBridgeWithNative(rawTools: unknown, option
 }): Array<Record<string, unknown>>;
 export declare function collectToolCallsFromResponsesWithNative(response: Record<string, unknown>): Array<Record<string, unknown>>;
 export declare function resolveFinishReasonWithNative(response: Record<string, unknown>, toolCalls: Array<Record<string, unknown>>): string;
+export declare function buildChatResponseFromResponsesWithNative(payload: unknown): Record<string, unknown> | null;
 export declare function hasValidThoughtSignatureWithNative(block: unknown, options?: Record<string, unknown>): boolean;
 export declare function sanitizeThinkingBlockWithNative(block: unknown): Record<string, unknown>;
 export declare function filterInvalidThinkingBlocksWithNative(messages: unknown, options?: Record<string, unknown>): unknown[];
@@ -146,6 +147,16 @@ export declare function extractStreamingToolCallsWithNative(input: {
     idCounter: number;
     toolCalls: Array<Record<string, unknown>>;
 };
+export declare function createStreamingToolExtractorStateWithNative(idPrefix?: string): Record<string, unknown>;
+export declare function resetStreamingToolExtractorStateWithNative(state: Record<string, unknown>): Record<string, unknown>;
+export declare function feedStreamingToolExtractorWithNative(input: {
+    state: Record<string, unknown>;
+    text: string;
+    nowMs?: number;
+}): {
+    state: Record<string, unknown>;
+    toolCalls: Array<Record<string, unknown>>;
+};
 export declare function isCompactionRequestWithNative(payload: unknown): boolean;
 export declare function encodeMetadataPassthroughWithNative(parameters: unknown, prefix: string, keys: readonly string[]): Record<string, string> | undefined;
 export declare function extractMetadataPassthroughWithNative(metadataField: unknown, prefix: string, keys: readonly string[]): {
@@ -194,6 +205,15 @@ export declare function prepareGeminiToolsForBridgeWithNative(rawTools: unknown,
 export declare function buildGeminiToolsFromBridgeWithNative(defs: unknown, mode?: 'antigravity' | 'default'): Array<Record<string, unknown>> | undefined;
 export declare function pickResponsesPersistedFieldsWithNative(payload: unknown): Record<string, unknown>;
 export declare function convertResponsesOutputToInputItemsWithNative(response: unknown): Array<Record<string, unknown>>;
+export declare function prepareResponsesConversationEntryWithNative(payload: unknown, context: unknown): {
+    basePayload: Record<string, unknown>;
+    input: Array<Record<string, unknown>>;
+    tools?: Array<Record<string, unknown>>;
+};
+export declare function resumeResponsesConversationPayloadWithNative(entry: unknown, responseId: string, submitPayload: unknown, requestId?: string): {
+    payload: Record<string, unknown>;
+    meta: Record<string, unknown>;
+};
 export declare function enforceChatBudgetWithNative(chat: unknown, allowedBytes: number, systemTextLimit: number): unknown;
 export declare function resolveBudgetForModelWithNative(modelId: string, fallback: {
     maxBytes: number;

package/dist/router/virtual-router/engine-selection/native-shared-conversion-semantics.js

@@ -111,6 +111,24 @@ function parseToolDefinitionOutput(raw) {
     const parsed = parseRecord(raw);
     return parsed;
 }
+function parseResponsesConversationResumeResult(raw) {
+    const parsed = parseRecord(raw);
+    if (!parsed) {
+        return null;
+    }
+    const payload = parsed.payload;
+    const meta = parsed.meta;
+    if (!payload || typeof payload !== 'object' || Array.isArray(payload)) {
+        return null;
+    }
+    if (!meta || typeof meta !== 'object' || Array.isArray(meta)) {
+        return null;
+    }
+    return {
+        payload: payload,
+        meta: meta
+    };
+}
 function parseToolDefinitionArray(raw) {
     const parsed = parseArray(raw);
     if (!parsed)
@@ -568,6 +586,32 @@ export function resolveFinishReasonWithNative(response, toolCalls) {
         return fail(reason);
     }
 }
+export function buildChatResponseFromResponsesWithNative(payload) {
+    const capability = 'buildChatResponseFromResponsesJson';
+    const fail = (reason) => failNativeRequired(capability, reason);
+    if (isNativeDisabledByEnv()) {
+        return fail('native disabled');
+    }
+    const fn = readNativeFunction(capability);
+    if (!fn) {
+        return fail();
+    }
+    const payloadJson = safeStringify(payload ?? null);
+    if (!payloadJson) {
+        return fail('json stringify failed');
+    }
+    try {
+        const raw = fn(payloadJson);
+        if (typeof raw !== 'string' || !raw) {
+            return fail('empty result');
+        }
+        return parseRecord(raw) ?? fail('invalid payload');
+    }
+    catch (error) {
+        const reason = error instanceof Error ? error.message : String(error ?? 'unknown');
+        return fail(reason);
+    }
+}
 export function hasValidThoughtSignatureWithNative(block, options) {
     const capability = 'hasValidThoughtSignatureJson';
     const fail = (reason) => failNativeRequired(capability, reason);
@@ -1414,6 +1458,92 @@ export function extractStreamingToolCallsWithNative(input) {
         return fail(reason);
     }
 }
+export function createStreamingToolExtractorStateWithNative(idPrefix) {
+    const capability = 'createStreamingToolExtractorStateJson';
+    const fail = (reason) => failNativeRequired(capability, reason);
+    if (isNativeDisabledByEnv()) {
+        return fail('native disabled');
+    }
+    const fn = readNativeFunction(capability);
+    if (!fn) {
+        return fail();
+    }
+    const payloadJson = safeStringify(idPrefix ? { idPrefix } : {});
+    if (!payloadJson) {
+        return fail('json stringify failed');
+    }
+    try {
+        const raw = fn(payloadJson);
+        if (typeof raw !== 'string' || !raw) {
+            return fail('empty result');
+        }
+        return parseRecord(raw) ?? fail('invalid payload');
+    }
+    catch (error) {
+        const reason = error instanceof Error ? error.message : String(error ?? 'unknown');
+        return fail(reason);
+    }
+}
+export function resetStreamingToolExtractorStateWithNative(state) {
+    const capability = 'resetStreamingToolExtractorStateJson';
+    const fail = (reason) => failNativeRequired(capability, reason);
+    if (isNativeDisabledByEnv()) {
+        return fail('native disabled');
+    }
+    const fn = readNativeFunction(capability);
+    if (!fn) {
+        return fail();
+    }
+    const payloadJson = safeStringify(state ?? {});
+    if (!payloadJson) {
+        return fail('json stringify failed');
+    }
+    try {
+        const raw = fn(payloadJson);
+        if (typeof raw !== 'string' || !raw) {
+            return fail('empty result');
+        }
+        return parseRecord(raw) ?? fail('invalid payload');
+    }
+    catch (error) {
+        const reason = error instanceof Error ? error.message : String(error ?? 'unknown');
+        return fail(reason);
+    }
+}
+export function feedStreamingToolExtractorWithNative(input) {
+    const capability = 'feedStreamingToolExtractorJson';
+    const fail = (reason) => failNativeRequired(capability, reason);
+    if (isNativeDisabledByEnv()) {
+        return fail('native disabled');
+    }
+    const fn = readNativeFunction(capability);
+    if (!fn) {
+        return fail();
+    }
+    const payloadJson = safeStringify(input ?? {});
+    if (!payloadJson) {
+        return fail('json stringify failed');
+    }
+    try {
+        const raw = fn(payloadJson);
+        if (typeof raw !== 'string' || !raw) {
+            return fail('empty result');
+        }
+        const parsed = parseRecord(raw);
+        if (!parsed || !parsed.state || typeof parsed.state !== 'object' || Array.isArray(parsed.state)) {
+            return fail('invalid payload');
+        }
+        const toolCalls = Array.isArray(parsed.toolCalls)
+            ? parsed.toolCalls.filter((entry) => entry && typeof entry === 'object' && !Array.isArray(entry))
+                .map((entry) => entry)
+            : [];
+        return { state: parsed.state, toolCalls };
+    }
+    catch (error) {
+        const reason = error instanceof Error ? error.message : String(error ?? 'unknown');
+        return fail(reason);
+    }
+}
 export function isCompactionRequestWithNative(payload) {
     const capability = 'isCompactionRequestJson';
     const fail = (reason) => failNativeRequired(capability, reason);
@@ -2177,6 +2307,77 @@ export function convertResponsesOutputToInputItemsWithNative(response) {
         return fail(reason);
     }
 }
+export function prepareResponsesConversationEntryWithNative(payload, context) {
+    const capability = 'prepareResponsesConversationEntryJson';
+    const fail = (reason) => failNativeRequired(capability, reason);
+    if (isNativeDisabledByEnv()) {
+        return fail('native disabled');
+    }
+    const fn = readNativeFunction(capability);
+    if (!fn) {
+        return fail();
+    }
+    const payloadJson = safeStringify(payload ?? null);
+    const contextJson = safeStringify(context ?? null);
+    if (!payloadJson || !contextJson) {
+        return fail('json stringify failed');
+    }
+    try {
+        const raw = fn(payloadJson, contextJson);
+        if (typeof raw !== 'string' || !raw) {
+            return fail('empty result');
+        }
+        const parsed = parseRecord(raw);
+        if (!parsed) {
+            return fail('invalid payload');
+        }
+        const basePayload = parsed.basePayload;
+        const input = parsed.input;
+        const tools = parsed.tools;
+        if (!basePayload || typeof basePayload !== 'object' || Array.isArray(basePayload) || !Array.isArray(input)) {
+            return fail('invalid payload');
+        }
+        return {
+            basePayload: basePayload,
+            input: input.filter((entry) => !!entry && typeof entry === 'object' && !Array.isArray(entry)),
+            tools: Array.isArray(tools)
+                ? tools.filter((entry) => !!entry && typeof entry === 'object' && !Array.isArray(entry))
+                : undefined
+        };
+    }
+    catch (error) {
+        const reason = error instanceof Error ? error.message : String(error ?? 'unknown');
+        return fail(reason);
+    }
+}
+export function resumeResponsesConversationPayloadWithNative(entry, responseId, submitPayload, requestId) {
+    const capability = 'resumeResponsesConversationPayloadJson';
+    const fail = (reason) => failNativeRequired(capability, reason);
+    if (isNativeDisabledByEnv()) {
+        return fail('native disabled');
+    }
+    const fn = readNativeFunction(capability);
+    if (!fn) {
+        return fail();
+    }
+    const entryJson = safeStringify(entry ?? null);
+    const submitPayloadJson = safeStringify(submitPayload ?? null);
+    if (!entryJson || !submitPayloadJson) {
+        return fail('json stringify failed');
+    }
+    try {
+        const raw = fn(entryJson, String(responseId ?? ''), submitPayloadJson, requestId);
+        if (typeof raw !== 'string' || !raw) {
+            return fail('empty result');
+        }
+        const parsed = parseResponsesConversationResumeResult(raw);
+        return parsed ?? fail('invalid payload');
+    }
+    catch (error) {
+        const reason = error instanceof Error ? error.message : String(error ?? 'unknown');
+        return fail(reason);
+    }
+}
 export function enforceChatBudgetWithNative(chat, allowedBytes, systemTextLimit) {
     const capability = 'enforceChatBudgetJson';
     const fail = (reason) => failNativeRequired(capability, reason);

package/dist/router/virtual-router/engine-selection/native-virtual-router-routing-instructions-semantics.d.ts

@@ -1,2 +1,3 @@
 export declare function parseRoutingInstructionKindsWithNative(request: unknown): string[];
+export declare function parseRoutingInstructionsWithNative(messages: Array<Record<string, unknown>>): Array<Record<string, unknown>>;
 export declare function cleanRoutingInstructionMarkersWithNative(request: Record<string, unknown>): Record<string, unknown>;

package/dist/router/virtual-router/engine-selection/native-virtual-router-routing-instructions-semantics.js

@@ -36,6 +36,19 @@ function parseRecordPayload(raw) {
         return null;
     }
 }
+function parseRecordArrayPayload(raw) {
+    try {
+        const parsed = JSON.parse(raw);
+        if (!Array.isArray(parsed)) {
+            return null;
+        }
+        const records = parsed.filter((entry) => entry && typeof entry === 'object' && !Array.isArray(entry));
+        return records.length === parsed.length ? records : null;
+    }
+    catch {
+        return null;
+    }
+}
 export function parseRoutingInstructionKindsWithNative(request) {
     const capability = 'parseRoutingInstructionKindsJson';
     const fail = (reason) => failNativeRequired(capability, reason);
@@ -60,6 +73,30 @@ export function parseRoutingInstructionKindsWithNative(request) {
         return fail(reason);
     }
 }
+export function parseRoutingInstructionsWithNative(messages) {
+    const capability = 'parseRoutingInstructionsJson';
+    const fail = (reason) => failNativeRequired(capability, reason);
+    const fn = readNativeFunction(capability);
+    if (!fn) {
+        return fail();
+    }
+    const messagesJson = safeStringify(messages);
+    if (!messagesJson) {
+        return fail('json stringify failed');
+    }
+    try {
+        const result = fn(messagesJson);
+        if (typeof result !== 'string' || !result) {
+            return fail('empty result');
+        }
+        const parsed = parseRecordArrayPayload(result);
+        return parsed ?? fail('invalid payload');
+    }
+    catch (error) {
+        const reason = error instanceof Error ? error.message : String(error ?? 'unknown');
+        return fail(reason);
+    }
+}
 export function cleanRoutingInstructionMarkersWithNative(request) {
     const capability = 'cleanRoutingInstructionMarkersJson';
     const fail = (reason) => failNativeRequired(capability, reason);

package/dist/router/virtual-router/engine.js

@@ -1,9 +1,6 @@
 import { VirtualRouterError, VirtualRouterErrorCode } from './types.js';
-import { ROUTING_INSTRUCTION_MARKER_PATTERN } from './routing-instructions/types.js';
-import { parseRoutingInstructions } from './routing-instructions/parse.js';
 import { createVirtualRouterEngineProxy } from './engine-selection/native-virtual-router-engine-proxy.js';
 import { cleanRoutingInstructionMarkersWithNative, parseRoutingInstructionKindsWithNative } from './engine-selection/native-virtual-router-routing-instructions-semantics.js';
-import { getLatestUserTextFromResponsesContext, hasLatestUserRoutingInstructionMarker, hasRoutingInstructionMarkerInResponsesContext } from './engine-legacy/helpers.js';
 import { extractMessageText, getLatestUserMessage } from './message-utils.js';
 import { ProviderRegistry } from './provider-registry.js';
 import { resolveStopMessageScope } from './engine/routing-state/store.js';
@@ -349,38 +346,3 @@ function cleanRoutingInstructionMarkersInPlace(request) {
         }
     }
 }
-function collectClientScopedInstructions(request) {
-    const messages = Array.isArray(request.messages)
-        ? request.messages
-        : [];
-    const responsesContext = request.semantics && typeof request.semantics === 'object'
-        ? request.semantics.responses?.context
-        : undefined;
-    const responsesHasMarker = hasRoutingInstructionMarkerInResponsesContext(responsesContext);
-    const latestUserHasMarker = hasLatestUserRoutingInstructionMarker(messages) || responsesHasMarker;
-    if (!latestUserHasMarker && !messages.some((message) => {
-        if (!message || typeof message !== 'object') {
-            return false;
-        }
-        const record = message;
-        return record.role === 'user' && typeof record.content === 'string' && ROUTING_INSTRUCTION_MARKER_PATTERN.test(record.content);
-    })) {
-        return { instructions: [], latestUserHasMarker };
-    }
-    let instructions = parseRoutingInstructions(messages);
-    if (instructions.length === 0 && responsesHasMarker) {
-        const responsesLatestUserText = getLatestUserTextFromResponsesContext(responsesContext);
-        if (responsesLatestUserText) {
-            instructions = parseRoutingInstructions([{ role: 'user', content: responsesLatestUserText }]);
-        }
-    }
-    return { instructions, latestUserHasMarker };
-}
-function isClientScopedInstruction(instruction) {
-    return (instruction.type === 'stopMessageSet' ||
-        instruction.type === 'stopMessageMode' ||
-        instruction.type === 'stopMessageClear' ||
-        instruction.type === 'preCommandSet' ||
-        instruction.type === 'preCommandClear' ||
-        instruction.type === 'clear');
-}

package/dist/router/virtual-router/features.js

@@ -3,6 +3,46 @@ import { extractAntigravityGeminiSessionIdWithNative } from './engine-selection/
 import { detectCodingTool, detectLastAssistantToolCategory, detectVisionTool, detectWebSearchToolDeclared, detectWebTool, extractMeaningfulDeclaredToolNames } from './tool-signals.js';
 import { computeRequestTokens } from './token-estimator.js';
 const THINKING_KEYWORDS = ['let me think', 'chain of thought', 'cot', 'reason step', 'deliberate'];
+function asRecord(value) {
+    return value && typeof value === 'object' && !Array.isArray(value)
+        ? value
+        : null;
+}
+function getLatestResponsesContextMessage(request) {
+    const contextInput = asRecord(request.semantics)?.responses;
+    const context = asRecord(contextInput)?.context;
+    const input = Array.isArray(asRecord(context)?.input) ? asRecord(context)?.input : [];
+    for (let idx = input.length - 1; idx >= 0; idx -= 1) {
+        const entry = asRecord(input[idx]);
+        if (!entry) {
+            continue;
+        }
+        const entryType = typeof entry.type === 'string' && entry.type.trim()
+            ? entry.type.trim().toLowerCase()
+            : 'message';
+        if (entryType !== 'message') {
+            continue;
+        }
+        const role = typeof entry.role === 'string' && entry.role.trim()
+            ? entry.role.trim().toLowerCase()
+            : 'user';
+        if (role !== 'user' && role !== 'assistant' && role !== 'tool') {
+            continue;
+        }
+        const content = entry.content;
+        if (typeof content !== 'string' && !Array.isArray(content)) {
+            continue;
+        }
+        return {
+            role,
+            message: {
+                role: role,
+                content: content
+            }
+        };
+    }
+    return null;
+}
 export function buildRoutingFeatures(request, metadata) {
     const antigravitySessionId = (() => {
         try {
@@ -18,10 +58,11 @@ export function buildRoutingFeatures(request, metadata) {
             return undefined;
         }
     })();
-    const latestMessageRole = getLatestMessageRole(request.messages);
-    const latestMessage = Array.isArray(request.messages) && request.messages.length
+    const responsesLatestMessage = getLatestResponsesContextMessage(request);
+    const latestMessageRole = responsesLatestMessage?.role || getLatestMessageRole(request.messages);
+    const latestMessage = responsesLatestMessage?.message || (Array.isArray(request.messages) && request.messages.length
         ? request.messages[request.messages.length - 1]
-        : undefined;
+        : undefined);
     const assistantMessages = request.messages.filter((msg) => msg.role === 'assistant');
     const latestUserText = latestMessageRole === 'user' && latestMessage
         ? extractMessageText(latestMessage)

package/dist/router/virtual-router/routing-instructions/parse.d.ts

@@ -1,18 +1,6 @@
 import type { StandardizedMessage } from '../../../conversion/hub/types/standardized.js';
 import type { RoutingInstruction } from './types.js';
 export declare function parseRoutingInstructions(messages: StandardizedMessage[]): RoutingInstruction[];
-/**
- * 解析并预处理路由指令，优先处理 clear 指令，确保新指令能够覆盖旧状态。
- * 返回清理后的指令列表，移除冗余的 stopMessageSet 指令。
- */
 export declare function parseAndPreprocessRoutingInstructions(messages: StandardizedMessage[]): RoutingInstruction[];
-/**
- * 提取 clear 指令（如果存在）。用于在路由选择前优先执行清理操作。
- * @returns 是否存在 clear 指令
- */
 export declare function extractClearInstruction(messages: StandardizedMessage[]): boolean;
-/**
- * 提取 stopMessageClear 指令（如果存在）。
- * @returns 是否存在 stopMessageClear 指令
- */
 export declare function extractStopMessageClearInstruction(messages: StandardizedMessage[]): boolean;