@jsonstudio/llms 0.6.1164 → 0.6.1354

package/dist/conversion/hub/response/response-runtime.js

@@ -59,40 +59,9 @@ function createToolNameResolver(options) {
     };
 }
 function extractAliasMapFromChatPayload(payload) {
-    const metadata = payload?.metadata;
-    if (metadata && typeof metadata === 'object' && metadata.anthropicToolNameMap) {
-        const candidate = metadata.anthropicToolNameMap;
-        if (candidate && typeof candidate === 'object') {
-            const serialized = {};
-            for (const [key, value] of Object.entries(candidate)) {
-                if (typeof key === 'string' && typeof value === 'string') {
-                    const trimmedKey = key.trim();
-                    const trimmedValue = value.trim();
-                    if (trimmedKey.length && trimmedValue.length) {
-                        serialized[trimmedKey] = trimmedValue;
-                    }
-                }
-            }
-            if (Object.keys(serialized).length) {
-                return serialized;
-            }
-        }
-    }
-    if (payload?.anthropicToolNameMap && typeof payload.anthropicToolNameMap === 'object') {
-        const map = {};
-        for (const [key, value] of Object.entries(payload.anthropicToolNameMap)) {
-            if (typeof key === 'string' && typeof value === 'string') {
-                const trimmedKey = key.trim();
-                const trimmedValue = value.trim();
-                if (trimmedKey.length && trimmedValue.length) {
-                    map[trimmedKey] = trimmedValue;
-                }
-            }
-        }
-        if (Object.keys(map).length) {
-            return map;
-        }
-    }
+    // Deprecated: tool-name alias maps are mappable semantics and must be carried via requestSemantics
+    // (ChatSemantics.tools.toolNameAliasMap). Do not embed them inside response payload fields/metadata.
+    void payload;
     return undefined;
 }
 function createToolAliasSerializer(aliasMap) {
@@ -285,9 +254,6 @@ export function buildOpenAIChatFromAnthropicMessage(payload, options) {
             chatResponse.request_id = chatResponse.id;
         }
     }
