@mettlelabs/mettle 0.0.0-beta.2-linux-arm64 → 0.0.0-beta.2

package/harness/chunk-56csr8sw.mjs

@@ -1,322 +0,0 @@
-import"./chunk-z6n9thea.mjs";
-import"./chunk-3wvjs93w.mjs";
-import"./chunk-c1631s2x.mjs";
-import"./chunk-50sbrf09.mjs";
-import {
-  resolveSuspendedToolRunId
-} from "./chunk-3m7jn5ac.mjs";
-import {
-  BACKGROUND_TASK_WORKFLOW_ID
-} from "./chunk-6kgqw9ny.mjs";
-import {
-  createStep$1,
-  createWorkflow
-} from "./chunk-ageqxj9v.mjs";
-import {
-  string,
-  boolean,
-  any,
-  unknown,
-  object,
-  _enum
-} from "./chunk-1sygmp11.mjs";
-
-// node_modules/.bun/@mastra+core@1.71.0+95d98e20cbc6e6e1/node_modules/@mastra/core/dist/workflow-DLhRNxEW.js
-var inputSchema = object({ taskId: string() });
-var attemptOutcomeSchema = _enum([
-  "success",
-  "retry",
-  "failed",
-  "cancelled",
-  "timed_out"
-]);
-var attemptOutputSchema = object({
-  taskId: string(),
-  outcome: attemptOutcomeSchema,
-  result: unknown().optional(),
-  error: any().optional()
-});
-var bodyIOSchema = object({
-  taskId: string(),
-  done: boolean().optional(),
-  result: unknown().optional()
-});
-var bodyOutputSchema = object({
-  taskId: string(),
-  done: boolean(),
-  result: unknown().optional()
-});
-var WORKFLOW_STATUS_TO_PERSIST = [
-  "suspended",
-  "pending",
-  "paused",
-  "waiting"
-];
-function buildBackgroundTaskWorkflow(manager) {
-  const runAttemptStep = createStep$1({
-    id: "run-attempt",
-    inputSchema: bodyIOSchema,
-    outputSchema: attemptOutputSchema,
-    execute: async ({ inputData, abortSignal: workflowAbortSignal, suspend, resumeData, suspendData }) => {
-      const { taskId } = inputData;
-      const storage = await manager.getStorage();
-      const task = await storage.getTask(taskId);
-      if (!task || task.status === "cancelled") {
-        manager.deregisterTaskContext(taskId);
-        return {
-          taskId,
-          outcome: "cancelled"
-        };
-      }
-      const executor = manager.taskContexts.get(taskId)?.executor ?? (task.agentId ? manager.getStaticExecutor(`${task.agentId}:${task.toolName}`) : undefined) ?? manager.getStaticExecutor(task.toolName);
-      if (!executor) {
-        const errorInfo = { message: `No executor registered for tool "${task.toolName}". Register the tool on Mastra (so workers can resolve it cross-process) or run the task in the same process as the producer.` };
-        await storage.updateTask(taskId, {
-          status: "failed",
-          error: errorInfo,
-          completedAt: /* @__PURE__ */ new Date
-        });
-        const failedTask = await storage.getTask(taskId);
-        if (failedTask) {
-          await manager.runLocalCompletionHooks(failedTask, "failed", { error: errorInfo });
-          await manager.publishLifecycleEvent("task.failed", failedTask);
-        }
-        manager.deregisterTaskContext(taskId);
-        throw new Error(errorInfo.message);
-      }
-      const progressThrottleMs = manager.config.progressThrottleMs;
-      const shouldThrottleProgress = typeof progressThrottleMs === "number" && Number.isFinite(progressThrottleMs) && progressThrottleMs > 0;
-      let lastProgressEmitMs;
-      const onProgress = async (chunk) => {
-        if (shouldThrottleProgress) {
-          const now = Date.now();
-          if (lastProgressEmitMs !== undefined && now - lastProgressEmitMs < progressThrottleMs)
-            return;
-          lastProgressEmitMs = now;
-        }
-        await manager.publishLifecycleEvent("task.output", {
-          ...task,
-          chunk
-        });
-      };
-      const abortController = new AbortController;
-      if (!manager.registerActiveAbortController(taskId, abortController)) {
-        manager.deregisterTaskContext(taskId);
-        return {
-          taskId,
-          outcome: "cancelled"
-        };
-      }
-      const onWorkflowAbort = () => abortController.abort(/* @__PURE__ */ new Error("Task cancelled"));
-      if (workflowAbortSignal.aborted)
-        abortController.abort(/* @__PURE__ */ new Error("Task cancelled"));
-      else
-        workflowAbortSignal.addEventListener("abort", onWorkflowAbort, { once: true });
-      const timeoutHandle = setTimeout(() => {
-        abortController.abort(/* @__PURE__ */ new Error(`Task timed out after ${task.timeoutMs}ms`));
-      }, task.timeoutMs);
-      let pendingSuspend;
-      const wrappedSuspend = async (data, suspendOptions) => {
-        await storage.updateTask(taskId, {
-          status: "suspended",
-          suspendPayload: data,
-          suspendedAt: /* @__PURE__ */ new Date
-        });
-        const suspendedTask = await storage.getTask(taskId);
-        if (suspendedTask) {
-          await manager.runLocalSuspendHooks(suspendedTask);
-          await manager.publishLifecycleEvent("task.suspended", suspendedTask);
-        }
-        pendingSuspend = {
-          data,
-          suspendOptions
-        };
-      };
-      try {
-        const args = { ...task.args };
-        delete args.suspendedToolRunId;
-        const suspendedToolRunId = resolveSuspendedToolRunId(suspendData?.suspendedToolRunId);
-        if (resumeData !== undefined && suspendedToolRunId)
-          args.suspendedToolRunId = suspendedToolRunId;
-        const result = await executor.execute(args, {
-          abortSignal: abortController.signal,
-          onProgress,
-          suspend: wrappedSuspend,
-          resumeData,
-          suspendedToolRunId: resumeData !== undefined ? suspendedToolRunId : undefined
-        });
-        if (pendingSuspend) {
-          const opts = pendingSuspend.suspendOptions;
-          const agentRunId = opts?.isAgentSuspend && typeof opts.runId === "string" ? opts.runId : undefined;
-          return suspend(!agentRunId ? pendingSuspend.data : pendingSuspend.data && typeof pendingSuspend.data === "object" ? {
-            ...pendingSuspend.data,
-            suspendedToolRunId: agentRunId
-          } : { suspendedToolRunId: agentRunId }, opts);
-        }
-        return {
-          taskId,
-          outcome: "success",
-          result
-        };
-      } catch (error) {
-        const currentTask = await storage.getTask(taskId);
-        if (!currentTask || currentTask.status === "cancelled") {
-          manager.deregisterTaskContext(taskId);
-          return {
-            taskId,
-            outcome: "cancelled"
-          };
-        }
-        if (manager.isShuttingDown()) {
-          manager.deregisterTaskContext(taskId);
-          return {
-            taskId,
-            outcome: "cancelled"
-          };
-        }
-        if (abortController.signal.aborted || error?.name === "AbortError" || error?.message === "Task cancelled" || error?.message?.startsWith("Task timed out after "))
-          return {
-            taskId,
-            outcome: "timed_out"
-          };
-        if (error?.name === "FGADeniedError")
-          return {
-            taskId,
-            outcome: "failed",
-            error: {
-              name: error.name,
-              message: error?.message ?? "Authorization denied",
-              stack: error?.stack
-            }
-          };
-        return {
-          taskId,
-          outcome: "retry",
-          error: {
-            message: error?.message ?? "Unknown error",
-            stack: error?.stack
-          }
-        };
-      } finally {
-        clearTimeout(timeoutHandle);
-        workflowAbortSignal.removeEventListener("abort", onWorkflowAbort);
-        manager.activeAbortControllers.delete(taskId);
-      }
-    }
-  });
-  const classifyOutcomeStep = createStep$1({
-    id: "classify-outcome",
-    inputSchema: attemptOutputSchema,
-    outputSchema: bodyOutputSchema,
-    execute: async ({ inputData }) => {
-      const { taskId, outcome, result, error } = inputData;
-      const storage = await manager.getStorage();
-      const task = await storage.getTask(taskId);
-      if (!task)
-        return {
-          taskId,
-          done: true
-        };
-      if (outcome === "cancelled") {
-        manager.deregisterTaskContext(taskId);
-        return {
-          taskId,
-          done: true
-        };
-      }
-      if (outcome === "timed_out") {
-        const status = task.status;
-        if (status !== "timed_out" && status !== "cancelled") {
-          await storage.updateTask(taskId, {
-            status: "timed_out",
-            error: { message: `Task timed out after ${task.timeoutMs}ms` },
-            completedAt: /* @__PURE__ */ new Date
-          });
-          const timedOutTask = await storage.getTask(taskId);
-          if (timedOutTask)
-            await manager.publishLifecycleEvent("task.failed", timedOutTask);
-        }
-        return {
-          taskId,
-          done: true
-        };
-      }
-      if (outcome === "success") {
-        if (task.status === "cancelled") {
-          manager.deregisterTaskContext(taskId);
-          return {
-            taskId,
-            done: true
-          };
-        }
-        await storage.updateTask(taskId, {
-          status: "completed",
-          result,
-          completedAt: /* @__PURE__ */ new Date
-        });
-        const completedTask = await storage.getTask(taskId);
-        if (completedTask) {
-          await manager.runLocalCompletionHooks(completedTask, "completed", { result });
-          await manager.publishLifecycleEvent("task.completed", completedTask);
-        }
-        return {
-          taskId,
-          done: true,
-          result
-        };
-      }
-      if (outcome === "retry" && task.retryCount < task.maxRetries) {
-        await storage.updateTask(taskId, {
-          retryCount: task.retryCount + 1,
-          error: undefined,
-          startedAt: /* @__PURE__ */ new Date
-        });
-        return {
-          taskId,
-          done: false
-        };
-      }
-      const errorInfo = error ?? { message: "Unknown error" };
-      await storage.updateTask(taskId, {
-        status: "failed",
-        error: errorInfo,
-        completedAt: /* @__PURE__ */ new Date
-      });
-      const failedTask = await storage.getTask(taskId);
-      if (failedTask) {
-        await manager.runLocalCompletionHooks(failedTask, "failed", { error: errorInfo });
-        await manager.publishLifecycleEvent("task.failed", failedTask);
-      }
-      const thrown = new Error(errorInfo.message);
-      if (errorInfo.name)
-        thrown.name = errorInfo.name;
-      if (errorInfo.stack)
-        thrown.stack = errorInfo.stack;
-      throw thrown;
-    }
-  });
-  const attemptBodyWorkflow = createWorkflow({
-    id: `${BACKGROUND_TASK_WORKFLOW_ID}__attempt`,
-    inputSchema: bodyIOSchema,
-    outputSchema: bodyOutputSchema,
-    steps: [runAttemptStep, classifyOutcomeStep],
-    options: {
-      validateInputs: false,
-      shouldPersistSnapshot: ({ workflowStatus }) => WORKFLOW_STATUS_TO_PERSIST.includes(workflowStatus),
-      tracingPolicy: { internal: 1 }
-    }
-  }).then(runAttemptStep).then(classifyOutcomeStep).commit();
-  return createWorkflow({
-    id: BACKGROUND_TASK_WORKFLOW_ID,
-    inputSchema,
-    outputSchema: bodyOutputSchema,
-    steps: [attemptBodyWorkflow],
-    options: {
-      shouldPersistSnapshot: ({ workflowStatus }) => WORKFLOW_STATUS_TO_PERSIST.includes(workflowStatus),
-      tracingPolicy: { internal: 1 }
-    }
-  }).dountil(attemptBodyWorkflow, async ({ inputData }) => inputData?.done === true).commit();
-}
-export {
-  buildBackgroundTaskWorkflow
-};