@brandboostinggmbh/observable-workflows 0.20.0-beta.4 → 0.20.0-beta.5

package/dist/index.d.ts

@@ -14,14 +14,15 @@ declare function createStepContext(context: StepContextOptions): Promise<{
  * This function is idempotent and can be safely run multiple times.
  *
  * @param db - D1Database instance
+ * @param retryConfig - Optional retry configuration for D1 operations
  */
-declare function ensureTables(db: D1Database): Promise<void>;
+declare function ensureTables(db: D1Database, retryConfig?: RetryConfig): Promise<void>;
 //#endregion
 //#region src/observableWorkflows/helperFunctions.d.ts
 /**
  * Configuration for retry behavior on D1 operations
  */
-interface RetryConfig$1 {
+interface RetryConfig {
   /** Maximum number of retry attempts (default: 3) */
   maxAttempts?: number;
   /** Initial delay in milliseconds (default: 100) */
@@ -49,7 +50,7 @@ interface RetryConfig$1 {
  * )
  * ```
  */
-declare function retryD1Operation<T>(operation: () => Promise<T>, config?: RetryConfig$1): Promise<T>;
+declare function retryD1Operation<T>(operation: () => Promise<T>, config?: RetryConfig): Promise<T>;
 declare function finalizeWorkflowRecord(options: InternalWorkflowContextOptions, {
   workflowStatus,
   endTime,
@@ -231,6 +232,7 @@ declare function workflowTableRowToWorkflowRun({
 }): Promise<WorkflowRun>;
 declare function updateWorkflowName(context: {
   D1: D1Database;
+  retryConfig?: RetryConfig;
 }, instanceId: string, newWorkflowName: string): Promise<D1Result<Record<string, unknown>>>;
 /**
  * Update workflow fields by instanceId. Only provided fields will be updated.
@@ -441,6 +443,8 @@ type StepContextOptions = {
   reuseSuccessfulSteps?: boolean;
   /** Optional external blob storage for large data that exceeds D1 size limits */
   externalBlobStorage?: ExternalBlobStorage;
+  /** Optional retry configuration for D1 operations */
+  retryConfig?: RetryConfig;
 };
 type ConsoleWrapper = {
   log: (message?: any, ...optionalParams: any[]) => void;
@@ -637,18 +641,6 @@ type ExternalBlobStorage = {
   get: (id: string) => Promise<string>;
   delete: (...keys: string[]) => Promise<number>;
 };
-type RetryConfig = {
-  /** Maximum number of retry attempts (default: 3) */
-  maxAttempts?: number;
-  /** Initial delay in milliseconds (default: 100) */
-  initialDelayMs?: number;
-  /** Maximum delay in milliseconds (default: 5000) */
-  maxDelayMs?: number;
-  /** Multiplier for exponential backoff (default: 2) */
-  backoffMultiplier?: number;
-  /** Whether to add jitter to delays (default: true) */
-  useJitter?: boolean;
-};
 type WorkflowContextOptions = {
   D1: D1Database;
   idFactory?: () => string;
@@ -774,6 +766,7 @@ declare const createCleanupManager: (context: {
   tenantId: string;
   serializer?: Serializer;
   externalBlobStorage?: ExternalBlobStorage;
+  retryConfig?: RetryConfig;
 }) => {
   countAffectedWorkflows: (config: DeleteConfig, limit: number) => Promise<{
     count: number;
@@ -820,6 +813,7 @@ declare const createLogAccessor: (context: {
   tenantId: string;
   serializer?: Serializer;
   externalBlobStorage?: ExternalBlobStorage;
+  retryConfig?: RetryConfig;
 }) => {
   listSteps: {
     (limit: number, offset: number, instanceId?: string): Promise<Step[]>;

package/dist/index.js

@@ -2,8 +2,8 @@
 /**
 * Detect the current schema version for each table
 */
-async function detectSchemaVersion(db) {
-	const workflowTableInfo = await retryD1Operation(() => db.prepare(`SELECT sql FROM sqlite_master WHERE type='table' AND name='WorkflowTable'`).first());
+async function detectSchemaVersion(db, retryConfig) {
+	const workflowTableInfo = await retryD1Operation(() => db.prepare(`SELECT sql FROM sqlite_master WHERE type='table' AND name='WorkflowTable'`).first(), retryConfig);
 	let workflowTable = "missing";
 	if (workflowTableInfo) {
 		const hasInputRef = workflowTableInfo.sql.includes("inputRef");
@@ -16,7 +16,7 @@ async function detectSchemaVersion(db) {
 		else if (!hasInputRef && inputHasNotNull) workflowTable = "v1";
 		else workflowTable = "v1";
 	}
-	const stepTableInfo = await retryD1Operation(() => db.prepare(`SELECT sql FROM sqlite_master WHERE type='table' AND name='StepTable'`).first());
+	const stepTableInfo = await retryD1Operation(() => db.prepare(`SELECT sql FROM sqlite_master WHERE type='table' AND name='StepTable'`).first(), retryConfig);
 	let stepTable = "missing";
 	if (stepTableInfo) {
 		const hasResultRef = stepTableInfo.sql.includes("resultRef");
@@ -26,7 +26,7 @@ async function detectSchemaVersion(db) {
 		else if (hasResultRef && hasErrorRef) stepTable = "v2";
 		else stepTable = "v1";
 	}
-	const logTableInfo = await retryD1Operation(() => db.prepare(`SELECT sql FROM sqlite_master WHERE type='table' AND name='LogTable'`).first());
+	const logTableInfo = await retryD1Operation(() => db.prepare(`SELECT sql FROM sqlite_master WHERE type='table' AND name='LogTable'`).first(), retryConfig);
 	let logTable = "missing";
 	if (logTableInfo) {
 		const hasStepTableCascadeFK = logTableInfo.sql.includes("FOREIGN KEY (instanceId, stepName) REFERENCES StepTable(instanceId, stepName) ON DELETE CASCADE");
@@ -34,7 +34,7 @@ async function detectSchemaVersion(db) {
 		if (hasStepTableCascadeFK && hasWorkflowTableFK) logTable = "v5";
 		else logTable = "v1";
 	}
-	const workflowPropertiesInfo = await retryD1Operation(() => db.prepare(`SELECT sql FROM sqlite_master WHERE type='table' AND name='WorkflowProperties'`).first());
+	const workflowPropertiesInfo = await retryD1Operation(() => db.prepare(`SELECT sql FROM sqlite_master WHERE type='table' AND name='WorkflowProperties'`).first(), retryConfig);
 	let workflowProperties = "missing";
 	if (workflowPropertiesInfo) workflowProperties = "v1";
 	const workflowDependenciesInfo = await db.prepare(`SELECT sql FROM sqlite_master WHERE type='table' AND name='WorkflowDependencies'`).first();
@@ -52,8 +52,8 @@ async function detectSchemaVersion(db) {
 * Migrate WorkflowTable from V1 to V2 schema
 * Adds inputRef column and makes input nullable
 */
-async function migrateWorkflowTableV1ToV2(db) {
-	const workflowTableInfo = await retryD1Operation(() => db.prepare(`SELECT sql FROM sqlite_master WHERE type='table' AND name='WorkflowTable'`).first());
+async function migrateWorkflowTableV1ToV2(db, retryConfig) {
+	const workflowTableInfo = await retryD1Operation(() => db.prepare(`SELECT sql FROM sqlite_master WHERE type='table' AND name='WorkflowTable'`).first(), retryConfig);
 	const hasInputRef = workflowTableInfo.sql.includes("inputRef");
 	const inputHasNotNull = workflowTableInfo.sql.includes("input TEXT NOT NULL");
 	if (!hasInputRef || inputHasNotNull) await retryD1Operation(() => db.batch([
@@ -78,14 +78,14 @@ async function migrateWorkflowTableV1ToV2(db) {
         FROM WorkflowTable`),
 		db.prepare(`DROP TABLE WorkflowTable`),
 		db.prepare(`ALTER TABLE WorkflowTable_new RENAME TO WorkflowTable`)
-	]));
+	]), retryConfig);
 }
 /**
 * Migrate WorkflowTable from V2/V3 to V4 schema
 * Adds triggerId column with UNIQUE constraint
 */
