@agentica/core 0.32.3-dev.2 → 0.32.3

package/src/MicroAgentica.ts

@@ -1,14 +1,11 @@
 import type { ILlmSchema } from "@samchon/openapi";
-import type OpenAI from "openai";
 
 import { Semaphore } from "tstl";
-import { v4 } from "uuid";
 
 import type { AgenticaOperation } from "./context/AgenticaOperation";
 import type { AgenticaOperationCollection } from "./context/AgenticaOperationCollection";
 import type { MicroAgenticaContext } from "./context/MicroAgenticaContext";
 import type { AgenticaUserMessageEvent } from "./events";
-import type { AgenticaRequestEvent } from "./events/AgenticaRequestEvent";
 import type { MicroAgenticaEvent } from "./events/MicroAgenticaEvent";
 import type { AgenticaUserMessageContent } from "./histories";
 import type { AgenticaExecuteHistory } from "./histories/AgenticaExecuteHistory";
@@ -20,13 +17,11 @@ import type { IMicroAgenticaProps } from "./structures/IMicroAgenticaProps";
 
 import { AgenticaTokenUsage } from "./context/AgenticaTokenUsage";
 import { AgenticaOperationComposer } from "./context/internal/AgenticaOperationComposer";
-import { AgenticaTokenUsageAggregator } from "./context/internal/AgenticaTokenUsageAggregator";
-import { createRequestEvent, createUserMessageEvent } from "./factory/events";
+import { createUserMessageEvent } from "./factory/events";
 import { call, describe } from "./orchestrate";
 import { transformHistory } from "./transformers/transformHistory";
 import { __map_take } from "./utils/__map_take";
