@jsonstudio/llms 0.6.753 → 0.6.802

package/dist/tools/apply-patch-structured.js

@@ -1,277 +1 @@
-export class StructuredApplyPatchError extends Error {
-    reason;
-    constructor(reason, message) {
-        super(message);
-        this.reason = reason;
-    }
-}
-const SUPPORTED_KINDS = [
-    'insert_after',
-    'insert_before',
-    'replace',
-    'delete',
-    'create_file',
-    'delete_file'
-];
-const FILE_PATH_INVALID_RE = /[\r\n]/;
-const decodeEscapedNewlinesIfObvious = (value) => {
-    if (!value)
-        return value;
-    if (value.includes('\n'))
-        return value;
-    const lower = value.toLowerCase();
-    const looksEscaped = value.includes('\\r\\n') ||
-        (value.includes('\\n') && /\\n[ \t]/.test(value)) ||
-        lower.includes('\\u000a') ||
-        lower.includes('\\u000d');
-    if (!looksEscaped) {
-        return value;
-    }
-    let out = value;
-    out = out.replace(/\\r\\n/g, '\n');
-    out = out.replace(/\\n/g, '\n');
-    out = out.replace(/\\r/g, '\n');
-    out = out.replace(/\\u000a/gi, '\n');
-    out = out.replace(/\\u000d/gi, '\n');
-    return out;
-};
-const toSafeString = (value, label) => {
-    const str = typeof value === 'string' ? value : '';
-    if (!str.trim()) {
-        throw new StructuredApplyPatchError('missing_field', `${label} is required`);
-    }
-    return str;
-};
-const normalizeFilePath = (raw, label) => {
-    let trimmed = raw.trim();
-    if (!trimmed) {
-        throw new StructuredApplyPatchError('invalid_file', `${label} must not be empty`);
-    }
-    if (FILE_PATH_INVALID_RE.test(trimmed)) {
-        const firstLine = trimmed.split(/[\r\n]/)[0]?.trim() ?? '';
-        if (!firstLine) {
-            throw new StructuredApplyPatchError('invalid_file', `${label} must be a single-line path`);
-        }
-        trimmed = firstLine;
-    }
-    return trimmed.replace(/\\/g, '/');
-};
-const splitTextIntoLines = (input) => {
-    const decoded = decodeEscapedNewlinesIfObvious(input);
-    const normalized = decoded.replace(/\r/g, '');
-    const parts = normalized.split('\n');
-    if (parts.length && parts[parts.length - 1] === '') {
-        parts.pop();
-    }
-    return parts.length ? parts : [''];
-};
-const normalizeLines = (value, label) => {
-    if (Array.isArray(value)) {
-        if (!value.length) {
-            return [];
-        }
-        const out = [];
-        for (const [idx, entry] of value.entries()) {
-            if (typeof entry !== 'string') {
-                if (entry === null || entry === undefined) {
-                    out.push('');
-                    continue;
-                }
-                out.push(String(entry));
-                continue;
-            }
-            // Preserve intentional whitespace
-            const normalized = entry.replace(/\r/g, '');
-            const decoded = decodeEscapedNewlinesIfObvious(normalized);
-            if (decoded.includes('\n')) {
-                out.push(...splitTextIntoLines(decoded));
-            }
-            else {
-                out.push(decoded);
-            }
-        }
-        return out;
-    }
-    if (typeof value === 'string') {
-        return splitTextIntoLines(value);
-    }
-    if (value === null || value === undefined) {
-        throw new StructuredApplyPatchError('invalid_lines', `${label} must be an array of strings or a multi-line string`);
-    }
-    return [String(value)];
-};
-const buildContextLines = (raw) => splitTextIntoLines(raw).map((line) => ` ${line}`);
-const buildPrefixedLines = (lines, prefix) => lines.map((line) => `${prefix}${line}`);
-const detectIndentFromAnchor = (anchorLines, mode) => {
-    const source = mode === 'first' ? anchorLines[0] ?? '' : anchorLines[anchorLines.length - 1] ?? '';
-    const match = source.match(/^(\s*)/);
-    return match ? match[1] ?? '' : '';
-};
-const applyAnchorIndent = (lines, anchorLines, position, enabled) => {
-    if (!enabled) {
-        return lines;
-    }
-    const indent = detectIndentFromAnchor(anchorLines, position);
-    if (!indent) {
-        return lines;
-    }
-    return lines.map((line) => {
-        if (!line.trim()) {
-            return line;
-        }
-        if (/^\s/.test(line)) {
-            return line;
-        }
-        return `${indent}${line}`;
-    });
-};
-export function buildStructuredPatch(payload) {
-    if (!payload || typeof payload !== 'object') {
-        throw new StructuredApplyPatchError('missing_payload', 'apply_patch arguments must be a JSON object');
-    }
-    if (!Array.isArray(payload.changes) || payload.changes.length === 0) {
-        throw new StructuredApplyPatchError('missing_changes', 'apply_patch requires a non-empty "changes" array');
-    }
-    const topLevelFile = typeof payload.file === 'string' && payload.file.trim()
-        ? normalizeFilePath(payload.file, 'file')
-        : undefined;
-    const sectionOrder = [];
-    const fileSections = new Map();
-    const ensureUpdateSection = (file) => {
-        const existing = fileSections.get(file);
-        if (existing) {
-            if (existing.type !== 'update') {
-                throw new StructuredApplyPatchError('invalid_change_sequence', `File "${file}" already marked as ${existing.type}`);
-            }
-            return existing;
-        }
-        const created = { type: 'update', hunks: [] };
-        sectionOrder.push(file);
-        fileSections.set(file, created);
-        return created;
-    };
-    for (const [index, change] of payload.changes.entries()) {
-        if (!change || typeof change !== 'object') {
-            throw new StructuredApplyPatchError('invalid_change', `Change at index ${index} must be an object`);
-        }
-        const kindRaw = typeof change.kind === 'string' ? change.kind.trim().toLowerCase() : '';
-        if (!kindRaw) {
-            throw new StructuredApplyPatchError('invalid_change_kind', `Change at index ${index} is missing "kind"`);
-        }
-        if (!SUPPORTED_KINDS.includes(kindRaw)) {
-            throw new StructuredApplyPatchError('invalid_change_kind', `Unsupported change kind "${change.kind}" at index ${index}`);
-        }
-        const file = change.file ? normalizeFilePath(change.file, `changes[${index}].file`) : topLevelFile;
-        if (!file) {
-            throw new StructuredApplyPatchError('invalid_file', `Change at index ${index} is missing "file"`);
-        }
-        if (kindRaw === 'create_file') {
-            if (fileSections.has(file)) {
-                throw new StructuredApplyPatchError('invalid_change_sequence', `File "${file}" already has pending changes`);
-            }
-            const lines = normalizeLines(change.lines, `changes[${index}].lines`);
-            sectionOrder.push(file);
-            fileSections.set(file, { type: 'add', lines });
-            continue;
-        }
-        if (kindRaw === 'delete_file') {
-            if (fileSections.has(file)) {
-                throw new StructuredApplyPatchError('invalid_change_sequence', `File "${file}" already has pending changes`);
-            }
-            sectionOrder.push(file);
-            fileSections.set(file, { type: 'delete' });
-            continue;
-        }
-        const section = ensureUpdateSection(file);
-        switch (kindRaw) {
-            case 'insert_after': {
-                const anchor = toSafeString(change.anchor, `changes[${index}].anchor`);
-                const anchorLines = splitTextIntoLines(anchor);
-                const additions = normalizeLines(change.lines, `changes[${index}].lines`);
-                if (!additions.length) {
-                    throw new StructuredApplyPatchError('invalid_lines', `changes[${index}].lines must include at least one line`);
-                }
-                const prepared = applyAnchorIndent(additions, anchorLines, 'last', change.use_anchor_indent);
-                const hunkBody = [...buildContextLines(anchor), ...buildPrefixedLines(prepared, '+')];
-                section.hunks.push(hunkBody);
-                break;
-            }
-            case 'insert_before': {
-                const anchor = toSafeString(change.anchor, `changes[${index}].anchor`);
-                const anchorLines = splitTextIntoLines(anchor);
-                const additions = normalizeLines(change.lines, `changes[${index}].lines`);
-                if (!additions.length) {
-                    throw new StructuredApplyPatchError('invalid_lines', `changes[${index}].lines must include at least one line`);
-                }
-                const prepared = applyAnchorIndent(additions, anchorLines, 'first', change.use_anchor_indent);
-                const hunkBody = [...buildPrefixedLines(prepared, '+'), ...buildContextLines(anchor)];
-                section.hunks.push(hunkBody);
-                break;
-            }
-            case 'replace': {
-                // 兼容仅提供 anchor 的 replace 形态：将 anchor 视为 target 以尽可能保留用户意图。
-                const targetSource = change.target ?? change.anchor;
-                const target = toSafeString(targetSource, `changes[${index}].target`);
-                const replacements = normalizeLines(change.lines, `changes[${index}].lines`);
-                const hunkBody = [
-                    ...buildPrefixedLines(splitTextIntoLines(target), '-'),
-                    ...buildPrefixedLines(replacements, '+')
-                ];
-                section.hunks.push(hunkBody);
-                break;
-            }
-            case 'delete': {
-                const target = toSafeString(change.target, `changes[${index}].target`);
-                const hunkBody = buildPrefixedLines(splitTextIntoLines(target), '-');
-                section.hunks.push(hunkBody);
-                break;
-            }
-            default: {
-                throw new StructuredApplyPatchError('invalid_change_kind', `Unsupported change kind "${change.kind}" at index ${index}`);
-            }
-        }
-    }
-    if (!sectionOrder.length) {
-        throw new StructuredApplyPatchError('missing_changes', 'apply_patch payload produced no file operations');
-    }
-    const lines = ['*** Begin Patch'];
-    for (const file of sectionOrder) {
-        const section = fileSections.get(file);
-        if (!section)
-            continue;
-        if (section.type === 'add') {
-            lines.push(`*** Add File: ${file}`);
-            for (const line of section.lines) {
-                lines.push(`+${line}`);
-            }
-        }
-        else if (section.type === 'delete') {
-            lines.push(`*** Delete File: ${file}`);
-        }
-        else {
-            lines.push(`*** Update File: ${file}`);
-            const hunks = section.hunks || [];
-            for (const hunk of hunks) {
-                // 结构化补丁仅负责生成统一 diff 形态，不对多段 hunk 做逻辑裁剪；
-                // 具体哪些 hunk 能成功应用由 apply_patch 客户端自行校验并返回错误信息。
-                for (const entry of hunk) {
-                    if (!entry.startsWith('@@')) {
-                        lines.push(entry);
-                    }
-                }
-            }
-        }
-    }
-    lines.push('*** End Patch');
-    return lines.join('\n');
-}
-export function isStructuredApplyPatchPayload(candidate) {
-    if (!candidate || typeof candidate !== 'object') {
-        return false;
-    }
-    const record = candidate;
-    if (!Array.isArray(record.changes)) {
-        return false;
-    }
-    return true;
-}
+export * from './apply-patch/structured.js';

