@jsonstudio/llms 0.6.567 → 0.6.586

package/dist/servertool/handlers/iflow-model-error-retry.js

@@ -0,0 +1,93 @@
+import { registerServerToolHandler } from '../registry.js';
+import { cloneJson } from '../server-side-tools.js';
+const FLOW_ID = 'iflow_model_error_retry';
+const handler = async (ctx) => {
+    if (!ctx.options.reenterPipeline) {
+        return null;
+    }
+    const adapterRecord = ctx.adapterContext;
+    // 避免在 followup 请求里再次触发，防止循环。
+    const followupRaw = adapterRecord.serverToolFollowup;
+    if (followupRaw === true || (typeof followupRaw === 'string' && followupRaw.trim().toLowerCase() === 'true')) {
+        return null;
+    }
+    // 仅针对 openai-chat 协议 + iflow.* providerKey 的 /v1/responses 路径启用。
+    if (ctx.options.providerProtocol !== 'openai-chat') {
+        return null;
+    }
+    const entryEndpoint = (ctx.options.entryEndpoint || '').toLowerCase();
+    if (!entryEndpoint.includes('/v1/responses')) {
+        return null;
+    }
+    const providerKey = typeof adapterRecord.providerKey === 'string' && adapterRecord.providerKey.trim()
+        ? adapterRecord.providerKey.trim().toLowerCase()
+        : '';
+    if (!providerKey.startsWith('iflow.')) {
+        return null;
+    }
+    // 仅在上游返回 error_code（HTTP 200 + 业务错误）时触发一次自动重试。
+    const base = ctx.base;
+    const errorCode = base.error_code;
+    const msg = base.msg;
+    if (typeof errorCode !== 'number' || errorCode === 0) {
+        return null;
+    }
+    if (typeof msg !== 'string' || !msg.trim().length) {
+        return null;
+    }
+    const captured = getCapturedRequest(ctx.adapterContext);
+    if (!captured) {
+        return null;
+    }
+    const followupPayload = buildRetryFollowupPayload(captured);
+    if (!followupPayload) {
+        return null;
+    }
+    return {
+        chatResponse: ctx.base,
+        execution: {
+            flowId: FLOW_ID,
+            followup: {
+                requestIdSuffix: ':retry',
+                payload: followupPayload,
+                metadata: {
+                    serverToolFollowup: true
+                }
+            }
+        }
+    };
+};
+registerServerToolHandler('iflow_model_error_retry', handler, { trigger: 'auto' });
+function getCapturedRequest(adapterContext) {
+    if (!adapterContext || typeof adapterContext !== 'object') {
+        return null;
+    }
+    const captured = adapterContext.capturedChatRequest;
+    if (!captured || typeof captured !== 'object' || Array.isArray(captured)) {
+        return null;
+    }
+    return captured;
+}
+function buildRetryFollowupPayload(source) {
+    if (!source || typeof source !== 'object') {
+        return null;
+    }
+    const payload = {};
+    if (typeof source.model === 'string' && source.model.trim()) {
+        payload.model = source.model.trim();
+    }
+    const rawMessages = source.messages;
+    if (Array.isArray(rawMessages)) {
+        payload.messages = cloneJson(rawMessages);
+    }
+    const rawTools = source.tools;
+    if (Array.isArray(rawTools) && rawTools.length) {
+        payload.tools = cloneJson(rawTools);
+    }
+    const parameters = source.parameters;
+    if (parameters && typeof parameters === 'object' && !Array.isArray(parameters)) {
+        const params = cloneJson(parameters);
+        Object.assign(payload, params);
+    }
+    return payload;
+}

package/dist/servertool/handlers/stop-message-auto.js

@@ -1,24 +1,52 @@
 import { registerServerToolHandler } from '../registry.js';
 import { cloneJson } from '../server-side-tools.js';
 import { loadRoutingInstructionStateSync, saveRoutingInstructionStateAsync } from '../../router/virtual-router/sticky-session-store.js';
