@io-orkes/conductor-javascript 3.0.0 → 3.0.2

package/dist/index.mjs

@@ -39160,7 +39160,7 @@ var defaultRunnerOptions = {
   concurrency: DEFAULT_CONCURRENCY,
   batchPollingTimeout: DEFAULT_BATCH_POLLING_TIMEOUT
 };
-var TaskRunner = class {
+var TaskRunner = class _TaskRunner {
   _client;
   worker;
   logger;
@@ -39285,21 +39285,94 @@ var TaskRunner = class {
       throw error;
     }
   };
+  /**
+   * Probed once per process. null = unknown, true = v2 endpoint available,
+   * false = legacy server (no /api/tasks/update-v2 endpoint).
+   */
+  static updateV2Available = null;
   updateTaskWithRetry = async (task, taskResult) => {
     const { workerID } = this.options;
     let retryCount = 0;
     let lastError = null;
     while (retryCount < this.maxRetries) {
       try {
+        if (process.env.CI) {
+          console.log(
+            `[TaskRunner] Submitting task result taskId=${taskResult.taskId} workflowId=${taskResult.workflowInstanceId} taskType=${this.worker.taskDefName} attempt=${retryCount + 1}/${this.maxRetries}`
+          );
+        }
         const updateStart = Date.now();
-        const { data: nextTask } = await TaskResource.updateTaskV2({
-          client: this._client,
-          body: {
-            ...taskResult,
-            workerId: workerID
+        if (_TaskRunner.updateV2Available === false) {
+          await TaskResource.updateTask({
+            client: this._client,
+            body: { ...taskResult, workerId: workerID },
+            throwOnError: true
+          });
+          const updateDurationMs2 = Date.now() - updateStart;
+          if (process.env.CI) {
+            console.log(
+              `[TaskRunner] Task result accepted (legacy) taskId=${taskResult.taskId} durationMs=${updateDurationMs2}`
+            );
           }
+          await this.eventDispatcher.publishTaskUpdateCompleted({
+            taskType: this.worker.taskDefName,
+            taskId: taskResult.taskId ?? "",
+            workerId: workerID,
+            workflowInstanceId: taskResult.workflowInstanceId,
+            durationMs: updateDurationMs2,
+            timestamp: /* @__PURE__ */ new Date()
+          });
+          return void 0;
+        }
+        const {
+          data: nextTask,
+          error,
+          response
+        } = await TaskResource.updateTaskV2({
+          client: this._client,
+          body: { ...taskResult, workerId: workerID },
+          throwOnError: false
         });
+        if (response.status === 404 || response.status === 405) {
+          if (_TaskRunner.updateV2Available === null) {
+            console.log(
+              `[TaskRunner] /api/tasks/update-v2 not available (HTTP ${response.status}), falling back to legacy /api/tasks endpoint`
+            );
+            _TaskRunner.updateV2Available = false;
+          }
+          await TaskResource.updateTask({
+            client: this._client,
+            body: { ...taskResult, workerId: workerID },
+            throwOnError: true
+          });
+          const updateDurationMs2 = Date.now() - updateStart;
+          if (process.env.CI) {
+            console.log(
+              `[TaskRunner] Task result accepted (legacy) taskId=${taskResult.taskId} durationMs=${updateDurationMs2}`
+            );
+          }
+          await this.eventDispatcher.publishTaskUpdateCompleted({
+            taskType: this.worker.taskDefName,
+            taskId: taskResult.taskId ?? "",
+            workerId: workerID,
+            workflowInstanceId: taskResult.workflowInstanceId,
+            durationMs: updateDurationMs2,
+            timestamp: /* @__PURE__ */ new Date()
+          });
+          return void 0;
+        }
+        if (!response.ok) {
+          throw error ?? new Error(`Task update failed with HTTP ${response.status}`);
+        }
+        if (_TaskRunner.updateV2Available === null) {
+          _TaskRunner.updateV2Available = true;
+        }
         const updateDurationMs = Date.now() - updateStart;
+        if (process.env.CI) {
+          console.log(
+            `[TaskRunner] Task result accepted taskId=${taskResult.taskId} durationMs=${updateDurationMs}`
+          );
+        }
         await this.eventDispatcher.publishTaskUpdateCompleted({
           taskType: this.worker.taskDefName,
           taskId: taskResult.taskId ?? "",
@@ -39316,6 +39389,9 @@ var TaskRunner = class {
           `Error updating task ${taskResult.taskId} on retry ${retryCount + 1}/${this.maxRetries}`,
           error
         );
+        console.log(
+          `[TaskRunner] Task update failed taskId=${taskResult.taskId} attempt=${retryCount + 1}/${this.maxRetries} error=${lastError?.message ?? String(error)}`
+        );
         retryCount++;
         if (retryCount < this.maxRetries) {
           const delayMs = retryCount * 10 * 1e3;
@@ -41328,20 +41404,51 @@ var TaskHandler = class _TaskHandler {
 
 // src/sdk/worker/schema/decorators.ts
 var SCHEMA_METADATA_KEY = Symbol("conductor:schemaField");
+function isNewDecoratorContext(arg) {
+  return typeof arg === "object" && arg !== null && "kind" in arg && typeof arg.kind === "string";
+}
+var schemaFieldProcessed = /* @__PURE__ */ new WeakMap();
+function storeSchemaFieldMetadata(cls, propertyKey, options, designType) {
+  const existing = Reflect.getOwnMetadata(SCHEMA_METADATA_KEY, cls) ?? [];
+  existing.push({
+    ...options,
+    propertyKey,
+    designType
+  });
+  Reflect.defineMetadata(SCHEMA_METADATA_KEY, existing, cls);
+}
 function schemaField(options = {}) {
-  return function(target, propertyKey) {
-    const existing = Reflect.getOwnMetadata(SCHEMA_METADATA_KEY, target.constructor) ?? [];
+  return function(targetOrValue, propertyKeyOrContext) {
+    if (isNewDecoratorContext(propertyKeyOrContext)) {
+      const propertyKey2 = String(propertyKeyOrContext.name);
+      return function(initialValue) {
+        const cls = this.constructor;
+        const processed = schemaFieldProcessed.get(cls) ?? /* @__PURE__ */ new Set();
+        if (!processed.has(propertyKey2)) {
+          processed.add(propertyKey2);
+          schemaFieldProcessed.set(cls, processed);
+          let designType2;
+          try {
+            designType2 = Reflect.getMetadata(
+              "design:type",
+              this,
+              propertyKey2
+            );
+          } catch {
+          }
+          storeSchemaFieldMetadata(cls, propertyKey2, options, designType2);
+        }
+        return initialValue;
+      };
+    }
+    const target = targetOrValue;
+    const propertyKey = propertyKeyOrContext;
     let designType;
     try {
       designType = Reflect.getMetadata("design:type", target, propertyKey);
     } catch {
     }
-    existing.push({
-      ...options,
-      propertyKey,
-      designType
-    });
-    Reflect.defineMetadata(SCHEMA_METADATA_KEY, existing, target.constructor);
+    storeSchemaFieldMetadata(target.constructor, propertyKey, options, designType);
   };
 }
 function inferType(designType) {
@@ -41402,9 +41509,20 @@ function generateSchemaFromClass(cls) {
 }
 
 // src/sdk/worker/decorators/worker.ts
+function isNewDecoratorContext2(arg) {
+  return typeof arg === "object" && arg !== null && "kind" in arg && typeof arg.kind === "string";
+}
 function worker(options) {
-  return function(target, propertyKey, descriptor) {
-    const executeFunction = descriptor?.value || target;
+  function decorator(target, propertyKeyOrContext, descriptor) {
+    let executeFunction;
+    let isNewApi = false;
+    if (isNewDecoratorContext2(propertyKeyOrContext)) {
+      executeFunction = target;
+      isNewApi = true;
+    } else {
+      const fn = descriptor?.value ?? target;
+      executeFunction = fn;
+    }
     if (typeof executeFunction !== "function") {
       throw new Error(
         `@worker decorator can only be applied to functions. Received: ${typeof executeFunction}`
@@ -41418,10 +41536,14 @@ function worker(options) {
     let resolvedInputSchema = options.inputSchema;
     let resolvedOutputSchema = options.outputSchema;
     if (options.inputType) {
-      resolvedInputSchema = generateSchemaFromClass(options.inputType);
+      resolvedInputSchema = generateSchemaFromClass(
+        options.inputType
+      );
     }
     if (options.outputType) {
-      resolvedOutputSchema = generateSchemaFromClass(options.outputType);
+      resolvedOutputSchema = generateSchemaFromClass(
+        options.outputType
+      );
     }
     const registeredWorker = {
       taskDefName: options.taskDefName,
@@ -41448,18 +41570,25 @@ function worker(options) {
           builderArgs.inputParameters ?? {}
         );
       }
-      return executeFunction.apply(this, args);
+      return executeFunction.apply(
+        this,
+        args
+      );
     };
     Object.defineProperty(dualModeFunction, "name", {
       value: executeFunction.name,
       configurable: true
     });
+    if (isNewApi) {
+      return dualModeFunction;
+    }
     if (descriptor) {
       descriptor.value = dualModeFunction;
       return descriptor;
     }
     return dualModeFunction;
-  };
+  }
+  return decorator;
 }
 
 // src/sdk/worker/metrics/MetricsCollector.ts