@jsonstudio/rcc 0.90.872 → 0.90.1270

package/node_modules/@jsonstudio/llms/dist/conversion/compat/profile-registry/registry.js

@@ -0,0 +1,154 @@
+/**
+ * Compat Profile Registry — loader and lookup.
+ *
+ * Parallel implementation (Step A). Loads all profile JSON files from disk,
+ * applies extended fields (headerPolicies, policyOverrides), and exposes
+ * a typed registry for downstream consumers.
+ *
+ * This is the THIN SHELL layer. The heavy validation (schema enforcement,
+ * action registration checks) will move to Rust per Guard #8.
+ * For now, we do minimal structural validation and fail-fast on missing data.
+ */
+import fs from 'node:fs';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+function getProfilesDir() {
+    return path.join(getCompatDir(), 'profiles');
+}
+function findPackageRoot(startDir) {
+    let current = startDir;
+    while (true) {
+        if (fs.existsSync(path.join(current, 'package.json'))) {
+            return current;
+        }
+        const parent = path.dirname(current);
+        if (parent === current) {
+            return null;
+        }
+        current = parent;
+    }
+}
+function findCompatDirFromModule() {
+    const moduleDir = path.dirname(fileURLToPath(import.meta.url));
+    const packageRoot = findPackageRoot(moduleDir);
+    if (!packageRoot) {
+        return null;
+    }
+    const candidates = [
+        path.join(packageRoot, 'dist', 'conversion', 'compat'),
+        path.join(packageRoot, 'src', 'conversion', 'compat')
+    ];
+    for (const candidate of candidates) {
+        if (fs.existsSync(path.join(candidate, 'profiles'))) {
+            return candidate;
+        }
+    }
+    return null;
+}
+function findCompatDirFromCwd() {
+    let current = process.cwd();
+    while (true) {
+        const candidates = [
+            path.join(current, 'src', 'conversion', 'compat'),
+            path.join(current, 'sharedmodule', 'llmswitch-core', 'src', 'conversion', 'compat'),
+            path.join(current, 'dist', 'conversion', 'compat'),
+            path.join(current, 'sharedmodule', 'llmswitch-core', 'dist', 'conversion', 'compat')
+        ];
+        for (const candidate of candidates) {
+            if (fs.existsSync(path.join(candidate, 'profiles'))) {
+                return candidate;
+            }
+        }
+        const parent = path.dirname(current);
+        if (parent === current) {
+            break;
+        }
+        current = parent;
+    }
+    throw new Error(`[CompatProfileRegistry] unable to locate compat directory from cwd=${process.cwd()}`);
+}
+function getCompatDir() {
+    const fromModule = findCompatDirFromModule();
+    if (fromModule) {
+        return fromModule;
+    }
+    return findCompatDirFromCwd();
+}
+/**
+ * Load all compat profile JSON files from the profiles directory.
+ * Returns a registry with profiles keyed by id.
+ *
+ * Fails fast on:
+ * - Missing or unreadable profiles directory
+ * - Invalid JSON in any profile file
+ * - Profile missing 'id' or 'protocol' fields
+ */
+export function loadCompatProfileRegistry(profilesDir) {
+    const dir = profilesDir ?? getProfilesDir();
+    if (!fs.existsSync(dir)) {
+        throw new Error(`[CompatProfileRegistry] profiles directory not found: ${dir}`);
+    }
+    const files = fs.readdirSync(dir).filter(f => f.endsWith('.json'));
+    const profiles = new Map();
+    for (const file of files) {
+        const filePath = path.join(dir, file);
+        const raw = fs.readFileSync(filePath, 'utf-8');
+        let entry;
+        try {
+            entry = JSON.parse(raw);
+        }
+        catch (err) {
+            throw new Error(`[CompatProfileRegistry] invalid JSON in ${filePath}: ${err instanceof Error ? err.message : String(err)}`);
+        }
+        if (typeof entry.id !== 'string' || !entry.id.trim()) {
+            throw new Error(`[CompatProfileRegistry] profile in ${filePath} is missing required field 'id'`);
+        }
+        if (typeof entry.protocol !== 'string') {
+            throw new Error(`[CompatProfileRegistry] profile "${entry.id}" in ${filePath} has invalid field 'protocol' (must be a string)`);
+        }
+        const profile = entry;
+        if (profiles.has(profile.id)) {
+            throw new Error(`[CompatProfileRegistry] duplicate profile id "${profile.id}" in ${filePath} (already loaded from another file)`);
+        }
+        profiles.set(profile.id, profile);
+    }
+    // Load provider-resolution-config.json (provider type / outbound / compat profile resolution)
+    const compatDir = profilesDir ? path.dirname(dir) : getCompatDir();
+    const configPath = path.join(compatDir, 'provider-resolution-config.json');
+    let providerResolutionConfig;
+    if (fs.existsSync(configPath)) {
+        const configRaw = fs.readFileSync(configPath, 'utf-8');
+        try {
+            providerResolutionConfig = JSON.parse(configRaw);
+        }
+        catch (err) {
+            throw new Error(`[CompatProfileRegistry] invalid JSON in ${configPath}: ${err instanceof Error ? err.message : String(err)}`);
+        }
+    }
+    return { profiles, providerBlocks: [], providerResolutionConfig };
+}
+/**
+ * Look up a profile by id. Throws if not found (fail-fast, no fallback).
+ */
+export function getProfile(registry, profileId) {
+    const entry = registry.profiles.get(profileId);
+    if (!entry) {
+        throw new Error(`[CompatProfileRegistry] profile not found: "${profileId}". ` +
+            `Available: ${[...registry.profiles.keys()].join(', ')}`);
+    }
+    return entry;
+}
+/**
+ * Get header policy rules for a profile (empty array if none).
+ */
+export function getHeaderPolicies(registry, profileId) {
+    const entry = getProfile(registry, profileId);
+    return entry.headerPolicies ?? [];
+}
+/**
+ * Get policy overrides for a profile (undefined if none).
+ */
+export function getPolicyOverrides(registry, profileId) {
+    const entry = getProfile(registry, profileId);
+    return entry.policyOverrides;
+}