-async function migrateWorkflowTableV2V3ToV4(db) {
-	const workflowTableInfo = await retryD1Operation(() => db.prepare(`SELECT sql FROM sqlite_master WHERE type='table' AND name='WorkflowTable'`).first());
+async function migrateWorkflowTableV2V3ToV4(db, retryConfig) {
+	const workflowTableInfo = await retryD1Operation(() => db.prepare(`SELECT sql FROM sqlite_master WHERE type='table' AND name='WorkflowTable'`).first(), retryConfig);
 	const hasTriggerId = workflowTableInfo.sql.includes("triggerId");
 	if (!hasTriggerId) await retryD1Operation(() => db.batch([
 		db.prepare(`CREATE TABLE WorkflowTable_new (
@@ -111,21 +111,21 @@ async function migrateWorkflowTableV2V3ToV4(db) {
         FROM WorkflowTable`),
 		db.prepare(`DROP TABLE WorkflowTable`),
 		db.prepare(`ALTER TABLE WorkflowTable_new RENAME TO WorkflowTable`)
-	]));
+	]), retryConfig);
 }
 /**
 * Migrate WorkflowTable from V4 to V6 schema
 * Adds result and resultRef columns for external storage support
 */
-async function migrateWorkflowTableV4ToV6(db) {
-	const workflowTableInfo = await db.prepare(`SELECT sql FROM sqlite_master WHERE type='table' AND name='WorkflowTable'`).first();
+async function migrateWorkflowTableV4ToV6(db, retryConfig) {
+	const workflowTableInfo = await retryD1Operation(() => db.prepare(`SELECT sql FROM sqlite_master WHERE type='table' AND name='WorkflowTable'`).first(), retryConfig);
 	const hasResultRef = workflowTableInfo.sql.includes("resultRef");
-	if (!hasResultRef) await db.batch([db.prepare(`ALTER TABLE WorkflowTable ADD COLUMN result TEXT`), db.prepare(`ALTER TABLE WorkflowTable ADD COLUMN resultRef TEXT`)]);
+	if (!hasResultRef) await retryD1Operation(() => db.batch([db.prepare(`ALTER TABLE WorkflowTable ADD COLUMN result TEXT`), db.prepare(`ALTER TABLE WorkflowTable ADD COLUMN resultRef TEXT`)]), retryConfig);
 }
 /**
 * Create or migrate WorkflowTable to the latest schema
 */
-async function migrateWorkflowTable(db, currentVersion) {
+async function migrateWorkflowTable(db, currentVersion, retryConfig) {
 	if (currentVersion === "missing") {
 		await retryD1Operation(() => db.prepare(`CREATE TABLE WorkflowTable (
           instanceId TEXT NOT NULL,
@@ -144,29 +144,29 @@ async function migrateWorkflowTable(db, currentVersion) {
           triggerId TEXT,
           PRIMARY KEY (instanceId),
           UNIQUE (triggerId)
-        )`).run());
+        )`).run(), retryConfig);
 		return;
 	}
 	if (currentVersion === "v1") {
-		await migrateWorkflowTableV1ToV2(db);
-		await migrateWorkflowTableV2V3ToV4(db);
-		await migrateWorkflowTableV4ToV6(db);
+		await migrateWorkflowTableV1ToV2(db, retryConfig);
+		await migrateWorkflowTableV2V3ToV4(db, retryConfig);
+		await migrateWorkflowTableV4ToV6(db, retryConfig);
 		return;
 	}
 	if (currentVersion === "v2") {
-		await migrateWorkflowTableV2V3ToV4(db);
-		await migrateWorkflowTableV4ToV6(db);
+		await migrateWorkflowTableV2V3ToV4(db, retryConfig);
+		await migrateWorkflowTableV4ToV6(db, retryConfig);
 		return;
 	}
 	if (currentVersion === "v4") {
-		await migrateWorkflowTableV4ToV6(db);
+		await migrateWorkflowTableV4ToV6(db, retryConfig);
 		return;
 	}
 }
 /**
 * Create or migrate StepTable to the latest schema
 */
-async function migrateStepTable(db, currentVersion) {
+async function migrateStepTable(db, currentVersion, retryConfig) {
 	if (currentVersion === "missing") {
 		await retryD1Operation(() => db.prepare(`CREATE TABLE StepTable (
           instanceId TEXT NOT NULL,
@@ -182,21 +182,21 @@ async function migrateStepTable(db, currentVersion) {
           tenantId TEXT NOT NULL,
           PRIMARY KEY (instanceId, stepName),
           FOREIGN KEY (instanceId) REFERENCES WorkflowTable(instanceId) ON DELETE CASCADE
-        )`).run());
+        )`).run(), retryConfig);
 		return;
 	}
 	if (currentVersion === "v1") {
-		const stepTableInfo = await retryD1Operation(() => db.prepare(`SELECT sql FROM sqlite_master WHERE type='table' AND name='StepTable'`).first());
+		const stepTableInfo = await retryD1Operation(() => db.prepare(`SELECT sql FROM sqlite_master WHERE type='table' AND name='StepTable'`).first(), retryConfig);
 		const hasResultRef = stepTableInfo.sql.includes("resultRef");
 		const hasErrorRef = stepTableInfo.sql.includes("errorRef");
-		if (!hasResultRef) await retryD1Operation(() => db.prepare(`ALTER TABLE StepTable ADD COLUMN resultRef TEXT`).run());
-		if (!hasErrorRef) await retryD1Operation(() => db.prepare(`ALTER TABLE StepTable ADD COLUMN errorRef TEXT`).run());
+		if (!hasResultRef) await retryD1Operation(() => db.prepare(`ALTER TABLE StepTable ADD COLUMN resultRef TEXT`).run(), retryConfig);
+		if (!hasErrorRef) await retryD1Operation(() => db.prepare(`ALTER TABLE StepTable ADD COLUMN errorRef TEXT`).run(), retryConfig);
 	}
 }
 /**
 * Create or migrate LogTable to the latest schema
 */
