@dbos-inc/dbos-sdk 4.9.3-preview → 4.9.4-preview

package/dist/src/system_database.js

@@ -21,6 +21,7 @@ const database_utils_1 = require("./database_utils");
 const migration_runner_1 = require("./sysdb_migrations/migration_runner");
 const migrations_1 = require("./sysdb_migrations/internal/migrations");
 const debugpoint_1 = require("./debugpoint");
+const serialization_1 = require("./serialization");
 exports.DBOS_FUNCNAME_SEND = 'DBOS.send';
 exports.DBOS_FUNCNAME_RECV = 'DBOS.recv';
 exports.DBOS_FUNCNAME_SETEVENT = 'DBOS.setEvent';
@@ -172,8 +173,9 @@ async function insertWorkflowStatus(client, initStatus, schemaName, ownerXid, in
         queue_partition_key,
         forked_from,
         parent_workflow_id,
+        serialization,
         owner_xid
-      ) VALUES($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11, $12, $13, $14, $15, $16, $17, $18, $19, $20, $21, $22, $23, $24, $26)
+      ) VALUES($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11, $12, $13, $14, $15, $16, $17, $18, $19, $20, $21, $22, $23, $24, $26, $27)
       ON CONFLICT (workflow_uuid)
         DO UPDATE SET
           recovery_attempts = CASE