package/node_modules/@jsonstudio/llms/dist/conversion/compat/profile-registry/types.d.ts

@@ -0,0 +1,75 @@
+/**
+ * Compat Profile Registry — type definitions.
+ *
+ * Parallel implementation (Step A). These types describe the NEW config-driven
+ * header policy and policy override structures. They do NOT affect existing
+ * runtime code until Step B wires them in.
+ */
+export interface HeaderPolicyWhen {
+    /** Match when the provider ID (lowercase) equals this value. */
+    providerId?: string;
+    /** Match when the provider type (lowercase) contains this substring. */
+    providerTypeContains?: string;
+}
+export interface HeaderPolicyRule {
+    /** Condition guard — ALL fields must match for the rule to fire. */
+    when: HeaderPolicyWhen;
+    /** Headers to set only if the key is NOT already present. */
+    setIfMissing?: Record<string, string>;
+    /** Headers to unconditionally set (overwrite). */
+    set?: Record<string, string>;
+}
+export interface PolicyPhaseOverride {
+    /** When true, policy observation/enforcement is skipped for this profile. */
+    skip: boolean;
+}
+export interface PolicyOverrideConfig {
+    observe?: PolicyPhaseOverride;
+    enforce?: PolicyPhaseOverride;
+}
+export interface CompatProfileEntry {
+    id: string;
+    protocol: string;
+    /** Declarative header injection rules evaluated at provider-normalization time. */
+    headerPolicies?: HeaderPolicyRule[];
+    /** Policy engine overrides evaluated at hub-policy time. */
+    policyOverrides?: PolicyOverrideConfig;
+    request?: unknown;
+    response?: unknown;
+    [key: string]: unknown;
+}
+export interface ProviderCompatBlock {
+    /** Provider ID pattern (lowercase exact match). */
+    providerId?: string;
+    /** Provider type pattern (lowercase substring match). */
+    providerTypeContains?: string;
+    /** The compatibility profile ID to resolve to. */
+    compatibilityProfile: string;
+    /** The outbound wire protocol to resolve to. */
+    outboundProfile: string;
+}
+export interface CompatProfileRegistry {
+    /** All loaded profiles keyed by id. */
+    profiles: Map<string, CompatProfileEntry>;
+    /** Provider compat blocks for default-profile resolution. */
+    providerBlocks: ProviderCompatBlock[];
+    /** Config-driven provider type / outbound / default-profile resolution. */
+    providerResolutionConfig?: ProviderResolutionConfig;
+}
+export interface TypeKeywordRule {
+    keywords: string[];
+    providerType: string;
+}
+export interface CompatibilityProfileBlock {
+    providerId?: string;
+    providerTypeContains?: string;
+    compatibilityProfile: string;
+}
+export interface ProviderResolutionConfig {
+    typeKeywords: TypeKeywordRule[];
+    defaultProviderType: string;
+    outboundProfiles: Record<string, string>;
+    defaultOutboundProfile: string;
+    compatibilityProfileBlocks: CompatibilityProfileBlock[];
+    defaultCompatibilityProfile: string;
+}