-async function migrateLogTable(db, currentVersion) {
+async function migrateLogTable(db, currentVersion, retryConfig) {
 	if (currentVersion === "missing") {
 		await retryD1Operation(() => db.prepare(`CREATE TABLE LogTable (
           instanceId TEXT NOT NULL,
@@ -208,14 +208,14 @@ async function migrateLogTable(db, currentVersion) {
           tenantId TEXT NOT NULL,
           FOREIGN KEY (instanceId, stepName) REFERENCES StepTable(instanceId, stepName) ON DELETE CASCADE DEFERRABLE INITIALLY DEFERRED,
           FOREIGN KEY (instanceId) REFERENCES WorkflowTable(instanceId) ON DELETE CASCADE
-        )`).run());
+        )`).run(), retryConfig);
 		return;
 	}
 }
 /**
 * Create or migrate WorkflowProperties table to the latest schema
 */
-async function migrateWorkflowPropertiesTable(db, currentVersion) {
+async function migrateWorkflowPropertiesTable(db, currentVersion, retryConfig) {
 	if (currentVersion === "missing") {
 		await retryD1Operation(() => db.prepare(`CREATE TABLE WorkflowProperties (
           instanceId TEXT NOT NULL,
@@ -226,16 +226,16 @@ async function migrateWorkflowPropertiesTable(db, currentVersion) {
           PRIMARY KEY (instanceId, key),
           FOREIGN KEY (instanceId) REFERENCES WorkflowTable(instanceId)
           ON DELETE CASCADE
-        )`).run());
+        )`).run(), retryConfig);
 		return;
 	}
 }
 /**
 * Create or migrate WorkflowDependencies table to the latest schema
 */
