@agentica/core 0.15.7 → 0.16.1

package/src/orchestrate/call.ts

@@ -10,63 +10,71 @@ import type { IValidation } from "typia";
 import {
   ChatGptTypeChecker,
   HttpLlm,
+  LlmTypeCheckerV3_1,
 } from "@samchon/openapi";
 
 import type { AgenticaCancelPrompt } from "../context/AgenticaCancelPrompt";
 import type { AgenticaContext } from "../context/AgenticaContext";
 import type { AgenticaOperation } from "../context/AgenticaOperation";
+import type { MicroAgenticaContext } from "../context/MicroAgenticaContext";
 import type { AgenticaCallEvent } from "../events/AgenticaCallEvent";
-import type { AgenticaExecutePrompt } from "../prompts/AgenticaExecutePrompt";
-import type { AgenticaPrompt } from "../prompts/AgenticaPrompt";
-import type { AgenticaTextPrompt } from "../prompts/AgenticaTextPrompt";
+import type { AgenticaExecuteHistory } from "../histories/AgenticaExecuteHistory";
+import type { AgenticaHistory } from "../histories/AgenticaHistory";
+import type { AgenticaTextHistory } from "../histories/AgenticaTextHistory";
+import type { MicroAgenticaHistory } from "../histories/MicroAgenticaHistory";
 
 import { AgenticaConstant } from "../constants/AgenticaConstant";
 import { AgenticaDefaultPrompt } from "../constants/AgenticaDefaultPrompt";
 import { AgenticaSystemPrompt } from "../constants/AgenticaSystemPrompt";
+import { isAgenticaContext } from "../context/internal/isAgenticaContext";
 import { createCallEvent, createCancelEvent, createExecuteEvent, createTextEvent, createValidateEvent } from "../factory/events";
+import { createCancelHistory, createExecuteHistory, createTextHistory, decodeHistory } from "../factory/histories";
 import { createOperationSelection } from "../factory/operations";
-import { createCancelPrompt, createExecutePrompt, createTextPrompt, decodePrompt } from "../factory/prompts";
 import { ChatGptCompletionMessageUtil } from "../utils/ChatGptCompletionMessageUtil";
 import { StreamUtil } from "../utils/StreamUtil";
 
 import { cancelFunction } from "./internal/cancelFunction";
 