package/node_modules/@jsonstudio/llms/dist/conversion/compat/profile-registry/types.js

@@ -0,0 +1,8 @@
+/**
+ * Compat Profile Registry — type definitions.
+ *
+ * Parallel implementation (Step A). These types describe the NEW config-driven
+ * header policy and policy override structures. They do NOT affect existing
+ * runtime code until Step B wires them in.
+ */
+export {};

package/node_modules/@jsonstudio/llms/dist/conversion/compat/profiles/anthropic-claude-code.json

@@ -4,14 +4,20 @@
   "request": {
     "mappings": [
       { "action": "snapshot", "phase": "compat-pre" },
-      {
-        "action": "anthropic_claude_code_system_prompt",
-        "config": { "preserveExistingSystemAsUserMessage": true }
-      },
+      { "action": "anthropic_claude_code_system_prompt", "config": { "preserveExistingSystemAsUserMessage": true } },
       { "action": "snapshot", "phase": "compat-post" }
     ]
   },
-  "response": {
-    "mappings": []
-  }
+  "response": { "mappings": [] },
+  "headerPolicies": [
+    {
+      "when": { "providerTypeContains": "anthropic" },
+      "setIfMissing": {
+        "User-Agent": "claude-cli/2.0.76 (external, cli)",
+        "X-App": "claude-cli",
+        "X-App-Version": "2.0.76",
+        "anthropic-beta": "claude-code"
+      }
+    }
+  ]
 }

package/node_modules/@jsonstudio/llms/dist/conversion/compat/profiles/chat-claude-code.json

@@ -4,15 +4,20 @@
   "request": {
     "mappings": [
       { "action": "snapshot", "phase": "compat-pre" },
-      {
-        "action": "anthropic_claude_code_system_prompt",
-        "config": { "preserveExistingSystemAsUserMessage": true }
-      },
+      { "action": "anthropic_claude_code_system_prompt", "config": { "preserveExistingSystemAsUserMessage": true } },
       { "action": "snapshot", "phase": "compat-post" }
     ]
   },
-  "response": {
-    "mappings": []
-  }
+  "response": { "mappings": [] },
+  "headerPolicies": [
+    {
+      "when": { "providerTypeContains": "anthropic" },
+      "setIfMissing": {
+        "User-Agent": "claude-cli/2.0.76 (external, cli)",
+        "X-App": "claude-cli",
+        "X-App-Version": "2.0.76",
+        "anthropic-beta": "claude-code"
+      }
+    }
+  ]
 }
-

package/node_modules/@jsonstudio/llms/dist/conversion/compat/profiles/chat-deepseek-web.json

@@ -3,7 +3,10 @@
   "protocol": "openai-chat",
   "request": {
     "mappings": [
-      { "action": "snapshot", "phase": "compat-pre" },
+      {
+        "action": "snapshot",
+        "phase": "compat-pre"
+      },
       {
         "action": "tool_text_request_guidance",
         "config": {
@@ -12,13 +15,21 @@
           "requireTools": true
         }
       },
-      { "action": "deepseek_web_request" },
-      { "action": "snapshot", "phase": "compat-post" }
+      {
+        "action": "deepseek_web_request"
+      },
+      {
+        "action": "snapshot",
+        "phase": "compat-post"
+      }
     ]
   },
   "response": {
     "mappings": [
-      { "action": "snapshot", "phase": "compat-pre" },
+      {
+        "action": "snapshot",
+        "phase": "compat-pre"
+      },
       {
         "action": "deepseek_web_response",
         "config": {
@@ -32,16 +43,34 @@
               },
               "argumentAliases": {
                 "exec_command": {
-                  "cmd": ["cmd", "command", "input.command", "script"],
-                  "command": ["cmd", "command", "input.command", "script"],
-                  "workdir": ["workdir", "cwd", "input.cwd"]
+                  "workdir": [
+                    "workdir",
+                    "cwd",
+                    "input.cwd"
+                  ]
                 }
               }
             }
           }
         }
       },