-    if (Object.keys(aliasCollector).length && !chatResponse.anthropicToolNameMap) {
-        chatResponse.anthropicToolNameMap = aliasCollector;
-    }
     return chatResponse;
 }
 function mapShellCommandArgsForAnthropic(raw) {
@@ -326,7 +292,7 @@ function mapShellCommandArgsForAnthropic(raw) {
 export function buildAnthropicResponseFromChat(chatResponse, options) {
     const choice = Array.isArray(chatResponse?.choices) ? chatResponse.choices[0] : undefined;
     const message = choice && typeof choice === 'object' ? choice.message : undefined;
-    const aliasMap = options?.aliasMap ?? extractAliasMapFromChatPayload(chatResponse);
+    const aliasMap = options?.aliasMap;
     const outboundAliasSerializer = createToolAliasSerializer(aliasMap);
     if (message) {
         try {

package/dist/conversion/hub/snapshot-recorder.js

@@ -38,9 +38,13 @@ export function createSnapshotRecorder(context, endpoint) {
 }
 const STAGE_KIND_MAP = {
     req_inbound_stage2_semantic_map: 'request_inbound',
+    'chat_process.req.stage2.semantic_map': 'request_inbound',
     req_outbound_stage1_semantic_map: 'request_outbound',
+    'chat_process.req.stage6.outbound.semantic_map': 'request_outbound',
     resp_inbound_stage3_semantic_map: 'response_inbound',
-    resp_outbound_stage1_client_remap: 'response_outbound'
+    'chat_process.resp.stage4.semantic_map_to_chat': 'response_inbound',
+    resp_outbound_stage1_client_remap: 'response_outbound',
+    'chat_process.resp.stage9.client_remap': 'response_outbound'
 };
 function normalizeStagePayload(stage, payload) {
     const kind = STAGE_KIND_MAP[stage];

package/dist/conversion/hub/standardized-bridge.js

@@ -1,4 +1,5 @@
 import { isJsonObject, jsonClone } from './types/json.js';
+import { cloneRuntimeMetadata } from '../shared/runtime-metadata.js';
 const HUB_CAPTURE_KEY = '__hub_capture';
 export function chatEnvelopeToStandardized(chat, options) {
     const parameters = { ...(chat.parameters ?? {}) };
@@ -14,9 +15,6 @@ export function chatEnvelopeToStandardized(chat, options) {
     if (isJsonObject(chat.metadata?.providerMetadata)) {
         hubState.providerMetadata = chat.metadata?.providerMetadata;
     }
-    if (isJsonObject(chat.metadata?.extraFields)) {
-        hubState.extraFields = chat.metadata?.extraFields;
-    }
     if (isJsonObject(chat.metadata?.protocolState)) {
         hubState.protocolState = chat.metadata?.protocolState;
     }
@@ -65,17 +63,31 @@ export function standardizedToChatEnvelope(request, options) {
     const sourceMeta = (request.metadata && typeof request.metadata === 'object'
         ? request.metadata
         : undefined);
-    if (sourceMeta) {
-        if (sourceMeta.webSearch && typeof sourceMeta.webSearch === 'object') {
-            metadata.webSearch = sourceMeta.webSearch;
-        }
-        if (sourceMeta.forceWebSearch === true) {
-            metadata.forceWebSearch = true;
+    // E1: internal runtime metadata must live under the __rt carrier (never as top-level metadata keys).
+    // Merge runtime hints from AdapterContext + StandardizedRequest.metadata (legacy/compat).
+    try {
+        const merged = {
+            ...(cloneRuntimeMetadata(adapterContext) ?? {}),
+            ...(cloneRuntimeMetadata(sourceMeta ?? null) ?? {})
+        };
+        if (sourceMeta && typeof sourceMeta === 'object') {
+            if (sourceMeta.webSearch && typeof sourceMeta.webSearch === 'object' && merged.webSearch === undefined) {
+                merged.webSearch = sourceMeta.webSearch;
+            }
+            if (sourceMeta.forceWebSearch === true && merged.forceWebSearch === undefined) {
+                merged.forceWebSearch = true;
+            }
+            if (sourceMeta.forceVision === true && merged.forceVision === undefined) {
+                merged.forceVision = true;
+            }
         }
-        if (sourceMeta.forceVision === true) {
-            metadata.forceVision = true;
+        if (Object.keys(merged).length) {
+            metadata.__rt = merged;
         }
     }
+    catch {
+        // best-effort
+    }
     if (typeof adapterContext.toolCallIdStyle === 'string' && adapterContext.toolCallIdStyle.length) {
         metadata.toolCallIdStyle = adapterContext.toolCallIdStyle;
     }
@@ -85,9 +97,6 @@ export function standardizedToChatEnvelope(request, options) {
     if (hubState?.providerMetadata) {
         metadata.providerMetadata = hubState.providerMetadata;
     }
-    if (hubState?.extraFields) {
-        metadata.extraFields = hubState.extraFields;
-    }
     if (hubState?.protocolState) {
         metadata.protocolState = hubState.protocolState;
     }
@@ -280,6 +289,5 @@ function hubStateContextPopulated(state) {
     return Boolean(state.context ||
         (state.missingFields && state.missingFields.length) ||
         state.providerMetadata ||
-        state.extraFields ||
         (state.protocolState && Object.keys(state.protocolState).length));
 }

package/dist/conversion/pipeline/codecs/v2/anthropic-openai-pipeline.js

@@ -31,6 +31,38 @@ function coerceAliasMap(candidate) {
     }
     return populated ? result : undefined;
 }
+function readAliasMapFromSemantics(semantics) {
+    if (!semantics || typeof semantics !== 'object' || Array.isArray(semantics)) {
+        return undefined;
+    }
+    const toolsNode = semantics.tools;
+    if (!toolsNode || typeof toolsNode !== 'object' || Array.isArray(toolsNode)) {
+        return undefined;
+    }
+    const candidate = toolsNode.toolNameAliasMap ??
+        toolsNode.toolAliasMap;
+    return coerceAliasMap(candidate);
+}
+function ensureAliasMapInSemantics(chatEnvelope, aliasMap) {
+    if (!chatEnvelope || typeof chatEnvelope !== 'object') {
+        return;
+    }
+    const semantics = chatEnvelope.semantics && typeof chatEnvelope.semantics === 'object' && !Array.isArray(chatEnvelope.semantics)
+        ? chatEnvelope.semantics
+        : (() => {
+            chatEnvelope.semantics = {};
+            return chatEnvelope.semantics;
+        })();
+    const toolsNode = semantics.tools && typeof semantics.tools === 'object' && !Array.isArray(semantics.tools)
+        ? semantics.tools
+        : (() => {
+            semantics.tools = {};
+            return semantics.tools;
+        })();
+    if (!toolsNode.toolNameAliasMap && !toolsNode.toolAliasMap) {
+        toolsNode.toolNameAliasMap = { ...aliasMap };
+    }
+}
 function createAnthropicHooks() {
     const formatAdapter = new AnthropicFormatAdapter();
     const semanticMapper = new AnthropicSemanticMapper();
@@ -45,11 +77,10 @@ function createAnthropicHooks() {
                 });
                 const formatEnvelope = await formatAdapter.parseRequest(wire, adapterContext);
                 const chatEnvelope = await semanticMapper.toChat(formatEnvelope, adapterContext);
-                const aliasMap = coerceAliasMap(adapterContext.anthropicToolNameMap) ??
-                    coerceAliasMap(chatEnvelope.metadata?.anthropicToolNameMap);
+                const aliasMap = readAliasMapFromSemantics(chatEnvelope.semantics);
                 if (aliasMap) {
-                    context.metadata = context.metadata ?? {};
-                    context.metadata.anthropicToolNameMap = aliasMap;
+                    // A1: tool alias map is mappable semantics; keep it in chat.semantics (never metadata).
+                    ensureAliasMapInSemantics(chatEnvelope, aliasMap);
                 }
                 const canonical = chatEnvelopeToStandardized(chatEnvelope, {
                     adapterContext,
@@ -61,7 +92,7 @@ function createAnthropicHooks() {
         },
         outbound: {
             serialize: async ({ canonical, context }) => {
-                const aliasMap = coerceAliasMap(context.metadata?.anthropicToolNameMap);
+                const aliasMap = readAliasMapFromSemantics(canonical.semantics);
                 const anthropicPayload = buildAnthropicFromOpenAIChat(canonical, {
                     toolNameMap: aliasMap,
                     requestId: context.requestId

package/dist/conversion/responses/responses-openai-bridge.js

@@ -4,6 +4,7 @@ import { convertMessagesToBridgeInput, convertBridgeInputToChatMessages } from '
 import { createToolCallIdTransformer, enforceToolCallIdStyle, resolveToolCallIdStyle, stripInternalToolingMetadata, sanitizeResponsesFunctionName } from '../shared/responses-tool-utils.js';
 import { mapBridgeToolsToChat, mapChatToolsToBridge } from '../shared/tool-mapping.js';
 import { ProviderProtocolError } from '../shared/errors.js';
+import { readRuntimeMetadata } from '../shared/runtime-metadata.js';
 // --- Utilities (ported strictly) ---
 import { canonicalizeChatResponseTools } from '../shared/tool-canonicalizer.js';
 import { normalizeMessageReasoningTools } from '../shared/reasoning-tool-normalizer.js';
@@ -249,10 +250,25 @@ function mergeResponsesTools(originalTools, fromChat) {
 export function buildResponsesRequestFromChat(payload, ctx, extras) {
     const chat = unwrapData(payload);
     const out = {};
-    const forceWebSearch = !!ctx &&
-        isObject(ctx.metadata) &&
-        isObject(ctx.metadata.webSearch) &&
-        ctx.metadata.webSearch.force === true;
+    const forceWebSearch = (() => {
+        if (!ctx || typeof ctx !== 'object') {
+            return false;
+        }
+        const metaCarrier = ctx.metadata && typeof ctx.metadata === 'object'
+            ? ctx.metadata
+            : undefined;
+        const rt = readRuntimeMetadata(metaCarrier ?? null);
+        if (rt && typeof rt === 'object') {
+            if (rt.forceWebSearch === true) {
+                return true;
+            }
+            const webSearch = rt.webSearch;
+            if (webSearch && typeof webSearch === 'object' && webSearch.force === true) {
+                return true;
+            }
+        }
+        return false;
+    })();
     // 基本字段
     out.model = chat.model;
     // tools: 反向映射为 ResponsesToolDefinition 形状

package/dist/conversion/shared/gemini-tool-utils.d.ts

@@ -1,5 +1,12 @@
 import type { BridgeToolDefinition } from './bridge-message-types.js';
 import type { MissingField } from '../hub/types/chat-envelope.js';
 import type { JsonValue, JsonObject } from '../hub/types/json.js';
+export declare function isGeminiFunctionNameSafe(name: string): boolean;
+export declare function sanitizeGeminiFunctionName(name: string, options?: {
+    maxLen?: number;
+}): string;
+export type GeminiToolSchemaMode = 'default' | 'antigravity';
 export declare function prepareGeminiToolsForBridge(rawTools: JsonValue | undefined, missing?: MissingField[]): BridgeToolDefinition[] | undefined;
-export declare function buildGeminiToolsFromBridge(defs: BridgeToolDefinition[] | undefined): JsonObject[] | undefined;
+export declare function buildGeminiToolsFromBridge(defs: BridgeToolDefinition[] | undefined, options?: {
+    mode?: GeminiToolSchemaMode;
+}): JsonObject[] | undefined;