@agentica/core 0.32.5 → 0.32.7

package/lib/index.mjs

@@ -898,9 +898,222 @@ const ChatGptTokenUsageAggregator = {
     sumPromptTokenDetail
 };
 
+const JsonUtil = {
+    parse
+};
+
+function parse(str) {
+    const corrected = pipe(stripFirstBrace, correctMissingLastBrace)(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 = JSON.parse(str);
+    const result = JsonUtil.parse(str);
     return result;
 }
 
@@ -1506,7 +1719,7 @@ async function correctJsonError(ctx, parseErrorEvent, previousValidationErrors,
 
 function parseArguments(operation, toolCall, life) {
     try {
-        const data = JSON.parse(toolCall.function.arguments);
+        const data = JsonUtil.parse(toolCall.function.arguments);
         return createCallEvent({
             id: toolCall.id,
             operation,
@@ -1824,7 +2037,7 @@ async function step$1(ctx, operations, retry, failures) {
                 if (tc.function.name !== "cancelFunctions") {
                     continue;
                 }
-                const input = JSON.parse(tc.function.arguments);
+                const input = JsonUtil.parse(tc.function.arguments);
                 const validation = (() => {
                     const _io0 = input => Array.isArray(input.functions) && input.functions.every((elem => "object" === typeof elem && null !== elem && _io1(elem)));
                     const _io1 = input => "string" === typeof input.reason && "string" === typeof input.name;
@@ -2867,7 +3080,7 @@ async function step(ctx, operations, retry, failures) {
                 if (tc.function.name !== "selectFunctions") {
                     continue;
                 }
-                const input = JSON.parse(tc.function.arguments);
+                const input = JsonUtil.parse(tc.function.arguments);
                 const validation = (() => {
                     const _io0 = input => Array.isArray(input.functions) && input.functions.every((elem => "object" === typeof elem && null !== elem && _io1(elem)));
                     const _io1 = input => "string" === typeof input.reason && "string" === typeof input.name;