-async function migrateWorkflowDependenciesTable(db, currentVersion) {
+async function migrateWorkflowDependenciesTable(db, currentVersion, retryConfig) {
 	if (currentVersion === "missing") {
-		await db.prepare(`CREATE TABLE WorkflowDependencies (
+		await retryD1Operation(() => db.prepare(`CREATE TABLE WorkflowDependencies (
           dependencyWorkflowId TEXT NOT NULL,
           dependentWorkflowId TEXT NOT NULL,
           tenantId TEXT NOT NULL,
@@ -243,15 +243,15 @@ async function migrateWorkflowDependenciesTable(db, currentVersion) {
           PRIMARY KEY (dependencyWorkflowId, dependentWorkflowId),
           FOREIGN KEY (dependencyWorkflowId) REFERENCES WorkflowTable(instanceId) ON DELETE CASCADE,
           FOREIGN KEY (dependentWorkflowId) REFERENCES WorkflowTable(instanceId) ON DELETE CASCADE
-        )`).run();
+        )`).run(), retryConfig);
 		return;
 	}
 }
 /**
 * Create necessary indexes
 */
-async function createIndexes(db) {
-	const existingIndexes = await retryD1Operation(() => db.prepare(`SELECT name FROM sqlite_master WHERE type='index' AND name LIKE 'idx_%'`).all());
+async function createIndexes(db, retryConfig) {
+	const existingIndexes = await retryD1Operation(() => db.prepare(`SELECT name FROM sqlite_master WHERE type='index' AND name LIKE 'idx_%'`).all(), retryConfig);
 	const existingIndexNames = new Set(existingIndexes.results?.map((row) => row.name) || []);
 	const indexes = [
 		{
@@ -341,23 +341,24 @@ async function createIndexes(db) {
 	];
 	const preparedStatements = [];
 	for (const index of indexes) if (!existingIndexNames.has(index.name)) preparedStatements.push(db.prepare(index.sql));
-	if (preparedStatements.length > 0) await retryD1Operation(() => db.batch(preparedStatements));
+	if (preparedStatements.length > 0) await retryD1Operation(() => db.batch(preparedStatements), retryConfig);
 }
 /**
 * Main migration function that ensures all tables exist and are up-to-date.
 * This function is idempotent and can be safely run multiple times.
 *
 * @param db - D1Database instance
+* @param retryConfig - Optional retry configuration for D1 operations
 */
-async function ensureTables(db) {
-	await retryD1Operation(() => db.prepare(`PRAGMA foreign_keys = ON`).run());
-	const schemaVersion = await detectSchemaVersion(db);
-	await migrateWorkflowTable(db, schemaVersion.workflowTable);
-	await migrateStepTable(db, schemaVersion.stepTable);
-	await migrateLogTable(db, schemaVersion.logTable);
-	await migrateWorkflowPropertiesTable(db, schemaVersion.workflowProperties);
-	await migrateWorkflowDependenciesTable(db, schemaVersion.workflowDependencies);
-	await createIndexes(db);
+async function ensureTables(db, retryConfig) {
+	await retryD1Operation(() => db.prepare(`PRAGMA foreign_keys = ON`).run(), retryConfig);
+	const schemaVersion = await detectSchemaVersion(db, retryConfig);
+	await migrateWorkflowTable(db, schemaVersion.workflowTable, retryConfig);
+	await migrateStepTable(db, schemaVersion.stepTable, retryConfig);
+	await migrateLogTable(db, schemaVersion.logTable, retryConfig);
+	await migrateWorkflowPropertiesTable(db, schemaVersion.workflowProperties, retryConfig);
+	await migrateWorkflowDependenciesTable(db, schemaVersion.workflowDependencies, retryConfig);
+	await createIndexes(db, retryConfig);
 }
 
 //#endregion
@@ -397,12 +398,12 @@ function sleep(ms) {
 }
 /**
 * Retry a D1 operation with exponential backoff for transient network errors
-* 
+*
 * @param operation - The async operation to retry
 * @param config - Retry configuration options
 * @returns The result of the operation
 * @throws The last error if all retry attempts fail
-* 
+*
 * @example
 * ```typescript
 * const result = await retryD1Operation(
@@ -436,11 +437,11 @@ async function finalizeWorkflowRecord(options, { workflowStatus, endTime, instan
 		const { data: resultData, externalRef: resultRef } = await serializeWithExternalStorage(result, options.serializer, options.externalBlobStorage);
 		return retryD1Operation(() => options.D1.prepare(`UPDATE WorkflowTable
             SET workflowStatus = ?, endTime = ?, result = ?, resultRef = ?
-            WHERE instanceId = ?`).bind(workflowStatus, endTime, resultData, resultRef, instanceId).run());
+            WHERE instanceId = ?`).bind(workflowStatus, endTime, resultData, resultRef, instanceId).run(), options.retryConfig);
 	}
 	return retryD1Operation(() => options.D1.prepare(`UPDATE WorkflowTable
             SET workflowStatus = ?, endTime = ?
-            WHERE instanceId = ?`).bind(workflowStatus, endTime, instanceId).run());
+            WHERE instanceId = ?`).bind(workflowStatus, endTime, instanceId).run(), options.retryConfig);
 }
 /**
 * Insert a new workflow record into the database.
@@ -471,7 +472,7 @@ async function insertWorkflowRecord(options, { instanceId, workflowType, workflo
         (instanceId, workflowType, workflowName, workflowMetadata, input, inputRef, tenantId, workflowStatus, startTime, endTime, parentInstanceId, triggerId)
         VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`).bind(instanceId, workflowType, workflowName, options.serializer.serialize(workflowMetadata), inputData, inputRef, tenantId, workflowStatus, startTime, endTime ?? null, parentInstanceId ?? null, triggerId ?? null);
 	if (!dependencies || dependencies.length === 0) {
-		const result = await retryD1Operation(() => insertWorkflowStatement.run());
+		const result = await retryD1Operation(() => insertWorkflowStatement.run(), options.retryConfig);
 		return {
 			success: result.success,
 			meta: result.meta
@@ -485,7 +486,7 @@ async function insertWorkflowRecord(options, { instanceId, workflowType, workflo
 		tenantId,
 		createdAt
 	}));
-	const results = await retryD1Operation(() => options.D1.batch([insertWorkflowStatement, ...dependencyStatements]));
+	const results = await retryD1Operation(() => options.D1.batch([insertWorkflowStatement, ...dependencyStatements]), options.retryConfig);
 	const allSucceeded = results.every((result) => result.success);
 	return {
 		success: allSucceeded,
@@ -495,10 +496,10 @@ async function insertWorkflowRecord(options, { instanceId, workflowType, workflo
 function insertStepRecordFull(context, { instanceId, name, status, metadata, startTime, endTime, result, error, resultRef, errorRef }) {
 	return retryD1Operation(() => context.D1.prepare(`INSERT INTO StepTable
             (instanceId, stepName, stepStatus, stepMetadata, startTime, endTime, result, error, resultRef, errorRef, tenantId)
-            VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`).bind(instanceId, name, status, metadata, startTime, endTime, result, error, resultRef ?? null, errorRef ?? null, context.tenantId).run());
+            VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`).bind(instanceId, name, status, metadata, startTime, endTime, result, error, resultRef ?? null, errorRef ?? null, context.tenantId).run(), context.retryConfig);
 }
 async function getStepRecord(context, stepName, instanceId) {
-	const existingStep = await retryD1Operation(() => context.D1.prepare(`SELECT * FROM StepTable WHERE instanceId = ? AND stepName = ? AND tenantId = ?`).bind(instanceId, stepName, context.tenantId).first());
+	const existingStep = await retryD1Operation(() => context.D1.prepare(`SELECT * FROM StepTable WHERE instanceId = ? AND stepName = ? AND tenantId = ?`).bind(instanceId, stepName, context.tenantId).first(), context.retryConfig);
 	const row = existingStep;
 	if (row) {
 		const result = await deserializeWithExternalStorage(row.result, row.resultRef, context.serializer, context.externalBlobStorage);
@@ -574,7 +575,7 @@ function pushLogToDB(options, { instanceId, stepName, message, timestamp, type,
 	const truncatedMessage = truncateLogMessage(message);
 	return retryD1Operation(() => options.D1.prepare(`INSERT INTO LogTable
            (instanceId, stepName, log, timestamp, type, logOrder, tenantId)
-           VALUES (?, ?, ?, ?, ?, ?, ?)`).bind(instanceId, stepName, truncatedMessage, timestamp, type, logOrder, tenantId).run());
+           VALUES (?, ?, ?, ?, ?, ?, ?)`).bind(instanceId, stepName, truncatedMessage, timestamp, type, logOrder, tenantId).run(), options.retryConfig);
 }
 var LogBatcher = class {
 	batch = [];
@@ -614,7 +615,7 @@ var LogBatcher = class {
                  (instanceId, stepName, log, timestamp, type, logOrder, tenantId)
                  VALUES (?, ?, ?, ?, ?, ?, ?)`).bind(entry.instanceId, entry.stepName, entry.message, entry.timestamp, entry.type, entry.logOrder, entry.tenantId));
 				return await this.options.D1.batch(statements);
-			});
+			}, this.options.retryConfig);
 		} catch (error) {
 			console.error("Batch log insert failed, falling back to individual inserts:", error);
 			await Promise.all(logsToFlush.map((entry) => pushLogToDB(this.options, entry)));
@@ -744,7 +745,7 @@ async function workflowTableRowToWorkflowRun({ row, serializer, externalBlobStor
 async function updateWorkflowName(context, instanceId, newWorkflowName) {
 	return await retryD1Operation(() => context.D1.prepare(`UPDATE WorkflowTable
           SET workflowName = ?
-          WHERE instanceId = ?`).bind(newWorkflowName, instanceId).run());
+          WHERE instanceId = ?`).bind(newWorkflowName, instanceId).run(), context.retryConfig);
 }
 /**
 * Update workflow fields by instanceId. Only provided fields will be updated.
@@ -821,7 +822,7 @@ async function updateWorkflow(context, instanceId, updates) {
 	};
 	bindings.push(instanceId);
 	const sql = `UPDATE WorkflowTable SET ${setClauses.join(", ")} WHERE instanceId = ?`;
-	return await retryD1Operation(() => context.D1.prepare(sql).bind(...bindings).run());
+	return await retryD1Operation(() => context.D1.prepare(sql).bind(...bindings).run(), context.retryConfig);
 }
 /**
 * Serialize a workflow property value for storage
@@ -856,7 +857,7 @@ async function upsertWorkflowProperty({ context, instanceId, key, value, tenantI
 	const { serializedValue, valueType } = serializeWorkflowPropertyValue(value);
 	const res = await retryD1Operation(() => context.D1.prepare(`INSERT OR REPLACE INTO WorkflowProperties
           (instanceId, key, value, valueType, tenantId)
-          VALUES (?, ?, ?, ?, ?)`).bind(instanceId, key, serializedValue, valueType, tenantId).run());
+          VALUES (?, ?, ?, ?, ?)`).bind(instanceId, key, serializedValue, valueType, tenantId).run(), context.retryConfig);
 	if (res.error) {
 		console.error("Error inserting workflow property:", res.error);
 		return false;
@@ -917,7 +918,7 @@ async function createWorkflowDependency({ context, dependencyWorkflowId, depende
 		dependencyWorkflowId,
 		dependentWorkflowId,
 		tenantId
-	}).run());
+	}).run(), context.retryConfig);
 }
 /**
 * Create multiple workflow dependencies in a single transaction.
@@ -950,7 +951,7 @@ async function createWorkflowDependencies({ context, dependencies, tenantId }) {
 		tenantId,
 		createdAt
 	}));
-	return await retryD1Operation(() => context.D1.batch(statements));
+	return await retryD1Operation(() => context.D1.batch(statements), context.retryConfig);
 }
 /**
 * Delete a specific workflow dependency relationship.
@@ -968,7 +969,7 @@ async function createWorkflowDependencies({ context, dependencies, tenantId }) {
 */
 async function deleteWorkflowDependency({ context, dependencyWorkflowId, dependentWorkflowId, tenantId }) {
 	return await retryD1Operation(() => context.D1.prepare(`DELETE FROM WorkflowDependencies
-          WHERE dependencyWorkflowId = ? AND dependentWorkflowId = ? AND tenantId = ?`).bind(dependencyWorkflowId, dependentWorkflowId, tenantId).run());
+          WHERE dependencyWorkflowId = ? AND dependentWorkflowId = ? AND tenantId = ?`).bind(dependencyWorkflowId, dependentWorkflowId, tenantId).run(), context.retryConfig);
 }
 
 //#endregion
@@ -996,7 +997,7 @@ const createCleanupManager = (context) => {
         AND workflowStatus IN (${statusPlaceholders})
       ORDER BY instanceId
       LIMIT ?
-    `).bind(context.tenantId, config.deleteWorkflowsOlderThanDays, ...statuses, limit).all());
+    `).bind(context.tenantId, config.deleteWorkflowsOlderThanDays, ...statuses, limit).all(), context.retryConfig);
 		return result.results;
 	};
 	const getAffectedSteps = async (config, limit) => {
@@ -1015,7 +1016,7 @@ const createCleanupManager = (context) => {
         LIMIT ?
       )
       ORDER BY s.instanceId, s.stepName
-    `).bind(context.tenantId, config.deleteWorkflowsOlderThanDays, ...statuses, limit).all());
+    `).bind(context.tenantId, config.deleteWorkflowsOlderThanDays, ...statuses, limit).all(), context.retryConfig);
 		return result.results;
 	};
 	const collectExternalStorageKeys = (workflows, steps) => {
@@ -1068,7 +1069,7 @@ const createCleanupManager = (context) => {
 		}
 		if (deletedWorkflows.length > 0) {
 			console.log(`Proceeding to delete workflows from the database...`);
-			await retryD1Operation(() => context.D1.prepare(`PRAGMA foreign_keys = ON`).run());
+			await retryD1Operation(() => context.D1.prepare(`PRAGMA foreign_keys = ON`).run(), context.retryConfig);
 			let totalDeletedCount = 0;
 			for (let i = 0; i < deletedWorkflows.length; i += 100) {
 				const batch = deletedWorkflows.slice(i, i + 100);
@@ -1076,7 +1077,7 @@ const createCleanupManager = (context) => {
 				const result = await retryD1Operation(() => context.D1.prepare(`
           DELETE FROM WorkflowTable 
           WHERE instanceId IN (${workflowIds})
-        `).bind(...batch.map((w) => w.instanceId)).run());
+        `).bind(...batch.map((w) => w.instanceId)).run(), context.retryConfig);
 				totalDeletedCount += result.meta.changes || 0;
 			}
 			return {
@@ -1092,7 +1093,7 @@ const createCleanupManager = (context) => {
 		};
 	};
 	const cleanupOrphanedSteps = async (config, limit) => {
-		await retryD1Operation(() => context.D1.prepare(`PRAGMA foreign_keys = ON`).run());
+		await retryD1Operation(() => context.D1.prepare(`PRAGMA foreign_keys = ON`).run(), context.retryConfig);
 		const orphanedSteps = await retryD1Operation(() => context.D1.prepare(`
       SELECT s.instanceId, s.stepName, s.errorRef, s.resultRef
       FROM StepTable s
@@ -1103,7 +1104,7 @@ const createCleanupManager = (context) => {
         )
       ORDER BY s.instanceId, s.stepName
       LIMIT ?
-    `).bind(context.tenantId, context.tenantId, limit).all());
+    `).bind(context.tenantId, context.tenantId, limit).all(), context.retryConfig);
 		const orphanedStepResults = orphanedSteps.results;
 		let deletedExternalStorageKeysCount = 0;
 		if (config.deleteRefsFromExternalStorage && context.externalBlobStorage && orphanedStepResults.length > 0) {
@@ -1123,7 +1124,7 @@ const createCleanupManager = (context) => {
           DELETE FROM StepTable 
           WHERE tenantId = ?
             AND instanceId IN (${instanceIds})
-        `).bind(context.tenantId, ...batch.map((s) => s.instanceId)).run());
+        `).bind(context.tenantId, ...batch.map((s) => s.instanceId)).run(), context.retryConfig);
 				totalDeletedSteps += deletedStepsResult.meta.changes || 0;
 			}
 			return {
@@ -1139,7 +1140,7 @@ const createCleanupManager = (context) => {
 		};
 	};
 	const cleanupOrphanedLogs = async (limit) => {
-		await retryD1Operation(() => context.D1.prepare(`PRAGMA foreign_keys = ON`).run());
+		await retryD1Operation(() => context.D1.prepare(`PRAGMA foreign_keys = ON`).run(), context.retryConfig);
 		const deletedLogsResult = await retryD1Operation(() => context.D1.prepare(`
       DELETE FROM LogTable
       WHERE tenantId = ?
