fix(workflow-tests): keep the error of a mock that throws (#9333)

* fix(workflow-tests): keep the error of a mock that throws

A mock that throws reaches the server as { runId, callId, error }. The reply
schema tried the output branch first, and its optional `output` matched,
stripping `error`: the block failed with "A mocked block must return an
object" instead of the thrown message, so a workflow that branches on its
error text behaved differently under test than live. The error branch is now
tried first.

* fix(workflow-tests): never read a mock error past the cap as an empty output

An error longer than the 10,000-character cap failed the error branch and
fell through to the output branch, which still read it as an empty output.
The output branch is now strict, so such a reply is refused instead.

* test(workflow-tests): drop the case that restates the reply schema

Author: waleedlatif1

apps/sim/lib/workflow-tests/protocol.test.ts

@@ -0,0 +1,20 @@
+import { describe, expect, it } from 'vitest'
+import { testReplyArgsSchema } from '@/lib/workflow-tests/protocol'
+
+describe('testReplyArgsSchema', () => {
+  it('keeps the error of a mock that threw', () => {
+    // The sandbox sends no `output` key for a thrown mock; an optional `output` must not claim it.
+    expect(
+      testReplyArgsSchema.parse({ runId: 'r', callId: 'c', error: '409 version conflict' })
+    ).toEqual({
+      runId: 'r',
+      callId: 'c',
+      error: '409 version conflict',
+    })
+  })
+
+  it('never reads an error past the cap as an empty output', () => {
+    const reply = { runId: 'r', callId: 'c', error: 'x'.repeat(10_001) }
+    expect(testReplyArgsSchema.safeParse(reply).success).toBe(false)
+  })
+})

apps/sim/lib/workflow-tests/protocol.ts

@@ -40,9 +40,17 @@ export const testStartArgsSchema = z.object({
   targets: z.array(testTargetSchema).max(MAX_TARGETS),
 })
 
+/**
+ * A mock's answer: its output, or the error it threw. The error branch is tried first, because
+ * `output: z.unknown()` also accepts an object with no `output`, which would turn a thrown mock
+ * into an empty output and lose its message.
+ */
 export const testReplyArgsSchema = z.union([
-  z.object({ runId: z.string().min(1), callId: z.string().min(1), output: z.unknown() }),
   z.object({ runId: z.string().min(1), callId: z.string().min(1), error: z.string().max(10_000) }),
+  // Strict, so a reply carrying an `error` (one past the cap included) is never read as an output.
+  z
+    .object({ runId: z.string().min(1), callId: z.string().min(1), output: z.unknown() })
+    .strict(),
 ])
 
 export const testNextArgsSchema = z.object({ runId: z.string().min(1) })