@agentica/core 0.32.7 → 0.32.9

package/lib/index.mjs

@@ -6,6 +6,8 @@ import { v4 } from "uuid";
 
 import { HttpLlm, OpenApi, McpLlm } from "@samchon/openapi";
 
+import { removeTrailingCommas, addMissingBraces, removeEmptyObjectPrefix } from "es-jsonkit";
+
 import * as __typia_transform__validateReport from "typia/lib/internal/_validateReport.js";
 
 import * as __typia_transform__assertGuard from "typia/lib/internal/_assertGuard.js";
@@ -903,214 +905,12 @@ const JsonUtil = {
 };
 
 function parse(str) {
-    const corrected = pipe(stripFirstBrace, correctMissingLastBrace)(str);
+    const corrected = pipe(removeEmptyObjectPrefix, addMissingBraces, removeTrailingCommas)(str);
     return JSON.parse(corrected);
 }
 
 const pipe = (...fns) => str => fns.reduce(((acc, fn) => fn(acc)), str);
 
-function stripFirstBrace(str) {
-    if (RegExp("^{}.").test(str) === true) {
-        return str.substring(2);
-    }
-    return str;
-}
-
-function correctMissingLastBrace(input) {
-    const initial = {
-        s: "OUT",
-        stack: [],
-        line: 1,
-        col: 0,
-        edits: []
-    };
-    const scanned = Array.from(input).reduce(((ps, ch, i) => {
-        const updated = ch === "\n" ? {
-            ...ps,
-            line: ps.line + 1,
-            col: 0
-        } : {
-            ...ps,
-            col: ps.col + 1
-        };
-        const tok = categorize(ch);
-        const trans = table[updated.s]?.[tok];
-        return trans ? trans(updated, ch, i) : updated;
-    }), initial);
-    if (scanned.s !== "OUT") return input;
-    const withTail = scanned.stack.length === 0 ? scanned : (() => {
-        const closers = scanned.stack.slice().reverse().map((e => closeOf[e.type])).join("");
-        return {
-            ...scanned,
-            edits: [ ...scanned.edits, {
-                op: "insert",
-                index: input.length,
-                text: closers
-            } ],
-            stack: []
-        };
-    })();
-    return applyEditsImmutable(input, withTail.edits);
-}
-
-function applyEditsImmutable(src, edits) {
-    const sorted = [ ...edits ].sort(((a, b) => a.index - b.index));
-    const built = sorted.reduce(((acc, e) => {
-        const prefix = src.slice(acc.cursor, e.index);
-        const acc1 = {
-            out: acc.out + prefix,
-            cursor: e.index
-        };
-        return e.op === "delete" ? {
-            out: acc1.out,
-            cursor: acc1.cursor + 1
-        } : e.op === "replace" ? {
-            out: acc1.out + e.text,
-            cursor: acc1.cursor + 1
-        } : {
-            out: acc1.out + e.text,
-            cursor: acc1.cursor
-        };
-    }), {
-        out: "",
-        cursor: 0
-    });
-    return built.out + src.slice(built.cursor);
-}
-
-const openOf = Object.freeze({
-    "}": "{",
-    "]": "["
-});
-
-const closeOf = Object.freeze({
-    "{": "}",
-    "[": "]"
-});
-
-const categorize = ch => {
-    switch (ch) {
-      case '"':
-        return "DQUOTE";
-
-      case "\\":
-        return "BSLASH";
-
-      case "{":
-        return "OCB";
-
-      case "[":
-        return "OSB";
-
-      case "}":
-        return "CCB";
-
-      case "]":
-        return "CSB";
-
-      case "\n":
-        return "NEWLINE";
-
-      default:
-        return "CHAR";
-    }
-};
-
-const push = (ps, type, index) => ({
-    ...ps,
-    stack: [ ...ps.stack, {
-        type,
-        index
-    } ]
-});
-
-const withEdit = (ps, edit) => ({
-    ...ps,
-    edits: [ ...ps.edits, edit ]
-});
-
-const popOrFix = (ps, closer, idx) => (() => {
-    if (ps.stack.length === 0) {
-        return withEdit(ps, {
-            op: "delete",
-            index: idx
-        });
-    }
-    const top = ps.stack[ps.stack.length - 1];
-    if (top !== undefined && top.type !== openOf[closer]) {
-        const expected = closeOf[top.type];
-        return withEdit({
-            ...ps,
-            stack: ps.stack.slice(0, -1)
-        }, {
-            op: "replace",
-            index: idx,
-            text: expected
-        });
-    }
-    return {
-        ...ps,
-        stack: ps.stack.slice(0, -1)
-    };
-})();
-
-const table = {
-    OUT: {
-        DQUOTE: ps => ({
-            ...ps,
-            s: "IN"
-        }),
-        OCB: (ps, _ch, i) => push(ps, "{", i),
-        OSB: (ps, _ch, i) => push(ps, "[", i),
-        CCB: (ps, _ch, i) => popOrFix(ps, "}", i),
-        CSB: (ps, _ch, i) => popOrFix(ps, "]", i)
-    },
-    IN: {
-        BSLASH: ps => ({
-            ...ps,
-            s: "ESC"
-        }),
-        DQUOTE: ps => ({
-            ...ps,
-            s: "OUT"
-        })
-    },
-    ESC: {
-        DQUOTE: ps => ({
-            ...ps,
-            s: "IN"
-        }),
-        BSLASH: ps => ({
-            ...ps,
-            s: "IN"
-        }),
-        OCB: ps => ({
-            ...ps,
-            s: "IN"
-        }),
-        OSB: ps => ({
-            ...ps,
-            s: "IN"
-        }),
-        CCB: ps => ({
-            ...ps,
-            s: "IN"
-        }),
-        CSB: ps => ({
-            ...ps,
-            s: "IN"
-        }),
-        CHAR: ps => ({
-            ...ps,
-            s: "IN"
-        }),
-        NEWLINE: ps => ({
-            ...ps,
-            s: "IN"
-        })
-    }
-};
-
 function transformCompletionChunk(source) {
     const str = source instanceof Uint8Array ? ByteArrayUtil.toUtf8(source) : source;
     const result = JsonUtil.parse(str);