@agentica/core 0.32.3-dev.3 → 0.32.4

package/src/Agentica.ts

@@ -1,16 +1,12 @@
 import type { ILlmSchema } from "@samchon/openapi";
-import type OpenAI from "openai";
 
 import { Semaphore } from "tstl";
-import { v4 } from "uuid";
 
 import type { AgenticaContext } from "./context/AgenticaContext";
 import type { AgenticaOperation } from "./context/AgenticaOperation";
 import type { AgenticaOperationCollection } from "./context/AgenticaOperationCollection";
 import type { AgenticaOperationSelection } from "./context/AgenticaOperationSelection";
-import type { AgenticaEventSource } from "./events";
 import type { AgenticaEvent } from "./events/AgenticaEvent";
-import type { AgenticaRequestEvent } from "./events/AgenticaRequestEvent";
 import type { AgenticaUserMessageEvent } from "./events/AgenticaUserMessageEvent";
 import type { AgenticaUserMessageContent } from "./histories";
 import type { AgenticaHistory } from "./histories/AgenticaHistory";
@@ -22,13 +18,11 @@ import type { IAgenticaVendor } from "./structures/IAgenticaVendor";
 
 import { AgenticaTokenUsage } from "./context/AgenticaTokenUsage";
 import { AgenticaOperationComposer } from "./context/internal/AgenticaOperationComposer";
-import { AgenticaTokenUsageAggregator } from "./context/internal/AgenticaTokenUsageAggregator";
-import { createInitializeEvent, createRequestEvent, createUserMessageEvent } from "./factory/events";
+import { createInitializeEvent, createUserMessageEvent } from "./factory/events";
 import { execute } from "./orchestrate/execute";
 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";
 
 /**
  * Agentica AI chatbot agent.
@@ -264,89 +258,13 @@ export class Agentica<Model extends ILlmSchema.Model> {
     dispatch: (event: AgenticaEvent<Model>) => Promise<void>;
     abortSignal?: AbortSignal;
   }): AgenticaContext<Model> {
-    const request = async (
-      source: AgenticaEventSource,
-      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,
-          signal: props.abortSignal,
-        },
-      });
-      await 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();
-
-      (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;
-    };
+    const request = getChatCompletionWithStreamingFunction<Model>({
+      vendor: this.props.vendor,
+      config: this.props.config,
+      dispatch: props.dispatch,
+      abortSignal: props.abortSignal,
+      usage: this.token_usage_,
+    });
 
     return {
       // APPLICATION

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,6 +123,9 @@ 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 = async (event: MicroAgenticaEvent<Model>): Promise<void> => {
@@ -164,6 +162,7 @@ export class MicroAgentica<Model extends ILlmSchema.Model> {
       prompt,
       dispatch,
       usage: this.token_usage_,
+      abortSignal: options.abortSignal,
     });
     const executes: AgenticaExecuteHistory<Model>[] = await call(
       ctx,
@@ -248,87 +247,15 @@ export class MicroAgentica<Model extends ILlmSchema.Model> {
     prompt: AgenticaUserMessageEvent;
     usage: AgenticaTokenUsage;
     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,
-      });
-      await 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();
-      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;
-    };
+    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/MicroAgenticaContext.ts

@@ -68,6 +68,10 @@ export interface MicroAgenticaContext<Model extends ILlmSchema.Model> {
    */
   prompt: AgenticaUserMessageHistory;
 
+  /**
+   * Abort signal.
+   */
+  abortSignal?: AbortSignal;
   // ----
   // HANDLERS
   // ----

package/src/orchestrate/call.ts

@@ -111,6 +111,7 @@ export async function call<Model extends ILlmSchema.Model>(
     const completion = await reduceStreamingWithDispatch(stream, (props) => {
       const event: AgenticaAssistantMessageEvent = createAssistantMessageEvent(props);
       void ctx.dispatch(event).catch(() => {});
+      ctx.abortSignal
     });
 
     const allAssistantMessagesEmpty = completion.choices.every(v => v.message.tool_calls == null && v.message.content === "");

package/src/orchestrate/cancel.ts

@@ -171,7 +171,7 @@ async function step<Model extends ILlmSchema.Model>(
     // parallel_tool_calls: true,
   });
 
-  const chunks = await StreamUtil.readAll(completionStream);
+  const chunks = await StreamUtil.readAll(completionStream, ctx.abortSignal);
   const completion = ChatGptCompletionMessageUtil.merge(chunks);
 
   // ----

package/src/orchestrate/describe.ts

@@ -45,7 +45,7 @@ export async function describe<Model extends ILlmSchema.Model>(
       ...props,
     });
     ctx.dispatch(event);
