@caretakerai/agent 0.0.35 → 0.0.37

package/dist/activities/activity.js

@@ -22,9 +22,24 @@ function stringify(activities, transformers) {
         }
         const message = transformer.stringify(activity);
         const lastMessage = messages.at(-1);
+        // Convert string content MessageContentComplex array of text messages to allow mixing text and other message types
+        if (typeof message.content === 'string') {
+            message.content = [{
+                    type: 'text',
+                    text: message.content
+                }];
+        }
         // Combine with previous message if same role
         if (lastMessage?.role === message.role) {
-            lastMessage.content = `${lastMessage.content}${exports.ACTIVITY_SEP}${message.content}`;
+            const lastMessageContent = lastMessage.content;
+            const messageContent = message.content;
+            // If both messages are text, combine them with ACTIVITY_SEP
+            if (lastMessageContent[0].type === 'text' && messageContent[0].type === 'text') {
+                lastMessageContent[0].text = `${lastMessageContent[0].text}${exports.ACTIVITY_SEP}${messageContent[0].text}`;
+            }
+            else {
+                lastMessage.content = [...lastMessageContent, ...messageContent];
+            }
             return messages;
         }
         // Otherwise add as new message

package/dist/agent.js

@@ -165,61 +165,97 @@ class Agent {
             history = await transformer.transform(history);
         }
         for (let i = 0; i < this.maxRetries; ++i) {
-            const inputHistory = [...history, ...outputHistory];
-            // Action activities should be executed to produce Observation before next LLM iteration
-            if (inputHistory.at(-1)?.kind !== activity_1.ActivityKind.Action) {
+            const combinedHistory = [...history, ...outputHistory];
+            // Find the latest action and observation indices
+            const latestActionIndex = combinedHistory.findLastIndex(activity => activity.kind === activity_1.ActivityKind.Action);
+            const latestObservationIndex = combinedHistory.findLastIndex(activity => activity.kind === activity_1.ActivityKind.Observation);
+            // Execute action if latest action has later index than latest observation
+            if (latestActionIndex > latestObservationIndex) {
                 try {
-                    let newActivities = await this.transform(inputHistory);
-                    // Apply output transformers to generated activities
-                    for (const transformer of this.outputTransformers) {
-                        newActivities = await transformer.transform(newActivities);
+                    // Get action source
+                    const { input: source } = combinedHistory[latestActionIndex];
+                    // Prefer custom executor is specified
+                    const result = this.executor
+                        ? await this.executor(source)
+                        : await (0, graphql_1.graphql)({ schema: this.schema, source });
+                    // Add new observation to the iteration history
+                    outputHistory.push({
+                        kind: activity_1.ActivityKind.Observation,
+                        input: (0, yaml_1.stringify)(result),
+                    });
+                    if (result.errors) {
+                        retryErrors.push(...result.errors);
+                        continue;
                     }
-                    outputHistory.push(...newActivities);
+                    // Continue to next iteration to check for more actions or generate new activities
+                    continue;
                 }
                 catch (e) {
                     const err = e;
-                    this.logger.warn(err.message);
+                    outputHistory.push({
+                        kind: activity_1.ActivityKind.Observation,
+                        input: err.toString(),
+                    });
+                    const message = `Retry ${i + 1} due to action error: ${err}`;
+                    this.logger.debug(message);
                     retryErrors.push(err);
-                    this.logger.debug(`Retry ${i + 1} due to malformed output: ${err.message}`);
                     continue;
                 }
             }
-            // Skip action execution if last activity is not an action
-            if ([...inputHistory, ...outputHistory].at(-1)?.kind !== activity_1.ActivityKind.Action) {
-                return;
-            }
-            // Execute action
+            // Generate new activities if no action needs execution
+            const inputHistory = [...history, ...outputHistory];
             try {
-                // Get action source
-                const { input: source } = [...inputHistory, ...outputHistory].at(-1);
-                // Prefer custom executor is specified
-                const result = this.executor
-                    ? await this.executor(source)
-                    : await (0, graphql_1.graphql)({ schema: this.schema, source });
-                // Add new observation to the iteration history
-                outputHistory.push({
-                    kind: activity_1.ActivityKind.Observation,
-                    input: (0, yaml_1.stringify)(result),
-                });
-                if (result.errors) {
-                    retryErrors.push(...result.errors);
-                    continue;
+                let newActivities = await this.transform(inputHistory);
+                // Apply output transformers to generated activities
+                for (const transformer of this.outputTransformers) {
+                    newActivities = await transformer.transform(newActivities);
+                }
+                outputHistory.push(...newActivities);
+                // Execute all actions generated in newActivities regardless of index
+                const actionsToExecute = newActivities.filter(activity => activity.kind === activity_1.ActivityKind.Action);
+                for (const action of actionsToExecute) {
+                    try {
+                        // Prefer custom executor is specified
+                        const result = this.executor
+                            ? await this.executor(action.input)
+                            : await (0, graphql_1.graphql)({ schema: this.schema, source: action.input });
+                        // Add new observation to the iteration history
+                        outputHistory.push({
+                            kind: activity_1.ActivityKind.Observation,
+                            input: (0, yaml_1.stringify)(result),
+                        });
+                        if (result.errors) {
+                            retryErrors.push(...result.errors);
+                            break; // Stop executing further actions if one has errors
+                        }
+                    }
+                    catch (e) {
+                        const err = e;
+                        outputHistory.push({
+                            kind: activity_1.ActivityKind.Observation,
+                            input: err.toString(),
+                        });
+                        const message = `Retry ${i + 1} due to action error: ${err}`;
+                        this.logger.debug(message);
+                        retryErrors.push(err);
+                        break; // Stop executing further actions if one has errors
+                    }
                 }
-                // Add iteration activities to the agent history and finish iteration
-                this.addActivities(...outputHistory);
-                return;
             }
             catch (e) {
                 const err = e;
-                outputHistory.push({
-                    kind: activity_1.ActivityKind.Observation,
-                    input: err.toString(),
-                });
-                const message = `Retry ${i + 1} due to action error: ${err}`;
-                this.logger.debug(message);
+                this.logger.warn(err.message);
                 retryErrors.push(err);
+                this.logger.debug(`Retry ${i + 1} due to malformed output: ${err.message}`);
                 continue;
             }
+            // If no action needs execution and last activity is not an action, finish iteration
+            const finalHistory = [...history, ...outputHistory];
+            if (finalHistory.at(-1)?.kind !== activity_1.ActivityKind.Action) {
+                // Add iteration activities to the agent history and finish iteration
+                this.addActivities(...outputHistory);
+                return;
+            }
         }
         throw new AgentRetryError('Max number of retries reached.', retryErrors);
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@caretakerai/agent",
-  "version": "0.0.35",
+  "version": "0.0.37",
   "description": "Single framework for building text-agents",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",