@jsonstudio/llms 0.6.34 → 0.6.74

package/dist/router/virtual-router/classifier.js

@@ -1,73 +1,67 @@
 import { DEFAULT_ROUTE, ROUTE_PRIORITY } from './types.js';
-import { DEFAULT_THINKING_KEYWORDS } from './default-thinking-keywords.js';
 const DEFAULT_LONG_CONTEXT_THRESHOLD = 180000;
 export class RoutingClassifier {
     config;
     constructor(config) {
-        const keywordConfig = normalizeKeywordConfig(config);
         this.config = {
             longContextThresholdTokens: config.longContextThresholdTokens ?? DEFAULT_LONG_CONTEXT_THRESHOLD,
-            thinkingKeywords: keywordConfig.thinking,
-            backgroundKeywords: keywordConfig.background,
-            visionKeywords: keywordConfig.vision,
-            codingKeywords: keywordConfig.coding
+            thinkingKeywords: normalizeList(config.thinkingKeywords, ['think step', 'analysis', 'reasoning']),
+            backgroundKeywords: normalizeList(config.backgroundKeywords, ['background', 'context dump'])
         };
     }
     classify(features) {
-        const evaluations = [
-            {
-                route: 'longcontext',
-                triggered: features.estimatedTokens >= (this.config.longContextThresholdTokens ?? DEFAULT_LONG_CONTEXT_THRESHOLD),
-                reason: 'longcontext:token-threshold'
+        const lastToolCategory = features.lastAssistantToolCategory;
+        const reachedLongContext = features.estimatedTokens >= (this.config.longContextThresholdTokens ?? DEFAULT_LONG_CONTEXT_THRESHOLD);
+        const thinkingKeywordHit = features.hasThinkingKeyword ||
+            containsKeywords(features.userTextSample, this.config.thinkingKeywords ?? []);
+        const codingContinuation = lastToolCategory === 'write';
+        const thinkingContinuation = lastToolCategory === 'read';
+        const searchContinuation = lastToolCategory === 'search';
+        const toolsContinuation = lastToolCategory === 'other';
+        const evaluationMap = {
+            vision: {
+                triggered: features.hasVisionTool && features.hasImageAttachment,
+                reason: 'vision:requires-tool+image'
             },
-            {
-                route: 'thinking',
-                triggered: features.hasThinkingKeyword ||
-                    containsKeywords(features.userTextSample, this.config.thinkingKeywords ?? []) ||
-                    features.previousToolCategory === 'context_read' ||
-                    features.previousToolCategory === 'plan',
-                reason: 'thinking:keywords'
+            longcontext: {
+                triggered: reachedLongContext,
+                reason: 'longcontext:token-threshold'
             },
-            {
-                route: 'background',
-                triggered: containsKeywords(features.userTextSample, this.config.backgroundKeywords ?? []),
-                reason: 'background:keywords'
+            websearch: {
+                triggered: features.hasWebTool || searchContinuation,
+                reason: searchContinuation ? 'websearch:last-tool-search' : 'websearch:web-tools-detected'
             },
-            {
-                route: 'vision',
-                triggered: (features.hasVisionTool && features.hasImageAttachment) ||
-                    features.previousToolCategory === 'vision',
-                reason: 'vision:requires-tool+image'
+            coding: {
+                triggered: codingContinuation,
+                reason: 'coding:last-tool-write'
             },
-            {
-                route: 'websearch',
-                triggered: features.hasWebTool,
-                reason: 'websearch:web-tools-detected'
+            thinking: {
+                triggered: thinkingContinuation || thinkingKeywordHit,
+                reason: thinkingContinuation ? 'thinking:last-tool-read' : 'thinking:keywords'
             },
-            {
-                route: 'coding',
-                triggered: features.hasCodingTool ||
-                    containsKeywords(features.userTextSample, this.config.codingKeywords ?? []) ||
-                    features.previousToolCategory === 'coding',
-                reason: 'coding:coding-tools-detected'
+            tools: {
+                triggered: toolsContinuation || features.hasTools || features.hasToolCallResponses,
+                reason: toolsContinuation ? 'tools:last-tool-other' : 'tools:tool-request-detected'
             },
-            {
-                route: 'tools',
-                triggered: features.hasTools || features.hasToolCallResponses,
-                reason: 'tools:tool-request-detected'
+            background: {
+                triggered: containsKeywords(features.userTextSample, this.config.backgroundKeywords ?? []),
+                reason: 'background:keywords'
+            }
+        };
+        for (const routeName of ROUTE_PRIORITY) {
+            const evaluation = evaluationMap[routeName];
+            if (evaluation && evaluation.triggered) {
+                const candidates = this.ensureDefaultCandidate([routeName]);
+                return this.buildResult(routeName, evaluation.reason, evaluationMap, candidates);
             }
-        ];
-        const triggeredEvaluations = evaluations.filter((evaluation) => evaluation.triggered);
-        const orderedRoutes = this.orderRoutes(triggeredEvaluations.map((entry) => entry.route));
-        const chosenRoute = orderedRoutes.length ? orderedRoutes[0] : DEFAULT_ROUTE;
-        const chosenReason = triggeredEvaluations.find((entry) => entry.route === chosenRoute)?.reason || 'fallback:default';
-        const candidates = this.ensureDefaultCandidate(orderedRoutes);
-        return this.buildResult(chosenRoute, chosenReason, evaluations, candidates);
+        }
+        const candidates = this.ensureDefaultCandidate([DEFAULT_ROUTE]);
+        return this.buildResult(DEFAULT_ROUTE, 'fallback:default', evaluationMap, candidates);
     }
     buildResult(routeName, chosenReason, evaluations, candidates) {
-        const diagnostics = evaluations
-            .filter((evaluation) => evaluation.triggered)
-            .map((evaluation) => evaluation.reason);
+        const diagnostics = Object.entries(evaluations)
+            .filter(([_, evaluation]) => evaluation.triggered)
+            .map(([_, evaluation]) => evaluation.reason);
         const reasoningParts = [chosenReason, ...diagnostics.filter((reason) => reason !== chosenReason)];
         return {
             routeName,
@@ -93,6 +87,12 @@ export class RoutingClassifier {
         return index >= 0 ? index : ROUTE_PRIORITY.length;
     }
 }
+function normalizeList(source, fallback) {
+    if (!source || source.length === 0) {
+        return fallback;
+    }
+    return source.map((item) => item.toLowerCase());
+}
 function containsKeywords(text, keywords) {
     if (!text || !keywords.length) {
         return false;
@@ -100,29 +100,3 @@ function containsKeywords(text, keywords) {
     const normalized = text.toLowerCase();
     return keywords.some((keyword) => normalized.includes(keyword));
 }
-function normalizeKeywordConfig(config) {
-    const injections = config.keywordInjections ?? {};
-    return {
-        thinking: mergeKeywordLists(DEFAULT_THINKING_KEYWORDS, config.thinkingKeywords, injections.thinking),
-        background: mergeKeywordLists(['background', 'context dump', '上下文'], config.backgroundKeywords, injections.background),
-        vision: mergeKeywordLists(['vision', 'image', 'picture', 'photo'], config.visionKeywords, injections.vision),
-        coding: mergeKeywordLists(config.codingKeywords, injections.coding)
-    };
-}
-function mergeKeywordLists(...lists) {
-    const set = new Set();
-    for (const list of lists) {
-        if (!Array.isArray(list)) {
-            continue;
-        }
-        for (const item of list) {
-            if (!item)
-                continue;
-            const normalized = String(item).toLowerCase();
-            if (normalized) {
-                set.add(normalized);
-            }
-        }
-    }
-    return Array.from(set);
-}

package/dist/router/virtual-router/features.js

@@ -1,6 +1,125 @@
 import { countRequestTokens } from './token-counter.js';
 const THINKING_KEYWORDS = ['let me think', 'chain of thought', 'cot', 'reason step', 'deliberate'];
 const WEB_TOOL_KEYWORDS = ['websearch', 'web_search', 'web-search', 'webfetch', 'web_fetch', 'web_request', 'search_web', 'internet_search'];
+const READ_TOOL_EXACT = new Set([
+    'read_file',
+    'read_text',
+    'view_file',
+    'view_code',
+    'view_document',
+    'open_file',
+    'get_file',
+    'download_file',
+    'describe_current_request',
+    'list_dir',
+    'list_directory',
+    'list_files',
+    'list_documents',
+    'list_resources',
+    'search_files',
+    'find_files'
+]);
+const WRITE_TOOL_EXACT = new Set([
+    'apply_patch',
+    'write_file',
+    'create_file',
+    'modify_file',
+    'edit_file',
+    'update_file',
+    'save_file',
+    'append_file',
+    'replace_file',
+    'delete_file',
+    'remove_file',
+    'rename_file',
+    'move_file',
+    'copy_file',
+    'mkdir',
+    'rmdir'
+]);
+const SEARCH_TOOL_EXACT = new Set(['websearch', 'web_search', 'search_web', 'internet_search', 'webfetch', 'web_fetch']);
+const READ_TOOL_KEYWORDS = ['read', 'list', 'view', 'download', 'open', 'show', 'fetch', 'inspect'];
+const WRITE_TOOL_KEYWORDS = ['write', 'patch', 'modify', 'edit', 'create', 'update', 'append', 'replace', 'delete', 'remove'];
+const SEARCH_TOOL_KEYWORDS = ['search', 'websearch', 'web_fetch', 'webfetch', 'web-request', 'web_request', 'internet'];
+const SHELL_TOOL_NAMES = new Set(['shell_command', 'shell', 'bash']);
+const SHELL_HEREDOC_PATTERN = /<<\s*['"]?[a-z0-9_-]+/i;
+const SHELL_WRITE_PATTERNS = [
+    'apply_patch',
+    'sed -i',
+    'perl -pi',
+    'tee ',
+    'cat <<',
+    'cat >',
+    'printf >',
+    'touch ',
+    'truncate',
+    'mkdir',
+    'mktemp',
+    'rmdir',
+    'rm ',
+    'rm-',
+    'unlink',
+    'mv ',
+    'cp ',
+    'ln -',
+    'chmod',
+    'chown',
+    'chgrp',
+    'tar ',
+    'git add',
+    'git commit',
+    'git apply',
+    'git am',
+    'git rebase',
+    'git checkout',
+    'git merge',
+    'patch <<',
+    'npm install',
+    'pnpm install',
+    'yarn add',
+    'yarn install',
+    'pip install',
+    'pip3 install',
+    'brew install',
+    'cargo add',
+    'cargo install',
+    'go install',
+    'make install'
+];
+const SHELL_SEARCH_PATTERNS = [
+    'rg ',
+    'rg-',
+    'grep ',
+    'grep-',
+    'ripgrep',
+    'find ',
+    'fd ',
+    'locate ',
+    'search ',
+    'ack ',
+    'ag ',
+    'where ',
+    'which ',
+    'codesearch'
+];
+const SHELL_READ_PATTERNS = [
+    'ls',
+    'dir ',
+    'pwd',
+    'cat ',
+    'type ',
+    'head ',
+    'tail ',
+    'stat',
+    'tree',
+    'wc ',
+    'du ',
+    'printf "',
+    'python - <<',
+    'python -c',
+    'node - <<',
+    'node -e'
+];
 export function buildRoutingFeatures(request, metadata) {
     const latestUserMessage = getLatestUserMessage(request.messages);
     const assistantMessages = request.messages.filter((msg) => msg.role === 'assistant');
@@ -8,18 +127,18 @@ export function buildRoutingFeatures(request, metadata) {
     const normalizedUserText = latestUserText.toLowerCase();
     const hasTools = Array.isArray(request.tools) && request.tools.length > 0;
     const hasToolCallResponses = assistantMessages.some((msg) => Array.isArray(msg.tool_calls) && msg.tool_calls.length > 0);
-    const estimatedTokens = countRequestTokens(request);
+    const estimatedTokens = computeRequestTokens(request, latestUserText);
     const hasThinking = detectKeyword(normalizedUserText, THINKING_KEYWORDS);
-    const previousToolCategory = detectPreviousToolCategory(request.messages);
-    const hasVisionTool = detectVisionTool(request) || previousToolCategory === 'vision';
-    const hasImageAttachment = previousToolCategory === 'vision' || (hasVisionTool && detectImageAttachment(latestUserMessage));
+    const hasVisionTool = detectVisionTool(request);
+    const hasImageAttachment = hasVisionTool && detectImageAttachment(latestUserMessage);
     const hasCodingTool = detectCodingTool(request);
     const hasWebTool = detectWebTool(request);
     const hasThinkingKeyword = hasThinking || detectExtendedThinkingKeyword(normalizedUserText);
+    const lastAssistantTool = detectLastAssistantToolCategory(assistantMessages);
     return {
         requestId: metadata.requestId,
         model: request.model,
-        totalMessages: latestUserText ? 1 : 0,
+        totalMessages: request.messages?.length ?? 0,
         userTextSample: latestUserText.slice(0, 2000),
         toolCount: request.tools?.length ?? 0,
         hasTools,
@@ -30,7 +149,8 @@ export function buildRoutingFeatures(request, metadata) {
         hasCodingTool,
         hasThinkingKeyword,
         estimatedTokens,
-        previousToolCategory,
+        lastAssistantToolCategory: lastAssistantTool?.category,
+        lastAssistantToolName: lastAssistantTool?.name,
         metadata: {
             ...metadata
         }
@@ -100,12 +220,15 @@ function detectCodingTool(request) {
         return false;
     }
     return request.tools.some((tool) => {
-        const functionName = extractToolName(tool);
-        const description = extractToolDescription(tool);
-        const chineseDesc = description;
-        return (/write_file|apply_patch|modify_file|edit_file|create_file|shell|terminal|bash|run_shell/i.test(functionName) ||
-            /write file|apply patch|modify file|edit file|create file|shell|terminal|bash|run shell/i.test(description || '') ||
-            /创建文件|修改文件|写入文件|执行shell|执行终端/.test(chineseDesc || ''));
+        const functionName = extractToolName(tool).toLowerCase();
+        const description = (extractToolDescription(tool) || '').toLowerCase();
+        if (!functionName && !description) {
+            return false;
+        }
+        if (WRITE_TOOL_EXACT.has(functionName)) {
+            return true;
+        }
+        return WRITE_TOOL_KEYWORDS.some((keyword) => functionName.includes(keyword.toLowerCase()) || description.includes(keyword.toLowerCase()));
     });
 }
 function detectWebTool(request) {
@@ -128,111 +251,20 @@ function detectExtendedThinkingKeyword(text) {
     const keywords = ['仔细分析', '思考', '超级思考', '深度思考', 'careful analysis', 'deep thinking', 'deliberate'];
     return keywords.some((keyword) => text.includes(keyword));
 }
-function detectPreviousToolCategory(messages) {
-    if (!Array.isArray(messages) || !messages.length) {
-        return null;
-    }
-    let lastUserIndex = messages.length;
-    for (let idx = messages.length - 1; idx >= 0; idx -= 1) {
-        if (messages[idx]?.role === 'user') {
-            lastUserIndex = idx;
-            break;
-        }
-    }
-    for (let idx = lastUserIndex - 1; idx >= 0; idx -= 1) {
-        const candidate = messages[idx];
-        if (!candidate || candidate.role !== 'assistant') {
-            continue;
-        }
-        const messageRecord = candidate;
-        const rawCalls = Array.isArray(messageRecord.tool_calls)
-            ? messageRecord.tool_calls
-            : [];
-        if (!rawCalls.length) {
-            continue;
-        }
-        for (const call of rawCalls) {
-            const categorized = categorizeToolCall(call);
-            if (categorized) {
-                return categorized;
-            }
-        }
-    }
-    return null;
-}
-function categorizeToolCall(call) {
-    if (!call) {
-        return null;
-    }
-    const fn = (call.function ?? call);
-    const name = typeof (fn?.name ?? call.name) === 'string' ? String(fn?.name ?? call.name) : '';
-    if (!name) {
-        return null;
-    }
-    const args = parseFunctionArguments(typeof fn?.arguments === 'string' ? fn.arguments : undefined);
-    if (name === 'update_plan') {
-        return 'plan';
-    }
-    if (name === 'view_image') {
-        return hasImageLink(args) ? 'vision' : null;
-    }
-    if (name === 'apply_patch') {
-        return 'coding';
-    }
-    if (name === 'shell_command') {
-        const command = typeof args?.command === 'string' ? args.command : '';
-        return classifyShellCommand(command);
-    }
-    return null;
-}
-function parseFunctionArguments(raw) {
-    if (!raw) {
-        return null;
-    }
+function computeRequestTokens(request, fallbackText) {
     try {
-        return JSON.parse(raw);
+        return countRequestTokens(request);
     }
     catch {
-        return null;
+        return fallbackEstimateTokens(fallbackText, request.messages?.length ?? 0);
     }
 }
-const CONTEXT_READ_PATTERNS = [
-    /\brg\b/i,
-    /\bsed\b/i,
-    /\bcat\b/i,
-    /\btail\b/i,
-    /\bhead\b/i,
-    /\bls\b/i,
-    /\bwc\b/i,
-    /\bgrep\b/i,
-    /node\s+-\s*<<['"]/i,
-    /python\s+-\s*<<['"]/i
-];
-function classifyShellCommand(command) {
-    if (!command) {
-        return null;
-    }
-    const normalized = command.trim();
-    if (!normalized) {
-        return null;
-    }
-    if (CONTEXT_READ_PATTERNS.some((pattern) => pattern.test(normalized))) {
-        return 'context_read';
-    }
-    return null;
-}
-const IMAGE_LINK_KEYS = ['imagePath', 'path', 'filepath', 'file', 'url', 'image', 'src'];
-function hasImageLink(args) {
-    if (!args || typeof args !== 'object') {
-        return false;
-    }
-    for (const key of IMAGE_LINK_KEYS) {
-        const value = args[key];
-        if (typeof value === 'string' && value.trim()) {
-            return true;
-        }
+function fallbackEstimateTokens(text, messageCount) {
+    if (!text) {
+        return Math.max(32, Math.max(messageCount, 1) * 16);
     }
-    return false;
+    const rough = Math.ceil(text.length / 4);
+    return Math.max(rough, Math.max(messageCount, 1) * 32);
 }
 function extractToolName(tool) {
     if (!tool || typeof tool !== 'object') {
@@ -262,3 +294,198 @@ function extractToolDescription(tool) {
     }
     return '';
 }
+function detectLastAssistantToolCategory(messages) {
+    for (let idx = messages.length - 1; idx >= 0; idx -= 1) {
+        const msg = messages[idx];
+        if (!msg || !Array.isArray(msg.tool_calls) || msg.tool_calls.length === 0) {
+            continue;
+        }
+        let fallback;
+        for (const call of msg.tool_calls) {
+            const classification = classifyToolCall(call);
+            if (!classification) {
+                continue;
+            }
+            if (!fallback) {
+                fallback = classification;
+            }
+            if (classification.category !== 'other') {
+                return classification;
+            }
+        }
+        if (fallback) {
+            return fallback;
+        }
+    }
+    return undefined;
+}
+function classifyToolCall(call) {
+    if (!call || typeof call !== 'object') {
+        return undefined;
+    }
+    const functionName = typeof call?.function?.name === 'string' && call.function.name.trim()
+        ? canonicalizeToolName(call.function.name)
+        : '';
+    if (!functionName) {
+        return undefined;
+    }
+    const argsObject = parseToolArguments(call?.function?.arguments);
+    const commandText = extractCommandText(argsObject);
+    const nameCategory = categorizeToolName(functionName);
+    if (nameCategory === 'write' || nameCategory === 'read' || nameCategory === 'search') {
+        return { category: nameCategory, name: functionName };
+    }
+    if (SHELL_TOOL_NAMES.has(functionName)) {
+        const shellCategory = classifyShellCommand(commandText);
+        return { category: shellCategory, name: functionName };
+    }
+    if (commandText) {
+        const derivedCategory = classifyShellCommand(commandText);
+        if (derivedCategory !== 'other') {
+            return { category: derivedCategory, name: functionName };
+        }
+    }
+    return { category: 'other', name: functionName };
+}
+function canonicalizeToolName(rawName) {
+    const trimmed = rawName.trim();
+    const markerIndex = trimmed.indexOf('arg_');
+    if (markerIndex > 0) {
+        return trimmed.slice(0, markerIndex);
+    }
+    return trimmed;
+}
+function parseToolArguments(rawArguments) {
+    if (!rawArguments) {
+        return undefined;
+    }
+    if (typeof rawArguments === 'string') {
+        try {
+            return JSON.parse(rawArguments);
+        }
+        catch {
+            return rawArguments;
+        }
+    }
+    if (typeof rawArguments === 'object') {
+        return rawArguments;
+    }
+    return undefined;
+}
+function extractCommandText(args) {
+    if (!args) {
+        return '';
+    }
+    if (typeof args === 'string') {
+        return args;
+    }
+    if (Array.isArray(args)) {
+        return args.map((item) => (typeof item === 'string' ? item : '')).filter(Boolean).join(' ');
+    }
+    if (typeof args === 'object') {
+        const record = args;
+        const command = record.command;
+        const input = record.input;
+        const nestedArgs = record.args;
+        if (typeof command === 'string') {
+            return command;
+        }
+        if (Array.isArray(command)) {
+            return command.map((item) => (typeof item === 'string' ? item : '')).filter(Boolean).join(' ');
+        }
+        if (typeof input === 'string') {
+            return input;
+        }
+        if (typeof nestedArgs === 'string') {
+            return nestedArgs;
+        }
+        if (Array.isArray(nestedArgs)) {
+            return nestedArgs.map((item) => (typeof item === 'string' ? item : '')).filter(Boolean).join(' ');
+        }
+    }
+    return '';
+}
+function categorizeToolName(name) {
+    const normalized = name.toLowerCase();
+    if (SEARCH_TOOL_EXACT.has(normalized) ||
+        SEARCH_TOOL_KEYWORDS.some((keyword) => normalized.includes(keyword.toLowerCase()))) {
+        return 'search';
+    }
+    if (READ_TOOL_EXACT.has(normalized) ||
+        READ_TOOL_KEYWORDS.some((keyword) => normalized.includes(keyword.toLowerCase()))) {
+        return 'read';
+    }
+    if (WRITE_TOOL_EXACT.has(normalized) ||
+        WRITE_TOOL_KEYWORDS.some((keyword) => normalized.includes(keyword.toLowerCase()))) {
+        return 'write';
+    }
+    return 'other';
+}
+function classifyShellCommand(command) {
+    if (!command) {
+        return 'other';
+    }
+    if (SHELL_HEREDOC_PATTERN.test(command)) {
+        return 'write';
+    }
+    const segments = splitCommandSegments(command).map(stripShellWrapper);
+    if (segments.some((segment) => matchesAnyPattern(segment, SHELL_WRITE_PATTERNS))) {
+        return 'write';
+    }
+    if (segments.some((segment) => matchesAnyPattern(segment, SHELL_SEARCH_PATTERNS))) {
+        return 'search';
+    }
+    if (segments.some((segment) => matchesAnyPattern(segment, SHELL_READ_PATTERNS))) {
+        return 'read';
+    }
+    const stripped = stripShellWrapper(command);
+    if (matchesAnyPattern(stripped, SHELL_WRITE_PATTERNS)) {
+        return 'write';
+    }
+    if (matchesAnyPattern(stripped, SHELL_SEARCH_PATTERNS)) {
+        return 'search';
+    }
+    if (matchesAnyPattern(stripped, SHELL_READ_PATTERNS)) {
+        return 'read';
+    }
+    return 'other';
+}
+function splitCommandSegments(command) {
+    return command
+        .split(/(?:\r?\n|&&|\|\||;)/)
+        .map((segment) => segment.trim())
+        .filter(Boolean);
+}
+function matchesAnyPattern(text, patterns) {
+    if (!text) {
+        return false;
+    }
+    const trimmed = text.trim().toLowerCase();
+    const normalized = trimmed.startsWith('sudo ') ? trimmed.slice(5).trim() : trimmed;
+    return patterns.some((pattern) => {
+        const lowered = pattern.toLowerCase().trim();
+        return normalized.startsWith(lowered);
+    });
+}
+function stripShellWrapper(segment) {
+    let normalized = segment.trim();
+    const wrappers = ['bash -lc ', 'bash -lc', 'sh -c ', 'sh -c', '/bin/sh -c ', '/bin/sh -c', 'env -i bash -lc ', 'env -i bash -lc'];
+    for (const wrapper of wrappers) {
+        if (normalized.toLowerCase().startsWith(wrapper)) {
+            normalized = normalized.slice(wrapper.length).trim();
+            break;
+        }
+    }
+    normalized = trimEnclosingQuotes(normalized);
+    if (normalized.startsWith('sudo ')) {
+        normalized = normalized.slice(5).trim();
+    }
+    return normalized;
+}
+function trimEnclosingQuotes(value) {
+    if ((value.startsWith('"') && value.endsWith('"') && value.length > 1) ||
+        (value.startsWith("'") && value.endsWith("'") && value.length > 1)) {
+        return value.slice(1, -1).trim();
+    }
+    return value;
+}