@jsonstudio/llms 0.6.467 → 0.6.567

package/dist/servertool/handlers/vision.js

@@ -60,7 +60,26 @@ function shouldRunVisionFlow(ctx) {
     if (followupFlag) {
         return false;
     }
-    return record.hasImageAttachment === true || record.hasImageAttachment === 'true';
+    const hasImageAttachment = record.hasImageAttachment === true || record.hasImageAttachment === 'true';
+    if (!hasImageAttachment) {
+        return false;
+    }
+    // 若当前已经使用具备内建多模态能力的 Provider（例如 Gemini/Claude/ChatGPT 路径），
+    // 且未显式 forceVision，则不再触发额外的 vision 二跳，避免同一轮请求跑两次。
+    const forceVision = record.forceVision === true || record.forceVision === 'true';
+    if (forceVision) {
+        return true;
+    }
+    const providerType = typeof record.providerType === 'string' ? record.providerType.toLowerCase() : '';
+    const providerProtocol = typeof record.providerProtocol === 'string' ? record.providerProtocol.toLowerCase() : '';
+    const inlineMultimodal = providerType === 'gemini' ||
+        providerType === 'responses' ||
+        providerProtocol === 'gemini-chat' ||
+        providerProtocol === 'openai-responses';
+    if (inlineMultimodal) {
+        return false;
+    }
+    return true;
 }
 function getCapturedRequest(adapterContext) {
     if (!adapterContext || typeof adapterContext !== 'object') {
@@ -80,15 +99,15 @@ function buildVisionAnalysisPayload(source) {
     if (typeof source.model === 'string' && source.model.trim()) {
         payload.model = source.model.trim();
     }
-    if (Array.isArray(source.messages)) {
-        payload.messages = cloneJson(source.messages);
-    }
-    else {
+    const rawMessages = source.messages;
+    if (!Array.isArray(rawMessages) || !rawMessages.length) {
         return null;
     }
-    if (Array.isArray(source.tools) && source.tools.length) {
-        payload.tools = cloneJson(source.tools);
+    const visionMessages = buildVisionAnalysisMessages(rawMessages);
+    if (!visionMessages.length) {
+        return null;
     }
+    payload.messages = visionMessages;
     const parameters = source.parameters;
     if (parameters && typeof parameters === 'object' && !Array.isArray(parameters)) {
         const params = cloneJson(parameters);
@@ -96,6 +115,85 @@ function buildVisionAnalysisPayload(source) {
     }
     return payload;
 }
+function buildVisionAnalysisMessages(sourceMessages) {
+    const latestUser = extractLatestUserMessageForVision(sourceMessages);
+    if (!latestUser) {
+        return [];
+    }
+    const userMessage = buildVisionUserMessage(latestUser);
+    if (!userMessage) {
+        return [];
+    }
+    const messages = [];
+    const systemMessage = buildVisionSystemMessage();
+    if (systemMessage) {
+        messages.push(systemMessage);
+    }
+    messages.push(userMessage);
+    return messages;
+}
+function extractLatestUserMessageForVision(sourceMessages) {
+    for (let idx = sourceMessages.length - 1; idx >= 0; idx -= 1) {
+        const msg = sourceMessages[idx];
+        if (!msg || typeof msg !== 'object' || Array.isArray(msg)) {
+            continue;
+        }
+        const role = msg.role;
+        if (typeof role === 'string' && role.trim().toLowerCase() === 'user') {
+            return cloneJson(msg);
+        }
+    }
+    return null;
+}
+function buildVisionSystemMessage() {
+    const content = '你是一名专业的图像分析助手。无论输入是界面截图、文档、图表、代码编辑器、应用窗口还是普通照片，都需要先用结构化、详细的自然语言完整描述画面内容（关键区域、文字信息、布局层次、颜色与对比度、元素之间的关系等），然后总结出与用户任务最相关的关键信息和潜在问题，最后给出具体、可执行的改进建议或结论，避免泛泛而谈。';
+    return {
+        role: 'system',
+        content
+    };
+}
+function buildVisionUserMessage(source) {
+    const roleRaw = source.role;
+    const role = typeof roleRaw === 'string' && roleRaw.trim().length
+        ? roleRaw.trim()
+        : 'user';
+    const rawContent = source.content;
+    const message = { role };
+    if (Array.isArray(rawContent)) {
+        const textParts = [];
+        const imageParts = [];
+        for (const part of rawContent) {
+            if (!part || typeof part !== 'object' || Array.isArray(part)) {
+                textParts.push(part);
+                continue;
+            }
+            const record = part;
+            const typeValue = typeof record.type === 'string' ? record.type.toLowerCase() : '';
+            if (typeValue.includes('image')) {
+                imageParts.push(part);
+            }
+            else {
+                textParts.push(part);
+            }
+        }
+        const combined = [];
+        if (textParts.length)
+            combined.push(...textParts);
+        if (imageParts.length)
+            combined.push(...imageParts);
+        if (!combined.length) {
+            return null;
+        }
+        message.content = combined;
+    }
+    else if (typeof rawContent === 'string' && rawContent.trim().length) {
+        message.content = rawContent.trim();
+    }
+    else {
+        return null;
+    }
+    return message;
+}
 function buildVisionFollowupPayload(source, summary) {
     if (!source || typeof source !== 'object') {
         return null;

package/dist/servertool/server-side-tools.d.ts

@@ -2,6 +2,8 @@ import type { JsonObject } from '../conversion/hub/types/json.js';
 import type { ServerSideToolEngineOptions, ServerSideToolEngineResult, ToolCall } from './types.js';
 import './handlers/web-search.js';
 import './handlers/vision.js';
+import './handlers/gemini-empty-reply-continue.js';
+import './handlers/stop-message-auto.js';
 export declare function runServerSideToolEngine(options: ServerSideToolEngineOptions): Promise<ServerSideToolEngineResult>;
 export declare function extractToolCalls(chatResponse: JsonObject): ToolCall[];
 export declare function cloneJson<T>(value: T): T;

package/dist/servertool/server-side-tools.js

@@ -1,6 +1,8 @@
 import { getServerToolHandler, listAutoServerToolHandlers } from './registry.js';
 import './handlers/web-search.js';
 import './handlers/vision.js';
+import './handlers/gemini-empty-reply-continue.js';
+import './handlers/stop-message-auto.js';
 export async function runServerSideToolEngine(options) {
     const base = asObject(options.chatResponse);
     if (!base) {

package/dist/tools/tool-registry.js

@@ -43,6 +43,164 @@ const toJson = (value) => {
         return '{}';
     }
 };
+const APPLY_PATCH_SECTION_RE = /^\*\*\*\s+(Add|Update|Delete|Copy|Move)\s+File:\s*(.+)$/;
+const sanitizeRelativePath = (value) => {
+    if (!value)
+        return null;
+    const trimmed = value.trim().replace(/\\/g, '/');
+    if (!trimmed)
+        return null;
+    if (trimmed.startsWith('/'))
+        return null;
+    if (/^[a-zA-Z]:/.test(trimmed))
+        return null;
+    if (trimmed.includes('\0'))
+        return null;
+    if (trimmed.includes('..')) {
+        const segments = trimmed.split('/');
+        if (segments.some((seg) => seg === '..')) {
+            return null;
+        }
+    }
+    return trimmed.replace(/\/{2,}/g, '/');
+};
+const collectExplicitPaths = (record) => {
+    const bucket = [];
+    const invalid = [];
+    const pushPath = (candidate) => {
+        const str = asString(candidate);
+        const normalized = sanitizeRelativePath(str);
+        if (normalized)
+            bucket.push(normalized);
+        else if (typeof candidate === 'string')
+            invalid.push(candidate);
+    };
+    const entries = [
+        record.paths,
+        record.path,
+        record.files,
+        record.file,
+        record.targets,
+        record.target_path
+    ];
+    for (const entry of entries) {
+        if (!entry)
+            continue;
+        if (typeof entry === 'string') {
+            pushPath(entry);
+        }
+        else if (Array.isArray(entry)) {
+            entry.forEach((item) => {
+                if (typeof item === 'string')
+                    pushPath(item);
+                else if (isRecord(item))
+                    pushPath(item.path);
+            });
+        }
+        else if (isRecord(entry)) {
+            pushPath(entry.path ?? entry.value);
+        }
+    }
+    return { paths: bucket, invalid };
+};
+const looksLikePatchBody = (text) => {
+    const trimmed = text.trim();
+    if (!trimmed)
+        return false;
+    const hunkRe = /^@@/m;
+    const diffLineRe = /^[ +-]/m;
+    return hunkRe.test(trimmed) || diffLineRe.test(trimmed);
+};
+const applyPathOverrides = (lines, overridePaths) => {
+    if (!overridePaths.length)
+        return;
+    const sections = [];
+    for (let i = 0; i < lines.length; i += 1) {
+        const match = lines[i].match(APPLY_PATCH_SECTION_RE);
+        if (match) {
+            sections.push({ index: i, action: match[1] });
+        }
+    }
+    if (!sections.length) {
+        const beginIdx = lines.findIndex((line) => line.trim() === '*** Begin Patch');
+        if (beginIdx >= 0) {
+            lines.splice(beginIdx + 1, 0, `*** Update File: ${overridePaths[0]}`);
+        }
+        return;
+    }
+    const limit = Math.min(sections.length, overridePaths.length);
+    for (let i = 0; i < limit; i += 1) {
+        lines[sections[i].index] = `*** ${sections[i].action} File: ${overridePaths[i]}`;
+    }
+};
+const normalizeApplyPatchInput = (rawPatch, options) => {
+    if (typeof rawPatch !== 'string') {
+        return null;
+    }
+    const text = rawPatch.replace(/\r\n/g, '\n');
+    const beginIdx = text.toLowerCase().indexOf('*** begin patch');
+    const endIdx = text.toLowerCase().lastIndexOf('*** end patch');
+    let candidate = '';
+    if (beginIdx >= 0 && endIdx >= 0 && endIdx > beginIdx) {
+        candidate = text.slice(beginIdx, endIdx + '*** End Patch'.length);
+    }
+    else if (options?.overridePaths && options.overridePaths.length) {
+        if (!looksLikePatchBody(text)) {
+            return null;
+        }
+        const headerPath = options.overridePaths[0];
+        candidate = ['*** Begin Patch', `*** Update File: ${headerPath}`, text.trim(), '*** End Patch'].join('\n');
+    }
+    else {
+        return null;
+    }
+    const lines = candidate.split(/\r?\n/);
+    if (!lines.length) {
+        return null;
+    }
+    let firstIdx = 0;
+    while (firstIdx < lines.length && lines[firstIdx].trim().length === 0) {
+        firstIdx += 1;
+    }
+    if (firstIdx >= lines.length) {
+        return null;
+    }
+    const firstLineRaw = lines[firstIdx];
+    const firstLineTrimmed = firstLineRaw.trim();
+    if (!firstLineTrimmed.toLowerCase().startsWith('*** begin patch')) {
+        return null;
+    }
+    if (firstLineTrimmed !== '*** Begin Patch') {
+        lines[firstIdx] = '*** Begin Patch';
+    }
+    let lastIdx = lines.length - 1;
+    while (lastIdx > firstIdx && lines[lastIdx].trim().length === 0) {
+        lastIdx -= 1;
+    }
+    if (lastIdx > firstIdx) {
+        const lastLineTrimmed = lines[lastIdx].trim();
+        if (lastLineTrimmed.toLowerCase().startsWith('*** end patch') && lastLineTrimmed !== '*** End Patch') {
+            lines[lastIdx] = '*** End Patch';
+        }
+    }
+    if (options?.overridePaths && options.overridePaths.length) {
+        applyPathOverrides(lines, options.overridePaths);
+    }
+    const normalized = lines.join('\n');
+    if (!normalized.includes('*** Begin Patch') || !normalized.includes('*** End Patch')) {
+        return null;
+    }
+    return normalized;
+};
+const logApplyPatchValidatorError = (message) => {
+    try {
+        // eslint-disable-next-line no-console
+        console.error(`\x1b[31m[apply_patch][validator] ${message}\x1b[0m`);
+    }
+    catch {
+        /* ignore */
+    }
+};
 const detectForbiddenWrite = (script) => {
     const normalized = script.toLowerCase();
     if (!normalized) {
@@ -95,12 +253,45 @@ export function validateToolCall(name, argsString) {
     const rawArgs = tryParseJson(typeof argsString === 'string' ? argsString : '{}');
     switch (normalizedName) {
         case 'apply_patch': {
-            const input = asString(rawArgs.input);
-            const patch = asString(rawArgs.patch) ?? input;
-            if (!patch) {
+            const record = rawArgs;
+            const inputField = asString(record.input);
+            const patchField = asString(record.patch);
+            const rawStr = typeof argsString === 'string' ? argsString : '';
+            let patchRaw = null;
+            if (patchField) {
+                patchRaw = patchField;
+            }
+            else if (inputField) {
+                patchRaw = inputField;
+            }
+            else if (rawStr && /\*\*\*\s+Begin Patch/i.test(rawStr)) {
+                patchRaw = rawStr;
+            }
+            if (!patchRaw) {
+                logApplyPatchValidatorError('missing apply_patch patch/input payload');
                 return { ok: false, reason: 'missing_input' };
             }
-            return { ok: true, normalizedArgs: toJson({ input: patch, patch }) };
+            const { paths: explicitPaths, invalid } = collectExplicitPaths(record);
+            if (invalid.length) {
+                invalid.forEach((value) => logApplyPatchValidatorError(`invalid path argument: ${value}`));
+            }
+            const normalizedPatch = normalizeApplyPatchInput(patchRaw, { overridePaths: explicitPaths });
+            if (!normalizedPatch) {
+                logApplyPatchValidatorError('patch text missing *** Begin Patch/*** End Patch or failed to auto-wrap with provided paths');
+                return { ok: false, reason: 'invalid_patch_header' };
+            }
+            // Canonical, parameterized shape; keep input for backwards compatibility.
+            const payload = {
+                patch: normalizedPatch,
+                input: normalizedPatch
+            };
+            if (explicitPaths.length) {
+                payload.paths = explicitPaths;
+            }
+            return {
+                ok: true,
+                normalizedArgs: toJson(payload)
+            };
         }
         case 'shell': {
             const rawCommand = rawArgs.command;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jsonstudio/llms",
-  "version": "0.6.467",
+  "version": "0.6.567",
   "type": "module",
   "main": "dist/index.js",
   "module": "dist/index.js",