package/dist/tools/args-json.d.ts

@@ -0,0 +1 @@
+export declare function parseToolArgsJson(input: unknown): unknown;

package/dist/tools/args-json.js

@@ -0,0 +1,175 @@
+// Shared JSON argument parsing helpers.
+// Goal: tolerate common markup artifacts injected by upstream providers (e.g. <arg_key>/<arg_value>),
+// while keeping behavior deterministic and side-effect free.
+const isRecord = (value) => typeof value === 'object' && value !== null && !Array.isArray(value);
+const stripXmlLikeTags = (input) => {
+    try {
+        return String(input || '').replace(/<[^>]+>/g, '');
+    }
+    catch {
+        return input;
+    }
+};
+const stripArgKeyArtifacts = (input) => {
+    try {
+        return String(input || '')
+            .replace(/<\/?\s*tool_call[^>]*>/gi, '')
+            .replace(/<\/?\s*arg_key\s*>/gi, '')
+            .replace(/<\/?\s*arg_value\s*>/gi, '');
+    }
+    catch {
+        return input;
+    }
+};
+const normalizeObjectKey = (rawKey) => {
+    const cleaned = stripXmlLikeTags(stripArgKeyArtifacts(rawKey)).trim();
+    if (!cleaned)
+        return rawKey;
+    return cleaned;
+};
+const coercePrimitive = (raw) => {
+    const trimmed = raw.trim();
+    if (!trimmed)
+        return '';
+    if (/^(true|false)$/i.test(trimmed))
+        return /^true$/i.test(trimmed);
+    if (/^-?\d+(?:\.\d+)?$/.test(trimmed))
+        return Number(trimmed);
+    if ((trimmed.startsWith('{') && trimmed.endsWith('}')) ||
+        (trimmed.startsWith('[') && trimmed.endsWith(']'))) {
+        try {
+            return JSON.parse(trimmed);
+        }
+        catch {
+            return trimmed;
+        }
+    }
+    return trimmed;
+};
+const extractInjectedArgPairs = (raw) => {
+    const delimiter = '</arg_key><arg_value>';
+    if (typeof raw !== 'string' || !raw.includes(delimiter))
+        return null;
+    const parts = raw.split(delimiter);
+    if (parts.length < 2)
+        return null;
+    const looksLikeKey = (s) => /^[A-Za-z_][A-Za-z0-9_-]*$/.test(s.trim());
+    const pairs = [];
+    let baseValue = parts[0] ?? '';
+    if (parts.length === 2) {
+        const k = (parts[0] ?? '').trim();
+        const v = (parts[1] ?? '').trim();
+        if (looksLikeKey(k) && v.length > 0) {
+            baseValue = '';
+            pairs.push({ key: k, value: coercePrimitive(v) });
+        }
+        return pairs.length ? { baseValue, pairs } : null;
+    }
+    for (let i = 1; i + 1 < parts.length; i += 2) {
+        const key = (parts[i] ?? '').trim();
+        const rawValue = (parts[i + 1] ?? '').trim();
+        if (!looksLikeKey(key)) {
+            continue;
+        }
+        if (rawValue.length === 0) {
+            continue;
+        }
+        pairs.push({ key, value: coercePrimitive(rawValue) });
+    }
+    if (!pairs.length)
+        return null;
+    return { baseValue, pairs };
+};
+const repairArgKeyArtifactsInKeys = (value) => {
+    const visit = (node) => {
+        if (Array.isArray(node)) {
+            for (const entry of node)
+                visit(entry);
+            return;
+        }
+        if (!isRecord(node))
+            return;
+        const keys = Object.keys(node);
+        for (const key of keys) {
+            const normalizedKey = normalizeObjectKey(key);
+            if (normalizedKey !== key && normalizedKey.trim()) {
+                if (!Object.prototype.hasOwnProperty.call(node, normalizedKey)) {
+                    node[normalizedKey] = node[key];
+                }
+                delete node[key];
+            }
+        }
+        for (const v of Object.values(node))
+            visit(v);
+    };
+    visit(value);
+};
+const repairArgKeyArtifactsInObject = (value) => {
+    const visit = (node) => {
+        if (Array.isArray(node)) {
+            for (const entry of node)
+                visit(entry);
+            return;
+        }
+        if (!isRecord(node))
+            return;
+        for (const [k, v] of Object.entries(node)) {
+            if (typeof v === 'string') {
+                const injected = extractInjectedArgPairs(v);
+                if (injected) {
+                    if (injected.baseValue !== '') {
+                        node[k] = injected.baseValue;
+                    }
+                    for (const pair of injected.pairs) {
+                        if (!Object.prototype.hasOwnProperty.call(node, pair.key)) {
+                            node[pair.key] = pair.value;
+                        }
+                    }
+                }
+            }
+            visit(node[k]);
+        }
+    };
+    visit(value);
+};
+export function parseToolArgsJson(input) {
+    const raw = typeof input === 'string' ? input : '';
+    if (!raw.trim())
+        return {};
+    try {
+        const parsed = JSON.parse(raw);
+        repairArgKeyArtifactsInKeys(parsed);
+        repairArgKeyArtifactsInObject(parsed);
+        return parsed;
+    }
+    catch {
+        // try stripping common tool-call markup artifacts and parsing again
+        try {
+            const stripped = stripArgKeyArtifacts(raw).trim();
+            if (stripped && stripped !== raw) {
+                const parsed = JSON.parse(stripped);
+                repairArgKeyArtifactsInKeys(parsed);
+                repairArgKeyArtifactsInObject(parsed);
+                return parsed;
+            }
+        }
+        catch {
+            // continue
+        }
+        // attempt to parse the first JSON container substring
+        try {
+            const candidate = raw.match(/\{[\s\S]*\}|\[[\s\S]*\]/)?.[0];
+            if (candidate) {
+                const strippedCandidate = stripArgKeyArtifacts(candidate).trim();
+                const parsed = JSON.parse(strippedCandidate);
+                repairArgKeyArtifactsInKeys(parsed);
+                repairArgKeyArtifactsInObject(parsed);
+                return parsed;
+            }
+        }
+        catch {
+            // ignore
+        }
+        return {};
+    }
+}