@@ -1155,7 +1156,7 @@ const createCleanupManager = (context) => {
           ))
         )
       LIMIT ?
-    `).bind(context.tenantId, context.tenantId, context.tenantId, limit).run());
+    `).bind(context.tenantId, context.tenantId, context.tenantId, limit).run(), context.retryConfig);
 		return { deletedOrphanedLogs: deletedLogsResult.meta.changes || 0 };
 	};
 	return {
@@ -1343,7 +1344,7 @@ const createLogAccessor = (context) => {
 		const limitClause = limit !== void 0 && actualOffset !== void 0 ? "LIMIT ? OFFSET ?" : "";
 		const sql = `SELECT * FROM StepTable ${whereClause} ORDER BY startTime ASC ${limitClause}`;
 		if (limit !== void 0 && actualOffset !== void 0) bindings.push(limit, actualOffset);
-		result = await retryD1Operation(() => context.D1.prepare(sql).bind(...bindings).all());
+		result = await retryD1Operation(() => context.D1.prepare(sql).bind(...bindings).all(), context.retryConfig);
 		if (result.results) {
 			const steps = await Promise.all(result.results.map(async (row) => {
 				let deserializedResult = null;
@@ -1370,7 +1371,7 @@ const createLogAccessor = (context) => {
 	const listWorkflows = async (limit, offset, filter, options) => {
 		const { sql, bindings } = buildFilteredWorkflowQuery(filter, { ignoreTenant: options?.ignoreTenant });
 		if (options?.debugLogs) console.log("listWorkflows SQL:", sql, "Bindings:", JSON.stringify(bindings));
-		const result = await retryD1Operation(() => context.D1.prepare(sql).bind(...bindings, limit, offset).all());
+		const result = await retryD1Operation(() => context.D1.prepare(sql).bind(...bindings, limit, offset).all(), context.retryConfig);
 		if (options?.debugLogs) console.log("listWorkflows SQL Query executed");
 		if (result.results) {
 			const workflows = await Promise.all(result.results.map((row) => workflowTableRowToWorkflowRun({
@@ -1387,7 +1388,7 @@ const createLogAccessor = (context) => {
 				for (let i = 0; i < instanceIds.length; i += BATCH_SIZE) {
 					const batchIds = instanceIds.slice(i, i + BATCH_SIZE);
 					const placeholders = batchIds.map(() => "?").join(", ");
-					const propertiesResult = await retryD1Operation(() => context.D1.prepare(`SELECT * FROM WorkflowProperties WHERE instanceId IN (${placeholders})`).bind(...batchIds).all());
+					const propertiesResult = await retryD1Operation(() => context.D1.prepare(`SELECT * FROM WorkflowProperties WHERE instanceId IN (${placeholders})`).bind(...batchIds).all(), context.retryConfig);
 					if (propertiesResult.results) for (const row of propertiesResult.results) {
 						const property = {
 							key: row.key,
@@ -1411,7 +1412,7 @@ const createLogAccessor = (context) => {
 					const dependenciesResult = await retryD1Operation(() => context.D1.prepare(`SELECT w.*, wd.createdAt, wd.dependentWorkflowId
                        FROM WorkflowDependencies wd
                        JOIN WorkflowTable w ON wd.dependencyWorkflowId = w.instanceId
-                       WHERE wd.dependentWorkflowId IN (${placeholders})`).bind(...batchIds).all());
+                       WHERE wd.dependentWorkflowId IN (${placeholders})`).bind(...batchIds).all(), context.retryConfig);
 					if (dependenciesResult.results) for (const row of dependenciesResult.results) {
 						const depWorkflow = await workflowTableRowToWorkflowRun({
 							row,
@@ -1441,7 +1442,7 @@ const createLogAccessor = (context) => {
 					const dependentsResult = await retryD1Operation(() => context.D1.prepare(`SELECT w.*, wd.createdAt, wd.dependencyWorkflowId
                        FROM WorkflowDependencies wd
                        JOIN WorkflowTable w ON wd.dependentWorkflowId = w.instanceId
-                       WHERE wd.dependencyWorkflowId IN (${placeholders})`).bind(...batchIds).all());
+                       WHERE wd.dependencyWorkflowId IN (${placeholders})`).bind(...batchIds).all(), context.retryConfig);
 					if (dependentsResult.results) for (const row of dependentsResult.results) {
 						const depWorkflow = await workflowTableRowToWorkflowRun({
 							row,
@@ -1466,7 +1467,7 @@ const createLogAccessor = (context) => {
 		return [];
 	};
 	const getWorkflowByParentId = async (parentInstanceId) => {
-		const result = await retryD1Operation(() => context.D1.prepare(`SELECT * FROM WorkflowTable WHERE parentInstanceId = ? AND tenantId = ?`).bind(parentInstanceId, context.tenantId).all());
+		const result = await retryD1Operation(() => context.D1.prepare(`SELECT * FROM WorkflowTable WHERE parentInstanceId = ? AND tenantId = ?`).bind(parentInstanceId, context.tenantId).all(), context.retryConfig);
 		if (result.results) {
 			const workflows = await Promise.all(result.results.map((row) => workflowTableRowToWorkflowRun({
 				row,
@@ -1478,7 +1479,7 @@ const createLogAccessor = (context) => {
 		return null;
 	};
 	const getWorkflowByTriggerId = async (triggerId) => {
-		const result = await retryD1Operation(() => context.D1.prepare(`SELECT * FROM WorkflowTable WHERE triggerId = ? AND tenantId = ?`).bind(triggerId, context.tenantId).first());
+		const result = await retryD1Operation(() => context.D1.prepare(`SELECT * FROM WorkflowTable WHERE triggerId = ? AND tenantId = ?`).bind(triggerId, context.tenantId).first(), context.retryConfig);
 		if (result) {
 			const workflow = await workflowTableRowToWorkflowRun({
 				row: result,
@@ -1490,12 +1491,12 @@ const createLogAccessor = (context) => {
 		return null;
 	};
 	const getWorkflowTypesByTenantId = async (tenantId) => {
-		const result = await retryD1Operation(() => context.D1.prepare(`SELECT DISTINCT workflowType FROM WorkflowTable WHERE tenantId = ?`).bind(tenantId).all());
+		const result = await retryD1Operation(() => context.D1.prepare(`SELECT DISTINCT workflowType FROM WorkflowTable WHERE tenantId = ?`).bind(tenantId).all(), context.retryConfig);
 		if (!result.results) return [];
 		return result.results.map((row) => row.workflowType);
 	};
 	const getWorkflowProperties = async (instanceId) => {
-		const result = await retryD1Operation(() => context.D1.prepare(`SELECT * FROM WorkflowProperties WHERE instanceId = ?`).bind(instanceId).all());
+		const result = await retryD1Operation(() => context.D1.prepare(`SELECT * FROM WorkflowProperties WHERE instanceId = ?`).bind(instanceId).all(), context.retryConfig);
 		if (!result.results) return [];
 		return result.results.map((row) => ({
 			key: row.key,
@@ -1505,7 +1506,7 @@ const createLogAccessor = (context) => {
 	};
 	/** This function gets the basic data of a workflow, without populating any of it's complex fields */
 	const getWorkflowShallow = async (instanceId, options) => {
-		const result = await retryD1Operation(() => context.D1.prepare(`SELECT * FROM WorkflowTable WHERE instanceId = ? AND tenantId = ?`).bind(instanceId, context.tenantId).first());
+		const result = await retryD1Operation(() => context.D1.prepare(`SELECT * FROM WorkflowTable WHERE instanceId = ? AND tenantId = ?`).bind(instanceId, context.tenantId).first(), context.retryConfig);
 		if (!result) return null;
 		const workflow = await workflowTableRowToWorkflowRun({
 			row: result,
@@ -1536,7 +1537,7 @@ const createLogAccessor = (context) => {
 			retryWorkflow.isRetryOf = workflow;
 		});
 		workflow.isRetryOf = parentWorkflow;
-		const allLogs = await retryD1Operation(() => context.D1.prepare(`SELECT * FROM LogTable WHERE instanceId = ? ORDER BY timestamp ASC, logOrder ASC`).bind(instanceId).all());
+		const allLogs = await retryD1Operation(() => context.D1.prepare(`SELECT * FROM LogTable WHERE instanceId = ? ORDER BY timestamp ASC, logOrder ASC`).bind(instanceId).all(), context.retryConfig);
 		const logs = allLogs.results?.map((logRow) => ({
 			instanceId: logRow.instanceId,
 			stepName: logRow.stepName,
@@ -1555,7 +1556,7 @@ const createLogAccessor = (context) => {
 			const dependenciesResult = await retryD1Operation(() => context.D1.prepare(`SELECT w.*, wd.createdAt 
                    FROM WorkflowDependencies wd
                    JOIN WorkflowTable w ON wd.dependencyWorkflowId = w.instanceId
-                   WHERE wd.dependentWorkflowId = ? AND wd.tenantId = ?`).bind(instanceId, context.tenantId).all());
+                   WHERE wd.dependentWorkflowId = ? AND wd.tenantId = ?`).bind(instanceId, context.tenantId).all(), context.retryConfig);
 			if (dependenciesResult.results) workflow.dependencies = await Promise.all(dependenciesResult.results.map(async (row) => {
 				const depWorkflow = await workflowTableRowToWorkflowRun({
 					row,
@@ -1574,7 +1575,7 @@ const createLogAccessor = (context) => {
 			const dependentsResult = await retryD1Operation(() => context.D1.prepare(`SELECT w.*, wd.createdAt 
                    FROM WorkflowDependencies wd
                    JOIN WorkflowTable w ON wd.dependentWorkflowId = w.instanceId
-                   WHERE wd.dependencyWorkflowId = ? AND wd.tenantId = ?`).bind(instanceId, context.tenantId).all());
+                   WHERE wd.dependencyWorkflowId = ? AND wd.tenantId = ?`).bind(instanceId, context.tenantId).all(), context.retryConfig);
 			if (dependentsResult.results) workflow.dependents = await Promise.all(dependentsResult.results.map(async (row) => {
 				const depWorkflow = await workflowTableRowToWorkflowRun({
 					row,
@@ -1592,7 +1593,7 @@ const createLogAccessor = (context) => {
 		return workflow;
 	};
 	const getStep = async (instanceId, stepName) => {
-		const result = await retryD1Operation(() => context.D1.prepare(`SELECT * FROM StepTable WHERE instanceId = ? AND stepName = ? AND tenantId = ?`).bind(instanceId, stepName, context.tenantId).all());
+		const result = await retryD1Operation(() => context.D1.prepare(`SELECT * FROM StepTable WHERE instanceId = ? AND stepName = ? AND tenantId = ?`).bind(instanceId, stepName, context.tenantId).all(), context.retryConfig);
 		if (!result.results || result.results.length === 0) return null;
 		const row = result.results[0];
 		if (!row) return null;
@@ -1609,7 +1610,7 @@ const createLogAccessor = (context) => {
 			error: deserializedError,
 			logs: []
 		};
-		const logResult = await retryD1Operation(() => context.D1.prepare(`SELECT * FROM LogTable WHERE instanceId = ? AND stepName = ? ORDER BY logOrder ASC`).bind(instanceId, stepName).all());
+		const logResult = await retryD1Operation(() => context.D1.prepare(`SELECT * FROM LogTable WHERE instanceId = ? AND stepName = ? ORDER BY logOrder ASC`).bind(instanceId, stepName).all(), context.retryConfig);
 		if (logResult.results) step.logs = logResult.results.map((logRow) => ({
 			instanceId: logRow.instanceId,
 			stepName: logRow.stepName,
@@ -1623,7 +1624,7 @@ const createLogAccessor = (context) => {
 		const result = await retryD1Operation(() => context.D1.prepare(`
       SELECT DISTINCT key, valueType FROM WorkflowProperties
       WHERE tenantId = ? AND (? IS NULL OR instanceId = ?)  
-      `).bind(context.tenantId, instanceId ?? null, instanceId ?? null).all());
+      `).bind(context.tenantId, instanceId ?? null, instanceId ?? null).all(), context.retryConfig);
 		console.log(`debug getPropertiesKeys: ${JSON.stringify(result)}`);
 		if (!result.results) return [];
 		return result.results.map((row) => ({
@@ -1689,7 +1690,7 @@ const createLogAccessor = (context) => {
       ${whereClause}
       GROUP BY workflowType
       ORDER BY workflowCount DESC
-    `).bind(...bindings).all());
+    `).bind(...bindings).all(), context.retryConfig);
 		if (!result.results) return [];
 		return result.results.map((row) => ({
 			workflowType: row.workflowType,
@@ -1877,7 +1878,8 @@ function createQueueWorkflowContext(options) {
 			D1: options.D1,
 			externalBlobStorage: options.externalBlobStorage,
 			serializer: internalContext.serializer,
-			tenantId: "unknown"
+			tenantId: "unknown",
+			retryConfig: options.retryConfig
 		});
 		const waitingWorkflows = await logAccessor.listWorkflows(250, 0, { workflowStatus: "waiting" }, {
 			ignoreTenant: true,
@@ -1924,7 +1926,7 @@ function createQueueWorkflowContext(options) {
 async function createStepContext(context) {
 	const instanceId = context.instanceId;
 	const reuseSuccessfulSteps = context.reuseSuccessfulSteps ?? true;
-	await ensureTables(context.D1);
+	await ensureTables(context.D1, context.retryConfig);
 	const step = async (step$1, callback) => {
 		const stepNameParam = typeof step$1 === "string" ? step$1 : step$1.name;
 		const stepMetadataParam = typeof step$1 === "string" ? void 0 : step$1.metadata;
@@ -2004,7 +2006,7 @@ async function createStepContext(context) {
 			const stepError$1 = null;
 			await retryD1Operation(() => context.D1.prepare(`UPDATE StepTable
           SET stepStatus = ?, endTime = ?, result = ?, error = ?, resultRef = ?, errorRef = ?
-          WHERE instanceId = ? AND stepName = ?`).bind(stepStatus$1, endTime, resultData, stepError$1, resultRef, null, instanceId, stepName).run());
+          WHERE instanceId = ? AND stepName = ?`).bind(stepStatus$1, endTime, resultData, stepError$1, resultRef, null, instanceId, stepName).run(), context.retryConfig);
 			await logBatcher.destroy();
 			return result;
 		} catch (error) {
@@ -2014,7 +2016,7 @@ async function createStepContext(context) {
 			const { data: errorData, externalRef: errorRef } = await serializeWithExternalStorage(error, context.serializer, context.externalBlobStorage);
 			await retryD1Operation(() => context.D1.prepare(`UPDATE StepTable
           SET stepStatus = ?, endTime = ?, result = ?, error = ?, resultRef = ?, errorRef = ?
-          WHERE instanceId = ? AND stepName = ?`).bind(stepStatus$1, endTime, stepResult$1, errorData, null, errorRef, instanceId, stepName).run());
+          WHERE instanceId = ? AND stepName = ?`).bind(stepStatus$1, endTime, stepResult$1, errorData, null, errorRef, instanceId, stepName).run(), context.retryConfig);
 			await logBatcher.destroy();
 			throw error;
 		}
@@ -2033,14 +2035,15 @@ function createWorkflowContext(options) {
 	};
 	const call = async ({ workflow, input, workflowName, tenantId, parentInstanceId, reuseSuccessfulSteps, triggerId, scheduledInstanceId }) => {
 		if (!ensuredTables) {
-			await ensureTables(options.D1);
+			await ensureTables(options.D1, options.retryConfig);
 			ensuredTables = true;
 		}
 		const logAccessor = createLogAccessor({
 			D1: internalContext.D1,
 			externalBlobStorage: internalContext.externalBlobStorage,
 			serializer: internalContext.serializer,
-			tenantId
+			tenantId,
+			retryConfig: options.retryConfig
 		});
 		if (scheduledInstanceId) {
 			const existingWorkflow = await logAccessor.getWorkflowShallow(scheduledInstanceId);
@@ -2096,7 +2099,8 @@ function createWorkflowContext(options) {
 			idFactory: internalContext.idFactory,
 			parentInstanceId,
 			reuseSuccessfulSteps,
-			externalBlobStorage: options.externalBlobStorage
+			externalBlobStorage: options.externalBlobStorage,
+			retryConfig: options.retryConfig
 		});
 		try {
 			const result = await workflow._callback(input, {
@@ -2116,7 +2120,10 @@ function createWorkflowContext(options) {
 					}
 				},
 				async setWorkflowName(newName) {
-					await updateWorkflowName({ D1: options.D1 }, instanceId, newName);
+					await updateWorkflowName({
+						D1: options.D1,
+						retryConfig: options.retryConfig
+					}, instanceId, newName);
 				},
 				async setWorkflowProperty(key, value) {
 					await upsertWorkflowProperty({
@@ -2166,10 +2173,10 @@ function createWorkflowContext(options) {
 	};
 	const retry = async ({ workflow, retryInstanceId, triggerId, retryOptions }) => {
 		if (!ensuredTables) {
-			await ensureTables(options.D1);
+			await ensureTables(options.D1, options.retryConfig);
 			ensuredTables = true;
 		}
-		const oldRun = await retryD1Operation(() => options.D1.prepare(`SELECT input, workflowName, tenantId, inputRef FROM WorkflowTable WHERE instanceId = ? `).bind(retryInstanceId).first());
+		const oldRun = await retryD1Operation(() => options.D1.prepare(`SELECT input, workflowName, tenantId, inputRef FROM WorkflowTable WHERE instanceId = ? `).bind(retryInstanceId).first(), options.retryConfig);
 		const oldWorkflowName = oldRun?.workflowName;
 		const tenantId = oldRun?.tenantId;
 		if (!tenantId) throw new Error(`No tenantId found for instanceId ${retryInstanceId}`);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@brandboostinggmbh/observable-workflows",
-  "version": "0.20.0-beta.4",
+  "version": "0.20.0-beta.5",
   "description": "My awesome typescript library",
   "type": "module",
   "license": "MIT",
@@ -53,7 +53,7 @@
     "test": "vitest run",
     "typecheck": "tsc --noEmit",
     "format": "prettier --cache --write .",
-    "release": "bumpp && pnpm publish",
-    "release:beta": "bumpp --preid beta && pnpm publish --tag beta"
+    "release": "npm login && bumpp && pnpm publish",
+    "release:beta": "npm login && bumpp --preid beta && pnpm publish --tag beta"
   }
 }