@hatchet-dev/typescript-sdk 1.30.1 → 1.31.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hatchet-dev/typescript-sdk",
-  "version": "1.30.1",
+  "version": "1.31.0",
   "description": "Background task orchestration & visibility for developers",
   "types": "dist/index.d.ts",
   "files": [

package/v1/client/worker/worker-internal.d.ts

@@ -113,6 +113,21 @@ export declare function mapSlotRequestsPb(task: {
     slotCost?: number;
 }, isDurable: boolean): Record<string, number>;
 export declare function mapRateLimitPb(limits: CreateWorkflowTaskOpts<any, any>['rateLimits']): CreateStepRateLimit[];
+export declare function mapConcurrencyPb(entries: Concurrency[]): {
+    expression: string;
+    maxRuns: number | undefined;
+    limitStrategy: import("../..").ConcurrencyLimitStrategy | undefined;
+    name: string | undefined;
+    isTenantScoped: boolean | undefined;
+    maxRunsExpression: string | undefined;
+}[];
+export declare function taskConcurrencyArr(task: {
+    concurrency?: Concurrency | Concurrency[];
+}, workflow: {
+    taskDefaults?: {
+        concurrency?: Concurrency | Concurrency[];
+    };
+}): Concurrency[];
 export declare function assertValidConcurrencyArr(concurrency: Concurrency[] | undefined): void;
 export declare function mapBatchConfigPb(batch: CreateWorkflowTaskOpts<any, any>['batch']): TaskBatchConfig | undefined;
 export declare function resolveExecutionTimeout(task: {

package/v1/client/worker/worker-internal.js

@@ -55,6 +55,8 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.InternalWorker = void 0;
 exports.mapSlotRequestsPb = mapSlotRequestsPb;
 exports.mapRateLimitPb = mapRateLimitPb;
+exports.mapConcurrencyPb = mapConcurrencyPb;
+exports.taskConcurrencyArr = taskConcurrencyArr;
 exports.assertValidConcurrencyArr = assertValidConcurrencyArr;
 exports.mapBatchConfigPb = mapBatchConfigPb;
 exports.resolveExecutionTimeout = resolveExecutionTimeout;
@@ -307,7 +309,7 @@ class InternalWorker {
                     eventTriggers,
                     cronTriggers,
                     sticky: stickyStrategy,
-                    concurrencyArr,
+                    concurrencyArr: mapConcurrencyPb(concurrencyArr),
                     onFailureTask,
                     defaultPriority: workflow.defaultPriority,
                     inputJsonSchema,
@@ -333,22 +335,13 @@ class InternalWorker {
                             slotRequests: mapSlotRequestsPb(task, durableTaskSet.has(task)),
                             batch: mapBatchConfigPb(batchOf(task)),
                             concurrency: (() => {
-                                var _a;
-                                const taskConcurrency = task.concurrency
-                                    ? Array.isArray(task.concurrency)
-                                        ? task.concurrency
-                                        : [task.concurrency]
-                                    : ((_a = workflow.taskDefaults) === null || _a === void 0 ? void 0 : _a.concurrency)
-                                        ? Array.isArray(workflow.taskDefaults.concurrency)
-                                            ? workflow.taskDefaults.concurrency
-                                            : [workflow.taskDefaults.concurrency]
-                                        : [];
+                                const taskConcurrency = taskConcurrencyArr(task, workflow);
                                 assertValidConcurrencyArr(taskConcurrency);
-                                return taskConcurrency;
+                                return mapConcurrencyPb(taskConcurrency);
                             })(),
                         });
                     }),
-                    concurrency: concurrencySolo,
+                    concurrency: concurrencySolo ? mapConcurrencyPb([concurrencySolo])[0] : undefined,
                     defaultFilters: (_w = (_v = workflow.defaultFilters) === null || _v === void 0 ? void 0 : _v.map((f) => ({
                         scope: f.scope,
                         expression: f.expression,
@@ -1116,10 +1109,42 @@ function parseBatchPayload(actionPayload) {
 function batchOf(task) {
     return 'batch' in task ? task.batch : undefined;
 }
+// mapConcurrencyPb maps SDK concurrency entries onto the proto shape; entries keep their
+// declared order, which is the chain order.
+function mapConcurrencyPb(entries) {
+    return entries.map((c) => ({
+        expression: c.expression,
+        // a string maxRuns is a CEL expression; the static field then carries the default
+        // of 1, which only governs slots created before the expression existed
+        maxRuns: typeof c.maxRuns === 'string' ? 1 : c.maxRuns,
+        limitStrategy: c.limitStrategy,
+        name: c.name,
+        isTenantScoped: c.isTenantScoped,
+        maxRunsExpression: typeof c.maxRuns === 'string' ? c.maxRuns : undefined,
+    }));
+}
+function taskConcurrencyArr(task, workflow) {
+    var _a;
+    if (task.concurrency) {
+        return Array.isArray(task.concurrency) ? task.concurrency : [task.concurrency];
+    }
+    if ((_a = workflow.taskDefaults) === null || _a === void 0 ? void 0 : _a.concurrency) {
+        return Array.isArray(workflow.taskDefaults.concurrency)
+            ? workflow.taskDefaults.concurrency
+            : [workflow.taskDefaults.concurrency];
+    }
+    return [];
+}
 function assertValidConcurrencyArr(concurrency) {
     concurrency === null || concurrency === void 0 ? void 0 : concurrency.forEach((c) => {
+        if (typeof c.maxRuns === 'string') {
+            if (!c.maxRuns.trim()) {
+                throw new Error('concurrency.maxRuns expression must be non-empty');
+            }
+            return;
+        }
         if (c.maxRuns !== undefined && (!Number.isInteger(c.maxRuns) || c.maxRuns <= 0)) {
-            throw new Error(`concurrency.maxRuns must be a positive integer when provided, got: ${c.maxRuns}`);
+            throw new Error(`concurrency.maxRuns must be a positive integer or a CEL expression, got: ${c.maxRuns}`);
         }
     });
 }

package/v1/declaration.d.ts

@@ -228,7 +228,9 @@ export type TaskDefaults = {
      */
     workerLabels?: CreateWorkflowTaskOpts<any, any>['desiredWorkerLabels'];
     /**
-     * (optional) the concurrency options for the task.
+     * (optional) the concurrency options for the task, processed in array order. Entries
+     * may be workflow-scoped strategies or tenant-scoped entries (`isTenantScoped`)
+     * strategies, whose definitions are upserted as part of workflow registration.
      */
     concurrency?: Concurrency | Concurrency[];
 };

package/v1/examples/concurrency_dynamic/workflow.d.ts

@@ -0,0 +1,10 @@
+export type WorkflowInput = {
+    account: string;
+    tier: string;
+};
+export type WorkflowOutput = {
+    'dynamic-task': {
+        account: string;
+    };
+};
+export declare const concurrencyDynamicWorkflow: import("../..").WorkflowDeclaration<WorkflowInput, WorkflowOutput, {}>;

package/v1/examples/concurrency_dynamic/workflow.js

@@ -0,0 +1,32 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.concurrencyDynamicWorkflow = void 0;
+const v1_1 = require("../..");
+const hatchet_client_1 = require("../hatchet-client");
+// > Dynamic Max Runs
+// maxRuns accepts a number or a CEL expression string. With an expression, each
+// concurrency group's limit is computed from the task's input.
+exports.concurrencyDynamicWorkflow = hatchet_client_1.hatchet.workflow({
+    name: 'concurrency-dynamic',
+});
+exports.concurrencyDynamicWorkflow.task({
+    name: 'dynamic-task',
+    concurrency: [
+        {
+            expression: 'input.account',
+            maxRuns: "input.tier == 'premium' ? 10 : 1",
+            limitStrategy: v1_1.ConcurrencyLimitStrategy.GROUP_ROUND_ROBIN,
+        },
+    ],
+    fn: (input) => __awaiter(void 0, void 0, void 0, function* () { return ({ account: input.account }); }),
+});
+// !!

package/v1/examples/concurrency_shared/workflow.d.ts

@@ -0,0 +1,17 @@
+import { Concurrency } from '../..';
+export declare const SLEEP_TIME_MS = 1500;
+export type WorkflowInput = {
+    group: string;
+    inline?: string;
+};
+export type RunWindow = {
+    startMs: number;
+    endMs: number;
+};
+export type WorkflowOutput = {
+    'shared-task': RunWindow;
+};
+export declare const sharedLimit: Concurrency;
+export declare const concurrencySharedWorkflowA: import("../..").WorkflowDeclaration<WorkflowInput, WorkflowOutput, {}>;
+export declare const concurrencySharedWorkflowB: import("../..").WorkflowDeclaration<WorkflowInput, WorkflowOutput, {}>;
+export declare const concurrencySharedMixedWorkflow: import("../..").WorkflowDeclaration<WorkflowInput, WorkflowOutput, {}>;

package/v1/examples/concurrency_shared/workflow.js

@@ -0,0 +1,70 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.concurrencySharedMixedWorkflow = exports.concurrencySharedWorkflowB = exports.concurrencySharedWorkflowA = exports.sharedLimit = exports.SLEEP_TIME_MS = void 0;
+const v1_1 = require("../..");
+const hatchet_client_1 = require("../hatchet-client");
+const sleep = (ms) => new Promise((resolve) => {
+    setTimeout(resolve, ms);
+});
+exports.SLEEP_TIME_MS = 1500;
+// > Shared Concurrency Strategy
+// A tenant-scoped strategy is shared across workflows: every task declaring the same name
+// consumes the same concurrency limit. The definition rides on workflow registration and
+// re-registering the name updates it in place.
+exports.sharedLimit = {
+    name: 'ts-example-shared-limit',
+    isTenantScoped: true,
+    expression: 'input.group',
+    maxRuns: 1,
+    limitStrategy: v1_1.ConcurrencyLimitStrategy.GROUP_ROUND_ROBIN,
+};
+const runWindowTask = () => __awaiter(void 0, void 0, void 0, function* () {
+    const startMs = Date.now();
+    yield sleep(exports.SLEEP_TIME_MS);
+    return { startMs, endMs: Date.now() };
+});
+exports.concurrencySharedWorkflowA = hatchet_client_1.hatchet.workflow({
+    name: 'concurrency-shared-a',
+});
+exports.concurrencySharedWorkflowA.task({
+    name: 'shared-task',
+    concurrency: [exports.sharedLimit],
+    fn: runWindowTask,
+});
+exports.concurrencySharedWorkflowB = hatchet_client_1.hatchet.workflow({
+    name: 'concurrency-shared-b',
+});
+exports.concurrencySharedWorkflowB.task({
+    name: 'shared-task',
+    concurrency: [exports.sharedLimit],
+    fn: runWindowTask,
+});
+// !!
+// > Mixed Inline And Shared Concurrency
+// A single task can combine a workflow-scoped inline strategy with a shared strategy;
+// both limits apply at once.
+exports.concurrencySharedMixedWorkflow = hatchet_client_1.hatchet.workflow({
+    name: 'concurrency-shared-mixed',
+});
+exports.concurrencySharedMixedWorkflow.task({
+    name: 'shared-task',
+    concurrency: [
+        {
+            expression: 'input.inline',
+            maxRuns: 1,
+            limitStrategy: v1_1.ConcurrencyLimitStrategy.GROUP_ROUND_ROBIN,
+        },
+        exports.sharedLimit,
+    ],
+    fn: runWindowTask,
+});
+// !!

package/v1/examples/e2e-worker.js

@@ -25,30 +25,31 @@ const workflow_4 = require("./concurrency_cancel_newest/workflow");
 const workflow_5 = require("./concurrency_cancel_queued_except_newest/workflow");
 const workflow_6 = require("./concurrency_cancel_queued_except_oldest/workflow");
 const workflow_7 = require("./concurrency_multiple_keys/workflow");
-const workflow_8 = require("./concurrency_workflow_level/workflow");
-const workflow_9 = require("./dag/workflow");
-const workflow_10 = require("./durable/workflow");
-const workflow_11 = require("./durable_event/workflow");
-const workflow_12 = require("./durable_eviction/workflow");
-const workflow_13 = require("./durable_callback_ordering/workflow");
-const workflow_14 = require("./durable_sleep/workflow");
-const workflow_15 = require("./logger/workflow");
-const workflow_16 = require("./non_retryable/workflow");
-const workflow_17 = require("./on_failure/workflow");
-const workflow_18 = require("./idempotency/workflow");
-const workflow_19 = require("./on_event/workflow");
-const workflow_20 = require("./return_exceptions/workflow");
-const workflow_21 = require("./run_details/workflow");
+const workflow_8 = require("./concurrency_shared/workflow");
+const workflow_9 = require("./concurrency_workflow_level/workflow");
+const workflow_10 = require("./dag/workflow");
+const workflow_11 = require("./durable/workflow");
+const workflow_12 = require("./durable_event/workflow");
+const workflow_13 = require("./durable_eviction/workflow");
+const workflow_14 = require("./durable_callback_ordering/workflow");
+const workflow_15 = require("./durable_sleep/workflow");
+const workflow_16 = require("./logger/workflow");
+const workflow_17 = require("./non_retryable/workflow");
+const workflow_18 = require("./on_failure/workflow");
+const workflow_19 = require("./idempotency/workflow");
+const workflow_20 = require("./on_event/workflow");
+const workflow_21 = require("./return_exceptions/workflow");
+const workflow_22 = require("./run_details/workflow");
 const e2e_workflows_1 = require("./simple/e2e-workflows");
-const workflow_22 = require("./batch_assign/workflow");
-const workflow_23 = require("./streaming/workflow");
-const workflow_24 = require("./subscribe_to_stream/workflow");
-const workflow_25 = require("./timeout/workflow");
-const workflow_26 = require("./webhooks/workflow");
-const workflow_27 = require("./child_index/workflow");
-const workflow_28 = require("./support_agent/workflow");
-const workflow_29 = require("./welcome_email/workflow");
-const workflow_30 = require("./pdf_pipeline/workflow");
+const workflow_23 = require("./batch_assign/workflow");
+const workflow_24 = require("./streaming/workflow");
+const workflow_25 = require("./subscribe_to_stream/workflow");
+const workflow_26 = require("./timeout/workflow");
+const workflow_27 = require("./webhooks/workflow");
+const workflow_28 = require("./child_index/workflow");
+const workflow_29 = require("./support_agent/workflow");
+const workflow_30 = require("./welcome_email/workflow");
+const workflow_31 = require("./pdf_pipeline/workflow");
 const workflows = [
     workflow_1.bulkChild,
     workflow_1.bulkParentWorkflow,
@@ -62,78 +63,81 @@ const workflows = [
     workflow_5.concurrencyCancelQueuedExceptNewestWorkflow,
     workflow_6.concurrencyCancelQueuedExceptOldestWorkflow,
     workflow_7.concurrencyMultipleKeysWorkflow,
-    workflow_8.concurrencyWorkflowLevelWorkflow,
-    workflow_9.dag,
-    workflow_10.durableWorkflow,
-    workflow_10.waitForSleepTwice,
-    workflow_10.spawnChildTask,
-    workflow_10.durableWithSpawn,
-    workflow_10.durableWithBulkSpawn,
-    workflow_10.durableSleepEventSpawn,
-    workflow_10.durableWithExplicitSpawn,
-    workflow_10.durableNonDeterminism,
-    workflow_10.durableReplayReset,
-    workflow_10.dagChildWorkflow,
-    workflow_10.durableSpawnDag,
-    workflow_10.waitForEventLookback,
-    workflow_10.waitForOrEventLookback,
-    workflow_10.waitForTwoEventsSecondPushedFirst,
-    workflow_10.errorRaisingTask,
-    workflow_10.errorRaisingDurableParent,
-    workflow_11.durableEvent,
-    workflow_11.durableEventWithFilter,
-    workflow_13.callbackOrderingLeaf,
-    workflow_13.callbackOrderingMid,
-    workflow_13.callbackOrderingRoot,
-    workflow_14.durableSleep,
-    workflow_12.evictableSleep,
-    workflow_12.evictableWaitForEvent,
-    workflow_12.evictableMemoThenWaitForEvent,
-    workflow_12.evictableChildSpawn,
-    workflow_12.multipleEviction,
-    workflow_12.nonEvictableSleep,
-    workflow_12.childTask,
-    workflow_12.bulkChildTask,
-    workflow_12.evictableChildBulkSpawn,
-    (0, workflow_15.createLoggingWorkflow)(hatchet_client_1.hatchet),
-    workflow_16.nonRetryableWorkflow,
-    workflow_17.failureWorkflow,
-    workflow_18.idempotentTask,
-    workflow_18.idempotentTaskShortWindow,
-    workflow_19.lower,
-    workflow_20.returnExceptionsTask,
-    workflow_21.runDetailTestWorkflow,
+    workflow_8.concurrencySharedWorkflowA,
+    workflow_8.concurrencySharedWorkflowB,
+    workflow_8.concurrencySharedMixedWorkflow,
+    workflow_9.concurrencyWorkflowLevelWorkflow,
+    workflow_10.dag,
+    workflow_11.durableWorkflow,
+    workflow_11.waitForSleepTwice,
+    workflow_11.spawnChildTask,
+    workflow_11.durableWithSpawn,
+    workflow_11.durableWithBulkSpawn,
+    workflow_11.durableSleepEventSpawn,
+    workflow_11.durableWithExplicitSpawn,
+    workflow_11.durableNonDeterminism,
+    workflow_11.durableReplayReset,
+    workflow_11.dagChildWorkflow,
+    workflow_11.durableSpawnDag,
+    workflow_11.waitForEventLookback,
+    workflow_11.waitForOrEventLookback,
+    workflow_11.waitForTwoEventsSecondPushedFirst,
+    workflow_11.errorRaisingTask,
+    workflow_11.errorRaisingDurableParent,
+    workflow_12.durableEvent,
+    workflow_12.durableEventWithFilter,
+    workflow_14.callbackOrderingLeaf,
+    workflow_14.callbackOrderingMid,
+    workflow_14.callbackOrderingRoot,
+    workflow_15.durableSleep,
+    workflow_13.evictableSleep,
+    workflow_13.evictableWaitForEvent,
+    workflow_13.evictableMemoThenWaitForEvent,
+    workflow_13.evictableChildSpawn,
+    workflow_13.multipleEviction,
+    workflow_13.nonEvictableSleep,
+    workflow_13.childTask,
+    workflow_13.bulkChildTask,
+    workflow_13.evictableChildBulkSpawn,
+    (0, workflow_16.createLoggingWorkflow)(hatchet_client_1.hatchet),
+    workflow_17.nonRetryableWorkflow,
+    workflow_18.failureWorkflow,
+    workflow_19.idempotentTask,
+    workflow_19.idempotentTaskShortWindow,
+    workflow_20.lower,
+    workflow_21.returnExceptionsTask,
+    workflow_22.runDetailTestWorkflow,
     e2e_workflows_1.helloWorld,
     e2e_workflows_1.helloWorldDurable,
-    workflow_23.streamingTask,
-    workflow_24.dagStream,
-    workflow_24.longStream,
-    workflow_25.timeoutTask,
-    workflow_25.refreshTimeoutTask,
-    workflow_26.webhookWorkflow,
-    workflow_27.childIndexChild,
-    workflow_27.childIndexParent,
-    workflow_27.scenarioTask,
-    workflow_27.orchestratorTask,
-    workflow_28.supportAgent,
-    workflow_28.triageTicket,
-    workflow_28.generateReply,
-    workflow_28.escalateTicket,
-    workflow_29.welcomeEmail,
-    workflow_30.pdfPipeline,
-    workflow_22.batchSimple,
-    workflow_22.batchKeyed,
-    workflow_22.batchKeyedFailable,
-    workflow_22.batchKeyedInterval,
-    workflow_22.batchLarge,
-    workflow_22.batchSingle,
-    workflow_22.batchOrdered,
-    workflow_22.batchBroadcast,
-    workflow_22.batchCancel,
-    workflow_22.child,
-    workflow_22.childBatch,
-    workflow_22.batchChildSpawn,
-    workflow_22.batchChildBatchSpawn,
+    workflow_24.streamingTask,
+    workflow_25.dagStream,
+    workflow_25.longStream,
+    workflow_26.timeoutTask,
+    workflow_26.refreshTimeoutTask,
+    workflow_27.webhookWorkflow,
+    workflow_28.childIndexChild,
+    workflow_28.childIndexParent,
+    workflow_28.scenarioTask,
+    workflow_28.orchestratorTask,
+    workflow_29.supportAgent,
+    workflow_29.triageTicket,
+    workflow_29.generateReply,
+    workflow_29.escalateTicket,
+    workflow_30.welcomeEmail,
+    workflow_31.pdfPipeline,
+    workflow_23.batchSimple,
+    workflow_23.batchKeyed,
+    workflow_23.batchKeyedFailable,
+    workflow_23.batchKeyedInterval,
+    workflow_23.batchLarge,
+    workflow_23.batchSingle,
+    workflow_23.batchOrdered,
+    workflow_23.batchBroadcast,
+    workflow_23.batchCancel,
+    workflow_23.child,
+    workflow_23.childBatch,
+    workflow_23.batchChildSpawn,
+    workflow_23.batchChildBatchSpawn,
 ];
 function main() {
     return __awaiter(this, void 0, void 0, function* () {

package/v1/task.d.ts

@@ -11,7 +11,7 @@ export { ConcurrencyLimitStrategy, WorkerLabelComparator };
  */
 export type Concurrency = {
     /**
-     * required the CEL expression to use for concurrency
+     * required: the CEL expression to use for concurrency
      *
      * @example
      * ```
@@ -20,17 +20,38 @@ export type Concurrency = {
      */
     expression: string;
     /**
-     * (optional) the maximum number of concurrent workflow runs
+     * (optional) the maximum number of concurrent runs: a fixed number, or a CEL
+     * expression over task input computing the max runs for that task's concurrency
+     * group. With an expression, a group's effective limit is the value from its most
+     * recently created task.
      *
      * default: 1
+     *
+     * @example
+     * ```
+     * maxRuns: 5
+     * maxRuns: "input.tier == 'premium' ? 10 : 1"
+     * ```
      */
-    maxRuns?: number;
+    maxRuns?: number | string;
     /**
      * (optional) the strategy to use when the concurrency limit is reached
      *
      * default: CANCEL_IN_PROGRESS
      */
     limitStrategy?: ConcurrencyLimitStrategy;
+    /**
+     * (required when isTenantScoped) the strategy name; unique per tenant for tenant-scoped
+     * strategies
+     */
+    name?: string;
+    /**
+     * (optional) when true, the entry defines (or updates in place) a tenant-scoped strategy
+     * shared across workflows, keyed by name: every task declaring the same name consumes
+     * the same concurrency limit. The position in the concurrency list is the chain order,
+     * and chains sharing tenant-scoped strategies must order them consistently.
+     */
+    isTenantScoped?: boolean;
 };
 /**
  * @deprecated use Concurrency instead

package/version.d.ts

@@ -1 +1 @@
-export declare const HATCHET_VERSION = "1.30.1";
+export declare const HATCHET_VERSION = "1.31.0";

package/version.js

@@ -1,4 +1,4 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.HATCHET_VERSION = void 0;
-exports.HATCHET_VERSION = '1.30.1';
+exports.HATCHET_VERSION = '1.31.0';