@jsonstudio/llms 0.6.2172 → 0.6.3214

package/dist/sse/sse-to-json/builders/response-builder.js

@@ -49,6 +49,9 @@ export class ResponsesResponseBuilder {
                 case 'response.output_item.added':
                     this.handleOutputItemStart(this.mapOutputItemAdded(event));
                     break;
+                case 'response.output_item.done':
+                    this.handleOutputItemDone(this.mapOutputItemDone(event));
+                    break;
                 case 'response.content_part.added':
                     this.handleContentPartStart(this.mapContentPartAdded(event));
                     break;
@@ -69,6 +72,18 @@ export class ResponsesResponseBuilder {
                 case 'response.reasoning_image.delta':
                     this.handleReasoningDelta(this.mapReasoningDelta(event));
                     break;
+                case 'response.reasoning_summary_text.delta':
+                    this.handleReasoningSummaryDelta(event);
+                    break;
+                case 'response.reasoning_summary_text.done':
+                    this.handleReasoningSummaryDone(event);
+                    break;
+                case 'response.reasoning_summary_part.added':
+                    this.handleReasoningSummaryPartAdded(event);
+                    break;
+                case 'response.reasoning_summary_part.done':
+                    this.handleReasoningSummaryPartDone(event);
+                    break;
                 case 'response.reasoning_text.done':
                     this.handleReasoningDone(this.mapReasoningDone(event));
                     break;
@@ -198,11 +213,14 @@ export class ResponsesResponseBuilder {
             contentParts: data.content_index !== undefined ? [] : [],
             currentContentIndex: 0,
             accumulatedContent: [],
+            summaryByIndex: new Map(),
+            currentSummaryIndex: 0,
             hasContentPartAdded: false,
             isTextInProgress: false,
             role: data.role,
             callId: data.call_id,
             name: data.name,
+            encryptedContent: typeof data.encrypted_content === 'string' ? data.encrypted_content : undefined,
             startTime: event.timestamp,
             lastEventTime: event.timestamp
         };
@@ -228,7 +246,20 @@ export class ResponsesResponseBuilder {
                 status: data.status ?? item.status ?? 'in_progress',
                 role: data.role ?? item.role,
                 call_id: data.call_id ?? item.call_id,
-                name: data.name ?? item.name
+                name: data.name ?? item.name,
+                encrypted_content: typeof item.encrypted_content === 'string' ? item.encrypted_content : undefined
+            }
+        };
+    }
+    mapOutputItemDone(event) {
+        const data = event.data;
+        const item = data.item || {};
+        return {
+            ...event,
+            type: 'output_item.done',
+            data: {
+                item_id: data.item_id ?? item.id,
+                item
             }
         };
     }