-      { "action": "snapshot", "phase": "compat-post" }
+      {
+        "action": "snapshot",
+        "phase": "compat-post"
+      }
     ]
+  },
+  "policyOverrides": {
+    "observe": {
+      "skip": true
+    },
+    "enforce": {
+      "skip": true
+    }
+  },
+  "sdkBinding": {
+    "family": "custom-runtime",
+    "supported": false,
+    "notes": "Web-account text-tool providers require the existing RouteCodex runtime path."
   }
 }

package/node_modules/@jsonstudio/llms/dist/conversion/compat/profiles/chat-qwen.json

@@ -3,20 +3,57 @@
   "protocol": "openai-chat",
   "request": {
     "mappings": [
-      { "action": "snapshot", "phase": "compat-pre" },
-      { "action": "dto_unwrap" },
-      { "action": "qwen_request_transform" },
-      { "action": "snapshot", "phase": "compat-post" },
-      { "action": "dto_rewrap" }
+      {
+        "action": "snapshot",
+        "phase": "compat-pre"
+      },
+      {
+        "action": "dto_unwrap"
+      },
+      {
+        "action": "qwen_request_transform"
+      },
+      {
+        "action": "snapshot",
+        "phase": "compat-post"
+      },
+      {
+        "action": "dto_rewrap"
+      }
     ]
   },
   "response": {
     "mappings": [
-      { "action": "snapshot", "phase": "compat-pre" },
-      { "action": "dto_unwrap" },
-      { "action": "qwen_response_transform" },
-      { "action": "snapshot", "phase": "compat-post" },
-      { "action": "dto_rewrap" }
+      {
+        "action": "snapshot",
+        "phase": "compat-pre"
+      },
+      {
+        "action": "dto_unwrap"
+      },
+      {
+        "action": "qwen_response_transform"
+      },
+      {
+        "action": "snapshot",
+        "phase": "compat-post"
+      },
+      {
+        "action": "dto_rewrap"
+      }
     ]
-  }
+  },
+  "headerPolicies": [
+    {
+      "when": {
+        "providerId": "qwen"
+      },
+      "setIfMissing": {
+        "X-DashScope-UserAgent": "QwenCode/0.14.3 (darwin; arm64)",
+        "X-DashScope-CacheControl": "enable",
+        "X-DashScope-AuthType": "qwen-oauth",
+        "User-Agent": "QwenCode/0.14.3 (darwin; arm64)"
+      }
+    }
+  ]
 }

package/node_modules/@jsonstudio/llms/dist/conversion/compat/profiles/compat-passthrough.json

@@ -0,0 +1,6 @@
+{
+  "id": "compat:passthrough",
+  "protocol": "openai-chat",
+  "request": { "mappings": [] },
+  "response": { "mappings": [] }
+}

package/node_modules/@jsonstudio/llms/dist/conversion/compat/provider-resolution-config.json

@@ -0,0 +1,24 @@
+{
+    "typeKeywords": [
+        { "keywords": ["anthropic", "claude"], "providerType": "anthropic" },
+        { "keywords": ["responses"], "providerType": "responses" },
+        { "keywords": ["gemini"], "providerType": "gemini" },
+        { "keywords": ["qwen"], "providerType": "qwen" },
+        { "keywords": ["glm"], "providerType": "glm" },
+        { "keywords": ["lmstudio"], "providerType": "lmstudio" }
+    ],
+    "defaultProviderType": "openai",
+    "outboundProfiles": {
+        "anthropic": "anthropic-messages",
+        "responses": "openai-responses",
+        "gemini": "gemini-chat"
+    },
+    "defaultOutboundProfile": "openai-chat",
+    "compatibilityProfileBlocks": [
+        { "providerId": "antigravity", "compatibilityProfile": "chat:gemini-cli" },
+        { "providerId": "gemini-cli", "compatibilityProfile": "chat:gemini-cli" },
+        { "providerTypeContains": "antigravity", "compatibilityProfile": "chat:gemini-cli" },
+        { "providerTypeContains": "gemini-cli", "compatibilityProfile": "chat:gemini-cli" }
+    ],
+    "defaultCompatibilityProfile": "compat:passthrough"
+}

