feat(core): decompose stringified property of JsonUtil.parse (#531)

Author: samchon

packages/core/src/orchestrate/call.ts

@@ -318,7 +318,10 @@ function parseArguments(
   life: number,
 ): AgenticaCallEvent | AgenticaJsonParseErrorEvent {
   try {
-    const data: Record<string, unknown> = JsonUtil.parse(toolCall.function.arguments);
+    const data: Record<string, unknown> = JsonUtil.parse(
+      toolCall.function.arguments,
+      operation.function.parameters,
+    );
     return createCallEvent({
       id: toolCall.id,
       operation,

packages/core/src/utils/JsonUtil.ts

@@ -1,5 +1,6 @@
-import type { IValidation } from "@samchon/openapi";
+import type { ILlmSchema, IValidation } from "@samchon/openapi";
 
+import { LlmTypeChecker } from "@samchon/openapi";
 import { addMissingBraces, removeEmptyObjectPrefix, removeTrailingCommas } from "es-jsonkit";
 import { jsonrepair } from "jsonrepair";
 import { Escaper } from "typia/lib/utils/Escaper";
@@ -11,9 +12,66 @@ export const JsonUtil = {
 
 const pipe = (...fns: ((str: string) => string)[]) => (str: string) => fns.reduce((acc, fn) => fn(acc), str);
 
-function parse(str: string) {
+function parse(
+  str: string,
+  parameters?: ILlmSchema.IParameters,
+): any {
   str = pipe(removeEmptyObjectPrefix, addMissingBraces, removeTrailingCommas, jsonrepair)(str);
-  return JSON.parse(str);
+  const output: any = JSON.parse(str);
+  if (parameters !== undefined) {
+    decompose(parameters, output);
+  }
+  return output;
+}
+
+function decompose(
+  parameters: ILlmSchema.IParameters,
+  output: any,
+): void {
+  if (Object.keys(parameters.properties).length !== 1) {
+    return;
+  }
+  else if (typeof output !== "object" || output === null) {
+    return;
+  }
+
+  const key: string = Object.keys(parameters.properties)[0]!;
+  const value: any = output[key];
+  const schema: ILlmSchema = parameters.properties[key]!;
+  if (
+    typeof value === "string"
+    && isInstanceType({
+      $defs: parameters.$defs,
+      schema,
+    }) === true
+  ) {
+    try {
+      output[key] = parse(value);
+    }
+    catch {}
+  }
+}
+
+function isInstanceType(props: {
+  $defs: Record<string, ILlmSchema>;
+  schema: ILlmSchema;
+}): boolean {
+  if (LlmTypeChecker.isReference(props.schema)) {
+    return isInstanceType({
+      $defs: props.$defs,
+      schema: props.$defs[props.schema.$ref.split("/").pop()!] ?? {},
+    });
+  }
+  return LlmTypeChecker.isNull(props.schema)
+    || LlmTypeChecker.isObject(props.schema)
+    || LlmTypeChecker.isArray(props.schema)
+    || (
+      LlmTypeChecker.isAnyOf(props.schema)
+      && props.schema.anyOf.every(s => isInstanceType({
+        $defs: props.$defs,
+        schema: s,
+      }))
+    );
 }
 
 function stringifyValidationFailure(

test/src/features/json_parse_decompose/test_json_parse_decompose_anyOf.ts

@@ -0,0 +1,17 @@
+import { JsonUtil } from "@agentica/core/src/utils/JsonUtil";
+import { TestValidator } from "@nestia/e2e";
+import typia from "typia";
+
+export function test_json_parse_decompose_anyOf(): void {
+  interface IInput {
+    data: { x: number } | null;
+  }
+
+  const parameters = typia.llm.parameters<IInput>();
+
+  // LLM이 anyOf [object, null] 타입을 문자열로 반환한 경우
+  const input = JSON.stringify({ data: "{\"x\":10}" });
+  const result = JsonUtil.parse(input, parameters);
+
+  TestValidator.equals("decompose_anyOf")(result.data)({ x: 10 });
+}

test/src/features/json_parse_decompose/test_json_parse_decompose_array.ts

@@ -0,0 +1,17 @@
+import { JsonUtil } from "@agentica/core/src/utils/JsonUtil";
+import { TestValidator } from "@nestia/e2e";
+import typia from "typia";
+
+export function test_json_parse_decompose_array(): void {
+  interface IInput {
+    items: number[];
+  }
+
+  const parameters = typia.llm.parameters<IInput>();
+
+  // LLM이 array를 문자열로 반환한 경우
+  const input = JSON.stringify({ items: "[1,2,3]" });
+  const result = JsonUtil.parse(input, parameters);
+
+  TestValidator.equals("decompose_array")(result.items)([1, 2, 3]);
+}

test/src/features/json_parse_decompose/test_json_parse_decompose_object.ts

@@ -0,0 +1,20 @@
+import { JsonUtil } from "@agentica/core/src/utils/JsonUtil";
+import { TestValidator } from "@nestia/e2e";
+import typia from "typia";
+
+export function test_json_parse_decompose_object(): void {
+  interface IInput {
+    data: {
+      foo: string;
+      bar: number;
+    };
+  }
+
+  const parameters = typia.llm.parameters<IInput>();
+
+  // LLM이 object를 문자열로 반환한 경우
+  const input = JSON.stringify({ data: "{\"foo\":\"hello\",\"bar\":42}" });
+  const result = JsonUtil.parse(input, parameters);
+
+  TestValidator.equals("decompose_object")(result.data)({ foo: "hello", bar: 42 });
+}

test/src/features/json_parse_decompose/test_json_parse_decompose_ref.ts

@@ -0,0 +1,22 @@
+import { JsonUtil } from "@agentica/core/src/utils/JsonUtil";
+import { TestValidator } from "@nestia/e2e";
+import typia from "typia";
+
+interface IUser {
+  id: number;
+  name: string;
+}
+
+interface IInput {
+  user: IUser;
+}
+
+export function test_json_parse_decompose_ref(): void {
+  const parameters = typia.llm.parameters<IInput>();
+
+  // LLM이 $ref로 정의된 object를 문자열로 반환한 경우
+  const input = JSON.stringify({ user: "{\"id\":123,\"name\":\"John\"}" });
+  const result = JsonUtil.parse(input, parameters);
+
+  TestValidator.equals("decompose_ref")(result.user)({ id: 123, name: "John" });
+}

test/src/features/json_parse_decompose/test_json_parse_decompose_skip.ts

@@ -0,0 +1,59 @@
+import { JsonUtil } from "@agentica/core/src/utils/JsonUtil";
+import { TestValidator } from "@nestia/e2e";
+import typia from "typia";
+
+export function test_json_parse_decompose_skip(): void {
+  test_skip_multiple_properties();
+  test_skip_string_schema();
+  test_skip_anyOf_with_string();
+}
+
+// 프로퍼티가 2개 이상이면 decompose 안함
+function test_skip_multiple_properties(): void {
+  interface IInput {
+    data1: { a: number };
+    data2: { b: number };
+  }
+
+  const parameters = typia.llm.parameters<IInput>();
+
+  const input = JSON.stringify({
+    data1: "{\"a\":1}",
+    data2: "{\"b\":2}",
+  });
+  const result = JsonUtil.parse(input, parameters);
+
+  // 2개 프로퍼티이므로 decompose 안함 - 문자열 그대로 유지
+  TestValidator.equals("skip_multi_data1")(result.data1)("{\"a\":1}");
+  TestValidator.equals("skip_multi_data2")(result.data2)("{\"b\":2}");
+}
+
+// 스키마가 string 타입이면 decompose 안함
+function test_skip_string_schema(): void {
+  interface IInput {
+    data: string;
+  }
+
+  const parameters = typia.llm.parameters<IInput>();
+
+  const input = JSON.stringify({ data: "{\"foo\":\"bar\"}" });
+  const result = JsonUtil.parse(input, parameters);
+
+  // string 스키마이므로 decompose 안함
+  TestValidator.equals("skip_string")(result.data)("{\"foo\":\"bar\"}");
+}
+
+// anyOf에 string이 포함되면 decompose 안함
+function test_skip_anyOf_with_string(): void {
+  interface IInput {
+    data: { x: number } | string;
+  }
+
+  const parameters = typia.llm.parameters<IInput>();
+
+  const input = JSON.stringify({ data: "{\"x\":1}" });
+  const result = JsonUtil.parse(input, parameters);
+
+  // anyOf에 string 포함되므로 decompose 안함
+  TestValidator.equals("skip_anyOf_string")(result.data)("{\"x\":1}");
+}