@jsonstudio/llms 0.6.1172 → 0.6.1397

package/dist/conversion/hub/pipeline/stages/resp_outbound/resp_outbound_stage1_client_remap/index.js

@@ -8,24 +8,28 @@ export function runRespOutboundStage1ClientRemap(options) {
     }
     else if (options.clientProtocol === 'anthropic-messages') {
         clientPayload = buildAnthropicResponseFromChat(options.payload, {
-            aliasMap: resolveAliasMapFromContext(options.adapterContext)
+            aliasMap: resolveAliasMapFromSemantics(options.requestSemantics)
         });
     }
     else {
-        const toolsRaw = resolveClientToolsRawFromContext(options.adapterContext);
+        const toolsRaw = resolveClientToolsRawFromSemantics(options.requestSemantics);
         clientPayload = buildResponsesPayloadFromChat(options.payload, {
             requestId: options.requestId,
             ...(toolsRaw ? { toolsRaw } : {})
         });
     }
-    recordStage(options.stageRecorder, 'resp_outbound_stage1_client_remap', clientPayload);
+    recordStage(options.stageRecorder, 'chat_process.resp.stage9.client_remap', clientPayload);
     return clientPayload;
 }
-function resolveAliasMapFromContext(adapterContext) {
-    if (!adapterContext) {
+function resolveAliasMapFromSemantics(semantics) {
+    if (!semantics || typeof semantics !== 'object' || Array.isArray(semantics)) {
         return undefined;
     }
-    const candidate = adapterContext.anthropicToolNameMap;
+    const toolsNode = semantics.tools;
+    if (!toolsNode || typeof toolsNode !== 'object' || Array.isArray(toolsNode)) {
+        return undefined;
+    }
+    const candidate = toolsNode.toolNameAliasMap;
     if (!candidate || typeof candidate !== 'object' || Array.isArray(candidate)) {
         return undefined;
     }
@@ -43,11 +47,15 @@ function resolveAliasMapFromContext(adapterContext) {
     }
     return Object.keys(map).length ? map : undefined;
 }
-function resolveClientToolsRawFromContext(adapterContext) {
-    if (!adapterContext) {
+function resolveClientToolsRawFromSemantics(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 = adapterContext.clientToolsRaw;
+    const candidate = toolsNode.clientToolsRaw;
     if (!candidate || !Array.isArray(candidate)) {
         return undefined;
     }

package/dist/conversion/hub/pipeline/stages/resp_outbound/resp_outbound_stage2_sse_stream/index.js

@@ -2,7 +2,7 @@ import { defaultSseCodecRegistry } from '../../../../../../sse/index.js';
 import { recordStage } from '../../../stages/utils.js';
 export async function runRespOutboundStage2SseStream(options) {
     if (!options.wantsStream) {
-        recordStage(options.stageRecorder, 'resp_outbound_stage2_sse_stream', {
+        recordStage(options.stageRecorder, 'chat_process.resp.stage10.sse_stream', {
             passthrough: false,
             protocol: options.clientProtocol,
             payload: options.clientPayload
@@ -13,7 +13,7 @@ export async function runRespOutboundStage2SseStream(options) {
     const stream = await codec.convertJsonToSse(options.clientPayload, {
         requestId: options.requestId
     });
-    recordStage(options.stageRecorder, 'resp_outbound_stage2_sse_stream', {
+    recordStage(options.stageRecorder, 'chat_process.resp.stage10.sse_stream', {
         passthrough: false,
         protocol: options.clientProtocol,
         payload: options.clientPayload

package/dist/conversion/hub/pipeline/stages/resp_process/resp_process_stage1_tool_governance/index.js

@@ -1,17 +1,55 @@
 import { runChatResponseToolFilters } from '../../../../../shared/tool-filter-pipeline.js';
 import { normalizeApplyPatchToolCallsOnResponse } from '../../../../../shared/tool-governor.js';
+import { buildChatResponseFromResponses } from '../../../../../shared/responses-response-utils.js';
 import { ToolGovernanceEngine } from '../../../../tool-governance/index.js';
 import { recordStage } from '../../../stages/utils.js';
 const toolGovernanceEngine = new ToolGovernanceEngine();
+function isCanonicalChatCompletion(payload) {
+    if (!payload || typeof payload !== 'object' || Array.isArray(payload)) {
+        return false;
+    }
+    const obj = payload;
+    const choices = Array.isArray(obj.choices) ? obj.choices : [];
+    if (!choices.length)
+        return false;
+    const first = choices[0] && typeof choices[0] === 'object' && !Array.isArray(choices[0]) ? choices[0] : null;
+    if (!first)
+        return false;
+    const msg = first.message;
+    return Boolean(msg && typeof msg === 'object' && !Array.isArray(msg));
+}
+function coerceToCanonicalChatCompletion(payload) {
+    if (isCanonicalChatCompletion(payload)) {
+        return payload;
+    }
+    // ServerTool followups may re-enter via the client protocol shape (e.g. OpenAI Responses object:'response').
+    // Response tool governance requires an OpenAI-chat-like surface (choices[].message) so text tool harvesting
+    // and tool governance remain a single fixed path.
+    try {
+        const coerced = buildChatResponseFromResponses(payload);
+        if (isCanonicalChatCompletion(coerced)) {
+            return coerced;
+        }
+    }
+    catch {
+        // best-effort: keep original payload when bridge fails
+    }
+    return payload;
+}
 export async function runRespProcessStage1ToolGovernance(options) {
-    const filtered = await runChatResponseToolFilters(options.payload, {
+    const canonicalInput = coerceToCanonicalChatCompletion(options.payload);
+    recordStage(options.stageRecorder, 'chat_process.resp.stage6.canonicalize_chat_completion', {
+        converted: canonicalInput !== options.payload,
+        canonicalPayload: canonicalInput
+    });
+    const filtered = await runChatResponseToolFilters(canonicalInput, {
         entryEndpoint: options.entryEndpoint,
         requestId: options.requestId,
         profile: 'openai-chat'
     });
     const patched = normalizeApplyPatchToolCallsOnResponse(filtered);
     const { payload: governed, summary } = toolGovernanceEngine.governResponse(patched, options.clientProtocol);
-    recordStage(options.stageRecorder, 'resp_process_stage1_tool_governance', {
+    recordStage(options.stageRecorder, 'chat_process.resp.stage7.tool_governance', {
         summary,
         applied: summary?.applied,
         filteredPayload: patched,

package/dist/conversion/hub/pipeline/stages/resp_process/resp_process_stage2_finalize/index.js

@@ -11,7 +11,7 @@ export async function runRespProcessStage2Finalize(options) {
     const processedRequest = buildProcessedRequestFromChatResponse(finalized, {
         stream: options.wantsStream
     });
-    recordStage(options.stageRecorder, 'resp_process_stage2_finalize', {
+    recordStage(options.stageRecorder, 'chat_process.resp.stage8.finalize', {
         model: finalized.model,
         stream: options.wantsStream
     });

package/dist/conversion/hub/pipeline/target-utils.js

@@ -1,3 +1,4 @@
+import { ensureRuntimeMetadata } from '../../shared/runtime-metadata.js';
 export function applyTargetMetadata(metadata, target, routeName, originalModel) {
     if (!metadata || typeof metadata !== 'object') {
         return;
@@ -9,11 +10,14 @@ export function applyTargetMetadata(metadata, target, routeName, originalModel)
     metadata.providerType = target.providerType;
     metadata.modelId = target.modelId;
     metadata.processMode = target.processMode || 'chat';
-    if (target.forceWebSearch === true) {
-        metadata.forceWebSearch = true;
-    }
-    if (target.forceVision === true) {
-        metadata.forceVision = true;
+    if (target.forceWebSearch === true || target.forceVision === true) {
+        const rt = ensureRuntimeMetadata(metadata);
+        if (target.forceWebSearch === true) {
+            rt.forceWebSearch = true;
+        }
+        if (target.forceVision === true) {
+            rt.forceVision = true;
+        }
     }
     if (target.responsesConfig?.toolCallIdStyle) {
         metadata.toolCallIdStyle = target.responsesConfig.toolCallIdStyle;

package/dist/conversion/hub/pipeline/thought-signature/thought-signature-center.d.ts

@@ -0,0 +1,14 @@
+import type { AdapterContext } from '../../types/chat-envelope.js';
+import type { JsonObject } from '../../types/json.js';
+export declare const SKIP_THOUGHT_SIGNATURE = "skip_thought_signature_validator";
+type LastEntry = {
+    text: string;
+    signature: string;
+    timestamp: number;
+};
+export declare function buildThoughtSignatureSessionKey(ctx: AdapterContext, payload?: JsonObject): string | undefined;
+export declare function cacheThoughtSignature(sessionKey: string, text: unknown, signature: unknown): void;
+export declare function getCachedThoughtSignature(sessionKey: string, text: unknown): string | undefined;
+export declare function getLastThoughtSignature(sessionKey: string): LastEntry | undefined;
+export declare function shouldHandleThoughtSignature(ctx: AdapterContext): boolean;
+export {};

package/dist/conversion/hub/pipeline/thought-signature/thought-signature-center.js

@@ -0,0 +1,289 @@
+import { createHash } from 'node:crypto';
+import fs from 'node:fs';
+import path from 'node:path';
+import os from 'node:os';
+export const SKIP_THOUGHT_SIGNATURE = 'skip_thought_signature_validator';
+const MEMORY_TTL_MS = 12 * 60 * 60 * 1000;
+const DISK_TTL_MS = 12 * 60 * 60 * 1000;
+const WRITE_INTERVAL_MS = 60 * 1000;
+const MAX_ENTRIES_PER_SESSION = 50;
+const MAX_SESSIONS = 200;
+const TEXT_HASH_HEX_LEN = 16;
+const sessionStores = new Map();
+const sessionLast = new Map();
+const diskEntries = new Map();
+let dirty = false;
+let writeTimer;
+let cleanupTimer;
+const stats = {
+    memoryHits: 0,
+    diskHits: 0,
+    misses: 0,
+    writes: 0,
+    lastWrite: 0
+};
+function resolveDefaultCachePath() {
+    const env = (process.env.ROUTECODEX_THOUGHT_SIGNATURE_CACHE_PATH ||
+        process.env.RCC_THOUGHT_SIGNATURE_CACHE_PATH ||
+        '').trim();
+    if (env)
+        return env;
+    const home = process.env.HOME || os.homedir() || '';
+    return path.join(home, '.routecodex', 'antigravity-signature-cache.json');
+}
+const persistencePath = resolveDefaultCachePath();
+function now() {
+    return Date.now();
+}
+function normalizeText(value) {
+    if (typeof value !== 'string')
+        return undefined;
+    const trimmed = value.trim();
+    return trimmed.length ? trimmed : undefined;
+}
+function normalizeSignature(value) {
+    if (typeof value !== 'string')
+        return undefined;
+    const trimmed = value.trim();
+    return trimmed.length ? trimmed : undefined;
+}
+function hashText(text) {
+    return createHash('sha256').update(text, 'utf8').digest('hex').slice(0, TEXT_HASH_HEX_LEN);
+}
+function makeDiskKey(sessionKey, textHash) {
+    return `${sessionKey}:${textHash}`;
+}
+function ensureSession(sessionKey) {
+    let store = sessionStores.get(sessionKey);
+    if (!store) {
+        pruneSessionsIfNeeded();
+        store = new Map();
+        sessionStores.set(sessionKey, store);
+    }
+    return store;
+}
+function pruneSession(store) {
+    const cutoff = now() - MEMORY_TTL_MS;
+    for (const [key, entry] of store) {
+        if (entry.timestamp < cutoff) {
+            store.delete(key);
+        }
+    }
+    if (store.size < MAX_ENTRIES_PER_SESSION)
+        return;
+    const entries = Array.from(store.entries()).sort((a, b) => a[1].timestamp - b[1].timestamp);
+    const toRemove = entries.slice(0, Math.floor(MAX_ENTRIES_PER_SESSION / 4));
+    for (const [key] of toRemove) {
+        store.delete(key);
+    }
+}
+function ensureCacheDir(filePath) {
+    try {
+        fs.mkdirSync(path.dirname(filePath), { recursive: true });
+    }
+    catch {
+        // best-effort
+    }
+}
+function loadPersistedCache() {
+    try {
+        if (!fs.existsSync(persistencePath))
+            return;
+        const raw = fs.readFileSync(persistencePath, 'utf-8');
+        if (!raw.trim())
+            return;
+        const parsed = JSON.parse(raw);
+        if (!parsed || parsed.version !== '1.0')
+            return;
+        const cutoff = now() - DISK_TTL_MS;
+        for (const [key, entry] of Object.entries(parsed.entries || {})) {
+            if (!entry || typeof entry.signature !== 'string')
+                continue;
+            const ts = typeof entry.timestamp === 'number' ? entry.timestamp : now();
+            if (ts < cutoff)
+                continue;
+            diskEntries.set(key, { signature: entry.signature, timestamp: ts });
+        }
+    }
+    catch {
+        // best-effort
+    }
+}
+function schedulePersist() {
+    if (writeTimer)
+        return;
+    writeTimer = setInterval(() => {
+        if (dirty) {
+            persistCache();
+        }
+    }, WRITE_INTERVAL_MS);
+    if (typeof writeTimer.unref === 'function') {
+        writeTimer.unref();
+    }
+}
+function scheduleCleanup() {
+    if (cleanupTimer)
+        return;
+    cleanupTimer = setInterval(() => {
+        const cutoff = now() - MEMORY_TTL_MS;
+        for (const store of sessionStores.values()) {
+            for (const [key, entry] of store.entries()) {
+                if (entry.timestamp < cutoff) {
+                    store.delete(key);
+                }
+            }
+        }
+    }, 30 * 60 * 1000);
+    if (typeof cleanupTimer.unref === 'function') {
+        cleanupTimer.unref();
+    }
+}
+function pruneSessionsIfNeeded() {
+    if (sessionStores.size < MAX_SESSIONS)
+        return;
+    const entries = [];
+    for (const key of sessionStores.keys()) {
+        const last = sessionLast.get(key);
+        entries.push({ key, ts: last?.timestamp ?? 0 });
+    }
+    entries.sort((a, b) => a.ts - b.ts);
+    const removeCount = Math.max(1, sessionStores.size - (MAX_SESSIONS - 1));
+    for (const entry of entries.slice(0, removeCount)) {
+        sessionStores.delete(entry.key);
+        sessionLast.delete(entry.key);
+        for (const diskKey of diskEntries.keys()) {
+            if (diskKey.startsWith(`${entry.key}:`)) {
+                diskEntries.delete(diskKey);
+            }
+        }
+    }
+}
+function persistCache() {
+    try {
+        ensureCacheDir(persistencePath);
+        const nowTs = now();
+        const validDisk = {};
+        for (const [key, entry] of diskEntries.entries()) {
+            if (nowTs - entry.timestamp <= DISK_TTL_MS) {
+                validDisk[key] = entry;
+            }
+        }
+        const merged = { ...validDisk };
+        for (const [sessionKey, store] of sessionStores.entries()) {
+            for (const [textHash, entry] of store.entries()) {
+                const diskKey = makeDiskKey(sessionKey, textHash);
+                merged[diskKey] = { signature: entry.signature, timestamp: entry.timestamp };
+            }
+        }
+        const data = {
+            version: '1.0',
+            memory_ttl_seconds: MEMORY_TTL_MS / 1000,
+            disk_ttl_seconds: DISK_TTL_MS / 1000,
+            entries: merged,
+            statistics: {
+                memory_hits: stats.memoryHits,
+                disk_hits: stats.diskHits,
+                misses: stats.misses,
+                writes: stats.writes + 1,
+                last_write: nowTs
+            }
+        };
+        const tmpPath = path.join(os.tmpdir(), `antigravity-cache-${Date.now()}-${Math.random().toString(36).slice(2)}.tmp`);
+        fs.writeFileSync(tmpPath, JSON.stringify(data, null, 2), 'utf-8');
+        try {
+            fs.renameSync(tmpPath, persistencePath);
+        }
+        catch {
+            fs.writeFileSync(persistencePath, fs.readFileSync(tmpPath));
+            try {
+                fs.unlinkSync(tmpPath);
+            }
+            catch {
+                // ignore cleanup errors
+            }
+        }
+        stats.writes += 1;
+        stats.lastWrite = nowTs;
+        dirty = false;
+    }
+    catch {
+        // best-effort
+    }
+}
+loadPersistedCache();
+schedulePersist();
+scheduleCleanup();
+export function buildThoughtSignatureSessionKey(ctx, payload) {
+    const sessionId = typeof ctx.sessionId === 'string'
+        ? String(ctx.sessionId).trim()
+        : typeof ctx.conversationId === 'string'
+            ? String(ctx.conversationId).trim()
+            : typeof ctx.requestId === 'string'
+                ? String(ctx.requestId).trim()
+                : '';
+    if (!sessionId)
+        return undefined;
+    const model = (payload && typeof payload.model === 'string' && String(payload.model).trim()) ||
+        (typeof ctx.clientModelId === 'string' ? String(ctx.clientModelId).trim() : '') ||
+        (typeof ctx.originalModelId === 'string' ? String(ctx.originalModelId).trim() : '');
+    const protocol = typeof ctx.providerProtocol === 'string' && ctx.providerProtocol.trim()
+        ? ctx.providerProtocol.trim()
+        : 'unknown';
+    const modelKey = model || 'unknown';
+    return `${protocol}:${modelKey}:${sessionId}`;
+}
+export function cacheThoughtSignature(sessionKey, text, signature) {
+    const normalizedText = normalizeText(text);
+    const normalizedSignature = normalizeSignature(signature);
+    if (!sessionKey || !normalizedText || !normalizedSignature)
+        return;
+    const textHash = hashText(normalizedText);
+    const store = ensureSession(sessionKey);
+    if (store.size >= MAX_ENTRIES_PER_SESSION) {
+        pruneSession(store);
+    }
+    store.set(textHash, { signature: normalizedSignature, timestamp: now() });
+    sessionLast.set(sessionKey, { text: normalizedText, signature: normalizedSignature, timestamp: now() });
+    dirty = true;
+}
+export function getCachedThoughtSignature(sessionKey, text) {
+    if (!sessionKey)
+        return undefined;
+    const normalizedText = normalizeText(text);
+    if (!normalizedText)
+        return undefined;
+    const textHash = hashText(normalizedText);
+    const store = sessionStores.get(sessionKey);
+    if (store) {
+        const entry = store.get(textHash);
+        if (entry) {
+            if (now() - entry.timestamp <= MEMORY_TTL_MS) {
+                stats.memoryHits += 1;
+                return entry.signature;
+            }
+            store.delete(textHash);
+        }
+    }
+    const diskKey = makeDiskKey(sessionKey, textHash);
+    const diskEntry = diskEntries.get(diskKey);
+    if (diskEntry && now() - diskEntry.timestamp <= DISK_TTL_MS) {
+        stats.diskHits += 1;
+        const mem = ensureSession(sessionKey);
+        mem.set(textHash, { signature: diskEntry.signature, timestamp: now() });
+        return diskEntry.signature;
+    }
+    stats.misses += 1;
+    return undefined;
+}
+export function getLastThoughtSignature(sessionKey) {
+    if (!sessionKey)
+        return undefined;
+    return sessionLast.get(sessionKey);
+}
+export function shouldHandleThoughtSignature(ctx) {
+    const provider = typeof ctx.providerId === 'string' ? ctx.providerId.toLowerCase() : '';
+    if (provider === 'antigravity')
+        return true;
+    const profile = typeof ctx.profileId === 'string' ? ctx.profileId.toLowerCase() : '';
+    return profile.includes('antigravity');
+}