@botpress/runtime 1.3.3 → 1.3.5

package/dist/definition.js

@@ -48,7 +48,7 @@ var init_define_BUILD = __esm({
 var define_PACKAGE_VERSIONS_default;
 var init_define_PACKAGE_VERSIONS = __esm({
   "<define:__PACKAGE_VERSIONS__>"() {
-    define_PACKAGE_VERSIONS_default = { runtime: "1.3.3", adk: "not-installed", sdk: "4.17.0", llmz: "0.0.26", zai: "2.1.16", cognitive: "0.1.47" };
+    define_PACKAGE_VERSIONS_default = { runtime: "1.3.5", adk: "not-installed", sdk: "4.17.0", llmz: "0.0.26", zai: "2.1.16", cognitive: "0.1.47" };
   }
 });
 
@@ -39770,6 +39770,7 @@ var WellKnownMetadata = {
 
 // src/runtime/autonomous.ts
 var import_lodash2 = __toESM(require_lodash(), 1);
+import { AsyncResource } from "node:async_hooks";
 var Autonomous;
 ((Autonomous2) => {
   Autonomous2.Tool = LlmzTool;
@@ -39888,7 +39889,7 @@ If the question is not related to the knowledge bases, do NOT use this tool.`.tr
             options.interruption
           ]);
           const llmz_execute = (await import("llmz")).execute;
-          const originalContext = context2.getAll();
+          const asyncResource = new AsyncResource("autonomous.execution");
           const getNewIteration = (index) => createSpan(
             "autonomous.iteration",
             {
@@ -39946,32 +39947,27 @@ Always prefer information from the knowledge bases over general knowledge when a
               });
               return instructions;
             },
-            ...(props.tools || props.knowledge) && {
-              tools: async (ctx) => {
-                const tools = props.tools ? await getValue(props.tools, ctx) : [];
-                const allTools = [...tools ?? []];
-                if (search_knowledge) {
-                  allTools.push(search_knowledge);
-                }
+            ...props.objects && {
+              objects: async (ctx) => {
+                const objs = await getValue(props.objects, ctx) ?? [];
                 iterationSpan?.setAttribute(
-                  "autonomous.tools",
-                  allTools?.map((t) => t.name).join(", ")
+                  "autonomous.objects",
+                  objs.map((o) => o.name).join(", ")
                 );
-                return allTools.map(
-                  (tool) => tool.clone({
-                    handler: (args, ctx2) => {
-                      context2.enterWith(originalContext);
-                      return context2.run(originalContext, () => {
+                for (const obj of objs) {
+                  obj.tools = obj.tools?.map(
+                    (tool) => tool.clone({
+                      handler: asyncResource.bind((args, ctx2) => {
                         let err = null;
                         const result = span(
                           "autonomous.tool",
                           {
+                            "autonomous.tool.object": obj.name,
                             "autonomous.tool.name": tool.name,
                             "autonomous.tool.input": args
                           },
                           async (s) => {
-                            context2.enterWith(originalContext);
-                            const value = await tool.execute(args, ctx2).catch((e) => {
+                            const value = tool.execute(args, ctx2).catch((e) => {
                               err = e;
                               if (err && err?.constructor && err?.constructor?.name && err?.constructor?.name === "ThinkSignal") {
                                 s.setAttributes({
@@ -40007,25 +40003,92 @@ Always prefer information from the knowledge bases over general knowledge when a
                           throw err;
                         }
                         return result;
-                      });
-                    }
+                      })
+                    })
+                  ) ?? [];
+                }
+                return objs;
+              }
+            },
+            ...(props.tools || props.knowledge) && {
+              tools: async (ctx) => {
+                const tools = props.tools ? await getValue(props.tools, ctx) : [];
+                const allTools = [...tools ?? []];
+                if (search_knowledge) {
+                  allTools.push(search_knowledge);
+                }
+                iterationSpan?.setAttribute(
+                  "autonomous.tools",
+                  allTools?.map((t) => t.name).join(", ")
+                );
+                return allTools.map(
+                  (tool) => tool.clone({
+                    handler: asyncResource.bind((args, ctx2) => {
+                      let err = null;
+                      const result = span(
+                        "autonomous.tool",
+                        {
+                          "autonomous.tool.name": tool.name,
+                          "autonomous.tool.input": args
+                        },
+                        async (s) => {
+                          const value = tool.execute(args, ctx2).catch((e) => {
+                            err = e;
+                            if (err && err?.constructor && err?.constructor?.name && err?.constructor?.name === "ThinkSignal") {
+                              s.setAttributes({
+                                "autonomous.tool.status": "think"
+                              });
+                              s.setStatus({
+                                code: SpanStatusCode.UNSET,
+                                message: "ThinkSignal"
+                              });
+                              err[HandledErrorProp] = true;
+                              throw err;
+                            } else {
+                              s.setAttributes({
+                                "autonomous.tool.status": "error",
+                                "autonomous.tool.error": err.message
+                              });
+                              s.setStatus({
+                                code: SpanStatusCode.ERROR,
+                                message: err.message
+                              });
+                              s.recordException(err);
+                              throw err;
+                            }
+                          });
+                          s.setAttributes({
+                            "autonomous.tool.output": value,
+                            "autonomous.tool.status": "success"
+                          });
+                          return value;
+                        }
+                      );
+                      if (err) {
+                        throw err;
+                      }
+                      return result;
+                    })
                   })
                 );
               }
             },
-            ...props.objects && { objects: props.objects },
             ...props.exits && { exits: props.exits },
             ...joinedSignal && { signal: joinedSignal },
             ...props.hooks?.onBeforeTool && {
-              onBeforeTool: props.hooks.onBeforeTool
+              onBeforeTool: asyncResource.bind(props.hooks.onBeforeTool)
             },
             ...props.hooks?.onAfterTool && {
-              onAfterTool: props.hooks.onAfterTool
+              onAfterTool: asyncResource.bind(props.hooks.onAfterTool)
             },
             ...props.hooks?.onBeforeExecution && {
-              onBeforeExecution: props.hooks.onBeforeExecution
+              onBeforeExecution: asyncResource.bind(
+                props.hooks.onBeforeExecution
+              )
+            },
+            ...props.hooks?.onExit && {
+              onExit: asyncResource.bind(props.hooks.onExit)
             },
-            ...props.hooks?.onExit && { onExit: props.hooks.onExit },
             onTrace: ({ trace: trace2, iteration }) => {
               if (trace2.type === "code_execution") {
               } else if (trace2.type === "llm_call_started") {
@@ -40039,7 +40102,11 @@ Always prefer information from the knowledge bases over general knowledge when a
                   "property.value": trace2.value
                 });
               }
-              props.hooks?.onTrace?.({ trace: trace2, iteration });
+              if (props.hooks?.onTrace) {
+                return asyncResource.runInAsyncScope(
+                  () => props.hooks.onTrace({ trace: trace2, iteration })
+                );
+              }
             },
             onIterationEnd: async (iteration, controller) => {
               iterationSpan?.setAttributes({
@@ -40087,8 +40154,11 @@ ${iteration.status.execution_error.stack}`;
                 });
               }
               iterationSpan?.end();
-              contextManager.enterWith(execSpan.ctx);
-              await props.hooks?.onIterationEnd?.(iteration, controller);
+              if (props.hooks?.onIterationEnd) {
+                return await asyncResource.runInAsyncScope(
+                  () => props.hooks.onIterationEnd(iteration, controller)
+                );
+              }
             }
           });
           execSpan.setAttribute(
@@ -45202,6 +45272,12 @@ var AutonomousToolSpan = {
   name: "autonomous.tool",
   importance: "high",
   attributes: {
+    "autonomous.tool.object": {
+      type: "string",
+      title: "Object Name",
+      description: "The name of the object being used",
+      required: false
+    },
     "autonomous.tool.name": {
       type: "string",
       title: "Tool Name",