avantgate 1.2.2 → 1.4.0

package/dist/chunk-DTM2OLCG.mjs

@@ -0,0 +1,252 @@
+import {
+  StepSuspendedError,
+  createIsolatedTool
+} from "./chunk-5VA3EKPJ.mjs";
+
+// src/workflow/errors.ts
+var WorkflowSagaRollbackError = class extends Error {
+  workflowId;
+  failedStepId;
+  originalError;
+  compensatedSteps;
+  failedCompensations;
+  constructor(params) {
+    const errorDetails = params.originalError instanceof Error ? params.originalError.message : String(params.originalError);
+    super(
+      `\xC9chec de l'\xE9tape '${params.failedStepId}' dans le workflow '${params.workflowId}'. Rollback Saga ex\xE9cut\xE9 sur [${params.compensatedSteps.join(", ")}]. Cause initiale: ${errorDetails}`
+    );
+    this.name = "WorkflowSagaRollbackError";
+    this.workflowId = params.workflowId;
+    this.failedStepId = params.failedStepId;
+    this.originalError = params.originalError;
+    this.compensatedSteps = params.compensatedSteps;
+    this.failedCompensations = params.failedCompensations ?? [];
+  }
+};
+var WorkflowValidationError = class extends Error {
+  workflowId;
+  issues;
+  constructor(workflowId, issues) {
+    super(`Validation des entr\xE9es \xE9chou\xE9e pour le workflow '${workflowId}'.`);
+    this.name = "WorkflowValidationError";
+    this.workflowId = workflowId;
+    this.issues = issues;
+  }
+};
+
+// src/workflow/engine.ts
+function generateRunId(workflowId) {
+  const timestamp = Date.now();
+  const randomSuffix = Math.random().toString(36).substring(2, 9);
+  return `run_${workflowId}_${timestamp}_${randomSuffix}`;
+}
+function validateInput(config, input) {
+  const parseResult = config.inputSchema.safeParse(input);
+  if (!parseResult.success) {
+    throw new WorkflowValidationError(config.id, parseResult.error.issues);
+  }
+  return parseResult.data;
+}
+function createStepContext(params) {
+  const { workflowId, stepId, runId, context, stepResults } = params;
+  return {
+    workflowId,
+    stepId,
+    runId,
+    tenantId: context?.tenantId,
+    userId: context?.userId,
+    services: context?.services ?? {},
+    storage: context?.storage,
+    getStepResult: (id) => stepResults[id],
+    waitForApproval: async (options) => {
+      if (context?.storage) {
+        const existing = await context.storage.getStep(workflowId, stepId);
+        if (existing && existing.status === "COMPLETED") {
+          return existing.result ?? options?.defaultResult;
+        }
+        const now = (/* @__PURE__ */ new Date()).toISOString();
+        await context.storage.saveStep({
+          workflowId,
+          stepId,
+          runId,
+          status: "WAITING_APPROVAL",
+          metadata: options?.metadata,
+          createdAt: now,
+          updatedAt: now
+        });
+      }
+      throw new StepSuspendedError(stepId, workflowId, options?.prompt);
+    }
+  };
+}
+async function rollbackSaga(params) {
+  const {
+    workflowId,
+    failedStepId,
+    originalError,
+    completedSteps,
+    input,
+    runId,
+    context,
+    stepResults
+  } = params;
+  const compensatedSteps = [];
+  const failedCompensations = [];
+  for (let i = completedSteps.length - 1; i >= 0; i--) {
+    const { step, result } = completedSteps[i];
+    if (!step.compensate) {
+      continue;
+    }
+    const stepCtx = createStepContext({
+      workflowId,
+      stepId: step.id,
+      runId,
+      context,
+      stepResults
+    });
+    try {
+      await step.compensate(result, input, stepCtx);
+      compensatedSteps.push(step.id);
+      if (context?.storage) {
+        await context.storage.updateStepStatus(workflowId, step.id, "FAILED", {
+          metadata: { compensated: true }
+        });
+      }
+    } catch (compensationError) {
+      failedCompensations.push({ stepId: step.id, error: compensationError });
+    }
+  }
+  throw new WorkflowSagaRollbackError({
+    workflowId,
+    failedStepId,
+    originalError,
+    compensatedSteps,
+    failedCompensations
+  });
+}
+async function executeWorkflow(config, rawInput, context) {
+  const input = validateInput(config, rawInput);
+  const runId = context?.runId ?? generateRunId(config.id);
+  const stepResults = {};
+  const completedSteps = [];
+  for (const step of config.steps) {
+    const stepCtx = createStepContext({
+      workflowId: config.id,
+      stepId: step.id,
+      runId,
+      context,
+      stepResults
+    });
+    try {
+      const result = await step.execute(input, stepCtx);
+      stepResults[step.id] = result;
+      completedSteps.push({ step, result });
+      if (context?.storage) {
+        await context.storage.updateStepStatus(config.id, step.id, "COMPLETED", { result });
+      }
+    } catch (error) {
+      if (error instanceof StepSuspendedError) {
+        return {
+          workflowId: config.id,
+          runId,
+          status: "WAITING_APPROVAL",
+          stepResults
+        };
+      }
+      await rollbackSaga({
+        workflowId: config.id,
+        failedStepId: step.id,
+        originalError: error,
+        completedSteps,
+        input,
+        runId,
+        context,
+        stepResults
+      });
+    }
+  }
+  const finalOutput = config.outputDto ? config.outputDto(stepResults, input) : stepResults;
+  return {
+    workflowId: config.id,
+    runId,
+    status: "COMPLETED",
+    stepResults,
+    output: finalOutput
+  };
+}
+
+// src/workflow/define-workflow.ts
+function resolveWorkflowImpact(config, options) {
+  if (options?.impact) {
+    return options.impact;
+  }
+  return config.impact ?? "MUTATIVE";
+}
+function resolveRequireApproval(impact, options) {
+  if (options?.requireApproval !== void 0) {
+    return options.requireApproval;
+  }
+  return impact === "DESTRUCTIVE";
+}
+function buildToolExecutionContext(options, toolCtx) {
+  const tenantId = typeof toolCtx?.tenantId === "string" ? toolCtx.tenantId : options?.defaultContext?.tenantId;
+  const userId = typeof toolCtx?.userId === "string" ? toolCtx.userId : options?.defaultContext?.userId;
+  return {
+    tenantId,
+    userId,
+    services: options?.defaultContext?.services ?? {},
+    storage: options?.storage ?? options?.defaultContext?.storage
+  };
+}
+function defineWorkflow(config) {
+  const workflowImpact = config.impact ?? "MUTATIVE";
+  return {
+    id: config.id,
+    name: config.name,
+    description: config.description,
+    impact: workflowImpact,
+    roles: config.roles,
+    config,
+    execute: async (input, context) => {
+      return await executeWorkflow(config, input, context);
+    },
+    asTool: (options) => {
+      const impact = resolveWorkflowImpact(config, options);
+      const requireApproval = resolveRequireApproval(impact, options);
+      const tool = createIsolatedTool({
+        name: config.id,
+        description: config.description ?? config.name,
+        roles: config.roles,
+        impact,
+        requireApproval,
+        parameters: config.inputSchema,
+        invalidationTags: typeof config.invalidationTags === "function" ? async (args, res) => {
+          const resolver = config.invalidationTags;
+          return await resolver(args, res ?? {});
+        } : config.invalidationTags,
+        execute: async (args, toolCtx) => {
+          const executionContext = buildToolExecutionContext(options, toolCtx);
+          const result = await executeWorkflow(config, args, executionContext);
+          return result.output;
+        },
+        llmDto: (result) => result
+      });
+      Object.assign(tool, {
+        _isWorkflow: true,
+        workflowId: config.id,
+        workflowConfig: {
+          totalSteps: config.steps.length,
+          impact
+        }
+      });
+      return tool;
+    }
+  };
+}
+
+export {
+  WorkflowSagaRollbackError,
+  WorkflowValidationError,
+  executeWorkflow,
+  defineWorkflow
+};

package/dist/index.d.ts

@@ -6,4 +6,5 @@ export * from "./response-validator";
 export * from "./control-layer";
 export * from "./prompts";
 export * from "./providers/http-client";
+export * from "./workflow";
 //# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,SAAS,CAAC;AACxB,cAAc,WAAW,CAAC;AAC1B,cAAc,aAAa,CAAC;AAC5B,cAAc,eAAe,CAAC;AAC9B,cAAc,sBAAsB,CAAC;AACrC,cAAc,iBAAiB,CAAC;AAChC,cAAc,WAAW,CAAC;AAC1B,cAAc,yBAAyB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,SAAS,CAAC;AACxB,cAAc,WAAW,CAAC;AAC1B,cAAc,aAAa,CAAC;AAC5B,cAAc,eAAe,CAAC;AAC9B,cAAc,sBAAsB,CAAC;AACrC,cAAc,iBAAiB,CAAC;AAChC,cAAc,WAAW,CAAC;AAC1B,cAAc,yBAAyB,CAAC;AACxC,cAAc,YAAY,CAAC"}