completion-error-handler

Author: tripolskypetr

package-lock.json

@@ -1,6 +1,6 @@
 {
   "name": "agent-swarm-kit",
-  "version": "1.1.143",
+  "version": "1.1.144",
   "description": "A TypeScript library for building orchestrated framework-agnostic multi-agent AI systems",
   "author": {
     "name": "Petr Tripolsky",

package.json

@@ -2,3 +2,5 @@ import { Subject } from "functools-kit";
 import { SessionId } from "../interfaces/Session.interface";
 
 export const disposeSubject = new Subject<SessionId>();
+
+export const errorSubject = new Subject<[SessionId, Error]>();

src/config/emitters.ts

@@ -2,20 +2,23 @@ import { ICompletionSchema } from "../../interfaces/Completion.interface";
 import swarm from "../../lib";
 import { GLOBAL_CONFIG } from "../../config/params";
 import beginContext from "../../utils/beginContext";
+import mapCompletionSchema from "../../helpers/mapCompletionSchema";
 
 const METHOD_NAME = "function.setup.addCompletion";
 
 /**
  * Function implementation
  */
 const addCompletionInternal = beginContext(
-  (completionSchema: ICompletionSchema) => {
+  (completionPublicSchema: ICompletionSchema) => {
     // Log the operation details if logging is enabled in GLOBAL_CONFIG
     GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
       swarm.loggerService.log(METHOD_NAME, {
-        completionSchema,
+        completionSchema: completionPublicSchema,
       });
 
+    const completionSchema = mapCompletionSchema(completionPublicSchema);
+
     // Register the completion in the validation and schema services
     swarm.completionValidationService.addCompletion(
       completionSchema.completionName

src/functions/setup/addCompletion.ts

@@ -3,6 +3,7 @@ import { AgentName } from "../../interfaces/Agent.interface";
 import { GLOBAL_CONFIG } from "../../config/params";
 import swarm, { ExecutionContextService } from "../../lib";
 import beginContext from "../../utils/beginContext";
+import { errorSubject } from "../../config/emitters";
 
 const METHOD_NAME = "function.target.execute";
 
@@ -57,27 +58,45 @@ const executeInternal = beginContext(
             agentName,
             swarmName,
           });
-          const result = await swarm.sessionPublicService.execute(
+
+          let result = "";
+          let errorValue = null;
+
+          const unError = errorSubject.once(([errorClientId, error]) => {
+            if (clientId === errorClientId) {
+              errorValue = error;
+            }
+          });
+
+          result = await swarm.sessionPublicService.execute(
             content,
             "tool",
             METHOD_NAME,
             clientId,
             swarmName
           );
+
+          unError();
+
+          if (errorValue) {
+            throw errorValue;
+          }
+
           isFinished = swarm.perfService.endExecution(
             executionId,
             clientId,
             result.length
           );
-          swarm.busService.commitExecutionEnd(clientId, {
-            agentName,
-            swarmName,
-          });
+
           return result;
         } finally {
           if (!isFinished) {
             swarm.perfService.endExecution(executionId, clientId, 0);
           }
+          swarm.busService.commitExecutionEnd(clientId, {
+            agentName,
+            swarmName,
+          });
           swarm.executionValidationService.decrementCount(executionId, clientId, swarmName);
         }
       },

src/functions/target/execute.ts

@@ -12,6 +12,8 @@ import {
   IOutlineResult,
 } from "../../interfaces/Outline.interface";
 import { getErrorMessage, randomString } from "functools-kit";
+import { errorSubject } from "../../config/emitters";
+import { IModelMessage } from "../../model/ModelMessage.model";
 
 const METHOD_NAME = "function.target.json";
 
@@ -79,6 +81,7 @@ const jsonInternal = beginContext(
     swarm.outlineValidationService.validate(outlineName, METHOD_NAME);
 
     const resultId = randomString();
+    const clientId = `${resultId}_outline`;
 
     const {
       getOutlineHistory,
@@ -146,12 +149,29 @@ const jsonInternal = beginContext(
       await getOutlineHistory(inputArgs);
       const messages = await history.list();
       try {
-        const output = await getCompletion({
+        let output: IModelMessage | IOutlineMessage;
+        let errorValue = null;
+
+        const unError = errorSubject.once(([errorClientId, error]) => {
+          if (clientId === errorClientId) {
+            errorValue = error;
+          }
+        });
+
+        output = await getCompletion({
+          clientId,
           messages: await history.list(),
           mode: "tool",
           outlineName,
           format,
         });
+
+        unError();
+
+        if (errorValue) {
+          throw errorValue;
+        }
+
         if (completionCallbacks?.onComplete) {
           completionCallbacks.onComplete(
             {
@@ -189,11 +209,14 @@ const jsonInternal = beginContext(
         return result;
       } catch (error) {
         errorMessage = getErrorMessage(error);
-        console.error(`agent-swarm outline error outlineName=${outlineName} attempt=${attempt}`, {
-          param,
-          lastData,
-          errorMessage,
-        })
+        console.error(
+          `agent-swarm outline error outlineName=${outlineName} attempt=${attempt}`,
+          {
+            param,
+            lastData,
+            errorMessage,
+          }
+        );
       }
     }
     const result = {

src/functions/target/json.ts

@@ -2,7 +2,7 @@ import { ICompletionSchema } from "../../interfaces/Completion.interface";
 import swarm from "../../lib";
 import { GLOBAL_CONFIG } from "../../config/params";
 import beginContext from "../../utils/beginContext";
-import removeUndefined from "../../helpers/removeUndefined";
+import mapCompletionSchema from "../../helpers/mapCompletionSchema";
 
 const METHOD_NAME = "function.test.overrideCompletion";
 
@@ -20,7 +20,7 @@ const overrideCompletionInternal = beginContext(
         completionSchema: publicCompletionSchema,
       });
 
-    const completionSchema = removeUndefined(publicCompletionSchema);
+    const completionSchema = mapCompletionSchema(publicCompletionSchema);
 
     return swarm.completionSchemaService.override(
       completionSchema.completionName,

src/functions/test/overrideCompletion.ts

@@ -0,0 +1,59 @@
+import { ICompletionSchema } from "../interfaces/Completion.interface";
+import removeUndefined from "./removeUndefined";
+import { errorSubject } from "../config/emitters";
+
+type TCompletionSchema = {
+  completionName: ICompletionSchema["completionName"];
+} & Partial<ICompletionSchema>;
+
+/**
+ * Maps a completion schema by wrapping its `getCompletion` method with error handling.
+ * If an error occurs during the execution of `getCompletion`, it emits the error using `errorSubject`.
+ * Also removes any undefined properties from the resulting schema object.
+ *
+ * @param {ICompletionSchema} param0 - The completion schema object containing a `getCompletion` function and other properties.
+ * @returns {ICompletionSchema} - The new completion schema with error-handled `getCompletion` and no undefined properties.
+ */
+export const mapCompletionSchema = ({
+  getCompletion,
+  ...schema
+}: TCompletionSchema): ICompletionSchema =>
+  removeUndefined({
+    ...schema,
+    getCompletion: getCompletion
+      ? async ({
+          mode,
+          messages,
+          agentName,
+          clientId,
+          format,
+          outlineName,
+          tools,
+        }) => {
+          const params = {
+            mode,
+            messages,
+            agentName,
+            clientId,
+            format,
+            outlineName,
+            tools,
+          };
+          try {
+            return await getCompletion(params);
+          } catch (error) {
+            if (clientId) {
+              errorSubject.next([clientId, error]);
+            }
+            return {
+              agentName,
+              content: "",
+              mode,
+              role: "assistant",
+            };
+          }
+        }
+      : undefined,
+  });
+
+export default mapCompletionSchema;