package/node_modules/@jsonstudio/llms/dist/conversion/hub/node-support.js

@@ -53,8 +53,11 @@ export async function runHubOutboundConversion(options) {
     return payload;
 }
 function maybeCreateStageRecorder(adapterContext, defaultEndpoint) {
-    const flag = process.env.ROUTECODEX_HUB_SNAPSHOTS;
-    if (flag && flag.trim() === '0') {
+    const flag = String(process.env.ROUTECODEX_HUB_SNAPSHOTS ?? process.env.RCC_HUB_SNAPSHOTS ?? '')
+        .trim()
+        .toLowerCase();
+    const enabled = flag === '1' || flag === 'true' || flag === 'yes' || flag === 'on';
+    if (!enabled) {
         return undefined;
     }
     const endpoint = defaultEndpoint || adapterContext.entryEndpoint || '/v1/chat/completions';

package/node_modules/@jsonstudio/llms/dist/conversion/hub/operation-table/semantic-mappers/anthropic-mapper-config.js

@@ -32,7 +32,6 @@ export const PASSTHROUGH_METADATA_PREFIX = 'rcc_passthrough_';
 export const PASSTHROUGH_PARAMETERS = ['tool_choice'];
 export const RESPONSES_DROPPED_PARAMETER_KEYS = [
     'prompt_cache_key',
-    'response_format',
     'parallel_tool_calls',
     'service_tier',
     'truncation',

package/node_modules/@jsonstudio/llms/dist/conversion/hub/operation-table/semantic-mappers/anthropic-mapper-from-chat.js

@@ -4,8 +4,15 @@ import { buildAnthropicFromOpenAIChatWithNative } from '../../../../router/virtu
 import { encodeMetadataPassthrough } from '../../../metadata-passthrough.js';
 import { isHubStageTimingDetailEnabled, logHubStageTiming } from '../../pipeline/hub-stage-timing.js';
 import { applyEffortBudget, buildAnthropicThinkingFromConfig, mergeAnthropicOutputConfig, mergeAnthropicThinkingConfig, normalizeAnthropicThinkingConfigFromUnknown, resolveConfiguredAnthropicThinkingBudgets, resolveConfiguredAnthropicThinkingConfig } from './anthropic-thinking-config.js';
-import { appendDroppedFieldAudit, appendLossyFieldAudit, hasExplicitEmptyToolsSemantics, isResponsesOrigin, } from './anthropic-semantics-audit.js';
+import { appendDroppedFieldAudit, appendLossyFieldAudit, appendPreservedFieldAudit, appendUnsupportedFieldAudit, hasExplicitEmptyToolsSemantics, isResponsesOrigin, } from './anthropic-semantics-audit.js';
 import { ANTHROPIC_TOP_LEVEL_FIELDS, PASSTHROUGH_METADATA_PREFIX, PASSTHROUGH_PARAMETERS, RESPONSES_DROPPED_PARAMETER_KEYS, sanitizeAnthropicPayload, } from './anthropic-mapper-config.js';
+function getAnthropicSemanticsNode(chat) {
+    if (!chat.semantics || typeof chat.semantics !== 'object') {
+        return undefined;
+    }
+    const node = chat.semantics.anthropic;
+    return node && isJsonObject(node) ? node : undefined;
+}
 const TRUTHY = new Set(['1', 'true', 'yes', 'on']);
 const FALSY = new Set(['0', 'false', 'no', 'off']);
 const DEFAULT_HEAVY_INPUT_THRESHOLD = 120_000;
@@ -78,6 +85,15 @@ function hasAnthropicSystemSemantic(chat) {
         return false;
     }
 }
+function hasChatSystemMessage(chat) {
+    return Array.isArray(chat.messages)
+        && chat.messages.some((message) => {
+            if (!message || typeof message !== 'object') {
+                return false;
+            }
+            return message.role === 'system';
+        });
+}
 export function buildAnthropicFormatEnvelopeFromChat(chat, ctx) {
     const requestId = typeof ctx.requestId === 'string' && ctx.requestId.trim().length
         ? ctx.requestId
@@ -107,6 +123,13 @@ export function buildAnthropicFormatEnvelopeFromChat(chat, ctx) {
             });
         }
     }
