@jsonstudio/llms 0.6.2172 → 0.6.3214

package/dist/conversion/shared/runtime-metadata.js

@@ -1,23 +0,0 @@
-import { isJsonObject, jsonClone } from '../hub/types/json.js';
-export function readRuntimeMetadata(carrier) {
-    if (!carrier || typeof carrier !== 'object') {
-        return undefined;
-    }
-    const candidate = carrier.__rt;
-    return candidate && isJsonObject(candidate) ? candidate : undefined;
-}
-export function ensureRuntimeMetadata(carrier) {
-    if (!carrier || typeof carrier !== 'object') {
-        throw new Error('ensureRuntimeMetadata requires object carrier');
-    }
-    const existing = readRuntimeMetadata(carrier);
-    if (existing) {
-        return existing;
-    }
-    carrier.__rt = {};
-    return carrier.__rt;
-}
-export function cloneRuntimeMetadata(carrier) {
-    const rt = readRuntimeMetadata(carrier);
-    return rt ? jsonClone(rt) : undefined;
-}

package/dist/conversion/shared/snapshot-hooks.d.ts

@@ -1,11 +0,0 @@
-export interface SnapshotHookOptions {
-    endpoint: string;
-    stage: string;
-    requestId: string;
-    data: unknown;
-    verbosity?: 'minimal' | 'verbose';
-    channel?: string;
-    providerKey?: string;
-    groupRequestId?: string;
-}
-export declare function writeSnapshotViaHooks(options: SnapshotHookOptions): Promise<void>;

package/dist/conversion/shared/snapshot-hooks.js

