@agentica/core 0.44.1 → 0.45.0

package/src/json/IAgenticaHistoryJson.ts

@@ -1,6 +1,7 @@
 import type { tags } from "typia";
 
 import type { AgenticaUserMessageContent } from "../histories";
+import type { AgenticaCallReasoningPayload } from "../histories/contents/AgenticaCallReasoningPayload";
 
 import type { IAgenticaOperationJson } from "./IAgenticaOperationJson";
 import type { IAgenticaOperationSelectionJson } from "./IAgenticaOperationSelectionJson";
@@ -78,7 +79,7 @@ export namespace IAgenticaHistoryJson {
    *
    * Selection prompt about candidate functions to call.
    */
-  export interface ISelect extends IBase<"select"> {
+  export interface ISelect extends IBase<"select">, AgenticaCallReasoningPayload {
     /**
      * Operations that have been selected.
      */
@@ -90,7 +91,7 @@ export namespace IAgenticaHistoryJson {
    *
    * Cancellation prompt about the candidate functions to be discarded.
    */
-  export interface ICancel extends IBase<"cancel"> {
+  export interface ICancel extends IBase<"cancel">, AgenticaCallReasoningPayload {
     /**
      * Operations that have been cancelled.
      */
@@ -102,7 +103,7 @@ export namespace IAgenticaHistoryJson {
    *
    * Execution prompt about the LLM function calling.
    */
-  export interface IExecute extends IBase<"execute"> {
+  export interface IExecute extends IBase<"execute">, AgenticaCallReasoningPayload {
     /**
      * Target operation to call.
      */

package/src/orchestrate/call.ts

@@ -14,6 +14,7 @@ import type { AgenticaAssistantMessageEvent, AgenticaValidateEvent } from "../ev
 import type { AgenticaCallEvent } from "../events/AgenticaCallEvent";
 import type { AgenticaExecuteEvent } from "../events/AgenticaExecuteEvent";
 import type { AgenticaJsonParseErrorEvent } from "../events/AgenticaJsonParseErrorEvent";
+import type { AgenticaCallReasoningPayload } from "../histories/contents/AgenticaCallReasoningPayload";
 import type { MicroAgenticaHistory } from "../histories/MicroAgenticaHistory";
 
 import { AgenticaConstant } from "../constants/AgenticaConstant";
@@ -26,6 +27,7 @@ import { createAssistantMessageEvent, createCallEvent, createExecuteEvent, creat
 import { decodeHistory, decodeUserMessageContent } from "../factory/histories";
 import { __get_retry } from "../utils/__retry";
 import { AssistantMessageEmptyError, AssistantMessageEmptyWithReasoningError } from "../utils/AssistantMessageEmptyError";
+import { ChatGptAssistantMessageUtil } from "../utils/ChatGptAssistantMessageUtil";
 import { ChatGptCompletionMessageUtil } from "../utils/ChatGptCompletionMessageUtil";
 import { reduceStreamingWithDispatch } from "../utils/ChatGptCompletionStreamingUtil";
 import { StreamUtil, toAsyncGenerator } from "../utils/StreamUtil";
@@ -133,6 +135,10 @@ export async function call(
 
   const retry: number = ctx.config?.retry ?? AgenticaConstant.RETRY;
   for (const choice of (completion.choices ?? [])) {
+    const assistant = ChatGptAssistantMessageUtil.collect(choice.message);
+    const reasoning: AgenticaCallReasoningPayload | undefined = assistant === undefined
+      ? undefined
+      : { assistant };
     for (const tc of choice.message.tool_calls ?? []) {
       if (tc.type === "function") {
         const operation: AgenticaOperation | undefined = operations.find(
@@ -145,6 +151,7 @@ export async function call(
           ctx,
           operation,
           tc,
+          reasoning,
           [],
           retry,
         );
@@ -166,6 +173,7 @@ async function predicate(
   ctx: AgenticaContext | MicroAgenticaContext,
   operation: AgenticaOperation,
   toolCall: OpenAI.ChatCompletionMessageFunctionToolCall,
+  reasoning: AgenticaCallReasoningPayload | undefined,
   previousValidationErrors: AgenticaValidateEvent[],
   life: number,
 ): Promise<AgenticaExecuteEvent> {
@@ -174,11 +182,12 @@ async function predicate(
     = parseArguments(
       operation,
       toolCall,
+      reasoning,
       life,
     );
   await ctx.dispatch(call);
   if (call.type === "jsonParseError") {
-    return correctJsonError(ctx, toolCall, call, previousValidationErrors, life - 1);
+    return correctJsonError(ctx, toolCall, reasoning, call, previousValidationErrors, life - 1);
   }
 
   // CHECK TYPE VALIDATION
@@ -224,11 +233,13 @@ async function correctTypeError(
         errors: validateEvent.result.errors,
       }),
       success: false,
+      assistant: callEvent.assistant,
     }),
     operation: callEvent.operation,
     toolCall: {
       id: callEvent.id,
       arguments: JSON.stringify(callEvent.arguments),
+      assistant: callEvent.assistant,
       result: [
         "🚨 VALIDATION FAILURE: Your function arguments do not conform to the required schema.",
         "",
@@ -269,6 +280,7 @@ async function correctTypeError(
 async function correctJsonError(
   ctx: AgenticaContext | MicroAgenticaContext,
   toolCall: OpenAI.ChatCompletionMessageFunctionToolCall,
+  reasoning: AgenticaCallReasoningPayload | undefined,
   parseErrorEvent: AgenticaJsonParseErrorEvent,
   previousValidationErrors: AgenticaValidateEvent[],
   life: number,
@@ -280,11 +292,13 @@ async function correctJsonError(
       arguments: {},
       value: new AgenticaJsonParseError(parseErrorEvent.failure),
       success: false,
+      assistant: reasoning?.assistant,
     }),
     operation: parseErrorEvent.operation,
     toolCall: {
       id: parseErrorEvent.id,
       arguments: parseErrorEvent.failure.input,
+      assistant: reasoning?.assistant,
       result: dedent`
         Invalid JSON format.
 
@@ -316,6 +330,7 @@ async function correctJsonError(
 function parseArguments(
   operation: AgenticaOperation,
   toolCall: OpenAI.ChatCompletionMessageFunctionToolCall,
+  reasoning: AgenticaCallReasoningPayload | undefined,
   life: number,
 ): AgenticaCallEvent | AgenticaJsonParseErrorEvent {
   const result: IJsonParseResult<Record<string, unknown>> = operation.function.parse(
@@ -333,6 +348,7 @@ function parseArguments(
     id: toolCall.id,
     operation,
     arguments: result.data,
+    assistant: reasoning?.assistant,
   });
 }
 
@@ -344,6 +360,7 @@ async function correctError(
     toolCall: {
       id: string;
       arguments: string;
+      assistant?: AgenticaCallReasoningPayload["assistant"];
       result: string;
     };
     systemPrompt: string;
@@ -371,7 +388,7 @@ async function correctError(
         ctx.config?.systemPrompt?.execute?.(ctx.histories as MicroAgenticaHistory[])
         ?? AgenticaSystemPrompt.EXECUTE,
       },
-      {
+      ChatGptAssistantMessageUtil.assign({
         role: "assistant",
         tool_calls: [
           {
@@ -383,7 +400,7 @@ async function correctError(
             },
           } satisfies OpenAI.ChatCompletionMessageFunctionToolCall,
         ],
-      } satisfies OpenAI.ChatCompletionAssistantMessageParam,
+      } satisfies OpenAI.ChatCompletionAssistantMessageParam, props.toolCall.assistant),
       {
         role: "tool",
         content: props.toolCall.result,
@@ -425,7 +442,8 @@ async function correctError(
     return ChatGptCompletionMessageUtil.merge(await StreamUtil.readAll(result.value));
   })();
 
-  const toolCall: OpenAI.ChatCompletionMessageFunctionToolCall | undefined = completion.choices?.[0]?.message.tool_calls?.filter(
+  const choice = completion.choices?.[0];
+  const toolCall: OpenAI.ChatCompletionMessageFunctionToolCall | undefined = choice?.message.tool_calls?.filter(
     tc => tc.type === "function",
   ).find(
     s => s.function.name === props.operation.name,
@@ -437,10 +455,14 @@ async function correctError(
       life: props.life - 1,
     });
   }
+  const assistant = choice === undefined
+    ? undefined
+    : ChatGptAssistantMessageUtil.collect(choice.message);
   return predicate(
     ctx,
     props.operation,
     toolCall,
+    assistant === undefined ? undefined : { assistant },
     props.previousValidationErrors,
     props.life,
   );
@@ -473,6 +495,7 @@ async function executeFunction(
       arguments: call.arguments,
       value,
       success: true,
+      assistant: call.assistant,
     });
   }
   catch (error) {
@@ -489,6 +512,7 @@ async function executeFunction(
           }
         : error,
       success: false,
+      assistant: call.assistant,
     });
   }
 }

package/src/orchestrate/cancel.ts

@@ -15,6 +15,7 @@ import { AgenticaConstant } from "../constants/AgenticaConstant";
 import { AgenticaDefaultPrompt } from "../constants/AgenticaDefaultPrompt";
 import { AgenticaSystemPrompt } from "../constants/AgenticaSystemPrompt";
 import { decodeHistory, decodeUserMessageContent } from "../factory/histories";
+import { ChatGptAssistantMessageUtil } from "../utils/ChatGptAssistantMessageUtil";
 import { ChatGptCompletionMessageUtil } from "../utils/ChatGptCompletionMessageUtil";
 import { StreamUtil } from "../utils/StreamUtil";
 
@@ -205,6 +206,7 @@ async function step(
   // PROCESS COMPLETION
   // ----
   for (const choice of (completion.choices ?? [])) {
+    const assistant = ChatGptAssistantMessageUtil.collect(choice.message);
     // TOOL CALLING HANDLER
     if (choice.message.tool_calls != null) {
       for (const tc of choice.message.tool_calls) {
@@ -224,7 +226,11 @@ async function step(
         }
 
         for (const reference of input.functions) {
-          cancelFunctionFromContext(ctx, reference);
+          cancelFunctionFromContext(
+            ctx,
+            reference,
+            assistant === undefined ? undefined : { assistant },
+          );
         }
       }
     }

package/src/orchestrate/internal/cancelFunctionFromContext.ts

@@ -2,6 +2,7 @@ import type { AgenticaContext } from "../../context/AgenticaContext";
 import type { AgenticaOperationSelection } from "../../context/AgenticaOperationSelection";
 import type { __IChatFunctionReference } from "../../context/internal/__IChatFunctionReference";
 import type { AgenticaCancelEvent } from "../../events";
+import type { AgenticaCallReasoningPayload } from "../../histories/contents/AgenticaCallReasoningPayload";
 
 import { createCancelEvent } from "../../factory/events";
 import { createOperationSelection } from "../../factory/operations";
@@ -12,6 +13,7 @@ import { createOperationSelection } from "../../factory/operations";
 export function cancelFunctionFromContext(
   ctx: AgenticaContext,
   reference: __IChatFunctionReference,
+  reasoning?: AgenticaCallReasoningPayload,
 ): void {
   const index: number = ctx.stack.findIndex(
     item => item.operation.name === reference.name,
@@ -28,6 +30,7 @@ export function cancelFunctionFromContext(
       operation: item.operation,
       reason: reference.reason,
     }),
+    assistant: reasoning?.assistant,
   });
   void ctx.dispatch(event).catch(() => {});
 }

package/src/orchestrate/internal/selectFunctionFromContext.ts

@@ -3,6 +3,7 @@ import type { AgenticaOperation } from "../../context/AgenticaOperation";
 import type { AgenticaOperationSelection } from "../../context/AgenticaOperationSelection";
 import type { __IChatFunctionReference } from "../../context/internal/__IChatFunctionReference";
 import type { AgenticaSelectEvent } from "../../events/AgenticaSelectEvent";
+import type { AgenticaCallReasoningPayload } from "../../histories/contents/AgenticaCallReasoningPayload";
 
 import { createSelectEvent } from "../../factory/events";
 import { createOperationSelection } from "../../factory/operations";
@@ -13,6 +14,7 @@ import { createOperationSelection } from "../../factory/operations";
 export function selectFunctionFromContext(
   ctx: AgenticaContext,
   reference: __IChatFunctionReference,
+  reasoning?: AgenticaCallReasoningPayload,
 ): void {
   const operation: AgenticaOperation | undefined
     = ctx.operations.flat.get(reference.name);
@@ -29,6 +31,7 @@ export function selectFunctionFromContext(
 
   const event: AgenticaSelectEvent = createSelectEvent({
     selection,
+    assistant: reasoning?.assistant,
   });
   void ctx.dispatch(event).catch(() => {});
 }

package/src/orchestrate/select.ts

@@ -18,6 +18,7 @@ import { createAssistantMessageEvent } from "../factory/events";
 import { decodeHistory, decodeUserMessageContent } from "../factory/histories";
 import { __get_retry } from "../utils/__retry";
 import { AssistantMessageEmptyError, AssistantMessageEmptyWithReasoningError } from "../utils/AssistantMessageEmptyError";
+import { ChatGptAssistantMessageUtil } from "../utils/ChatGptAssistantMessageUtil";
 import { reduceStreamingWithDispatch } from "../utils/ChatGptCompletionStreamingUtil";
 import { toAsyncGenerator } from "../utils/StreamUtil";
 
@@ -261,6 +262,7 @@ async function step(
   // PROCESS COMPLETION
   // ----
   for (const choice of (completion.choices ?? [])) {
+    const assistant = ChatGptAssistantMessageUtil.collect(choice.message);
     // FUNCTION CALLING
     if (choice.message.tool_calls != null) {
       for (const tc of choice.message.tool_calls) {
@@ -279,7 +281,11 @@ async function step(
           continue;
         }
         for (const reference of input.functions) {
-          selectFunctionFromContext(ctx, reference);
+          selectFunctionFromContext(
+            ctx,
+            reference,
+            assistant === undefined ? undefined : { assistant },
+          );
         }
       }
     }

package/src/transformers/transformHistory.ts

@@ -95,6 +95,7 @@ function transformSelect(props: {
       }),
       reason: props.history.selection.reason,
     }),
+    assistant: props.history.assistant,
   });
 }
 
@@ -112,6 +113,7 @@ function transformCancel(props: {
       }),
       reason: props.history.selection.reason,
     }),
+    assistant: props.history.assistant,
   });
 }
 
@@ -133,6 +135,7 @@ function transformExecute(props: {
      */
     value: props.history.value as Record<string, unknown>,
     success: props.history.success,
+    assistant: props.history.assistant,
   });
 }
 

package/src/utils/ChatGptAssistantMessageUtil.ts

@@ -0,0 +1,47 @@
+import type OpenAI from "openai";
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return value != null && typeof value === "object" && Array.isArray(value) === false;
+}
+
+function collect(source: unknown): Record<string, unknown> | undefined {
+  if (isRecord(source) === false) {
+    return undefined;
+  }
+  const output: Record<string, unknown> = {};
+  for (const [key, value] of Object.entries(source)) {
+    if (key.startsWith("reasoning") && value !== undefined) {
+      output[key] = value;
+    }
+  }
+  return Object.keys(output).length === 0
+    ? undefined
+    : output;
+}
+
+function assign<Message extends OpenAI.ChatCompletionAssistantMessageParam>(
+  message: Message,
+  payload: Record<string, unknown> | undefined,
+): Message {
+  const collected = collect(payload);
+  if (collected === undefined) {
+    return message;
+  }
+  return {
+    ...message,
+    ...collected,
+  };
+}
+
+function assignFrom<Message extends OpenAI.ChatCompletionAssistantMessageParam>(
+  message: Message,
+  source: unknown,
+): Message {
+  return assign(message, collect(source));
+}
+
+export const ChatGptAssistantMessageUtil = {
+  assign,
+  assignFrom,
+  collect,
+};

package/src/utils/ChatGptCompletionMessageUtil.spec.ts

@@ -264,6 +264,36 @@ describe("chatGptCompletionMessageUtil", () => {
       const result = ChatGptCompletionMessageUtil.mergeChoice(acc, cur);
       expect(result.message.refusal).toBe("I cannot do that");
     });
+
+    it("should merge reasoning payloads", () => {
+      const acc: ChatCompletion.Choice = {
+        index: 0,
+        message: {
+          role: "assistant",
+          content: null,
+          reasoning: "think",
+          reasoning_content: "deep",
+          reasoning_details: [{ index: 0 }],
+        } as any,
+      } as any;
+
+      const cur: ChatCompletionChunk.Choice = {
+        index: 0,
+        delta: {
+          reasoning: " more",
+          reasoning_content: " seek",
+          reasoning_details: [{ index: 1 }],
+        } as any,
+      } as any;
+
+      const result = ChatGptCompletionMessageUtil.mergeChoice(acc, cur);
+      expect((result.message as { reasoning?: string }).reasoning).toBe("think more");
+      expect((result.message as { reasoning_content?: string }).reasoning_content).toBe("deep seek");
+      expect((result.message as { reasoning_details?: unknown[] }).reasoning_details).toEqual([
+        { index: 0 },
+        { index: 1 },
+      ]);
+    });
   });
 
   describe("mergeToolCalls", () => {

package/src/utils/ChatGptCompletionMessageUtil.ts

@@ -11,6 +11,7 @@ import { dedent, LlmJson } from "@typia/utils";
 
 // import typia from "typia";
 import { ByteArrayUtil } from "./ByteArrayUtil";
+import { ChatGptAssistantMessageUtil } from "./ChatGptAssistantMessageUtil";
 import { ChatGptTokenUsageAggregator } from "./ChatGptTokenUsageAggregator";
 
 function transformCompletionChunk(source: string | Uint8Array): ChatCompletionChunk {
@@ -54,7 +55,7 @@ function accumulate(origin: ChatCompletion, chunk: ChatCompletionChunk): ChatCom
           ?? (null as unknown as ChatCompletion.Choice["finish_reason"]),
 
       logprobs: choice.logprobs ?? null,
-      message: {
+      message: ChatGptAssistantMessageUtil.assignFrom({
         tool_calls: choice.delta.tool_calls !== undefined
           ? choice.delta.tool_calls.reduce((acc, cur) => {
               acc[cur.index] = {
@@ -71,11 +72,7 @@ function accumulate(origin: ChatCompletion, chunk: ChatCompletionChunk): ChatCom
         content: choice.delta.content ?? null,
         refusal: choice.delta.refusal ?? null,
         role: "assistant",
-        ...({
-          // for open router
-          reasoning: (choice.delta as { reasoning?: string }).reasoning ?? null,
-        }),
-      } satisfies ChatCompletionMessage,
+      } satisfies ChatCompletionMessage, choice.delta),
     };
   });
 
@@ -154,15 +151,7 @@ function mergeChoice(acc: ChatCompletion.Choice, cur: ChatCompletionChunk.Choice
     }
   }
 
-  // for open router
-  if ((cur.delta as { reasoning?: string }).reasoning != null) {
-    if ((acc.message as { reasoning?: string }).reasoning == null) {
-      (acc.message as { reasoning?: string }).reasoning = (cur.delta as { reasoning?: string }).reasoning;
-    }
-    else {
-      (acc.message as unknown as { reasoning: string }).reasoning += (cur.delta as { reasoning: string }).reasoning;
-    }
-  }
+  mergeAssistantMessagePayload(acc.message, cur.delta);
 
   if (cur.delta.tool_calls != null) {
     acc.message.tool_calls ??= [];
@@ -201,6 +190,33 @@ function mergeToolCalls(acc: ChatCompletionMessageFunctionToolCall, cur: ChatCom
   return acc;
 }
 
+function mergeAssistantMessagePayload(
+  message: ChatCompletionMessage,
+  delta: ChatCompletionChunk.Choice.Delta,
+): void {
+  const target = message as unknown as Record<string, unknown>;
+  const source = delta as Record<string, unknown>;
+  for (const [key, value] of Object.entries(source)) {
+    if (key.startsWith("reasoning") === false || value === undefined) {
+      continue;
+    }
+    if (typeof value === "string") {
+      target[key] = typeof target[key] === "string"
+        ? `${target[key]}${value}`
+        : value;
+    }
+    else if (Array.isArray(value)) {
+      target[key] = [
+        ...(Array.isArray(target[key]) ? target[key] : []),
+        ...value,
+      ];
+    }
+    else {
+      target[key] = value;
+    }
+  }
+}
+
 export const ChatGptCompletionMessageUtil = {
   transformCompletionChunk,
   accumulate,