+    if (trimmedParameters && Object.prototype.hasOwnProperty.call(trimmedParameters, 'response_format')) {
+        appendUnsupportedFieldAudit(chat, {
+            field: 'response_format',
+            targetProtocol: 'anthropic-messages',
+            reason: 'structured_output_not_supported'
+        });
+    }
     if (trimmedParameters) {
         for (const [key, value] of Object.entries(trimmedParameters)) {
             if (ANTHROPIC_TOP_LEVEL_FIELDS.has(key) || key === 'stop') {
@@ -117,6 +140,13 @@ export function buildAnthropicFormatEnvelopeFromChat(chat, ctx) {
             }
         }
     }
+    if (trimmedParameters && Object.prototype.hasOwnProperty.call(trimmedParameters, 'tool_choice')) {
+        appendPreservedFieldAudit(chat, {
+            field: 'tool_choice',
+            targetProtocol: 'anthropic-messages',
+            reason: 'preserved_verbatim_top_level'
+        });
+    }
     const passthroughMetadata = encodeMetadataPassthrough(chat.parameters, {
         prefix: PASSTHROUGH_METADATA_PREFIX,
         keys: PASSTHROUGH_PARAMETERS
@@ -163,21 +193,38 @@ export function buildAnthropicFormatEnvelopeFromChat(chat, ctx) {
         baseRequest.tools = [];
     }
     try {
-        const sysNode = chat.semantics && typeof chat.semantics === 'object' ? chat.semantics.system : undefined;
-        if (sysNode && typeof sysNode === 'object' && !Array.isArray(sysNode) && sysNode.blocks !== undefined) {
-            baseRequest.system = jsonClone(sysNode.blocks);
+        const anthropicSemantics = getAnthropicSemanticsNode(chat);
+        if (!hasChatSystemMessage(chat)) {
+            const sysBlocks = anthropicSemantics?.systemBlocks;
+            if (Array.isArray(sysBlocks) && sysBlocks.length > 0) {
+                baseRequest.system = jsonClone(sysBlocks);
+            }
+            else {
+                const sysNode = chat.semantics && typeof chat.semantics === 'object' ? chat.semantics.system : undefined;
+                if (sysNode && typeof sysNode === 'object' && !Array.isArray(sysNode) && sysNode.blocks !== undefined) {
+                    baseRequest.system = jsonClone(sysNode.blocks);
+                }
+            }
         }
     }
     catch {
         // ignore
     }
     try {
+        const anthropicSemantics = getAnthropicSemanticsNode(chat);
         const extras = chat.semantics && typeof chat.semantics === 'object' ? chat.semantics.providerExtras : undefined;
-        const mirror = extras && typeof extras === 'object' && !Array.isArray(extras) ? extras.anthropicMirror : undefined;
-        if (mirror && typeof mirror === 'object' && !Array.isArray(mirror)) {
+        const mirror = anthropicSemantics?.messageContentShape;
+        if (mirror !== undefined) {
             baseRequest.__anthropicMirror = jsonClone(mirror);
         }
-        const providerMetadata = extras && typeof extras === 'object' && !Array.isArray(extras) ? extras.providerMetadata : undefined;
+        else {
+            const legacyMirror = extras && typeof extras === 'object' && !Array.isArray(extras) ? extras.anthropicMirror : undefined;
+            if (legacyMirror && typeof legacyMirror === 'object' && !Array.isArray(legacyMirror)) {
+                baseRequest.__anthropicMirror = jsonClone(legacyMirror);
+            }
+        }
+        const providerMetadata = anthropicSemantics?.providerMetadata ??
+            (extras && typeof extras === 'object' && !Array.isArray(extras) ? extras.providerMetadata : undefined);
         if (providerMetadata && typeof providerMetadata === 'object' && !Array.isArray(providerMetadata)) {
             const existing = baseRequest.metadata && isJsonObject(baseRequest.metadata)
                 ? jsonClone(baseRequest.metadata)

package/node_modules/@jsonstudio/llms/dist/conversion/hub/operation-table/semantic-mappers/anthropic-mapper-to-chat.js

@@ -2,7 +2,8 @@ import { isJsonObject, jsonClone } from '../../types/json.js';
 import { buildOpenAIChatFromAnthropic } from '../../../codecs/anthropic-openai-codec.js';
 import { extractMetadataPassthrough } from '../../../metadata-passthrough.js';
 import { buildAnthropicToolAliasMapWithNative } from '../../../../router/virtual-router/engine-selection/native-chat-process-governance-semantics.js';
-import { cloneAnthropicSystemBlocks, ensureSemantics, ensureToolsSemanticsNode, markExplicitEmptyTools } from './anthropic-semantics-audit.js';
+import { normalizeAnthropicToolAliasMap } from '../../process/chat-process-anthropic-alias.js';
+import { cloneAnthropicSystemBlocks, ensureAnthropicSemanticsNode, ensureSemantics, ensureToolsSemanticsNode, markExplicitEmptyTools } from './anthropic-semantics-audit.js';
 import { collectAnthropicParameters, PASSTHROUGH_METADATA_PREFIX, PASSTHROUGH_PARAMETERS } from './anthropic-mapper-config.js';
 export async function buildAnthropicChatEnvelopeFromPayload(payload, ctx, chatMapper) {
     const missing = [];
@@ -38,14 +39,22 @@ export async function buildAnthropicChatEnvelopeFromPayload(payload, ctx, chatMa
     const systemBlocks = cloneAnthropicSystemBlocks(payload.system);
     if (systemBlocks) {
         semantics.system.blocks = jsonClone(systemBlocks);
+        const anthropicNode = ensureAnthropicSemanticsNode(chatEnvelope);
+        anthropicNode.systemBlocks = jsonClone(systemBlocks);
     }
     if (payload.tools && Array.isArray(payload.tools) && payload.tools.length === 0) {
         markExplicitEmptyTools(chatEnvelope);
     }
-    const aliasMap = buildAnthropicToolAliasMapWithNative(payload.tools);
+    if (Array.isArray(payload.tools) && payload.tools.length > 0) {
+        const anthropicNode = ensureAnthropicSemanticsNode(chatEnvelope);
+        anthropicNode.clientToolsRaw = jsonClone(payload.tools);
+    }
+    const aliasMap = normalizeAnthropicToolAliasMap(buildAnthropicToolAliasMapWithNative(payload.tools));
     if (aliasMap) {
         const toolsNode = ensureToolsSemanticsNode(chatEnvelope);
         toolsNode.toolNameAliasMap = jsonClone(aliasMap);
+        const anthropicNode = ensureAnthropicSemanticsNode(chatEnvelope);
+        anthropicNode.toolNameAliasMap = jsonClone(aliasMap);
     }
     if (Array.isArray(payload.messages) && payload.messages.length) {
         const shapes = payload.messages.map((entry) => {
@@ -66,6 +75,8 @@ export async function buildAnthropicChatEnvelopeFromPayload(payload, ctx, chatMa
         });
         const mirrorNode = { messageContentShape: shapes };
         semantics.providerExtras.anthropicMirror = jsonClone(mirrorNode);
+        const anthropicNode = ensureAnthropicSemanticsNode(chatEnvelope);
+        anthropicNode.messageContentShape = jsonClone(mirrorNode.messageContentShape);
     }
     if (missing.length) {
         metadata.missingFields = Array.isArray(metadata.missingFields)
@@ -76,6 +87,8 @@ export async function buildAnthropicChatEnvelopeFromPayload(payload, ctx, chatMa
         (payload.metadata && isJsonObject(payload.metadata) ? jsonClone(payload.metadata) : undefined);
     if (providerMetadata) {
         semantics.providerExtras.providerMetadata = jsonClone(providerMetadata);
+        const anthropicNode = ensureAnthropicSemanticsNode(chatEnvelope);
+        anthropicNode.providerMetadata = jsonClone(providerMetadata);
     }
     const mergedParameters = { ...(chatEnvelope.parameters ?? {}) };
     const mergeParameters = (source) => {