@@ -1,503 +0,0 @@
-import fs from 'node:fs/promises';
-import path from 'node:path';
-import os from 'node:os';
-const DEFAULT_SNAPSHOT_ROOT = path.join(os.homedir(), '.routecodex', 'codex-samples');
-const DEFAULT_ERRORSAMPLES_ROOT = path.join(os.homedir(), '.routecodex', 'errorsamples');
-const PENDING_PROVIDER_DIR = '__pending__';
-const POLICY_VIOLATIONS_DIR = '__policy_violations__';
-function resolveSnapshotRoot() {
-    const envOverride = process.env.RCC_SNAPSHOT_DIR ||
-        process.env.ROUTECODEX_SNAPSHOT_DIR;
-    if (envOverride && envOverride.trim()) {
-        return path.resolve(envOverride.trim());
-    }
-    return DEFAULT_SNAPSHOT_ROOT;
-}
-function resolveErrorsamplesRoot() {
-    const envOverride = process.env.ROUTECODEX_ERRORSAMPLES_DIR ||
-        process.env.ROUTECODEX_ERROR_SAMPLES_DIR;
-    if (envOverride && String(envOverride).trim()) {
-        return path.resolve(String(envOverride).trim());
-    }
-    return DEFAULT_ERRORSAMPLES_ROOT;
-}
-function safeErrorsampleName(name) {
-    return String(name || 'sample').replace(/[^\w.-]/g, '_');
-}
-async function cleanupZeroByteJsonFiles(dir) {
-    let entries = [];
-    try {
-        entries = await fs.readdir(dir);
-    }
-    catch {
-        return;
-    }
-    const candidates = entries.filter((name) => name.endsWith('.json'));
-    if (candidates.length === 0) {
-        return;
-    }
-    await Promise.allSettled(candidates.map(async (name) => {
-        const full = path.join(dir, name);
-        try {
-            const st = await fs.stat(full);
-            if (!st.isFile() || st.size > 0) {
-                return;
-            }
-            await fs.unlink(full);
-        }
-        catch {
-            // ignore cleanup failures
-        }
-    }));
-}
-async function writeUniqueErrorsampleFile(dir, baseName, contents) {
-    const parsed = path.parse(baseName);
-    const ext = parsed.ext || '.json';
-    const stem = parsed.name || 'sample';
-    const tmpDir = path.join(dir, '_tmp');
-    try {
-        await fs.mkdir(tmpDir, { recursive: true });
-    }
-    catch {
-        // ignore; fallback to direct writes
-    }
-    for (let i = 0; i < 32; i += 1) {
-        const suffix = `${Date.now()}_${Math.random().toString(36).slice(2, 8)}`;
-        const fileName = `${stem}_${suffix}${ext}`;
-        try {
-            const dest = path.join(dir, fileName);
-            const tmp = path.join(tmpDir, `${fileName}.tmp`);
-            await fs.writeFile(tmp, contents, { encoding: 'utf-8', flag: 'wx' });
-            await fs.rename(tmp, dest);
-            return;
-        }
-        catch (error) {
-            if (toErrorCode(error) === 'EEXIST') {
-                continue;
-            }
-            throw error;
-        }
-    }
-    // last resort (best-effort overwrite into a timestamped file)
-    const fallback = `${stem}_${Date.now()}_${Math.random().toString(36).slice(2, 8)}${ext}`;
-    await fs.writeFile(path.join(dir, fallback), contents, { encoding: 'utf-8' });
-}
-function resolveSnapshotFolder(endpoint) {
-    const lowered = (endpoint || '').trim().toLowerCase();
-    if (lowered.includes('/v1/responses') || lowered.includes('/responses.submit')) {
-        return 'openai-responses';
-    }
-    if (lowered.includes('/v1/messages')) {
-        return 'anthropic-messages';
-    }
-    return 'openai-chat';
-}
-function sanitizeToken(value, fallback) {
-    if (typeof value !== 'string') {
-        return fallback;
-    }
-    const trimmed = value.trim();
-    if (!trimmed) {
-        return fallback;
-    }
-    return trimmed.replace(/[^A-Za-z0-9_.-]/g, '_') || fallback;
-}
-function channelSuffix(channel) {
-    if (!channel) {
-        return '';
-    }
-    const token = sanitizeToken(channel, '');
-    return token ? `_${token}` : '';
-}
-function readStringField(value) {
-    return typeof value === 'string' && value.trim().length ? value.trim() : undefined;
-}
-function extractNestedProviderKey(value) {
-    if (!value || typeof value !== 'object') {
-        return undefined;
-    }
-    const obj = value;
-    const direct = readStringField(obj.providerKey) ||
-        readStringField(obj.providerId) ||
-        readStringField(obj.profileId);
-    if (direct) {
-        return direct;
-    }
-    const target = obj.target;
-    if (target && typeof target === 'object') {
-        const tk = readStringField(target.providerKey);
-        if (tk) {
-            return tk;
-        }
-    }
-    const meta = obj.meta;
-    if (meta && typeof meta === 'object') {
-        const m = meta;
-        const fromMeta = readStringField(m.providerKey) ||
-            readStringField(m.providerId);
-        if (fromMeta) {
-            return fromMeta;
-        }
-        const ctx = m.context;
-        if (ctx && typeof ctx === 'object') {
-            const c = ctx;
-            const fromCtx = readStringField(c.providerKey) ||
-                readStringField(c.providerId) ||
-                readStringField(c.profileId);
-            if (fromCtx) {
-                return fromCtx;
-            }
-        }
-    }
-    return undefined;
-}
-function extractNestedGroupRequestId(value) {
-    if (!value || typeof value !== 'object') {
-        return undefined;
-    }
-    const obj = value;
-    const direct = readStringField(obj.clientRequestId) ||
-        readStringField(obj.groupRequestId);
-    if (direct) {
-        return direct;
-    }
-    const meta = obj.meta;
-    if (meta && typeof meta === 'object') {
-        const m = meta;
-        const fromMeta = readStringField(m.clientRequestId) ||
-            readStringField(m.groupRequestId);
-        if (fromMeta) {
-            return fromMeta;
-        }
-        const ctx = m.context;
-        if (ctx && typeof ctx === 'object') {
-            const c = ctx;
-            const fromCtx = readStringField(c.clientRequestId) ||
-                readStringField(c.groupRequestId);
-            if (fromCtx) {
-                return fromCtx;
-            }
-        }
-    }
-    return undefined;
-}
-function extractNestedEntryEndpoint(value) {
-    if (!value || typeof value !== 'object') {
-        return undefined;
-    }
-    const obj = value;
-    const direct = readStringField(obj.entryEndpoint) ||
-        readStringField(obj.entry_endpoint);
-    if (direct) {
-        return direct;
-    }
-    const meta = obj.meta;
-    if (meta && typeof meta === 'object') {
-        const m = meta;
-        const fromMeta = readStringField(m.entryEndpoint) ||
-            readStringField(m.entry_endpoint);
-        if (fromMeta) {
-            return fromMeta;
-        }
-        const ctx = m.context;
-        if (ctx && typeof ctx === 'object') {
-            const c = ctx;
-            const fromCtx = readStringField(c.entryEndpoint) ||
-                readStringField(c.entry_endpoint);
-            if (fromCtx) {
-                return fromCtx;
-            }
-        }
-    }
-    const metadata = obj.metadata;
-    if (metadata && typeof metadata === 'object') {
-        const md = metadata;
-        const fromMetadata = readStringField(md.entryEndpoint) ||
-            readStringField(md.entry_endpoint);
-        if (fromMetadata) {
-            return fromMetadata;
-        }
-    }
-    const runtime = obj.runtime;
-    if (runtime && typeof runtime === 'object') {
-        const r = runtime;
-        const fromRuntime = readStringField(r.entryEndpoint) ||
-            readStringField(r.entry_endpoint);
-        if (fromRuntime) {
-            return fromRuntime;
-        }
-    }
-    return undefined;
-}
-function toErrorCode(error) {
-    if (!error || typeof error !== 'object') {
-        return undefined;
-    }
-    const code = error.code;
-    return typeof code === 'string' && code.trim() ? code : undefined;
-}
-function readNumberField(value) {
-    return typeof value === 'number' && Number.isFinite(value) ? value : undefined;
-}
-function isHubPolicyStage(stage) {
-    return typeof stage === 'string' && stage.startsWith('hub_policy.');
-}
-function isHubToolSurfaceStage(stage) {
-    return typeof stage === 'string' && stage.startsWith('hub_toolsurface.');
-}
-function hasPolicyViolations(value) {
-    if (!value || typeof value !== 'object') {
-        return false;
-    }
-    const obj = value;
-    const violations = obj.violations;
-    if (Array.isArray(violations) && violations.length > 0) {
-        return true;
-    }
-    const summary = obj.summary;
-    if (summary && typeof summary === 'object') {
-        const total = readNumberField(summary.totalViolations);
-        if (typeof total === 'number' && total > 0) {
-            return true;
-        }
-    }
-    return false;
-}
-function hasToolSurfaceDiff(value) {
-    if (!value || typeof value !== 'object') {
-        return false;
-    }
-    const obj = value;
-    const diffCount = readNumberField(obj.diffCount);
-    if (typeof diffCount === 'number' && diffCount > 0) {
-        return true;
-    }
-    // Response-side tool surface mismatch detection records expected/detected protocol
-    // without a numeric diffCount; treat any protocol mismatch as a diff.
-    const expected = readStringField(obj.expectedProtocol);
-    const detected = readStringField(obj.detectedProtocol);
-    if (expected && detected && expected !== detected) {
-        return true;
-    }
-    return false;
-}
-function hasPolicyEnforcementChanges(value) {
-    if (!value || typeof value !== 'object') {
-        return false;
-    }
-    const obj = value;
-    const removed = obj.removedTopLevelKeys;
-    if (Array.isArray(removed) && removed.length > 0) {
-        return true;
-    }
-    const flattened = obj.flattenedWrappers;
-    if (Array.isArray(flattened) && flattened.length > 0) {
-        return true;
-    }
-    return false;
-}
-async function writeUniqueFile(dir, baseName, contents) {
-    const parsed = path.parse(baseName);
-    const ext = parsed.ext || '.json';
-    const stem = parsed.name || 'snapshot';
-    const tmpPrefix = `.__tmp_${stem}_${process.pid}_${Date.now()}`;
-    for (let i = 0; i < 64; i += 1) {
-        const name = i === 0 ? `${stem}${ext}` : `${stem}_${i}${ext}`;
-        try {
-            const dest = path.join(dir, name);
-            const tmp = path.join(dir, `${tmpPrefix}_${Math.random().toString(36).slice(2, 8)}${ext}`);
-            await fs.writeFile(tmp, contents, { encoding: 'utf-8', flag: 'wx' });
-            try {
-                await fs.link(tmp, dest);
-                await fs.unlink(tmp).catch(() => { });
-                return;
-            }
-            catch (error) {
-                await fs.unlink(tmp).catch(() => { });
-                if (toErrorCode(error) === 'EEXIST') {
-                    continue;
-                }
-                throw error;
-            }
-        }
-        catch (error) {
-            if (toErrorCode(error) === 'EEXIST') {
-                continue;
-            }
-            throw error;
-        }
-    }
-    const fallback = `${stem}_${Date.now()}_${Math.random().toString(36).slice(2, 8)}${ext}`;
-    const dest = path.join(dir, fallback);
-    const tmp = path.join(dir, `${tmpPrefix}_${Math.random().toString(36).slice(2, 8)}${ext}`);
-    await fs.writeFile(tmp, contents, { encoding: 'utf-8', flag: 'wx' });
-    try {
-        await fs.link(tmp, dest);
-    }
-    finally {
-        await fs.unlink(tmp).catch(() => { });
-    }
-}
-const requestProviderIndex = globalThis
-    .__routecodexSnapshotProviderIndex ||
-    new Map();
-globalThis
-    .__routecodexSnapshotProviderIndex = requestProviderIndex;
-async function mergeDirs(src, dest) {
-    await fs.mkdir(dest, { recursive: true });
-    let entries = [];
-    try {
-        entries = await fs.readdir(src);
-    }
-    catch {
-        return;
-    }
-    for (const name of entries) {
-        const from = path.join(src, name);
-        const to = path.join(dest, name);
-        try {
-            await fs.rename(from, to);
-        }
-        catch (error) {
-            if (toErrorCode(error) === 'EEXIST') {
-                // avoid overwriting; keep both
-                const parsed = path.parse(name);
-                const ext = parsed.ext || '';
-                const stem = parsed.name || 'snapshot';
-                const suffix = `${Date.now()}_${Math.random().toString(36).slice(2, 8)}`;
-                try {
-                    await fs.rename(from, path.join(dest, `${stem}_${suffix}${ext}`));
-                }
-                catch {
-                    // ignore move failure
-                }
-                continue;
-            }
-            // ignore other move failures
-        }
-    }
-    try {
-        await fs.rmdir(src);
-    }
-    catch {
-        // ignore
-    }
-}
-async function promotePendingDir(options) {
-    if (!options.groupRequestToken || options.providerToken === PENDING_PROVIDER_DIR) {
-        return;
-    }
-    const pending = path.join(options.root, options.folder, PENDING_PROVIDER_DIR, options.groupRequestToken);
-    const dest = path.join(options.root, options.folder, options.providerToken, options.groupRequestToken);
-    try {
-        await fs.access(pending);
-    }
-    catch {
-        return;
-    }
-    await fs.mkdir(path.dirname(dest), { recursive: true });
-    try {
-        await fs.rename(pending, dest);
-    }
-    catch {
-        // if rename fails (already exists / cross-device), merge
-        await mergeDirs(pending, dest);
-    }
-}
-async function writeSnapshotFile(options, rootOverride) {
-    const root = rootOverride || resolveSnapshotRoot();
-    const folder = resolveSnapshotFolder(extractNestedEntryEndpoint(options.data) || options.endpoint);
-    const stageToken = sanitizeToken(options.stage, 'snapshot');
-    const groupRequestToken = sanitizeToken(options.groupRequestId ||
-        extractNestedGroupRequestId(options.data) ||
-        options.requestId, `req_${Date.now()}`);
-    const providerFromOptions = readStringField(options.providerKey);
-    const providerFromData = extractNestedProviderKey(options.data);
-    const knownProvider = requestProviderIndex.get(groupRequestToken);
-    const providerToken = sanitizeToken(providerFromOptions || providerFromData || knownProvider || PENDING_PROVIDER_DIR, PENDING_PROVIDER_DIR);
-    if (!knownProvider && providerToken !== PENDING_PROVIDER_DIR) {
-        requestProviderIndex.set(groupRequestToken, providerToken);
-        await promotePendingDir({ root, folder, groupRequestToken, providerToken });
-    }
-    const dir = path.join(root, folder, providerToken, groupRequestToken);
-    await fs.mkdir(dir, { recursive: true });
-    // Write a stable runtime marker for this request folder (best-effort).
-    try {
-        const metaPath = path.join(dir, '__runtime.json');
-        const payload = JSON.stringify({
-            timestamp: new Date().toISOString(),
-            versions: {
-                routecodex: process.env.ROUTECODEX_VERSION,
-                routecodexBuildTime: process.env.ROUTECODEX_BUILD_TIME,
-                llmswitchCore: process.env.ROUTECODEX_LLMSWITCH_CORE_VERSION,
-                node: process.version
-            }
-        }, null, 2);
-        await fs.writeFile(metaPath, payload, { encoding: 'utf-8', flag: 'wx' }).catch(() => { });
-    }
-    catch {
-        // ignore
-    }
-    const spacing = options.verbosity === 'minimal' ? undefined : 2;
-    const payload = spacing !== undefined
-        ? JSON.stringify(options.data, null, spacing)
-        : JSON.stringify(options.data);
-    const fileName = `${stageToken}${channelSuffix(options.channel)}.json`;
-    await writeUniqueFile(dir, fileName, payload);
-}
-export async function writeSnapshotViaHooks(options) {
-    const stage = sanitizeToken(options.stage, 'snapshot');
-    // 1) Normal snapshots (always).
-    try {
-        await writeSnapshotFile({ ...options, stage });
-    }
-    catch {
-        // snapshot writes must never block callers
-    }
-    // 2) Policy violations snapshots (copy-on-violation only).
-    // This allows leaving observe mode always on without drowning normal codex-samples traffic.
-    try {
-        if (isHubPolicyStage(stage) &&
-            (hasPolicyViolations(options.data) || hasPolicyEnforcementChanges(options.data))) {
-            const base = resolveSnapshotRoot();
-            const policyRoot = path.join(base, POLICY_VIOLATIONS_DIR);
-            await writeSnapshotFile({ ...options, stage }, policyRoot);
-        }
-    }
-    catch {
-        // never block callers
-    }
-    // 3) Tool surface diffs (copy-on-diff only) → ~/.routecodex/errorsamples/tool-surface/
-    try {
-        if (isHubToolSurfaceStage(stage) && hasToolSurfaceDiff(options.data)) {
-            const root = resolveErrorsamplesRoot();
-            const dir = path.join(root, safeErrorsampleName('tool-surface'));
-            await fs.mkdir(dir, { recursive: true });
-            // Best-effort cleanup: when the process exits abruptly, an in-flight async
-            // write can leave behind 0-byte placeholder files. Keep the observable
-            // directory clean so operators can tail it.
-            await cleanupZeroByteJsonFiles(dir);
-            const stamp = new Date().toISOString();
-            const payload = {
-                kind: 'hub_toolsurface_diff',
-                timestamp: stamp,
-                endpoint: options.endpoint,
-                stage,
-                requestId: options.requestId,
-                providerKey: options.providerKey,
-                groupRequestId: options.groupRequestId,
-                runtime: {
-                    routecodexVersion: process.env.ROUTECODEX_VERSION,
-                    routecodexBuildTime: process.env.ROUTECODEX_BUILD_TIME,
-                    llmswitchCore: process.env.ROUTECODEX_LLMSWITCH_CORE_VERSION,
-                    node: process.version
-                },
-                observation: options.data
-            };
-            await writeUniqueErrorsampleFile(dir, `${safeErrorsampleName(stage)}.json`, JSON.stringify(payload, null, 2));
-        }
-    }
-    catch {
-        // never block callers
-    }
-}