@@ -187,7 +189,7 @@ async function insertWorkflowStatus(client, initStatus, schemaName, ownerXid, in
             THEN EXCLUDED.executor_id
             ELSE workflow_status.executor_id
           END
-        RETURNING recovery_attempts, status, name, class_name, config_name, queue_name, workflow_deadline_epoch_ms, executor_id, owner_xid`, [
+        RETURNING recovery_attempts, status, name, class_name, config_name, queue_name, workflow_deadline_epoch_ms, executor_id, owner_xid, serialization`, [
             initStatus.workflowUUID,
             initStatus.status,
             initStatus.workflowName,
@@ -214,6 +216,7 @@ async function insertWorkflowStatus(client, initStatus, schemaName, ownerXid, in
             initStatus.forkedFrom ?? null,
             initStatus.parentWorkflowID ?? null,
             (incrementAttempts ?? false) ? 1 : 0,
+            initStatus.serialization,
             ownerXid,
         ]);
         if (rows.length === 0) {
@@ -222,6 +225,7 @@ async function insertWorkflowStatus(client, initStatus, schemaName, ownerXid, in
         const ret = rows[0];
         ret.class_name = ret.class_name ?? '';
         ret.config_name = ret.config_name ?? '';
+        initStatus.serialization = ret.serialization;
         return ret;
     }
     catch (error) {
@@ -287,8 +291,8 @@ async function updateWorkflowStatus(client, workflowID, status, schemaName, opti
 async function recordOperationResult(client, workflowID, functionID, functionName, checkConflict, schemaName, startTimeEpochMs, endTimeEpochMs, options = {}) {
     try {
         const out = await client.query(`INSERT INTO ${schemaName}.operation_outputs
-       (workflow_uuid, function_id, output, error, function_name, child_workflow_id, started_at_epoch_ms, completed_at_epoch_ms)
-       VALUES ($1, $2, $3, $4, $5, $6, $7, $8)
+       (workflow_uuid, function_id, output, error, function_name, child_workflow_id, started_at_epoch_ms, completed_at_epoch_ms, serialization)
+       VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9)
        ON CONFLICT DO NOTHING RETURNING completed_at_epoch_ms;`, [
             workflowID,
             functionID,
@@ -298,6 +302,7 @@ async function recordOperationResult(client, workflowID, functionID, functionNam
             options.childWorkflowID ?? null,
             startTimeEpochMs,
             endTimeEpochMs,
+            options.serialization ?? null,
         ]);
         if (checkConflict && (out?.rowCount ?? 0) > 0 && Number(out?.rows?.[0]?.completed_at_epoch_ms) !== endTimeEpochMs) {
             dbos_executor_1.DBOSExecutor.globalInstance?.logger.warn(`Step output for ${workflowID}(${functionID}):${functionName} already recorded`);
@@ -344,6 +349,7 @@ function mapWorkflowStatus(row) {
         startedAtEpochMs: row.started_at_epoch_ms ? Number(row.started_at_epoch_ms) : undefined,
         forkedFrom: row.forked_from ?? undefined,
         parentWorkflowID: row.parent_workflow_id ?? undefined,
+        serialization: row.serialization,
     };
 }
 // SQLSTATE classes/codes that are generally safe to retry
@@ -601,7 +607,7 @@ class PostgresSystemDatabase {
                 if (status === workflow_1.StatusString.MAX_RECOVERY_ATTEMPTS_EXCEEDED) {
                     throw new error_1.DBOSMaxRecoveryAttemptsExceededError(initStatus.workflowUUID, options?.maxRetries ?? -1);
                 }
-                return { status, deadlineEpochMS, shouldExecuteOnThisExecutor: false };
+                return { status, deadlineEpochMS, shouldExecuteOnThisExecutor: false, serialization: resRow.serialization };
             }
             // Upsert above already set executor assignment and incremented the recovery attempt
             shouldCommit = true;
@@ -617,7 +623,12 @@ class PostgresSystemDatabase {
                 throw new error_1.DBOSMaxRecoveryAttemptsExceededError(initStatus.workflowUUID, options.maxRetries);
             }
             this.logger.debug(`Workflow ${initStatus.workflowUUID} attempt number: ${attempts}.`);
-            return { status, deadlineEpochMS, shouldExecuteOnThisExecutor: true };
+            return {
+                status,
+                deadlineEpochMS,
+                shouldExecuteOnThisExecutor: true,
+                serialization: resRow.serialization,
+            };
         }
         finally {
             try {
@@ -744,33 +755,34 @@ class PostgresSystemDatabase {
                 priority: 0,
                 queuePartitionKey: undefined,
                 forkedFrom: workflowID,
+                serialization: workflowStatus.serialization,
             }, this.schemaName, null);
             if (startStep > 0) {
                 // Copy operation outputs
                 const copyOutputsQuery = `INSERT INTO "${this.schemaName}".operation_outputs
-          (workflow_uuid, function_id, output, error, function_name, child_workflow_id)
-          SELECT $1 AS workflow_uuid, function_id, output, error, function_name, child_workflow_id
+          (workflow_uuid, function_id, output, error, serialization, function_name, child_workflow_id)
+          SELECT $1 AS workflow_uuid, function_id, output, error, serialization, function_name, child_workflow_id
           FROM "${this.schemaName}".operation_outputs
           WHERE workflow_uuid = $2 AND function_id < $3`;
                 await client.query(copyOutputsQuery, [newWorkflowID, workflowID, startStep]);
                 // Copy streams
                 const copyStreamsQuery = `INSERT INTO "${this.schemaName}".streams
-          (workflow_uuid, key, value, "offset", function_id)
-          SELECT $1 AS workflow_uuid, key, value, "offset", function_id
+          (workflow_uuid, key, value, serialization, "offset", function_id)
+          SELECT $1 AS workflow_uuid, key, value, serialization, "offset", function_id
           FROM "${this.schemaName}".streams
           WHERE workflow_uuid = $2 AND function_id < $3`;
                 await client.query(copyStreamsQuery, [newWorkflowID, workflowID, startStep]);
                 // Copy events history
                 const copyEventsHistoryQuery = `INSERT INTO "${this.schemaName}".workflow_events_history
-          (workflow_uuid, function_id, key, value)
-          SELECT $1 AS workflow_uuid, function_id, key, value
+          (workflow_uuid, function_id, key, value, serialization)
+          SELECT $1 AS workflow_uuid, function_id, key, value, serialization
           FROM "${this.schemaName}".workflow_events_history
           WHERE workflow_uuid = $2 AND function_id < $3`;
                 await client.query(copyEventsHistoryQuery, [newWorkflowID, workflowID, startStep]);
                 // Copy only the latest version of each event (max function_id per key) into workflow_events
                 const copyLatestEventsQuery = `INSERT INTO "${this.schemaName}".workflow_events
-          (workflow_uuid, key, value)
-          SELECT $1 AS workflow_uuid, weh1.key, weh1.value
+          (workflow_uuid, key, value, serialization)
+          SELECT $1 AS workflow_uuid, weh1.key, weh1.value, serialization
           FROM "${this.schemaName}".workflow_events_history weh1
           WHERE weh1.workflow_uuid = $2
             AND weh1.function_id = (
@@ -846,7 +858,8 @@ class PostgresSystemDatabase {
             }
             else {
                 await recordOperationResult(client, workflowID, functionID, exports.DBOS_FUNCNAME_SLEEP, false, this.schemaName, Date.now(), Date.now(), {
-                    output: JSON.stringify(endTimeMs),
+                    output: serialization_1.DBOSPortableJSON.stringify(endTimeMs),
+                    serialization: serialization_1.DBOSPortableJSON.name(),
                 });
             }
             return {
@@ -859,13 +872,13 @@ class PostgresSystemDatabase {
         }
     }
     nullTopic = '__null__topic__';
-    async send(workflowID, functionID, destinationID, message, topic) {
+    async send(workflowID, functionID, destinationID, message, topic, serialization) {
         topic = topic ?? this.nullTopic;
         const client = await this.pool.connect();
         try {
             await client.query('BEGIN ISOLATION LEVEL READ COMMITTED');
             await this.#runAndRecordResult(client, exports.DBOS_FUNCNAME_SEND, workflowID, functionID, async () => {
-                await client.query(`INSERT INTO "${this.schemaName}".notifications (destination_uuid, topic, message) VALUES ($1, $2, $3);`, [destinationID, topic, message]);
+                await client.query(`INSERT INTO "${this.schemaName}".notifications (destination_uuid, topic, message, serialization) VALUES ($1, $2, $3, $4);`, [destinationID, topic, message, serialization]);
                 return undefined;
             });
             await client.query('COMMIT');
@@ -894,7 +907,7 @@ class PostgresSystemDatabase {
             if (res.functionName !== exports.DBOS_FUNCNAME_RECV) {
                 throw new error_1.DBOSUnexpectedStepError(workflowID, functionID, exports.DBOS_FUNCNAME_RECV, res.functionName);
             }
-            return res.output;
+            return { serializedValue: res.output, serialization: res.serialization ?? null };
         }
         const timeoutms = timeoutSeconds !== undefined ? timeoutSeconds * 1000 : undefined;
         let finishTime = timeoutms !== undefined ? Date.now() + timeoutms : undefined;
@@ -948,6 +961,7 @@ class PostgresSystemDatabase {
         await this.checkIfCanceled(workflowID);
         // Transactionally consume and return the message if it's in the DB, otherwise return null.
         let message = null;
+        let serialization = null;
         const client = await this.pool.connect();
         try {
             await client.query(`BEGIN ISOLATION LEVEL READ COMMITTED`);
@@ -962,12 +976,14 @@ class PostgresSystemDatabase {
             ORDER BY created_at_epoch_ms ASC
             LIMIT 1
           )
-        RETURNING notifications.message;`, [workflowID, topic])).rows;
+        RETURNING notifications.message, notifications.serialization;`, [workflowID, topic])).rows;
             if (finalRecvRows.length > 0) {
                 message = finalRecvRows[0].message;
+                serialization = finalRecvRows[0].serialization;
             }
             await recordOperationResult(client, workflowID, functionID, exports.DBOS_FUNCNAME_RECV, true, this.schemaName, startTime, Date.now(), {
                 output: message,
+                serialization,
             });
             await client.query(`COMMIT`);
         }
@@ -979,7 +995,7 @@ class PostgresSystemDatabase {
         finally {
             client.release();
         }
-        return message;
+        return { serializedValue: message, serialization };
     }
     // Only used in tests
     async setWorkflowStatus(workflowID, status, resetRecoveryAttempts, internalOptions) {
@@ -993,21 +1009,21 @@ class PostgresSystemDatabase {
             client.release();
         }
     }
-    async setEvent(workflowID, functionID, key, message) {
+    async setEvent(workflowID, functionID, key, message, serialization) {
         const client = await this.pool.connect();
         try {
             await client.query('BEGIN ISOLATION LEVEL READ COMMITTED');
             await this.#runAndRecordResult(client, exports.DBOS_FUNCNAME_SETEVENT, workflowID, functionID, async () => {
-                await client.query(`INSERT INTO "${this.schemaName}".workflow_events (workflow_uuid, key, value)
-             VALUES ($1, $2, $3)
+                await client.query(`INSERT INTO "${this.schemaName}".workflow_events (workflow_uuid, key, value, serialization)
+             VALUES ($1, $2, $3, $4)
              ON CONFLICT (workflow_uuid, key)
              DO UPDATE SET value = $3
-             RETURNING workflow_uuid;`, [workflowID, key, message]);
+             RETURNING workflow_uuid;`, [workflowID, key, message, serialization]);
                 // Also write to the immutable history table for fork support
-                await client.query(`INSERT INTO "${this.schemaName}".workflow_events_history (workflow_uuid, function_id, key, value)
-             VALUES ($1, $2, $3, $4)
+                await client.query(`INSERT INTO "${this.schemaName}".workflow_events_history (workflow_uuid, function_id, key, value, serialization)
+             VALUES ($1, $2, $3, $4, $5)
              ON CONFLICT (workflow_uuid, function_id, key)
-             DO UPDATE SET value = $4;`, [workflowID, functionID, key, message]);
+             DO UPDATE SET value = $4;`, [workflowID, functionID, key, message, serialization]);
                 return undefined;
             });
             await client.query('COMMIT');
@@ -1030,11 +1046,12 @@ class PostgresSystemDatabase {
                 if (res.functionName !== exports.DBOS_FUNCNAME_GETEVENT) {
                     throw new error_1.DBOSUnexpectedStepError(callerWorkflow.workflowID, callerWorkflow.functionID, exports.DBOS_FUNCNAME_GETEVENT, res.functionName);
                 }
-                return res.output;
+                return { serializedValue: res.output, serialization: null };
             }
         }
         // Get the return the value. if it's in the DB, otherwise return null.
         let value = null;
+        let valueSer = null;
         const payloadKey = `${workflowID}::${key}`;
         const timeoutms = timeoutSeconds !== undefined ? timeoutSeconds * 1000 : undefined;
         let finishTime = timeoutms !== undefined ? Date.now() + timeoutms : undefined;
@@ -1055,11 +1072,12 @@ class PostgresSystemDatabase {
                 if (callerWorkflow?.workflowID)
                     await this.checkIfCanceled(callerWorkflow?.workflowID);
                 // Check if the key is already in the DB, then wait for the notification if it isn't.
-                const initRecvRows = (await this.pool.query(`SELECT key, value
+                const initRecvRows = (await this.pool.query(`SELECT key, value, serialization
              FROM "${this.schemaName}".workflow_events
              WHERE workflow_uuid=$1 AND key=$2;`, [workflowID, key])).rows;
                 if (initRecvRows.length > 0) {
                     value = initRecvRows[0].value;
+                    valueSer = initRecvRows[0].serialization;
                     break;
                 }
                 const ct = Date.now();
@@ -1096,9 +1114,12 @@ class PostgresSystemDatabase {
         }
         // Record the output if it is inside a workflow.
         if (callerWorkflow) {
-            await this.recordOperationResult(callerWorkflow.workflowID, callerWorkflow.functionID, exports.DBOS_FUNCNAME_GETEVENT, true, startTime, { output: value });
+            await this.recordOperationResult(callerWorkflow.workflowID, callerWorkflow.functionID, exports.DBOS_FUNCNAME_GETEVENT, true, startTime, {
+                output: value,
+                serialization: valueSer,
+            });
         }
-        return value;
+        return { serializedValue: value, serialization: valueSer };
     }
     #setWFCancelMap(workflowID) {
         if (this.runningWorkflowMap.has(workflowID)) {
@@ -1261,7 +1282,7 @@ class PostgresSystemDatabase {
             class_name, config_name, recovery_attempts, queue_name,
             workflow_timeout_ms, workflow_deadline_epoch_ms, started_at_epoch_ms,
             deduplication_id, inputs, priority, queue_partition_key, forked_from,
-            parent_workflow_id
+            parent_workflow_id, serialization
           FROM "${this.schemaName}".workflow_status
           WHERE workflow_uuid = $1`, [wfID]);
                 if (statusResult.rows.length === 0) {
@@ -1271,19 +1292,20 @@ class PostgresSystemDatabase {
                 // Export operation_outputs
                 const outputsResult = await client.query(`SELECT
             workflow_uuid, function_id, function_name, output, error,
-            child_workflow_id, started_at_epoch_ms, completed_at_epoch_ms
+            child_workflow_id, started_at_epoch_ms, completed_at_epoch_ms,
+            serialization
           FROM "${this.schemaName}".operation_outputs
           WHERE workflow_uuid = $1`, [wfID]);
                 // Export workflow_events
-                const eventsResult = await client.query(`SELECT workflow_uuid, key, value
+                const eventsResult = await client.query(`SELECT workflow_uuid, key, value, serialization
           FROM "${this.schemaName}".workflow_events
           WHERE workflow_uuid = $1`, [wfID]);
                 // Export workflow_events_history
-                const historyResult = await client.query(`SELECT workflow_uuid, function_id, key, value
+                const historyResult = await client.query(`SELECT workflow_uuid, function_id, key, value, serialization
           FROM "${this.schemaName}".workflow_events_history
           WHERE workflow_uuid = $1`, [wfID]);
                 // Export streams
-                const streamsResult = await client.query(`SELECT workflow_uuid, key, value, "offset", function_id
+                const streamsResult = await client.query(`SELECT workflow_uuid, key, value, "offset", function_id, serialization
           FROM "${this.schemaName}".streams
           WHERE workflow_uuid = $1`, [wfID]);
                 exportedWorkflows.push({
@@ -1314,8 +1336,8 @@ class PostgresSystemDatabase {
             class_name, config_name, recovery_attempts, queue_name,
             workflow_timeout_ms, workflow_deadline_epoch_ms, started_at_epoch_ms,
             deduplication_id, inputs, priority, queue_partition_key, forked_from,
-            parent_workflow_id
-          ) VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11, $12, $13, $14, $15, $16, $17, $18, $19, $20, $21, $22, $23, $24, $25, $26, $27)`, [
+            parent_workflow_id, serialization
+          ) VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11, $12, $13, $14, $15, $16, $17, $18, $19, $20, $21, $22, $23, $24, $25, $26, $27, $28)`, [
                     status.workflow_uuid,
                     status.status,
                     status.name,
@@ -1343,13 +1365,15 @@ class PostgresSystemDatabase {
                     status.queue_partition_key,
                     status.forked_from,
                     status.parent_workflow_id,
+                    status.serialization,
                 ]);
                 // Import operation_outputs
                 for (const output of workflow.operation_outputs) {
                     await client.query(`INSERT INTO "${this.schemaName}".operation_outputs (
               workflow_uuid, function_id, function_name, output, error,
-              child_workflow_id, started_at_epoch_ms, completed_at_epoch_ms
-            ) VALUES ($1, $2, $3, $4, $5, $6, $7, $8)`, [
+              child_workflow_id, started_at_epoch_ms, completed_at_epoch_ms,
+              serialization
+            ) VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9)`, [
                         output.workflow_uuid,
                         output.function_id,
                         output.function_name,
@@ -1358,25 +1382,26 @@ class PostgresSystemDatabase {
                         output.child_workflow_id,
                         output.started_at_epoch_ms,
                         output.completed_at_epoch_ms,
+                        output.serialization,
                     ]);
                 }
                 // Import workflow_events
                 for (const event of workflow.workflow_events) {
                     await client.query(`INSERT INTO "${this.schemaName}".workflow_events (
-              workflow_uuid, key, value
-            ) VALUES ($1, $2, $3)`, [event.workflow_uuid, event.key, event.value]);
+              workflow_uuid, key, value, serialization
+            ) VALUES ($1, $2, $3, $4)`, [event.workflow_uuid, event.key, event.value, event.serialization]);
                 }
                 // Import workflow_events_history
                 for (const history of workflow.workflow_events_history) {
                     await client.query(`INSERT INTO "${this.schemaName}".workflow_events_history (
-              workflow_uuid, function_id, key, value
-            ) VALUES ($1, $2, $3, $4)`, [history.workflow_uuid, history.function_id, history.key, history.value]);
+              workflow_uuid, function_id, key, value, serialization
+            ) VALUES ($1, $2, $3, $4, $5)`, [history.workflow_uuid, history.function_id, history.key, history.value, history.serialization]);
                 }
                 // Import streams
                 for (const stream of workflow.streams) {
                     await client.query(`INSERT INTO "${this.schemaName}".streams (
-              workflow_uuid, key, value, "offset", function_id
-            ) VALUES ($1, $2, $3, $4, $5)`, [stream.workflow_uuid, stream.key, stream.value, stream.offset, stream.function_id]);
+              workflow_uuid, key, value, "offset", function_id, serialization
+            ) VALUES ($1, $2, $3, $4, $5, $6)`, [stream.workflow_uuid, stream.key, stream.value, stream.offset, stream.function_id, stream.serialization]);
                 }
             }
             await client.query('COMMIT');
@@ -1464,15 +1489,15 @@ class PostgresSystemDatabase {
                 if (callerID)
                     await this.checkIfCanceled(callerID);
                 try {
-                    const { rows } = await this.pool.query(`SELECT status, output, error FROM "${this.schemaName}".workflow_status 
+                    const { rows } = await this.pool.query(`SELECT status, output, error, serialization FROM "${this.schemaName}".workflow_status 
              WHERE workflow_uuid=$1`, [workflowID]);
                     if (rows.length > 0) {
                         const status = rows[0].status;
                         if (status === workflow_1.StatusString.SUCCESS) {
-                            return { output: rows[0].output };
+                            return { output: rows[0].output, serialization: rows[0].serialization };
                         }
                         else if (status === workflow_1.StatusString.ERROR) {
-                            return { error: rows[0].error };
+                            return { error: rows[0].error, serialization: rows[0].serialization };
                         }
                         else if (status === workflow_1.StatusString.CANCELLED) {
                             return { cancelled: true };
@@ -1652,6 +1677,9 @@ class PostgresSystemDatabase {
         if (input.loadOutput) {
             selectColumns.push('output', 'error');
         }
+        if (input.loadInput || input.loadOutput) {
+            selectColumns.push('serialization');
+        }
         input.sortDesc = input.sortDesc ?? false; // By default, sort in ascending order
         // Build WHERE clauses
         const whereClauses = [];
@@ -1871,7 +1899,7 @@ class PostgresSystemDatabase {
         // Return the IDs of all functions we marked started
         return claimedIDs;
     }
-    async writeStreamFromStep(workflowID, functionID, key, value) {
+    async writeStreamFromStep(workflowID, functionID, key, serializedValue, serialization) {
         const client = await this.pool.connect();
         try {
             await client.query('BEGIN ISOLATION LEVEL READ COMMITTED');
@@ -1881,11 +1909,9 @@ class PostgresSystemDatabase {
             // Next offset is max + 1, or 0 if no records exist
             const maxOffset = maxOffsetResult.rows[0].max;
             const nextOffset = maxOffset !== null ? maxOffset + 1 : 0;
-            // Serialize the value before storing
-            const serializedValue = JSON.stringify(value);
             // Insert the new stream entry
-            await client.query(`INSERT INTO "${this.schemaName}".streams (workflow_uuid, key, value, "offset", function_id)
-         VALUES ($1, $2, $3, $4, $5)`, [workflowID, key, serializedValue, nextOffset, functionID]);
+            await client.query(`INSERT INTO "${this.schemaName}".streams (workflow_uuid, key, value, "offset", function_id, serialization)
+         VALUES ($1, $2, $3, $4, $5, $6)`, [workflowID, key, serializedValue, nextOffset, functionID, serialization]);
             await client.query('COMMIT');
         }
         catch (e) {
@@ -1897,11 +1923,10 @@ class PostgresSystemDatabase {
             client.release();
         }
     }
-    async writeStreamFromWorkflow(workflowID, functionID, key, value) {
+    async writeStreamFromWorkflow(workflowID, functionID, key, serializedValue, serialization, functionName) {
         const client = await this.pool.connect();
         try {
             await client.query('BEGIN ISOLATION LEVEL READ COMMITTED');
-            const functionName = value === exports.DBOS_STREAM_CLOSED_SENTINEL ? exports.DBOS_FUNCNAME_CLOSESTREAM : exports.DBOS_FUNCNAME_WRITESTREAM;
             await this.#runAndRecordResult(client, functionName, workflowID, functionID, async () => {
                 // Find the maximum offset for this workflow_uuid and key combination
                 const maxOffsetResult = await client.query(`SELECT MAX("offset") FROM "${this.schemaName}".streams 
@@ -1909,11 +1934,9 @@ class PostgresSystemDatabase {
                 // Next offset is max + 1, or 0 if no records exist
                 const maxOffset = maxOffsetResult.rows[0].max;
                 const nextOffset = maxOffset !== null ? maxOffset + 1 : 0;
-                // Serialize the value before storing
-                const serializedValue = JSON.stringify(value);
                 // Insert the new stream entry
-                await client.query(`INSERT INTO "${this.schemaName}".streams (workflow_uuid, key, value, "offset", function_id)
-           VALUES ($1, $2, $3, $4, $5)`, [workflowID, key, serializedValue, nextOffset, functionID]);
+                await client.query(`INSERT INTO "${this.schemaName}".streams (workflow_uuid, key, value, "offset", function_id, serialization)
+           VALUES ($1, $2, $3, $4, $5, $6)`, [workflowID, key, serializedValue, nextOffset, functionID, serialization]);
                 return undefined;
             });
             await client.query('COMMIT');
@@ -1928,19 +1951,19 @@ class PostgresSystemDatabase {
         }
     }
     async closeStream(workflowID, functionID, key) {
-        await this.writeStreamFromWorkflow(workflowID, functionID, key, exports.DBOS_STREAM_CLOSED_SENTINEL);
+        await this.writeStreamFromWorkflow(workflowID, functionID, key, exports.DBOS_STREAM_CLOSED_SENTINEL, 'portable_json', exports.DBOS_FUNCNAME_CLOSESTREAM);
     }
     async readStream(workflowID, key, offset) {
         const client = await this.pool.connect();
         try {
-            const result = await client.query(`SELECT value FROM "${this.schemaName}".streams 
+            const result = await client.query(`SELECT value, serialization FROM "${this.schemaName}".streams 
          WHERE workflow_uuid = $1 AND key = $2 AND "offset" = $3`, [workflowID, key, offset]);
             if (result.rows.length === 0) {
                 throw new Error(`No value found for workflow_uuid=${workflowID}, key=${key}, offset=${offset}`);
             }
             // Deserialize the value before returning
             const row = result.rows[0];
-            return JSON.parse(row.value);
+            return { serializedValue: row.value, serialization: row.serialization };
         }
         finally {
             client.release();
@@ -2072,7 +2095,7 @@ __decorate([
 __decorate([
     dbRetry(),
     __metadata("design:type", Function),
-    __metadata("design:paramtypes", [String, Number, String, Object, String]),
+    __metadata("design:paramtypes", [String, Number, String, Object, Object, Object]),
     __metadata("design:returntype", Promise)
 ], PostgresSystemDatabase.prototype, "send", null);
 __decorate([
@@ -2084,7 +2107,7 @@ __decorate([
 __decorate([
     dbRetry(),
     __metadata("design:type", Function),
-    __metadata("design:paramtypes", [String, Number, String, Object]),
+    __metadata("design:paramtypes", [String, Number, String, Object, Object]),
     __metadata("design:returntype", Promise)
 ], PostgresSystemDatabase.prototype, "setEvent", null);
 __decorate([
@@ -2138,13 +2161,13 @@ __decorate([
 __decorate([
     dbRetry(),
     __metadata("design:type", Function),
-    __metadata("design:paramtypes", [String, Number, String, Object]),
+    __metadata("design:paramtypes", [String, Number, String, String, Object]),
     __metadata("design:returntype", Promise)
 ], PostgresSystemDatabase.prototype, "writeStreamFromStep", null);
 __decorate([
     dbRetry(),
     __metadata("design:type", Function),
-    __metadata("design:paramtypes", [String, Number, String, Object]),
+    __metadata("design:paramtypes", [String, Number, String, String, Object, String]),
     __metadata("design:returntype", Promise)
 ], PostgresSystemDatabase.prototype, "writeStreamFromWorkflow", null);
 __decorate([