@@ -515,7 +546,18 @@ export class ResponsesResponseBuilder {
         if (!outputItemState) {
             throw new Error(`Output item not found: ${data.item_id}`);
         }
-        outputItemState.accumulatedContent = data.summary || [];
+        outputItemState.accumulatedContent = [];
+        if (Array.isArray(data.summary)) {
+            data.summary.forEach((entry, index) => {
+                if (typeof entry === 'string') {
+                    outputItemState.summaryByIndex.set(index, entry);
+                    return;
+                }
+                if (entry && typeof entry === 'object' && typeof entry.text === 'string') {
+                    outputItemState.summaryByIndex.set(index, entry.text);
+                }
+            });
+        }
         outputItemState.lastEventTime = event.timestamp;
     }
     /**
@@ -530,6 +572,86 @@ export class ResponsesResponseBuilder {
         outputItemState.accumulatedContent.push(data.delta);
         outputItemState.lastEventTime = event.timestamp;
     }
+    handleReasoningSummaryDelta(event) {
+        const data = event.data;
+        const outputItemState = this.outputItemBuilders.get(data.item_id);
+        if (!outputItemState) {
+            throw new Error(`Output item not found: ${data.item_id}`);
+        }
+        const index = typeof data.summary_index === 'number'
+            ? data.summary_index
+            : outputItemState.currentSummaryIndex;
+        const delta = typeof data.delta === 'string' ? data.delta : '';
+        if (!delta) {
+            return;
+        }
+        const previous = outputItemState.summaryByIndex.get(index) ?? '';
+        outputItemState.summaryByIndex.set(index, `${previous}${delta}`);
+        outputItemState.currentSummaryIndex = index;
+        outputItemState.lastEventTime = event.timestamp;
+    }
+    handleReasoningSummaryDone(event) {
+        const data = event.data;
+        const outputItemState = this.outputItemBuilders.get(data.item_id);
+        if (!outputItemState) {
+            throw new Error(`Output item not found: ${data.item_id}`);
+        }
+        const index = typeof data.summary_index === 'number'
+            ? data.summary_index
+            : outputItemState.currentSummaryIndex;
+        const text = typeof data.text === 'string' ? data.text : '';
+        if (!text) {
+            return;
+        }
+        outputItemState.summaryByIndex.set(index, text);
+        outputItemState.currentSummaryIndex = index;
+        outputItemState.lastEventTime = event.timestamp;
+    }
+    handleReasoningSummaryPartAdded(event) {
+        const data = event.data;
+        const outputItemState = this.outputItemBuilders.get(data.item_id);
+        if (!outputItemState) {
+            throw new Error(`Output item not found: ${data.item_id}`);
+        }
+        let index;
+        if (typeof data.summary_index === 'number') {
+            index = data.summary_index;
+        }
+        else if (outputItemState.summaryByIndex.size) {
+            let maxIndex = -1;
+            for (const key of outputItemState.summaryByIndex.keys()) {
+                if (key > maxIndex)
+                    maxIndex = key;
+            }
+            index = maxIndex + 1;
+        }
+        else {
+            index = 0;
+        }
+        if (!outputItemState.summaryByIndex.has(index)) {
+            outputItemState.summaryByIndex.set(index, '');
+        }
+        outputItemState.currentSummaryIndex = index;
+        outputItemState.lastEventTime = event.timestamp;
+    }
+    handleReasoningSummaryPartDone(event) {
+        const data = event.data;
+        const outputItemState = this.outputItemBuilders.get(data.item_id);
+        if (!outputItemState) {
+            throw new Error(`Output item not found: ${data.item_id}`);
+        }
+        const index = typeof data.summary_index === 'number'
+            ? data.summary_index
+            : outputItemState.currentSummaryIndex;
+        const part = data.part && typeof data.part === 'object' ? data.part : undefined;
+        const text = part && typeof part.text === 'string' ? part.text : '';
+        if (!text) {
+            return;
+        }
+        outputItemState.summaryByIndex.set(index, text);
+        outputItemState.currentSummaryIndex = index;
+        outputItemState.lastEventTime = event.timestamp;
+    }
     mapReasoningDelta(event) {
         const data = event.data;
         return {
@@ -565,6 +687,10 @@ export class ResponsesResponseBuilder {
         if (!outputItemState) {
             throw new Error(`Output item not found: ${data.item_id}`);
         }
+        const text = typeof data.text === 'string' ? data.text : '';
+        if (text && outputItemState.accumulatedContent.length === 0) {
+            outputItemState.accumulatedContent.push({ type: 'reasoning_text', text });
+        }
         outputItemState.status = 'completed';
         outputItemState.lastEventTime = event.timestamp;
     }
@@ -580,6 +706,23 @@ export class ResponsesResponseBuilder {
         // 若为 custom_tool_call 变体（已在 start 阶段重命名为 function_call），尝试提取 name/arguments
         try {
             const item = data.item || {};
+            if (outputItemState.type === 'reasoning' && item && typeof item === 'object') {
+                if (!outputItemState.encryptedContent && typeof item.encrypted_content === 'string') {
+                    outputItemState.encryptedContent = item.encrypted_content;
+                }
+                const summary = Array.isArray(item.summary) ? item.summary : [];
+                if (summary.length && outputItemState.summaryByIndex.size === 0) {
+                    summary.forEach((entry, index) => {
+                        if (typeof entry === 'string') {
+                            outputItemState.summaryByIndex.set(index, entry);
+                            return;
+                        }
+                        if (entry && typeof entry === 'object' && typeof entry.text === 'string') {
+                            outputItemState.summaryByIndex.set(index, entry.text);
+                        }
+                    });
+                }
+            }
             if (outputItemState.type === 'function_call') {
                 if (!outputItemState.name && typeof item.name === 'string')
                     outputItemState.name = item.name;
@@ -775,12 +918,27 @@ export class ResponsesResponseBuilder {
      * 构建推理项
      */
     buildReasoningItem(state) {
-        return {
+        const summaryEntries = state.summaryByIndex.size > 0
+            ? Array.from(state.summaryByIndex.entries())
+                .sort((a, b) => a[0] - b[0])
+                .map(([, text]) => text)
+                .filter(item => typeof item === 'string')
+            : (Array.isArray(state.accumulatedContent)
+                ? state.accumulatedContent.filter(item => typeof item === 'string')
+                : []);
+        const summaryParts = summaryEntries
+            .map((text) => typeof text === 'string' && text.length ? ({ type: 'summary_text', text }) : null)
+            .filter((entry) => Boolean(entry));
+        const item = {
             id: state.id,
             type: 'reasoning',
-            summary: Array.isArray(state.accumulatedContent) ? state.accumulatedContent.filter(item => typeof item === 'string') : [],
+            summary: summaryParts,
             content: state.accumulatedContent.filter(item => typeof item === 'object')
         };
+        if (typeof state.encryptedContent === 'string' && state.encryptedContent.length) {
+            item.encrypted_content = state.encryptedContent;
+        }
+        return item;
     }
     /**
      * 获取构建结果

package/dist/sse/sse-to-json/responses-sse-to-json-converter.js

@@ -231,6 +231,8 @@ export class ResponsesSseToJsonConverterRefactored {
                 break;
             case 'response.reasoning_text.delta':
             case 'response.reasoning_text.done':
+            case 'response.reasoning_summary_text.delta':
+            case 'response.reasoning_summary_text.done':
                 context.eventStats.reasoningEventsCount++;
                 break;
             case 'response.function_call_arguments.delta':

package/dist/sse/types/responses-types.d.ts

@@ -141,8 +141,12 @@ export interface ResponsesMessageItem {
 export interface ResponsesReasoningItem {
     id: string;
     type: 'reasoning';
-    summary?: string[];
-    content: ResponsesReasoningContent[];
+    summary?: Array<string | {
+        type: 'summary_text';
+        text: string;
+    }>;
+    content?: ResponsesReasoningContent[];
+    encrypted_content?: string;
 }
 export type ResponsesReasoningContent = {
     type: 'reasoning_text';

package/dist/tools/apply-patch/patch-text/normalize.js

@@ -179,6 +179,16 @@ const stripConflictMarkers = (text) => {
         return text;
     }
 };
+const splitInlineBeginPatchFileHeader = (text) => {
+    if (!text)
+        return text;
+    return text.replace(/\*\*\*\s*Begin Patch(?:\s*\*\*\*)?\s*(Create|Add|Update|Delete)\s+File:\s*([^\n]+?)(?:\s+\*\*\*)?(?=\n|$)/gi, (_m, actionRaw, pathRaw) => {
+        const action = String(actionRaw || '').trim().toLowerCase();
+        const mappedAction = action === 'create' ? 'Add' : `${action.charAt(0).toUpperCase()}${action.slice(1)}`;
+        const path = String(pathRaw || '').trim();
+        return `*** Begin Patch\n*** ${mappedAction} File: ${path}`;
+    });
+};
 export const normalizeApplyPatchText = (raw) => {
     if (!raw)
         return raw;
@@ -189,6 +199,7 @@ export const normalizeApplyPatchText = (raw) => {
     if (!text)
         return raw;
     text = stripConflictMarkers(text);
+    text = splitInlineBeginPatchFileHeader(text);
     text = normalizeBeginEndMarkers(text);
     // Some models emit a GNU unified diff wrapped in apply_patch markers, e.g.:
     //   *** Begin Patch ***

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

@@ -8,6 +8,11 @@ const resolveTopLevelFile = (record) => {
         asString(record.filename);
     if (direct)
         return direct;
+    // Shape fix: treat top-level target as file path when changes exist.
+    const target = asString(record.target);
+    if (target && Array.isArray(record.changes) && record.changes.length > 0) {
+        return target;
+    }
     return undefined;
 };
 const buildSingleChangePayload = (record) => {

package/dist/tools/args-json.js

@@ -21,6 +21,22 @@ const stripArgKeyArtifacts = (input) => {
         return input;
     }
 };
+const repairArgKeyArtifactsInRawJson = (input) => {
+    try {
+        let out = String(input || '');
+        if (!out.includes('<arg_key') && !out.includes('<arg_value') && !out.includes('</arg_key') && !out.includes('</arg_value')) {
+            return out;
+        }
+        // Repair patterns like: "file</arg_key><arg_value>a.ts" -> "file":"a.ts"
+        out = out.replace(/"([^"]+?)\s*<\/?\s*arg_key\s*>\s*<\/?\s*arg_value\s*>([^"]*?)"/gi, '"$1":"$2"');
+        // Strip remaining tag artifacts after pair repair.
+        out = stripArgKeyArtifacts(out);
+        return out;
+    }
+    catch {
+        return input;
+    }
+};
 const normalizeObjectKey = (rawKey) => {
     const cleaned = stripXmlLikeTags(stripArgKeyArtifacts(rawKey)).trim();
     if (!cleaned)
@@ -143,6 +159,19 @@ export function parseToolArgsJson(input) {
         return parsed;
     }
     catch {
+        // attempt raw string repair for arg_key/arg_value artifacts
+        try {
+            const repairedRaw = repairArgKeyArtifactsInRawJson(raw).trim();
+            if (repairedRaw && repairedRaw !== raw) {
+                const parsed = JSON.parse(repairedRaw);
+                repairArgKeyArtifactsInKeys(parsed);
+                repairArgKeyArtifactsInObject(parsed);
+                return parsed;
+            }
+        }
+        catch {
+            // continue
+        }
         // try stripping common tool-call markup artifacts and parsing again
         try {
             const stripped = stripArgKeyArtifacts(raw).trim();

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

@@ -4,4 +4,7 @@ export type ExecCommandValidationResult = {
     message?: string;
     normalizedArgs?: string;
 };
-export declare function validateExecCommandArgs(argsString: string, rawArgs: unknown): ExecCommandValidationResult;
+export type ExecCommandValidationOptions = {
+    policyFile?: string;
+};
+export declare function validateExecCommandArgs(argsString: string, rawArgs: unknown, options?: ExecCommandValidationOptions): ExecCommandValidationResult;

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

@@ -1,5 +1,8 @@
 import { parseToolArgsJson } from '../args-json.js';
 import { normalizeExecCommandArgs } from './normalize.js';
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
 const isRecord = (value) => typeof value === 'object' && value !== null && !Array.isArray(value);
 const toJson = (value) => {
     try {
@@ -9,6 +12,7 @@ const toJson = (value) => {
         return '{}';
     }
 };
+const POLICY_CACHE = new Map();
 const GIT_RESET_HARD_PATTERN = /\bgit\s+reset\s+--hard(?:\s|$)/i;
 const GIT_CHECKOUT_PATTERN = /\bgit\s+checkout\b/i;
 const SHELL_SEPARATORS = new Set([';', '&&', '||', '|', '&']);
@@ -124,10 +128,90 @@ function evaluateGitCheckoutScope(command) {
     }
     return null;
 }
-function detectPolicyViolation(command) {
+function resolvePolicyPath(rawPath) {
+    const trimmed = rawPath.trim();
+    if (!trimmed) {
+        return '';
+    }
+    if (trimmed.startsWith('~/')) {
+        return path.join(os.homedir(), trimmed.slice(2));
+    }
+    return path.resolve(trimmed);
+}
+function loadPolicyRules(policyFile) {
+    const resolved = typeof policyFile === 'string' ? resolvePolicyPath(policyFile) : '';
+    if (!resolved) {
+        return [];
+    }
+    try {
+        const stat = fs.statSync(resolved);
+        if (!stat.isFile()) {
+            return [];
+        }
+        const cached = POLICY_CACHE.get(resolved);
+        if (cached && cached.mtimeMs === stat.mtimeMs) {
+            return cached.rules;
+        }
+        const raw = fs.readFileSync(resolved, 'utf8');
+        const parsed = raw.trim() ? JSON.parse(raw) : {};
+        const rulesNode = isRecord(parsed) && Array.isArray(parsed.rules) ? parsed.rules : [];
+        const rules = [];
+        for (const item of rulesNode) {
+            if (!isRecord(item)) {
+                continue;
+            }
+            const type = typeof item.type === 'string' ? item.type.trim().toLowerCase() : '';
+            if (type !== 'regex') {
+                continue;
+            }
+            const pattern = typeof item.pattern === 'string' ? item.pattern : '';
+            if (!pattern.trim()) {
+                continue;
+            }
+            const id = typeof item.id === 'string' && item.id.trim() ? item.id.trim() : `rule_${rules.length + 1}`;
+            const reason = typeof item.reason === 'string' && item.reason.trim()
+                ? item.reason.trim()
+                : `policy rule "${id}" blocked this command`;
+            const flagsRaw = typeof item.flags === 'string' ? item.flags.trim() : '';
+            let regex;
+            try {
+                regex = new RegExp(pattern, flagsRaw || 'i');
+            }
+            catch {
+                continue;
+            }
+            rules.push({ id, regex, reason });
+        }
+        POLICY_CACHE.set(resolved, { mtimeMs: stat.mtimeMs, rules });
+        return rules;
+    }
+    catch {
+        return [];
+    }
+}
+function detectPolicyRuleViolation(command, options) {
+    const rules = loadPolicyRules(options?.policyFile);
+    if (!rules.length) {
+        return null;
+    }
+    for (const rule of rules) {
+        if (rule.regex.test(command)) {
+            return {
+                reason: 'forbidden_exec_command_policy',
+                message: rule.reason
+            };
+        }
+    }
+    return null;
+}
+function detectPolicyViolation(command, options) {
     if (!command || !command.trim()) {
         return null;
     }
+    const policyViolation = detectPolicyRuleViolation(command, options);
+    if (policyViolation) {
+        return policyViolation;
+    }
     if (GIT_RESET_HARD_PATTERN.test(command)) {
         return {
             reason: 'forbidden_git_reset_hard',
@@ -136,7 +220,7 @@ function detectPolicyViolation(command) {
     }
     return evaluateGitCheckoutScope(command);
 }
-export function validateExecCommandArgs(argsString, rawArgs) {
+export function validateExecCommandArgs(argsString, rawArgs, options) {
     const raw = typeof argsString === 'string' ? argsString : String(argsString ?? '');
     const parsed = isRecord(rawArgs) && Object.keys(rawArgs).length > 0
         ? rawArgs
@@ -146,7 +230,7 @@ export function validateExecCommandArgs(argsString, rawArgs) {
         return { ok: false, reason: normalized.reason };
     }
     const command = typeof normalized.normalized.cmd === 'string' ? normalized.normalized.cmd : '';
-    const violation = detectPolicyViolation(command);
+    const violation = detectPolicyViolation(command, options);
     if (violation) {
         return { ok: false, reason: violation.reason, message: violation.message };
     }

package/dist/tools/tool-registry.d.ts

@@ -5,5 +5,11 @@ export interface ToolValidationResult {
     warnings?: Array<Record<string, unknown>>;
     normalizedArgs?: string;
 }
+export interface ToolValidationOptions {
+    execCommandGuard?: {
+        enabled?: boolean;
+        policyFile?: string;
+    };
+}
 export declare function getAllowedToolNames(): string[];
-export declare function validateToolCall(name: string, argsString: string): ToolValidationResult;
+export declare function validateToolCall(name: string, argsString: string, options?: ToolValidationOptions): ToolValidationResult;

package/dist/tools/tool-registry.js

@@ -81,7 +81,7 @@ export function getAllowedToolNames() {
         'list_mcp_resource_templates'
     ];
 }
-export function validateToolCall(name, argsString) {
+export function validateToolCall(name, argsString, options) {
     const normalizedName = String(name || '').trim();
     if (!normalizedName) {
         return { ok: false, reason: 'empty_tool_name' };
@@ -93,7 +93,8 @@ export function validateToolCall(name, argsString) {
     const rawArgsAny = parseToolArgsJson(typeof argsString === 'string' ? argsString : '{}');
     switch (normalizedName) {
         case 'exec_command': {
-            const validation = validateExecCommandArgs(argsString, rawArgsAny);
+            const guard = options?.execCommandGuard;
+            const validation = validateExecCommandArgs(argsString, rawArgsAny, guard && guard.enabled ? { policyFile: guard.policyFile } : undefined);
             if (!validation.ok) {
                 const reason = validation.reason || 'unknown';
                 captureExecCommandRegression({