-import { ChatGptCompletionMessageUtil } from "./utils/ChatGptCompletionMessageUtil";
-import { streamDefaultReaderToAsyncGenerator, StreamUtil } from "./utils/StreamUtil";
+import { getChatCompletionWithStreamingFunction } from "./utils/request";
 
 /**
  * Micro AI chatbot.
@@ -128,21 +123,27 @@ export class MicroAgentica<Model extends ILlmSchema.Model> {
    */
   public async conversate(
     content: string | AgenticaUserMessageContent | Array<AgenticaUserMessageContent>,
+    options: {
+      abortSignal?: AbortSignal;
+    } = {},
   ): Promise<MicroAgenticaHistory<Model>[]> {
     const histories: Array<() => Promise<MicroAgenticaHistory<Model>>> = [];
-    const dispatch = (event: MicroAgenticaEvent<Model>): void => {
-      this.dispatch(event).catch(() => {});
-      if ("toHistory" in event) {
-        if ("join" in event) {
-          histories.push(async () => {
-            await event.join();
-            return event.toHistory();
-          });
-        }
-        else {
-          histories.push(async () => event.toHistory());
+    const dispatch = async (event: MicroAgenticaEvent<Model>): Promise<void> => {
+      try {
+        await this.dispatch(event);
+        if ("toHistory" in event) {
+          if ("join" in event) {
+            histories.push(async () => {
+              await event.join();
+              return event.toHistory();
+            });
+          }
+          else {
+            histories.push(async () => event.toHistory());
+          }
         }
       }
+      catch {}
     };
 
     const prompt: AgenticaUserMessageEvent = createUserMessageEvent({
@@ -155,12 +156,13 @@ export class MicroAgentica<Model extends ILlmSchema.Model> {
             }]
           : [content],
     });
-    dispatch(prompt);
+    void dispatch(prompt).catch(() => {});
 
     const ctx: MicroAgenticaContext<Model> = this.getContext({
       prompt,
       dispatch,
       usage: this.token_usage_,
+      abortSignal: options.abortSignal,
     });
     const executes: AgenticaExecuteHistory<Model>[] = await call(
       ctx,
@@ -244,88 +246,16 @@ export class MicroAgentica<Model extends ILlmSchema.Model> {
   public getContext(props: {
     prompt: AgenticaUserMessageEvent;
     usage: AgenticaTokenUsage;
-    dispatch: (event: MicroAgenticaEvent<Model>) => void;
+    dispatch: (event: MicroAgenticaEvent<Model>) => Promise<void>;
+    abortSignal?: AbortSignal;
   }): MicroAgenticaContext<Model> {
-    const request = async (
-      source: MicroAgenticaEvent.Source,
-      body: Omit<OpenAI.ChatCompletionCreateParamsStreaming, "model" | "stream">,
-    ): Promise<ReadableStream<OpenAI.Chat.Completions.ChatCompletionChunk>> => {
-      const event: AgenticaRequestEvent = createRequestEvent({
-        source,
-        body: {
-          ...body,
-          model: this.props.vendor.model,
-          stream: true,
-          stream_options: {
-            include_usage: true,
-          },
-        },
-        options: this.props.vendor.options,
-      });
-      props.dispatch(event);
-
-      // completion
-      const backoffStrategy = this.props.config?.backoffStrategy ?? ((props) => {
-        throw props.error;
-      });
-      const completion = await (async () => {
-        let count = 0;
-        while (true) {
-          try {
-            return await this.props.vendor.api.chat.completions.create(
-              event.body,
-              event.options,
-            );
-          }
-          catch (error) {
-            const waiting = backoffStrategy({ count, error });
-            await new Promise(resolve => setTimeout(resolve, waiting));
-            count++;
-          }
-        }
-      })();
-
-      const [streamForEvent, temporaryStream] = StreamUtil.transform(
-        completion.toReadableStream() as ReadableStream<Uint8Array>,
-        value =>
-          ChatGptCompletionMessageUtil.transformCompletionChunk(value),
-      ).tee();
-
-      const [streamForAggregate, streamForReturn] = temporaryStream.tee();
-
-      void (async () => {
-        const reader = streamForAggregate.getReader();
-        while (true) {
-          const chunk = await reader.read();
-          if (chunk.done) {
-            break;
-          }
-          if (chunk.value.usage != null) {
-            AgenticaTokenUsageAggregator.aggregate({
-              kind: source,
-              completionUsage: chunk.value.usage,
-              usage: props.usage,
-            });
-          }
-        }
-      })().catch(() => {});
-
-      const [streamForStream, streamForJoin] = streamForEvent.tee();
-      props.dispatch({
-        id: v4(),
-        type: "response",
-        source,
-        stream: streamDefaultReaderToAsyncGenerator(streamForStream.getReader()),
-        body: event.body,
-        options: event.options,
-        join: async () => {
-          const chunks = await StreamUtil.readAll(streamForJoin);
-          return ChatGptCompletionMessageUtil.merge(chunks);
-        },
-        created_at: new Date().toISOString(),
-      });
-      return streamForReturn;
-    };
+    const request = getChatCompletionWithStreamingFunction<Model>({
+      vendor: this.props.vendor,
+      config: this.props.config,
+      dispatch: props.dispatch,
+      abortSignal: props.abortSignal,
+      usage: this.token_usage_,
+    });
     return {
       operations: this.operations_,
       config: this.props.config,

package/src/context/AgenticaContext.ts

@@ -115,7 +115,7 @@ export interface AgenticaContext<Model extends ILlmSchema.Model> {
    *
    * @param event Event to deliver
    */
-  dispatch: (event: AgenticaEvent<Model>) => void;
+  dispatch: (event: AgenticaEvent<Model>) => Promise<void>;
 
   /**
    * Request to the OpenAI server.

package/src/context/MicroAgenticaContext.ts

@@ -79,7 +79,7 @@ export interface MicroAgenticaContext<Model extends ILlmSchema.Model> {
    *
    * @param event Event to deliver
    */
-  dispatch: (event: MicroAgenticaEvent<Model>) => void;
+  dispatch: (event: MicroAgenticaEvent<Model>) => Promise<void>;
 
   /**
    * Request to the OpenAI server.

package/src/orchestrate/call.ts

@@ -60,12 +60,14 @@ export async function call<Model extends ILlmSchema.Model>(
           role: "user",
           content: ctx.prompt.contents.map(decodeUserMessageContent),
         },
-        ...(prevError instanceof AssistantMessageEmptyWithReasoningError ? [
+        ...(prevError instanceof AssistantMessageEmptyWithReasoningError
+          ? [
           {
             role: "assistant",
             content: prevError.reasoning,
           } satisfies OpenAI.ChatCompletionMessageParam,
-        ] : []),
+            ]
+          : []),
         // SYSTEM PROMPT
         ...(ctx.config?.systemPrompt?.execute === null
           ? []
@@ -108,7 +110,7 @@ export async function call<Model extends ILlmSchema.Model>(
 
     const completion = await reduceStreamingWithDispatch(stream, (props) => {
       const event: AgenticaAssistantMessageEvent = createAssistantMessageEvent(props);
-      ctx.dispatch(event);
+      void ctx.dispatch(event).catch(() => {});
     });
 
     const allAssistantMessagesEmpty = completion.choices.every(v => v.message.tool_calls == null && v.message.content === "");
@@ -131,7 +133,7 @@ export async function call<Model extends ILlmSchema.Model>(
         return "";
       },
     });
-    ctx.dispatch(event);
+    void ctx.dispatch(event).catch(() => {});
     return [];
   }
 
@@ -154,7 +156,7 @@ export async function call<Model extends ILlmSchema.Model>(
           [],
           retry,
         );
-        ctx.dispatch(event);
+        await ctx.dispatch(event);
         executes.push(event);
         if (isAgenticaContext(ctx)) {
           cancelFunctionFromContext(ctx, {
@@ -181,7 +183,7 @@ async function predicate<Model extends ILlmSchema.Model>(
       operation,
       toolCall,
     );
-  ctx.dispatch(call);
+  await ctx.dispatch(call);
   if (call.type === "jsonParseError") {
     return correctJsonError(ctx, call, previousValidationErrors, life - 1);
   }
@@ -194,7 +196,7 @@ async function predicate<Model extends ILlmSchema.Model>(
       operation,
       result: check,
     });
-    ctx.dispatch(event);
+    await ctx.dispatch(event);
     return correctTypeError(
       ctx,
       call,

package/src/orchestrate/cancel.ts

@@ -48,9 +48,8 @@ export async function cancel<Model extends ILlmSchema.Model>(
         {
           ...ctx,
           stack: stacks[i]!,
-          dispatch: (e) => {
+          dispatch: async (e) => {
             events.push(e);
-            return e;
           },
         },
         operations,
@@ -81,7 +80,9 @@ export async function cancel<Model extends ILlmSchema.Model>(
     const cancelled: AgenticaCancelEvent<Model>[]
         = events.filter(e => e.type === "cancel");
     (cancelled.length !== 0 ? cancelled : events)
-      .forEach(ctx.dispatch);
+      .forEach((e) => {
+        void ctx.dispatch(e).catch(() => {});
+      });
   }
 }
 

package/src/orchestrate/select.ts

@@ -51,9 +51,8 @@ export async function select<Model extends ILlmSchema.Model>(
         {
           ...ctx,
           stack: stacks[i]!,
-          dispatch: (e) => {
+          dispatch: async (e) => {
             events.push(e);
-            return e;
           },
         },
         operations,
@@ -84,7 +83,9 @@ export async function select<Model extends ILlmSchema.Model>(
     const selected: AgenticaSelectEvent<Model>[]
       = events.filter(e => e.type === "select");
     (selected.length !== 0 ? selected : events)
-      .forEach(ctx.dispatch);
+      .forEach((e) => {
+        void ctx.dispatch(e).catch(() => {});
+      });
   }
 }
 
@@ -153,12 +154,14 @@ async function step<Model extends ILlmSchema.Model>(
           content: ctx.prompt.contents.map(decodeUserMessageContent),
         },
         // PREVIOUS ERROR
-        ...(prevError instanceof AssistantMessageEmptyWithReasoningError ? [
+        ...(prevError instanceof AssistantMessageEmptyWithReasoningError
+          ? [
           {
             role: "assistant",
             content: prevError.reasoning,
           } satisfies OpenAI.ChatCompletionMessageParam,
-        ] : []),
+            ]
+          : []),
         // SYSTEM PROMPT
         {
           role: "system",
@@ -190,7 +193,7 @@ async function step<Model extends ILlmSchema.Model>(
 
     const completion = await reduceStreamingWithDispatch(stream, (props) => {
       const event: AgenticaAssistantMessageEvent = createAssistantMessageEvent(props);
-      ctx.dispatch(event);
+      void ctx.dispatch(event).catch(() => {});
     });
     const allAssistantMessagesEmpty = completion.choices.every(v => v.message.tool_calls == null && v.message.content === "");
     if (allAssistantMessagesEmpty) {
@@ -212,7 +215,7 @@ async function step<Model extends ILlmSchema.Model>(
         return "";
       },
     });
-    ctx.dispatch(event);
+    void ctx.dispatch(event).catch(() => {});
     return;
   }
   // ----

package/src/utils/request.ts

@@ -0,0 +1,100 @@
+import OpenAI from "openai";
+import { AgenticaEventSource, AgenticaRequestEvent, AgenticaResponseEvent } from "../events";
+import { ChatGptCompletionMessageUtil } from "./ChatGptCompletionMessageUtil";
+import { streamDefaultReaderToAsyncGenerator, StreamUtil } from "./StreamUtil";
+import { createRequestEvent } from "../factory";
+import { IAgenticaConfig, IAgenticaVendor, IMicroAgenticaConfig } from "../structures";
+import { ILlmSchema } from "@samchon/openapi";
+import { AgenticaTokenUsageAggregator } from "../context/internal/AgenticaTokenUsageAggregator";
+import { AgenticaTokenUsage } from "../context/AgenticaTokenUsage";
+import { v4 } from "uuid";
+
+export const getChatCompletionWithStreamingFunction = <Model extends ILlmSchema.Model>(props: {
+  vendor: IAgenticaVendor;
+  config?: IAgenticaConfig<Model> | IMicroAgenticaConfig<Model>;
+  dispatch: (event: AgenticaRequestEvent | AgenticaResponseEvent) => Promise<void>;
+  abortSignal?: AbortSignal;
+  usage: AgenticaTokenUsage;
+}) => async (
+  source: AgenticaEventSource,
+  body: Omit<OpenAI.ChatCompletionCreateParamsStreaming, "model" | "stream">,
+) => {
+  const event: AgenticaRequestEvent = createRequestEvent({
+    source,
+    body: {
+      ...body,
+      model: props.vendor.model,
+      stream: true,
+      stream_options: {
+        include_usage: true,
+      },
+    },
+    options: {
+      ...props.vendor.options,
+      signal: props.abortSignal,
+    },
+  });
+  await props.dispatch(event);
+
+  // completion
+  const backoffStrategy = props.config?.backoffStrategy ?? ((props) => {
+    throw props.error;
+  });
+  const completion = await (async () => {
+    let count = 0;
+    while (true) {
+      try {
+        return await props.vendor.api.chat.completions.create(
+          event.body,
+          event.options,
+        );
+      }
+      catch (error) {
+        const waiting = backoffStrategy({ count, error });
+        await new Promise(resolve => setTimeout(resolve, waiting));
+        count++;
+      }
+    }
+  })();
+
+  const [streamForEvent, temporaryStream] = StreamUtil.transform(
+    completion.toReadableStream() as ReadableStream<Uint8Array>,
+    value =>
+      ChatGptCompletionMessageUtil.transformCompletionChunk(value),
+  ).tee();
+
+  const [streamForAggregate, streamForReturn] = temporaryStream.tee();
+
+  (async () => {
+    const reader = streamForAggregate.getReader();
+    while (true) {
+      const chunk = await reader.read();
+      if (chunk.done) {
+        break;
+      }
+      if (chunk.value.usage != null) {
+        AgenticaTokenUsageAggregator.aggregate({
+          kind: source,
+          completionUsage: chunk.value.usage,
+          usage: props.usage,
+        });
+      }
+    }
+  })().catch(() => {});
+
+  const [streamForStream, streamForJoin] = streamForEvent.tee();
+  void props.dispatch({
+    id: v4(),
+    type: "response",
+    source,
+    stream: streamDefaultReaderToAsyncGenerator(streamForStream.getReader()),
+    body: event.body,
+    options: event.options,
+    join: async () => {
+      const chunks = await StreamUtil.readAll(streamForJoin);
+      return ChatGptCompletionMessageUtil.merge(chunks);
+    },
+    created_at: new Date().toISOString(),
+  }).catch(() => {});
+  return streamForReturn;
+};