+const STOPMESSAGE_DEBUG = (process.env.ROUTECODEX_STOPMESSAGE_DEBUG || '').trim() === '1';
+function debugLog(message, extra) {
+    if (!STOPMESSAGE_DEBUG) {
+        return;
+    }
+    try {
+        // eslint-disable-next-line no-console
+        console.log(`\x1b[38;5;33m[stopMessage][debug] ${message}` +
+            (extra ? ` ${JSON.stringify(extra)}` : '') +
+            '\x1b[0m');
+    }
+    catch {
+        /* ignore logging failures */
+    }
+}
 const FLOW_ID = 'stop_message_flow';
 const handler = async (ctx) => {
     const record = ctx.adapterContext;
+    debugLog('handler_start', {
+        requestId: record.requestId,
+        providerProtocol: record.providerProtocol
+    });
     const followupRaw = record.serverToolFollowup;
     if (followupRaw === true || (typeof followupRaw === 'string' && followupRaw.trim().toLowerCase() === 'true')) {
+        debugLog('skip_servertool_followup_flag');
+        return null;
+    }
+    const connectionState = resolveClientConnectionState(record.clientConnectionState);
+    if (connectionState?.disconnected === true) {
+        debugLog('skip_client_disconnected');
         return null;
     }
     const clientDisconnectedRaw = record.clientDisconnected;
     if (clientDisconnectedRaw === true ||
         (typeof clientDisconnectedRaw === 'string' && clientDisconnectedRaw.trim().toLowerCase() === 'true')) {
+        debugLog('skip_client_disconnected_flag');
         return null;
     }
     const stickyKey = resolveStickyKey(record);
     if (!stickyKey) {
+        debugLog('skip_no_sticky_key');
         return null;
     }
     const state = loadRoutingInstructionStateSync(stickyKey);
     if (!state || !state.stopMessageText || !state.stopMessageMaxRepeats) {
+        debugLog('skip_no_state', { stickyKey });
         return null;
     }
     const text = typeof state.stopMessageText === 'string' ? state.stopMessageText.trim() : '';
@@ -26,25 +54,45 @@ const handler = async (ctx) => {
         ? Math.max(1, Math.floor(state.stopMessageMaxRepeats))
         : 0;
     if (!text || maxRepeats <= 0) {
+        debugLog('skip_invalid_text_or_maxRepeats', {
+            stickyKey,
+            textLength: text.length,
+            maxRepeats
+        });
         return null;
     }
     const used = typeof state.stopMessageUsed === 'number' && Number.isFinite(state.stopMessageUsed)
         ? Math.max(0, Math.floor(state.stopMessageUsed))
         : 0;
     if (used >= maxRepeats) {
+        debugLog('skip_reached_max_repeats', {
+            stickyKey,
+            used,
+            maxRepeats
+        });
         return null;
     }
     if (!isStopFinishReason(ctx.base)) {
+        debugLog('skip_not_stop_finish_reason', {
+            stickyKey
+        });
         return null;
     }
     const captured = getCapturedRequest(ctx.adapterContext);
     if (!captured) {
+        debugLog('skip_no_captured_request', {
+            stickyKey
+        });
         return null;
     }
     state.stopMessageUsed = used + 1;
+    state.stopMessageLastUsedAt = Date.now();
     saveRoutingInstructionStateAsync(stickyKey, state);
     const followupPayload = buildStopMessageFollowupPayload(captured, text);
     if (!followupPayload) {
+        debugLog('skip_failed_build_followup', {
+            stickyKey
+        });
         return null;
     }
     return {
@@ -56,7 +104,10 @@ const handler = async (ctx) => {
                 payload: followupPayload,
                 metadata: {
                     serverToolFollowup: true,
-                    stream: false
+                    stream: false,
+                    preserveRouteHint: false,
+                    disableStickyRoutes: true,
+                    ...(connectionState ? { clientConnectionState: connectionState } : {})
                 }
             }
         }
@@ -65,12 +116,12 @@ const handler = async (ctx) => {
 registerServerToolHandler('stop_message_auto', handler, { trigger: 'auto' });
 function resolveStickyKey(record) {
     const sessionId = typeof record.sessionId === 'string' && record.sessionId.trim() ? record.sessionId.trim() : '';
-    if (sessionId) {
-        return `session:${sessionId}`;
-    }
     const conversationId = typeof record.conversationId === 'string' && record.conversationId.trim()
         ? record.conversationId.trim()
         : '';
+    if (sessionId) {
+        return `session:${sessionId}`;
+    }
     if (conversationId) {
         return `conversation:${conversationId}`;
     }
@@ -145,3 +196,9 @@ function buildStopMessageFollowupPayload(source, text) {
     }
     return payload;
 }
+function resolveClientConnectionState(value) {
+    if (!value || typeof value !== 'object' || Array.isArray(value)) {
+        return null;
+    }
+    return value;
+}

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

@@ -3,6 +3,7 @@ import type { ServerSideToolEngineOptions, ServerSideToolEngineResult, ToolCall
 import './handlers/web-search.js';
 import './handlers/vision.js';
 import './handlers/gemini-empty-reply-continue.js';
+import './handlers/iflow-model-error-retry.js';
 import './handlers/stop-message-auto.js';
 export declare function runServerSideToolEngine(options: ServerSideToolEngineOptions): Promise<ServerSideToolEngineResult>;
 export declare function extractToolCalls(chatResponse: JsonObject): ToolCall[];

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

@@ -2,12 +2,16 @@ import { getServerToolHandler, listAutoServerToolHandlers } from './registry.js'
 import './handlers/web-search.js';
 import './handlers/vision.js';
 import './handlers/gemini-empty-reply-continue.js';
+import './handlers/iflow-model-error-retry.js';
 import './handlers/stop-message-auto.js';
 export async function runServerSideToolEngine(options) {
     const base = asObject(options.chatResponse);
     if (!base) {
         return { mode: 'passthrough', finalChatResponse: options.chatResponse };
     }
+    if (isClientDisconnected(options.adapterContext)) {
+        return { mode: 'passthrough', finalChatResponse: base };
+    }
     const toolCalls = extractToolCalls(base);
     const contextBase = {
         base,
@@ -91,6 +95,29 @@ function getArray(value) {
 export function cloneJson(value) {
     return JSON.parse(JSON.stringify(value));
 }
+function isClientDisconnected(adapterContext) {
+    if (!adapterContext || typeof adapterContext !== 'object') {
+        return false;
+    }
+    const state = adapterContext.clientConnectionState;
+    if (state && typeof state === 'object' && !Array.isArray(state)) {
+        const disconnected = state.disconnected;
+        if (disconnected === true) {
+            return true;
+        }
+        if (typeof disconnected === 'string' && disconnected.trim().toLowerCase() === 'true') {
+            return true;
+        }
+    }
+    const raw = adapterContext.clientDisconnected;
+    if (raw === true) {
+        return true;
+    }
+    if (typeof raw === 'string' && raw.trim().toLowerCase() === 'true') {
+        return true;
+    }
+    return false;
+}
 export function extractTextFromChatLike(payload) {
     let current = payload;
     const visited = new Set();

package/dist/sse/json-to-sse/event-generators/responses.js

@@ -81,9 +81,16 @@ function normalizeUsage(usage) {
         return fallback;
     }
     const asAny = usage;
-    const inputRaw = Number((asAny.input_tokens ?? asAny.prompt_tokens));
+    const baseInputRaw = Number((asAny.input_tokens ?? asAny.prompt_tokens));
+    const baseInput = Number.isFinite(baseInputRaw) ? baseInputRaw : 0;
+    let cachedRaw = Number(asAny.cache_read_input_tokens);
+    if (!Number.isFinite(cachedRaw) && asAny.input_tokens_details && typeof asAny.input_tokens_details === 'object') {
+        const details = asAny.input_tokens_details;
+        cachedRaw = Number(details.cached_tokens);
+    }
+    const cached = Number.isFinite(cachedRaw) ? cachedRaw : 0;
+    const input = baseInput + cached;
     const outputRaw = Number((asAny.output_tokens ?? asAny.completion_tokens));
-    const input = Number.isFinite(inputRaw) ? inputRaw : 0;
     const output = Number.isFinite(outputRaw) ? outputRaw : 0;
     const totalRaw = Number(asAny.total_tokens);
     const total = Number.isFinite(totalRaw) ? totalRaw : input + output;

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

@@ -111,12 +111,16 @@ export function createAnthropicResponseBuilder(options) {
                     break;
                 }
                 case 'message_delta': {
-                    const delta = event.data?.delta;
+                    const data = event.data ?? {};
+                    const delta = data?.delta;
                     if (delta?.stop_reason) {
                         state.stopReason = delta.stop_reason;
                     }
-                    if (delta?.usage) {
-                        state.usage = delta.usage;
+                    // 部分实现将 usage 挂在 delta.usage，部分实现挂在顶层 event.data.usage，
+                    // 这里统一优先读取 delta.usage，缺失时回退到 data.usage。
+                    const usageNode = (delta && delta.usage) ?? data.usage;
+                    if (usageNode) {
+                        state.usage = usageNode;
                     }
                     break;
                 }
@@ -132,6 +136,22 @@ export function createAnthropicResponseBuilder(options) {
         },
         getResult() {
             if (!state.completed) {
+                // 对部分实现（或网络提前关闭）导致缺失 message_stop 的 SSE 流，
+                // 只要已经累计到可用内容，就以最佳努力方式返回结果，而不是直接抛错。
+                if (state.content.length > 0) {
+                    return {
+                        success: true,
+                        response: {
+                            id: state.id || `msg_${Date.now()}`,
+                            type: 'message',
+                            role: state.role || 'assistant',
+                            model: state.model || 'unknown',
+                            content: state.content,
+                            usage: state.usage,
+                            stop_reason: state.stopReason ?? 'end_turn'
+                        }
+                    };
+                }
                 return { success: false, error: new Error('Anthropic SSE stream incomplete') };
             }
             return {

package/dist/tools/apply-patch-structured.d.ts

@@ -0,0 +1,20 @@
+export type StructuredApplyPatchKind = 'insert_after' | 'insert_before' | 'replace' | 'delete' | 'create_file' | 'delete_file';
+export interface StructuredApplyPatchChange {
+    file?: string;
+    kind: StructuredApplyPatchKind | string;
+    anchor?: string;
+    target?: string;
+    lines?: string[] | string;
+    use_anchor_indent?: boolean;
+}
+export interface StructuredApplyPatchPayload extends Record<string, unknown> {
+    instructions?: string;
+    file?: string;
+    changes: StructuredApplyPatchChange[];
+}
+export declare class StructuredApplyPatchError extends Error {
+    reason: string;
+    constructor(reason: string, message: string);
+}
+export declare function buildStructuredPatch(payload: StructuredApplyPatchPayload): string;
+export declare function isStructuredApplyPatchPayload(candidate: unknown): candidate is StructuredApplyPatchPayload;

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

@@ -0,0 +1,240 @@
+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 INVALID_FILE_FORMAT_RE = /^([A-Za-z]:|\/)/;
+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) => {
+    const trimmed = raw.trim();
+    if (!trimmed) {
+        throw new StructuredApplyPatchError('invalid_file', `${label} must not be empty`);
+    }
+    if (FILE_PATH_INVALID_RE.test(trimmed)) {
+        throw new StructuredApplyPatchError('invalid_file', `${label} must be a single-line relative path`);
+    }
+    if (INVALID_FILE_FORMAT_RE.test(trimmed)) {
+        throw new StructuredApplyPatchError('invalid_file', `${label} must be relative to the workspace root`);
+    }
+    return trimmed.replace(/\\/g, '/');
+};
+const splitTextIntoLines = (input) => {
+    const normalized = input.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 [];
+        }
+        return value.map((entry, idx) => {
+            if (typeof entry !== 'string') {
+                if (entry === null || entry === undefined) {
+                    return '';
+                }
+                return String(entry);
+            }
+            // Preserve intentional whitespace
+            return entry.replace(/\r/g, '');
+        });
+    }
+    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': {
+                const target = toSafeString(change.target, `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}`);
+            for (const hunk of section.hunks) {
+                // 每个 hunk 仅需一个开头的 "@@" 行，后面直接跟上下文/增删行。
+                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;
+}

package/dist/tools/tool-description-utils.d.ts

@@ -0,0 +1,5 @@
+export declare function normalizeToolName(value: unknown): string;
+export declare function isShellToolName(value: unknown): boolean;
+export declare function hasApplyPatchToolDeclared(tools: unknown[] | undefined): boolean;
+export declare function buildShellDescription(toolDisplayName: string, hasApplyPatch: boolean): string;
+export declare function appendApplyPatchReminder(description: string, hasApplyPatch: boolean): string;

package/dist/tools/tool-description-utils.js

@@ -0,0 +1,50 @@
+const SHELL_TOOL_ALIASES = new Set(['shell', 'shell_command', 'exec_command']);
+const APPLY_PATCH_NAME = 'apply_patch';
+export function normalizeToolName(value) {
+    return typeof value === 'string' ? value.trim().toLowerCase() : '';
+}
+function extractToolFunctionName(entry) {
+    if (!entry || typeof entry !== 'object') {
+        return '';
+    }
+    const fnName = typeof entry.function?.name === 'string'
+        ? entry.function.name
+        : undefined;
+    if (fnName && fnName.trim().length > 0) {
+        return fnName.trim();
+    }
+    const topName = typeof entry.name === 'string' ? entry.name : '';
+    return topName.trim();
+}
+export function isShellToolName(value) {
+    return SHELL_TOOL_ALIASES.has(normalizeToolName(value));
+}
+export function hasApplyPatchToolDeclared(tools) {
+    if (!Array.isArray(tools)) {
+        return false;
+    }
+    return tools.some((entry) => normalizeToolName(extractToolFunctionName(entry)) === APPLY_PATCH_NAME);
+}
+export function buildShellDescription(toolDisplayName, hasApplyPatch) {
+    const label = toolDisplayName && toolDisplayName.trim().length > 0
+        ? toolDisplayName.trim()
+        : 'shell';
+    const base = 'Runs a shell command and returns its output.';
+    const workdirLine = `- Always set the \`workdir\` param when using the ${label} function. Avoid using \`cd\` unless absolutely necessary.`;
+    const applyPatchLine = '- Prefer apply_patch for editing files instead of shell redirection or here-doc usage.';
+    return hasApplyPatch ? `${base}\n${workdirLine}\n${applyPatchLine}` : `${base}\n${workdirLine}`;
+}
+export function appendApplyPatchReminder(description, hasApplyPatch) {
+    if (!hasApplyPatch) {
+        return description;
+    }
+    const trimmed = description?.trim() ?? '';
+    if (!trimmed) {
+        return buildShellDescription('shell', true);
+    }
+    if (trimmed.includes('apply_patch')) {
+        return trimmed;
+    }
+    const applyPatchLine = '- Prefer apply_patch for editing files instead of shell redirection or here-doc usage.';
+    return `${trimmed}\n${applyPatchLine}`;
+}