-export async function call<Model extends ILlmSchema.Model>(ctx: AgenticaContext<Model>): Promise<AgenticaPrompt<Model>[]> {
+export async function call<Model extends ILlmSchema.Model>(
+  ctx: AgenticaContext<Model> | MicroAgenticaContext<Model>,
+  operations: AgenticaOperation<Model>[],
+): Promise<AgenticaHistory<Model>[]> {
   // ----
   // EXECUTE CHATGPT API
   // ----
   const completionStream = await ctx.request("call", {
     messages: [
-        // COMMON SYSTEM PROMPT
-        {
-          role: "system",
-          content: AgenticaDefaultPrompt.write(ctx.config),
-        } satisfies OpenAI.ChatCompletionSystemMessageParam,
-        // PREVIOUS HISTORIES
-        ...ctx.histories.map(decodePrompt).flat(),
-        // USER INPUT
-        {
-          role: "user",
-          content: ctx.prompt.text,
-        },
-        // SYSTEM PROMPT
-        {
+      // COMMON SYSTEM PROMPT
+      {
+        role: "system",
+        content: AgenticaDefaultPrompt.write(ctx.config),
+      } satisfies OpenAI.ChatCompletionSystemMessageParam,
+      // PREVIOUS HISTORIES
+      ...ctx.histories.map(decodeHistory).flat(),
+      // USER INPUT
+      {
+        role: "user",
+        content: ctx.prompt.text,
+      },
+      // SYSTEM PROMPT
+      ...(ctx.config?.systemPrompt?.execute === null
+        ? []
+        : [{
           role: "system",
-          content:
-            ctx.config?.systemPrompt?.execute?.(ctx.histories)
+          content: ctx.config?.systemPrompt?.execute?.(ctx.histories as MicroAgenticaHistory<Model>[])
             ?? AgenticaSystemPrompt.EXECUTE,
-        },
+        } satisfies OpenAI.ChatCompletionSystemMessageParam]),
     ],
     // STACKED FUNCTIONS
-    tools: ctx.stack.map(
+    tools: operations.map(
       s =>
         ({
           type: "function",
           function: {
-            name: s.operation.name,
-            description: s.operation.function.description,
-            parameters: (s.operation.function.separated !== undefined
-              ? (s.operation.function.separated.llm
+            name: s.name,
+            description: s.function.description,
+            parameters: (s.function.separated !== undefined
+              ? (s.function.separated.llm
                 ?? ({
                   type: "object",
                   properties: {},
@@ -74,7 +82,7 @@ export async function call<Model extends ILlmSchema.Model>(ctx: AgenticaContext<
                   additionalProperties: false,
                   $defs: {},
                 } satisfies IChatGptSchema.IParameters))
-              : s.operation.function.parameters) as Record<string, any>,
+              : s.function.parameters) as Record<string, any>,
           },
         }) as OpenAI.ChatCompletionTool,
     ),
@@ -88,9 +96,9 @@ export async function call<Model extends ILlmSchema.Model>(ctx: AgenticaContext<
   const closures: Array<
     () => Promise<
       Array<
-        | AgenticaExecutePrompt<Model>
+        | AgenticaExecuteHistory<Model>
         | AgenticaCancelPrompt<Model>
-        | AgenticaTextPrompt
+        | AgenticaTextHistory
       >
     >
   > = [];
@@ -108,7 +116,7 @@ export async function call<Model extends ILlmSchema.Model>(ctx: AgenticaContext<
         }
         closures.push(
           async (): Promise<
-            [AgenticaExecutePrompt<Model>, AgenticaCancelPrompt<Model>]
+            [AgenticaExecuteHistory<Model>, AgenticaCancelPrompt<Model>]
           > => {
             const call: AgenticaCallEvent<Model> = createCallEvent({
               id: tc.id,
@@ -124,35 +132,37 @@ export async function call<Model extends ILlmSchema.Model>(ctx: AgenticaContext<
             }
             await ctx.dispatch(call);
 
-            const execute: AgenticaExecutePrompt<Model> = await propagate(
+            const execute: AgenticaExecuteHistory<Model> = await propagate(
               ctx,
               call,
               0,
             );
-            void ctx.dispatch(
+            ctx.dispatch(
               createExecuteEvent({
                 id: call.id,
                 operation: call.operation,
                 arguments: execute.arguments,
                 value: execute.value,
               }),
-            );
+            ).catch(() => {});
 
-            await cancelFunction(ctx, {
-              name: call.operation.name,
-              reason: "completed",
-            });
-            void ctx.dispatch(
-              createCancelEvent({
-                selection: createOperationSelection({
-                  operation: call.operation,
-                  reason: "complete",
+            if (isAgenticaContext(ctx)) {
+              await cancelFunction(ctx, {
+                name: call.operation.name,
+                reason: "completed",
+              });
+              ctx.dispatch(
+                createCancelEvent({
+                  selection: createOperationSelection({
+                    operation: call.operation,
+                    reason: "complete",
+                  }),
                 }),
-              }),
-            );
+              ).catch(() => {});
+            }
             return [
               execute,
-              createCancelPrompt({
+              createCancelHistory({
                 id: call.id,
                 selections: [
                   createOperationSelection({
@@ -172,11 +182,11 @@ export async function call<Model extends ILlmSchema.Model>(ctx: AgenticaContext<
       && choice.message.content.length > 0
     ) {
       closures.push(async () => {
-        const value: AgenticaTextPrompt = createTextPrompt({
+        const value: AgenticaTextHistory = createTextHistory({
           role: "assistant",
           text: choice.message.content!,
         });
-        void ctx.dispatch(
+        ctx.dispatch(
           createTextEvent({
             role: "assistant",
             get: () => value.text,
@@ -184,7 +194,7 @@ export async function call<Model extends ILlmSchema.Model>(ctx: AgenticaContext<
             stream: StreamUtil.to(value.text),
             join: async () => Promise.resolve(value.text),
           }),
-        );
+        ).catch(() => {});
         return [value];
       });
     }
@@ -192,7 +202,11 @@ export async function call<Model extends ILlmSchema.Model>(ctx: AgenticaContext<
   return (await Promise.all(closures.map(async fn => fn()))).flat();
 }
 
-async function propagate<Model extends ILlmSchema.Model>(ctx: AgenticaContext<Model>, call: AgenticaCallEvent<Model>, retry: number): Promise<AgenticaExecutePrompt<Model>> {
+async function propagate<Model extends ILlmSchema.Model>(
+  ctx: AgenticaContext<Model> | MicroAgenticaContext<Model>,
+  call: AgenticaCallEvent<Model>,
+  retry: number,
+): Promise<AgenticaExecuteHistory<Model>> {
   if (call.operation.protocol === "http") {
     // ----
     // HTTP PROTOCOL
@@ -202,15 +216,15 @@ async function propagate<Model extends ILlmSchema.Model>(ctx: AgenticaContext<Mo
       call.arguments,
     );
     if (check.success === false) {
-      void ctx.dispatch(
+      ctx.dispatch(
         createValidateEvent({
           id: call.id,
           operation: call.operation,
           result: check,
         }),
-      );
+      ).catch(() => {});
       if (retry++ < (ctx.config?.retry ?? AgenticaConstant.RETRY)) {
-        const trial: AgenticaExecutePrompt<Model> | null = await correct(
+        const trial: AgenticaExecuteHistory<Model> | null = await correct(
           ctx,
           call,
           retry,
@@ -236,7 +250,7 @@ async function propagate<Model extends ILlmSchema.Model>(ctx: AgenticaContext<Mo
         (success === false
           ? await correct(ctx, call, retry, response.body)
           : null)
-        ?? createExecutePrompt({
+        ?? createExecuteHistory({
           operation: call.operation,
           id: call.id,
           arguments: call.arguments,
@@ -246,7 +260,7 @@ async function propagate<Model extends ILlmSchema.Model>(ctx: AgenticaContext<Mo
     }
     catch (error) {
       // DISPATCH ERROR
-      return createExecutePrompt({
+      return createExecuteHistory({
         operation: call.operation,
         id: call.id,
         arguments: call.arguments,
@@ -274,18 +288,18 @@ async function propagate<Model extends ILlmSchema.Model>(ctx: AgenticaContext<Mo
       call.arguments,
     );
     if (check.success === false) {
-      void ctx.dispatch(
+      ctx.dispatch(
         createValidateEvent({
           id: call.id,
           operation: call.operation,
           result: check,
         }),
-      );
+      ).catch(() => {});
       return (
         (retry++ < (ctx.config?.retry ?? AgenticaConstant.RETRY)
           ? await correct(ctx, call, retry, check.errors)
           : null)
-        ?? createExecutePrompt({
+        ?? createExecuteHistory({
           id: call.id,
           operation: call.operation,
           arguments: call.arguments,
@@ -300,7 +314,7 @@ async function propagate<Model extends ILlmSchema.Model>(ctx: AgenticaContext<Mo
     // EXECUTE FUNCTION
     try {
       const value = await executeClassOperation(call.operation, call.arguments);
-      return createExecutePrompt({
+      return createExecuteHistory({
         id: call.id,
         operation: call.operation,
         arguments: call.arguments,
@@ -308,7 +322,7 @@ async function propagate<Model extends ILlmSchema.Model>(ctx: AgenticaContext<Mo
       });
     }
     catch (error) {
-      return createExecutePrompt({
+      return createExecuteHistory({
         id: call.id,
         operation: call.operation,
         arguments: call.arguments,
@@ -358,7 +372,12 @@ async function executeClassOperation<Model extends ILlmSchema.Model>(operation:
   return ((execute as Record<string, unknown>)[operation.function.name] as (...args: unknown[]) => Promise<unknown>)(operationArguments);
 }
 
-async function correct<Model extends ILlmSchema.Model>(ctx: AgenticaContext<Model>, call: AgenticaCallEvent<Model>, retry: number, error: unknown): Promise<AgenticaExecutePrompt<Model> | null> {
+async function correct<Model extends ILlmSchema.Model>(
+  ctx: AgenticaContext<Model> | MicroAgenticaContext<Model>,
+  call: AgenticaCallEvent<Model>,
+  retry: number,
+  error: unknown,
+): Promise<AgenticaExecuteHistory<Model> | null> {
   // ----
   // EXECUTE CHATGPT API
   // ----
@@ -370,19 +389,22 @@ async function correct<Model extends ILlmSchema.Model>(ctx: AgenticaContext<Mode
           content: AgenticaDefaultPrompt.write(ctx.config),
         } satisfies OpenAI.ChatCompletionSystemMessageParam,
         // PREVIOUS HISTORIES
-        ...ctx.histories.map(decodePrompt).flat(),
+        ...ctx.histories.map(decodeHistory).flat(),
         // USER INPUT
         {
           role: "user",
           content: ctx.prompt.text,
         },
         // TYPE CORRECTION
-        {
-          role: "system",
-          content:
-            ctx.config?.systemPrompt?.execute?.(ctx.histories)
+        ...(ctx.config?.systemPrompt?.execute === null
+          ? []
+          : [{
+            role: "system",
+            content:
+            ctx.config?.systemPrompt?.execute?.(ctx.histories as MicroAgenticaHistory<Model>[])
             ?? AgenticaSystemPrompt.EXECUTE,
-        },
+          } satisfies OpenAI.ChatCompletionSystemMessageParam]
+        ),
         {
           role: "assistant",
           tool_calls: [
@@ -495,5 +517,7 @@ function isObject($defs: Record<string, IChatGptSchema>, schema: IChatGptSchema)
       && isObject($defs, $defs[schema.$ref.split("/").at(-1)!]!))
     || (ChatGptTypeChecker.isAnyOf(schema)
       && schema.anyOf.every(schema => isObject($defs, schema)))
+    || (LlmTypeCheckerV3_1.isOneOf(schema)
+      && schema.oneOf.every(schema => isObject($defs, schema)))
   );
 }

package/src/orchestrate/cancel.ts

@@ -16,7 +16,7 @@ import type { AgenticaEvent } from "../events/AgenticaEvent";
 import { AgenticaConstant } from "../constants/AgenticaConstant";
 import { AgenticaDefaultPrompt } from "../constants/AgenticaDefaultPrompt";
 import { AgenticaSystemPrompt } from "../constants/AgenticaSystemPrompt";
-import { createCancelPrompt, decodePrompt } from "../factory/prompts";
+import { createCancelHistory, decodeHistory } from "../factory/histories";
 import { ChatGptCompletionMessageUtil } from "../utils/ChatGptCompletionMessageUtil";
 import { StreamUtil } from "../utils/StreamUtil";
 
@@ -78,7 +78,7 @@ export async function cancel<Model extends ILlmSchema.Model>(ctx: AgenticaContex
   }
 
   // RE-COLLECT SELECT FUNCTION EVENTS
-  const collection: AgenticaCancelPrompt<Model> = createCancelPrompt({
+  const collection: AgenticaCancelPrompt<Model> = createCancelHistory({
     id: v4(),
     selections: [],
   });
@@ -137,7 +137,7 @@ async function step<Model extends ILlmSchema.Model>(ctx: AgenticaContext<Model>,
           ),
         },
         // PREVIOUS HISTORIES
-        ...ctx.histories.map(decodePrompt).flat(),
+        ...ctx.histories.map(decodeHistory).flat(),
         // USER INPUT
         {
           role: "user",
@@ -225,7 +225,7 @@ async function step<Model extends ILlmSchema.Model>(ctx: AgenticaContext<Model>,
           continue;
         }
 
-        const collection: AgenticaCancelPrompt<Model> = createCancelPrompt({
+        const collection: AgenticaCancelPrompt<Model> = createCancelHistory({
           id: tc.id,
           selections: [],
         });

package/src/orchestrate/describe.ts

@@ -2,18 +2,22 @@ import type { ILlmSchema } from "@samchon/openapi";
 import type OpenAI from "openai";
 
 import type { AgenticaContext } from "../context/AgenticaContext";
-import type { AgenticaDescribePrompt } from "../prompts/AgenticaDescribePrompt";
-import type { AgenticaExecutePrompt } from "../prompts/AgenticaExecutePrompt";
+import type { MicroAgenticaContext } from "../context/MicroAgenticaContext";
+import type { AgenticaDescribeHistory } from "../histories/AgenticaDescribeHistory";
+import type { AgenticaExecuteHistory } from "../histories/AgenticaExecuteHistory";
 
 import { AgenticaDefaultPrompt } from "../constants/AgenticaDefaultPrompt";
 import { AgenticaSystemPrompt } from "../constants/AgenticaSystemPrompt";
 import { createDescribeEvent } from "../factory/events";
-import { createDescribePrompt, decodePrompt } from "../factory/prompts";
+import { createDescribeHistory, decodeHistory } from "../factory/histories";
 import { ChatGptCompletionMessageUtil } from "../utils/ChatGptCompletionMessageUtil";
 import { MPSC } from "../utils/MPSC";
 import { StreamUtil } from "../utils/StreamUtil";
 
-export async function describe<Model extends ILlmSchema.Model>(ctx: AgenticaContext<Model>, histories: AgenticaExecutePrompt<Model>[]): Promise<AgenticaDescribePrompt<Model>[]> {
+export async function describe<Model extends ILlmSchema.Model>(
+  ctx: AgenticaContext<Model> | MicroAgenticaContext<Model>,
+  histories: AgenticaExecuteHistory<Model>[],
+): Promise<AgenticaDescribeHistory<Model>[]> {
   if (histories.length === 0) {
     return [];
   }
@@ -26,7 +30,7 @@ export async function describe<Model extends ILlmSchema.Model>(ctx: AgenticaCont
         content: AgenticaDefaultPrompt.write(ctx.config),
       } satisfies OpenAI.ChatCompletionSystemMessageParam,
       // FUNCTION CALLING HISTORIES
-      ...histories.map(decodePrompt).flat(),
+      ...histories.map(decodeHistory).flat(),
       // SYSTEM PROMPT
       {
         role: "system",
@@ -78,7 +82,7 @@ export async function describe<Model extends ILlmSchema.Model>(ctx: AgenticaCont
         };
         mpsc.produce(choice.delta.content);
 
-        void ctx.dispatch(
+        ctx.dispatch(
           createDescribeEvent({
             executes: histories,
             stream: mpsc.consumer,
@@ -89,7 +93,7 @@ export async function describe<Model extends ILlmSchema.Model>(ctx: AgenticaCont
               return describeContext[choice.index]!.content;
             },
           }),
-        );
+        ).catch(() => {});
       }
     };
 
@@ -105,7 +109,7 @@ export async function describe<Model extends ILlmSchema.Model>(ctx: AgenticaCont
   if (completion == null) {
     throw new Error("No completion received");
   }
-  const descriptions: AgenticaDescribePrompt<Model>[] = completion.choices
+  const descriptions: AgenticaDescribeHistory<Model>[] = completion.choices
     .map(choice =>
       choice.message.role === "assistant"
         ? choice.message.content
@@ -114,7 +118,7 @@ export async function describe<Model extends ILlmSchema.Model>(ctx: AgenticaCont
     .filter(str => str !== null)
     .map(
       content =>
-        createDescribePrompt({
+        createDescribeHistory({
           executes: histories,
           text: content,
         }),

package/src/orchestrate/execute.ts

@@ -1,8 +1,8 @@
 import type { ILlmSchema } from "@samchon/openapi";
 
 import type { AgenticaContext } from "../context/AgenticaContext";
-import type { AgenticaExecutePrompt } from "../prompts/AgenticaExecutePrompt";
-import type { AgenticaPrompt } from "../prompts/AgenticaPrompt";
+import type { AgenticaExecuteHistory } from "../histories/AgenticaExecuteHistory";
+import type { AgenticaHistory } from "../histories/AgenticaHistory";
 import type { IAgenticaExecutor } from "../structures/IAgenticaExecutor";
 
 import { call } from "./call";
@@ -13,8 +13,8 @@ import { cancelFunction } from "./internal/cancelFunction";
 import { select } from "./select";
 
 export function execute<Model extends ILlmSchema.Model>(executor: Partial<IAgenticaExecutor<Model>> | null) {
-  return async (ctx: AgenticaContext<Model>): Promise<AgenticaPrompt<Model>[]> => {
-    const histories: AgenticaPrompt<Model>[] = [];
+  return async (ctx: AgenticaContext<Model>): Promise<AgenticaHistory<Model>[]> => {
+    const histories: AgenticaHistory<Model>[] = [];
 
     // FUNCTIONS ARE NOT LISTED YET
     if (ctx.ready() === false) {
@@ -55,13 +55,13 @@ export function execute<Model extends ILlmSchema.Model>(executor: Partial<IAgent
     // FUNCTION CALLING LOOP
     while (true) {
       // EXECUTE FUNCTIONS
-      const prompts: AgenticaPrompt<Model>[] = await (
+      const prompts: AgenticaHistory<Model>[] = await (
         executor?.call ?? call
-      )(ctx);
+      )(ctx, ctx.stack.map(s => s.operation));
       histories.push(...prompts);
 
       // EXPLAIN RETURN VALUES
-      const executes: AgenticaExecutePrompt<Model>[] = prompts.filter(
+      const executes: AgenticaExecuteHistory<Model>[] = prompts.filter(
         prompt => prompt.type === "execute",
       );
       for (const e of executes) {

package/src/orchestrate/initialize.ts

@@ -5,12 +5,12 @@ import typia from "typia";
 
 import type { AgenticaContext } from "../context/AgenticaContext";
 import type { __IChatInitialApplication } from "../context/internal/__IChatInitialApplication";
-import type { AgenticaPrompt } from "../prompts/AgenticaPrompt";
+import type { AgenticaHistory } from "../histories/AgenticaHistory";
 
 import { AgenticaDefaultPrompt } from "../constants/AgenticaDefaultPrompt";
 import { AgenticaSystemPrompt } from "../constants/AgenticaSystemPrompt";
 import { createTextEvent } from "../factory/events";
-import { createTextPrompt, decodePrompt } from "../factory/prompts";
+import { createTextHistory, decodeHistory } from "../factory/histories";
 import { ChatGptCompletionMessageUtil } from "../utils/ChatGptCompletionMessageUtil";
 import { MPSC } from "../utils/MPSC";
 import { StreamUtil } from "../utils/StreamUtil";
@@ -20,7 +20,7 @@ const FUNCTION: ILlmFunction<"chatgpt"> = typia.llm.application<
   "chatgpt"
 >().functions[0]!;
 
-export async function initialize<Model extends ILlmSchema.Model>(ctx: AgenticaContext<Model>): Promise<AgenticaPrompt<Model>[]> {
+export async function initialize<Model extends ILlmSchema.Model>(ctx: AgenticaContext<Model>): Promise<AgenticaHistory<Model>[]> {
   // ----
   // EXECUTE CHATGPT API
   // ----
@@ -32,7 +32,7 @@ export async function initialize<Model extends ILlmSchema.Model>(ctx: AgenticaCo
           content: AgenticaDefaultPrompt.write(ctx.config),
         } satisfies OpenAI.ChatCompletionSystemMessageParam,
         // PREVIOUS HISTORIES
-        ...ctx.histories.map(decodePrompt).flat(),
+        ...ctx.histories.map(decodeHistory).flat(),
         // USER INPUT
         {
           role: "user",
@@ -106,7 +106,7 @@ export async function initialize<Model extends ILlmSchema.Model>(ctx: AgenticaCo
         };
         mpsc.produce(choice.delta.content);
 
-        void ctx.dispatch(
+        ctx.dispatch(
           createTextEvent({
             role: "assistant",
             stream: mpsc.consumer,
@@ -117,7 +117,7 @@ export async function initialize<Model extends ILlmSchema.Model>(ctx: AgenticaCo
               return textContext[choice.index]!.content;
             },
           }),
-        );
+        ).catch(() => {});
       }
     };
 
@@ -137,14 +137,14 @@ export async function initialize<Model extends ILlmSchema.Model>(ctx: AgenticaCo
   // ----
   // PROCESS COMPLETION
   // ----
-  const prompts: AgenticaPrompt<Model>[] = [];
+  const prompts: AgenticaHistory<Model>[] = [];
   for (const choice of completion.choices) {
     if (
       choice.message.role === "assistant"
       && choice.message.content != null
     ) {
       prompts.push(
-        createTextPrompt({
+        createTextHistory({
           role: "assistant",
           text: choice.message.content,
         }),

package/src/orchestrate/internal/selectFunction.ts

@@ -8,6 +8,9 @@ import type { __IChatFunctionReference } from "../../context/internal/__IChatFun
 import { createSelectEvent } from "../../factory/events";
 import { createOperationSelection } from "../../factory/operations";
 
+/**
+ * @internal
+ */
 export async function selectFunction<Model extends ILlmSchema.Model>(ctx: AgenticaContext<Model>, reference: __IChatFunctionReference): Promise<AgenticaOperation<Model> | null> {
   const operation: AgenticaOperation<Model> | undefined
       = ctx.operations.flat.get(reference.name);
@@ -21,10 +24,10 @@ export async function selectFunction<Model extends ILlmSchema.Model>(ctx: Agenti
         reason: reference.reason,
       });
   ctx.stack.push(selection);
-  void ctx.dispatch(
+  ctx.dispatch(
     createSelectEvent({
       selection,
     }),
-  );
+  ).catch(() => {});
   return operation;
 }