-  });
+  }, ctx.abortSignal);
 }
 
 export const ChatGptDescribeFunctionAgent = {

package/src/orchestrate/initialize.ts

@@ -66,7 +66,7 @@ export async function initialize<Model extends ILlmSchema.Model>(ctx: AgenticaCo
   const completion = await reduceStreamingWithDispatch(completionStream, (props) => {
     const event: AgenticaAssistantMessageEvent = createAssistantMessageEvent(props);
     ctx.dispatch(event);
-  });
+  }, ctx.abortSignal);
 
   if (completion === null) {
     throw new Error("No completion received");

package/src/orchestrate/select.ts

@@ -194,7 +194,7 @@ async function step<Model extends ILlmSchema.Model>(
     const completion = await reduceStreamingWithDispatch(stream, (props) => {
       const event: AgenticaAssistantMessageEvent = createAssistantMessageEvent(props);
       void ctx.dispatch(event).catch(() => {});
-    });
+    }, ctx.abortSignal);
     const allAssistantMessagesEmpty = completion.choices.every(v => v.message.tool_calls == null && v.message.content === "");
     if (allAssistantMessagesEmpty) {
       const firstChoice = completion.choices.at(0);

package/src/utils/ChatGptCompletionStreamingUtil.ts

@@ -7,7 +7,7 @@ async function reduceStreamingWithDispatch(stream: ReadableStream<ChatCompletion
   done: () => boolean;
   get: () => string;
   join: () => Promise<string>;
-}) => void) {
+}) => void, abortSignal?: AbortSignal) {
   const streamContext = new Map<number, { content: string; mpsc: MPSC<string> }>();
 
   const nullableCompletion = await StreamUtil.reduce<ChatCompletionChunk, Promise<ChatCompletion>>(stream, async (accPromise, chunk) => {
@@ -59,7 +59,7 @@ async function reduceStreamingWithDispatch(stream: ReadableStream<ChatCompletion
     }
     registerContext(chunk.choices);
     return ChatGptCompletionMessageUtil.accumulate(acc, chunk);
-  });
+  }, { abortSignal });
 
   if (nullableCompletion == null) {
     throw new Error(

package/src/utils/StreamUtil.spec.ts

@@ -149,7 +149,7 @@ describe("streamUtil", () => {
       const stringResult = await StreamUtil.reduce<number, string>(
         stringStream,
         (acc, cur) => acc + cur.toString(),
-        "",
+        { initial: ""},
       );
 
       expect(stringResult).toBe("123");
@@ -160,7 +160,7 @@ describe("streamUtil", () => {
       const sumResult = await StreamUtil.reduce<number, number>(
         sumStream,
         (acc, cur) => acc + cur,
-        0,
+        { initial: 0 },
       );
 
       expect(sumResult).toBe(15);
@@ -171,6 +171,7 @@ describe("streamUtil", () => {
       const noInitialResult = await StreamUtil.reduce<number>(
         noInitialStream,
         (acc, cur) => acc + cur,
+        { initial: 0 },
       );
 
       expect(noInitialResult).toBe(10);
@@ -181,7 +182,7 @@ describe("streamUtil", () => {
       const emptyResult = await StreamUtil.reduce<number, string>(
         emptyStream,
         (acc, cur) => acc + cur.toString(),
-        "initial value",
+        { initial: "initial value" },
       );
 
       expect(emptyResult).toBe("initial value");
@@ -192,6 +193,7 @@ describe("streamUtil", () => {
       const emptyNoInitialResult = await StreamUtil.reduce<number>(
         emptyNoInitialStream,
         (acc, cur) => acc + cur,
+        { initial: 0 },
       );
 
       expect(emptyNoInitialResult).toBeNull();
@@ -202,7 +204,7 @@ describe("streamUtil", () => {
       const stringResult = await StreamUtil.reduce<number, string>(
         stringStream,
         (acc, cur) => acc + cur.toString(),
-        "",
+        { initial: "" },
       );
 
       expect(stringResult).toBe("123");
@@ -213,6 +215,7 @@ describe("streamUtil", () => {
       const noInitialResult = await StreamUtil.reduce<number>(
         noInitialStream,
         (acc, cur) => acc + cur,
+        { initial: 0 },
       );
 
       expect(noInitialResult).toBe(10);
@@ -229,7 +232,7 @@ describe("streamUtil", () => {
           }
           return [...acc, `item${cur}`];
         },
-        [],
+        { initial: [] },
       );
 
       expect(transformResult).toEqual(["item1", "item2", "item3"]);
@@ -240,7 +243,7 @@ describe("streamUtil", () => {
       const emptyResult = await StreamUtil.reduce<number, string>(
         emptyStream,
         (acc, cur) => acc + cur.toString(),
-        "initial",
+        { initial: "initial" },
       );
 
       expect(emptyResult).toBe("initial");
@@ -256,7 +259,7 @@ describe("streamUtil", () => {
       const delayResult = await StreamUtil.reduce<number, number>(
         delayStream,
         (acc, cur) => acc + cur,
-        0,
+        { initial: 0 },
       );
 
       expect(delayResult).toBe(6);
@@ -274,7 +277,7 @@ describe("streamUtil", () => {
             }
             return acc + cur;
           },
-          0,
+          { initial: 0 },
         ),
       ).rejects.toThrow("Test error");
     });
@@ -285,7 +288,7 @@ describe("streamUtil", () => {
       const result = await StreamUtil.reduce<number | null | undefined, number>(
         stream,
         (acc, cur) => (acc ?? 0) + (cur ?? 0),
-        0,
+        { initial: 0 },
       );
 
       expect(result).toBe(9); // 1 + 0 + 3 + 0 + 5 = 9

package/src/utils/StreamUtil.ts

@@ -4,12 +4,12 @@
  * Utility functions for streams.
  */
 
-async function readAll<T>(stream: ReadableStream<T>): Promise<T[]> {
+async function readAll<T>(stream: ReadableStream<T>, abortSignal?: AbortSignal): Promise<T[]> {
   const reader = stream.getReader();
   const result: T[] = [];
   while (true) {
     const { done, value } = await reader.read();
-    if (done) {
+    if (done || abortSignal?.aborted === true) {
       break;
     }
     result.push(value);
@@ -17,12 +17,16 @@ async function readAll<T>(stream: ReadableStream<T>): Promise<T[]> {
   return result;
 }
 
-async function reduce<T, R = T>(stream: ReadableStream<T>, reducer: (acc: T | R, cur: T) => R, initial?: R): Promise<R | null> {
+async function reduce<T, R = T>(stream: ReadableStream<T>, reducer: (acc: T | R, cur: T) => R, options: { initial?: R, abortSignal?: AbortSignal }): Promise<R | null> {
   const reader = stream.getReader();
   const iterator = streamDefaultReaderToAsyncGenerator(reader);
-  let acc = (initial ?? null) as R | null | T;
+  let acc = (options.initial ?? null) as R | null | T;
 
   for await (const value of iterator) {
+    if (options.abortSignal?.aborted === true) {
+      break;
+    }
+
     if (acc === null) {
       acc = value;
       continue;
@@ -49,28 +53,28 @@ export async function* toAsyncGenerator<T>(value: T): AsyncGenerator<T, undefine
   yield value;
 }
 
-export async function* streamDefaultReaderToAsyncGenerator<T>(reader: ReadableStreamDefaultReader<T>): AsyncGenerator<Awaited<T>, undefined, undefined> {
+export async function* streamDefaultReaderToAsyncGenerator<T>(reader: ReadableStreamDefaultReader<T>, abortSignal?: AbortSignal): AsyncGenerator<Awaited<T>, undefined, undefined> {
   while (true) {
     const { done, value } = await reader.read();
-    if (done) {
+    if (done || abortSignal?.aborted === true) {
       break;
     }
     yield value;
   }
 }
 
-function transform<T, R>(stream: ReadableStream<T>, transformer: (value: T) => R): ReadableStream<R> {
+function transform<T, R>(stream: ReadableStream<T>, transformer: (value: T) => R, abortSignal?: AbortSignal): ReadableStream<R> {
   const reader = stream.getReader();
 
   return new ReadableStream<R>({
     pull: async (controller) => {
       const { done, value } = await reader.read();
-      if (!done) {
-        controller.enqueue(transformer(value));
-      }
-      else {
+      if (done === true || abortSignal?.aborted === true) {
         controller.close();
+        return;
       }
+      
+      controller.enqueue(transformer(value));
     },
   });
 }

package/src/utils/request.ts

@@ -0,0 +1,101 @@
+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),
+    props.abortSignal,
+  ).tee();
+
+  const [streamForAggregate, streamForReturn] = temporaryStream.tee();
+
+  (async () => {
+    const reader = streamForAggregate.getReader();
+    while (true) {
+      const chunk = await reader.read();
+      if (chunk.done || props.abortSignal?.aborted === true) {
+        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(), props.abortSignal),
+    body: event.body,
+    options: event.options,
+    join: async () => {
+      const chunks = await StreamUtil.readAll(streamForJoin, props.abortSignal);
+      return ChatGptCompletionMessageUtil.merge(chunks);
+    },
+    created_at: new Date().toISOString(),
+  }).catch(() => {});
+  return streamForReturn;
+};