package/dist/tools/exec-command/normalize.d.ts

@@ -0,0 +1,17 @@
+type UnknownRecord = Record<string, unknown>;
+export type ExecCommandNormalizeResult = {
+    ok: true;
+    normalized: UnknownRecord;
+} | {
+    ok: false;
+    reason: 'missing_cmd';
+    normalized: UnknownRecord;
+};
+/**
+ * Normalize Codex CLI exec_command arguments (shape fixes only):
+ * - accept cmd/command/toon as sources for cmd
+ * - drop "toon" (must never be exposed to client)
+ * - repair common `find -exec ... ;` meta issues in cmd
+ */
+export declare function normalizeExecCommandArgs(args: unknown): ExecCommandNormalizeResult;
+export {};

package/dist/tools/exec-command/normalize.js

@@ -0,0 +1,112 @@
+import { repairFindMeta } from '../../conversion/shared/tooling.js';
+const isRecord = (value) => typeof value === 'object' && value !== null && !Array.isArray(value);
+const asNonEmptyString = (value) => {
+    if (typeof value !== 'string')
+        return undefined;
+    const trimmed = value.trim();
+    return trimmed ? trimmed : undefined;
+};
+const asPrimitiveString = (value) => {
+    if (typeof value === 'string')
+        return asNonEmptyString(value);
+    if (typeof value === 'number' && Number.isFinite(value))
+        return String(value);
+    if (typeof value === 'boolean')
+        return String(value);
+    return undefined;
+};
+const asFiniteNumber = (value) => {
+    if (typeof value !== 'number' || !Number.isFinite(value))
+        return undefined;
+    return value;
+};
+const asBoolean = (value) => {
+    if (typeof value !== 'boolean')
+        return undefined;
+    return value;
+};
+const asStringArray = (value) => {
+    if (!Array.isArray(value))
+        return undefined;
+    const out = [];
+    for (const entry of value) {
+        if (typeof entry === 'string') {
+            out.push(entry);
+            continue;
+        }
+        if (entry == null)
+            continue;
+        out.push(String(entry));
+    }
+    return out.length ? out : undefined;
+};
+/**
+ * Normalize Codex CLI exec_command arguments (shape fixes only):
+ * - accept cmd/command/toon as sources for cmd
+ * - drop "toon" (must never be exposed to client)
+ * - repair common `find -exec ... ;` meta issues in cmd
+ */
+export function normalizeExecCommandArgs(args) {
+    const base = isRecord(args) ? { ...args } : {};
+    const cmdCandidate = asPrimitiveString(base.cmd) ??
+        asPrimitiveString(base.command) ??
+        asPrimitiveString(base.toon) ??
+        asPrimitiveString(base.script) ??
+        (() => {
+            const arr = asStringArray(base.command) ?? asStringArray(base.cmd);
+            return arr ? arr.join(' ') : undefined;
+        })();
+    // Always drop toon from outward-facing args (even if used as cmd source).
+    try {
+        if (Object.prototype.hasOwnProperty.call(base, 'toon')) {
+            delete base.toon;
+        }
+    }
+    catch {
+        // ignore
+    }
+    if (!cmdCandidate) {
+        // Keep captured samples free of hidden TOON payloads.
+        try {
+            if (Object.prototype.hasOwnProperty.call(base, 'toon')) {
+                delete base.toon;
+            }
+        }
+        catch {
+            // ignore
+        }
+        return { ok: false, reason: 'missing_cmd', normalized: base };
+    }
+    const fixedCmd = repairFindMeta(cmdCandidate);
+    const normalized = { cmd: fixedCmd };
+    const workdir = asNonEmptyString(base.workdir) ??
+        asNonEmptyString(base.cwd) ??
+        asNonEmptyString(base.workDir);
+    if (workdir)
+        normalized.workdir = workdir;
+    const login = asBoolean(base.login);
+    if (login !== undefined)
+        normalized.login = login;
+    const tty = asBoolean(base.tty);
+    if (tty !== undefined)
+        normalized.tty = tty;
+    const shell = asNonEmptyString(base.shell);
+    if (shell)
+        normalized.shell = shell;
+    const sandboxPermissions = asNonEmptyString(base.sandbox_permissions) ??
+        (asBoolean(base.with_escalated_permissions) ? 'require_escalated' : undefined);
+    if (sandboxPermissions)
+        normalized.sandbox_permissions = sandboxPermissions;
+    const justification = asNonEmptyString(base.justification);
+    if (justification)
+        normalized.justification = justification;
+    const maxOutput = asFiniteNumber(base.max_output_tokens) ?? asFiniteNumber(base.max_tokens);
+    if (maxOutput !== undefined)
+        normalized.max_output_tokens = maxOutput;
+    const yieldTime = asFiniteNumber(base.yield_time_ms) ??
+        asFiniteNumber(base.yield_ms) ??
+        asFiniteNumber(base.wait_ms);
+    if (yieldTime !== undefined)
+        normalized.yield_time_ms = yieldTime;
+    return { ok: true, normalized };
+}

package/dist/tools/exec-command/regression-capturer.d.ts

@@ -0,0 +1,11 @@
+interface RegressionSample {
+    id: string;
+    timestamp: string;
+    errorType: string;
+    originalArgs: string;
+    normalizedArgs?: string;
+    validationError?: string;
+    source?: string;
+}
+export declare function captureExecCommandRegression(sample: Omit<RegressionSample, 'id' | 'timestamp'>): void;
+export {};