@hef2024/llmasaservice-ui 0.24.2 → 0.24.4

package/src/toolArgsParser.ts

@@ -0,0 +1,346 @@
+const TOOL_ARGS_CANDIDATE_PARSE_DEPTH = 3;
+
+const isPlainObject = (value: unknown): value is Record<string, unknown> => {
+  return typeof value === 'object' && value !== null && !Array.isArray(value);
+};
+
+const stripMarkdownCodeFence = (input: string): string => {
+  const trimmed = input.trim();
+  if (!trimmed.startsWith('```')) return trimmed;
+
+  const withoutStart = trimmed.replace(/^```[a-zA-Z0-9_-]*\s*/u, '');
+  return withoutStart.replace(/```$/u, '').trim();
+};
+
+const stripOuterQuotes = (input: string): string => {
+  const trimmed = input.trim();
+  if (trimmed.length < 2) return trimmed;
+
+  const first = trimmed[0];
+  const last = trimmed[trimmed.length - 1];
+  if ((first === '"' && last === '"') || (first === "'" && last === "'")) {
+    return trimmed.slice(1, -1).trim();
+  }
+
+  return trimmed;
+};
+
+const normalizeSmartQuotes = (input: string): string => {
+  return input
+    .replace(/[“”]/gu, '"')
+    .replace(/[‘’]/gu, "'");
+};
+
+const convertSingleQuotedStrings = (input: string): string => {
+  let output = '';
+  let inSingle = false;
+  let inDouble = false;
+  let escaped = false;
+
+  for (let index = 0; index < input.length; index += 1) {
+    const char = input[index];
+
+    if (inSingle) {
+      if (escaped) {
+        output += char === '"' ? '\\"' : char;
+        escaped = false;
+        continue;
+      }
+
+      if (char === '\\') {
+        output += '\\';
+        escaped = true;
+        continue;
+      }
+
+      if (char === "'") {
+        output += '"';
+        inSingle = false;
+        continue;
+      }
+
+      output += char === '"' ? '\\"' : char;
+      continue;
+    }
+
+    if (inDouble) {
+      output += char;
+
+      if (escaped) {
+        escaped = false;
+        continue;
+      }
+
+      if (char === '\\') {
+        escaped = true;
+        continue;
+      }
+
+      if (char === '"') {
+        inDouble = false;
+      }
+
+      continue;
+    }
+
+    if (char === "'") {
+      output += '"';
+      inSingle = true;
+      continue;
+    }
+
+    if (char === '"') {
+      output += '"';
+      inDouble = true;
+      continue;
+    }
+
+    output += char;
+  }
+
+  return output;
+};
+
+const quoteBareObjectKeys = (input: string): string => {
+  return input.replace(
+    /([{,]\s*)([A-Za-z_$][A-Za-z0-9_$-]*)(\s*:)/gu,
+    '$1"$2"$3',
+  );
+};
+
+const stripTrailingCommas = (input: string): string => {
+  return input.replace(/,\s*([}\]])/gu, '$1');
+};
+
+const normalizeEscapesOutsideStrings = (input: string): string => {
+  let output = '';
+  let inDouble = false;
+  let inSingle = false;
+  let escaped = false;
+
+  for (let index = 0; index < input.length; index += 1) {
+    const char = input[index];
+    const next = index + 1 < input.length ? input[index + 1] : '';
+
+    if (inDouble || inSingle) {
+      output += char;
+
+      if (escaped) {
+        escaped = false;
+        continue;
+      }
+
+      if (char === '\\') {
+        escaped = true;
+        continue;
+      }
+
+      if (inDouble && char === '"') {
+        inDouble = false;
+      } else if (inSingle && char === "'") {
+        inSingle = false;
+      }
+      continue;
+    }
+
+    if (char === '"') {
+      inDouble = true;
+      output += char;
+      continue;
+    }
+
+    if (char === "'") {
+      inSingle = true;
+      output += char;
+      continue;
+    }
+
+    if (char === '\\') {
+      if (next === 'n') {
+        output += '\n';
+        index += 1;
+        continue;
+      }
+      if (next === 'r') {
+        output += '\r';
+        index += 1;
+        continue;
+      }
+      if (next === 't') {
+        output += '\t';
+        index += 1;
+        continue;
+      }
+      if (next === '"') {
+        output += '"';
+        index += 1;
+        continue;
+      }
+      if (next === "'") {
+        output += "'";
+        index += 1;
+        continue;
+      }
+      if (next === '\\') {
+        output += '\\';
+        index += 1;
+        continue;
+      }
+    }
+
+    output += char;
+  }
+
+  return output;
+};
+
+const normalizeJsLikeJson = (input: string): string => {
+  const normalizedQuotes = normalizeSmartQuotes(input);
+  const normalizedSingleQuotes = convertSingleQuotedStrings(normalizedQuotes);
+  const withQuotedKeys = quoteBareObjectKeys(normalizedSingleQuotes);
+  return stripTrailingCommas(withQuotedKeys);
+};
+
+const extractFirstJsonObject = (input: string): string | null => {
+  const start = input.indexOf('{');
+  if (start === -1) return null;
+
+  let depth = 0;
+  let inString = false;
+  let quoteChar = '';
+  let escaped = false;
+
+  for (let index = start; index < input.length; index += 1) {
+    const char = input[index];
+
+    if (inString) {
+      if (escaped) {
+        escaped = false;
+        continue;
+      }
+
+      if (char === '\\') {
+        escaped = true;
+        continue;
+      }
+
+      if (char === quoteChar) {
+        inString = false;
+        quoteChar = '';
+      }
+
+      continue;
+    }
+
+    if (char === '"' || char === "'") {
+      inString = true;
+      quoteChar = char;
+      continue;
+    }
+
+    if (char === '{') {
+      depth += 1;
+      continue;
+    }
+
+    if (char === '}') {
+      depth -= 1;
+      if (depth === 0) {
+        return input.slice(start, index + 1);
+      }
+    }
+  }
+
+  return null;
+};
+
+const parseMaybeNestedJson = (input: string): unknown => {
+  let current: unknown = input;
+
+  for (let depth = 0; depth < TOOL_ARGS_CANDIDATE_PARSE_DEPTH; depth += 1) {
+    if (typeof current !== 'string') {
+      return current;
+    }
+
+    const trimmed = current.trim();
+    if (!trimmed) {
+      return {};
+    }
+
+    current = JSON.parse(trimmed);
+  }
+
+  return current;
+};
+
+const addCandidate = (candidates: Set<string>, value: string | null | undefined) => {
+  if (typeof value !== 'string') return;
+  const trimmed = value.trim();
+  if (!trimmed) return;
+  candidates.add(trimmed);
+};
+
+const buildProgressiveQuoteUnescapes = (input: string, rounds = 4): string[] => {
+  const values: string[] = [];
+  let current = input;
+
+  for (let round = 0; round < rounds; round += 1) {
+    const next = current.replace(/\\"/gu, '"');
+    if (next === current) {
+      break;
+    }
+    values.push(next);
+    current = next;
+  }
+
+  return values;
+};
+
+export const parseToolArguments = (rawArgs: unknown): Record<string, unknown> | null => {
+  if (isPlainObject(rawArgs)) {
+    return rawArgs;
+  }
+
+  if (typeof rawArgs !== 'string') {
+    return {};
+  }
+
+  const base = rawArgs.trim();
+  if (!base) {
+    return {};
+  }
+
+  const codeFenceStripped = stripMarkdownCodeFence(base);
+  const extracted = extractFirstJsonObject(codeFenceStripped);
+
+  const candidates = new Set<string>();
+  addCandidate(candidates, base);
+  addCandidate(candidates, codeFenceStripped);
+  addCandidate(candidates, stripOuterQuotes(codeFenceStripped));
+  buildProgressiveQuoteUnescapes(base).forEach((candidate) => addCandidate(candidates, candidate));
+  buildProgressiveQuoteUnescapes(codeFenceStripped).forEach((candidate) =>
+    addCandidate(candidates, candidate),
+  );
+  addCandidate(candidates, extracted);
+  buildProgressiveQuoteUnescapes(extracted || '').forEach((candidate) =>
+    addCandidate(candidates, candidate),
+  );
+  addCandidate(candidates, normalizeJsLikeJson(codeFenceStripped));
+  addCandidate(candidates, extracted ? normalizeJsLikeJson(extracted) : null);
+  Array.from(candidates).forEach((candidate) => {
+    addCandidate(candidates, normalizeEscapesOutsideStrings(candidate));
+  });
+
+  for (const candidate of candidates) {
+    try {
+      const parsed = parseMaybeNestedJson(candidate);
+      if (isPlainObject(parsed)) {
+        return parsed;
+      }
+    } catch {
+      continue;
+    }
+  }
+
+  return null;
+};