package/dist/conversion/shared/text-markup-normalizer/extractors-apply-patch.d.ts

@@ -1,2 +0,0 @@
-import { type ToolCallLite } from './extractors-shared.js';
-export declare function extractApplyPatchCallsFromText(text: string): ToolCallLite[] | null;

package/dist/conversion/shared/text-markup-normalizer/extractors-apply-patch.js

@@ -1,129 +0,0 @@
-import { isStructuredApplyPatchPayload } from '../../../tools/apply-patch-structured.js';
-import { genToolCallId } from './extractors-shared.js';
-function extractStructuredApplyPatchPayloads(text) {
-    const payloads = [];
-    try {
-        const fenceRe = /```(?:json|apply_patch|toon)?\s*([\s\S]*?)\s*```/gi;
-        let fm;
-        while ((fm = fenceRe.exec(text)) !== null) {
-            const body = fm[1] || '';
-            try {
-                const parsed = JSON.parse(body);
-                if (isStructuredApplyPatchPayload(parsed)) {
-                    payloads.push(parsed);
-                }
-            }
-            catch {
-                /* ignore invalid JSON */
-            }
-        }
-        if (!payloads.length && typeof text === 'string' && text.includes('"changes"')) {
-            try {
-                const parsed = JSON.parse(text);
-                if (isStructuredApplyPatchPayload(parsed)) {
-                    payloads.push(parsed);
-                }
-            }
-            catch {
-                /* ignore */
-            }
-        }
-    }
-    catch {
-        /* ignore */
-    }
-    return payloads;
-}
-function normalizeRawApplyPatchBlock(raw) {
-    try {
-        const lines = String(raw || '')
-            .split(/\r?\n/)
-            .map((line) => line.replace(/\r/g, ''));
-        while (lines.length > 0 && !lines[0].trim()) {
-            lines.shift();
-        }
-        while (lines.length > 0 && !lines[lines.length - 1].trim()) {
-            lines.pop();
-        }
-        if (!lines.length)
-            return '';
-        const indents = lines
-            .filter((line) => line.trim().length > 0)
-            .map((line) => {
-            const m = line.match(/^[ \t]*/);
-            return m ? m[0].length : 0;
-        });
-        const minIndent = indents.length ? Math.min(...indents) : 0;
-        if (minIndent <= 0) {
-            return lines.join('\n').trim();
-        }
-        return lines
-            .map((line) => line.replace(new RegExp(`^[ \\t]{0,${minIndent}}`), ''))
-            .join('\n')
-            .trim();
-    }
-    catch {
-        return String(raw || '').trim();
-    }
-}
-function extractRawApplyPatchBlocks(text) {
-    const out = [];
-    try {
-        if (typeof text !== 'string' || !text)
-            return out;
-        const seen = new Set();
-        const blockRe = /\*\*\*\s*Begin Patch(?:\s*\*\*\*)?[\s\S]*?\*\*\*\s*End Patch(?:\s*\*\*\*)?/gi;
-        let m;
-        while ((m = blockRe.exec(text)) !== null) {
-            const normalized = normalizeRawApplyPatchBlock(String(m[0] || ''));
-            if (!normalized)
-                continue;
-            // Avoid turning incidental prose into apply_patch.
-            if (!/\*\*\*\s*(?:Add|Update|Delete)\s+File:/i.test(normalized))
-                continue;
-            if (seen.has(normalized))
-                continue;
-            seen.add(normalized);
-            out.push(normalized);
-        }
-    }
-    catch {
-        /* ignore */
-    }
-    return out;
-}
-export function extractApplyPatchCallsFromText(text) {
-    try {
-        if (typeof text !== 'string' || !text)
-            return null;
-        const payloads = extractStructuredApplyPatchPayloads(text);
-        const patchBlocks = extractRawApplyPatchBlocks(text);
-        if (!payloads.length && !patchBlocks.length)
-            return null;
-        const out = [];
-        for (const payload of payloads) {
-            let argsStr = '{}';
-            try {
-                argsStr = JSON.stringify(payload);
-            }
-            catch {
-                argsStr = '{"changes":[]}';
-            }
-            out.push({ id: genToolCallId(), name: 'apply_patch', args: argsStr });
-        }
-        for (const patch of patchBlocks) {
-            let argsStr = '{}';
-            try {
-                argsStr = JSON.stringify({ patch, input: patch });
-            }
-            catch {
-                argsStr = '{"patch":""}';
-            }
-            out.push({ id: genToolCallId(), name: 'apply_patch', args: argsStr });
-        }
-        return out;
-    }
-    catch {
-        return null;
-    }
-}

package/dist/conversion/shared/text-markup-normalizer/extractors-json.d.ts

@@ -1,4 +0,0 @@
-import { type TextMarkupNormalizeOptions, type ToolCallLite } from './extractors-shared.js';
-export declare function tryParseJsonWithModelRepairs(raw: string): unknown | null;
-export declare function salvageToolArgsFromRawText(toolName: string, rawArgs: string): Record<string, unknown> | null;
-export declare function extractJsonToolCallsFromText(text: string, options?: TextMarkupNormalizeOptions): ToolCallLite[] | null;