From 92b09932207c496a380aa69efa5f85a8a101531e Mon Sep 17 00:00:00 2001
From: Frank Midigo <midigofrank@gmail.com>
Date: Wed, 22 Apr 2026 08:25:36 +0300
Subject: [PATCH 01/21] PoC for webhook responses

---
 lib/lightning/workflows/trigger.ex        |  2 +
 lib/lightning_web/channels/run_channel.ex | 49 +++++++++++++++--------
 2 files changed, 35 insertions(+), 16 deletions(-)

diff --git a/lib/lightning/workflows/trigger.ex b/lib/lightning/workflows/trigger.ex
index c6aa449e350..60b7b79362e 100644
--- a/lib/lightning/workflows/trigger.ex
+++ b/lib/lightning/workflows/trigger.ex
@@ -55,6 +55,8 @@ defmodule Lightning.Workflows.Trigger do
 
     field :delete, :boolean, virtual: true
     field :has_auth_method, :boolean, virtual: true
+    field :webhook_response_success_code, :integer, virtual: true, default: 200
+    field :webhook_response_error_code, :integer, virtual: true, default: 400
 
     many_to_many :webhook_auth_methods, Lightning.Workflows.WebhookAuthMethod,
       join_through: "trigger_webhook_auth_methods",
diff --git a/lib/lightning_web/channels/run_channel.ex b/lib/lightning_web/channels/run_channel.ex
index 4ff9d65ceef..c7df66b0d04 100644
--- a/lib/lightning_web/channels/run_channel.ex
+++ b/lib/lightning_web/channels/run_channel.ex
@@ -210,6 +210,7 @@ defmodule LightningWeb.RunChannel do
         reply_with(socket, {:error, changeset})
 
       {:ok, step} ->
+        maybe_broadcast_custom_webhook_response(socket.assigns.run, payload)
         reply_with(socket, {:ok, %{step_id: step.id}})
     end
   end
@@ -306,6 +307,32 @@ defmodule LightningWeb.RunChannel do
   # Ignore other messages
   def handle_info(_msg, socket), do: {:noreply, socket}
 
+  defp maybe_broadcast_custom_webhook_response(run, payload) do
+    case payload["webhook_response"] do
+      nil ->
+        :ok
+
+      webhook_response ->
+        run_with_preloads = Repo.preload(run, work_order: [:trigger])
+        trigger = run_with_preloads.work_order.trigger
+
+        if trigger && trigger.type == :webhook &&
+             trigger.webhook_reply == :custom do
+          topic =
+            "work_order:#{run_with_preloads.work_order.id}:webhook_response"
+
+          status_code = webhook_response["code"] || 200
+          body = webhook_response["body"] || %{}
+
+          Phoenix.PubSub.broadcast(
+            Lightning.PubSub,
+            topic,
+            {:webhook_response, status_code, body}
+          )
+        end
+    end
+  end
+
   defp maybe_broadcast_webhook_response(run, payload) do
     work_order = run.work_order
     trigger = work_order.trigger
@@ -313,10 +340,7 @@ defmodule LightningWeb.RunChannel do
     if trigger && trigger.type == :webhook &&
          trigger.webhook_reply == :after_completion do
       topic = "work_order:#{work_order.id}:webhook_response"
-
-      # TODO - Later allow workflow authors to customize the status code
-      # and body of the reply.
-      status_code = determine_status_code(run.state)
+      status_code = determine_status_code(run.state, trigger)
 
       body = %{
         data: payload["final_state"],
@@ -340,18 +364,11 @@ defmodule LightningWeb.RunChannel do
     end
   end
 
-  # TODO - decide how we should respond... do we use HTTP codes for run states?
-  defp determine_status_code(state) do
-    case state do
-      :success -> 201
-      :failed -> 201
-      :crashed -> 201
-      :exception -> 201
-      :killed -> 201
-      :cancelled -> 201
-      _other -> 201
-    end
-  end
+  defp determine_status_code(:success, trigger),
+    do: trigger.webhook_response_success_code
+
+  defp determine_status_code(_state, trigger),
+    do: trigger.webhook_response_error_code
 
   defp update_scrubber(nil, samples, basic_auth) do
     Scrubber.start_link(samples: samples, basic_auth: basic_auth)

From 53b09e6755e98c50523afd5882e0f903aeae0917 Mon Sep 17 00:00:00 2001
From: Frank Midigo <midigofrank@gmail.com>
Date: Wed, 22 Apr 2026 08:59:59 +0300
Subject: [PATCH 02/21] Allow users to change status codes from UI

---
 .../adapters/YAMLStateToYDoc.ts               |   8 +
 .../components/inspector/TriggerForm.tsx      | 139 +++++++++++++++++-
 .../js/collaborative-editor/types/session.ts  |   4 +-
 .../js/collaborative-editor/types/trigger.ts  |  18 ++-
 assets/js/yaml/types.ts                       |   2 +
 .../collaboration/workflow_serializer.ex      |  22 ++-
 lib/lightning/workflows/trigger.ex            |  27 +++-
 lib/lightning_web/channels/run_channel.ex     |   4 +-
 ...add_webhook_response_codes_to_triggers.exs |  10 ++
 9 files changed, 223 insertions(+), 11 deletions(-)
 create mode 100644 priv/repo/migrations/20260422052858_add_webhook_response_codes_to_triggers.exs

diff --git a/assets/js/collaborative-editor/adapters/YAMLStateToYDoc.ts b/assets/js/collaborative-editor/adapters/YAMLStateToYDoc.ts
index 1ea725db71d..f3f946f62f4 100644
--- a/assets/js/collaborative-editor/adapters/YAMLStateToYDoc.ts
+++ b/assets/js/collaborative-editor/adapters/YAMLStateToYDoc.ts
@@ -77,6 +77,14 @@ export class YAMLStateToYDoc {
 
     if (trigger.type === 'webhook') {
       triggerMap.set('webhook_reply', trigger.webhook_reply ?? null);
+      triggerMap.set(
+        'webhook_response_success_code',
+        trigger.webhook_response_success_code ?? null
+      );
+      triggerMap.set(
+        'webhook_response_error_code',
+        trigger.webhook_response_error_code ?? null
+      );
     }
 
     return triggerMap;
diff --git a/assets/js/collaborative-editor/components/inspector/TriggerForm.tsx b/assets/js/collaborative-editor/components/inspector/TriggerForm.tsx
index a1be264f046..01e336f8527 100644
--- a/assets/js/collaborative-editor/components/inspector/TriggerForm.tsx
+++ b/assets/js/collaborative-editor/components/inspector/TriggerForm.tsx
@@ -398,6 +398,7 @@ export function TriggerForm({ trigger }: TriggerFormProps) {
                                   e.target.value as
                                     | 'before_start'
                                     | 'after_completion'
+                                    | 'custom'
                                 )
                               }
                               onBlur={field.handleBlur}
@@ -418,14 +419,17 @@ export function TriggerForm({ trigger }: TriggerFormProps) {
                                 Async (default)
                               </option>
                               <option value="after_completion">Sync</option>
+                              <option value="custom">Custom (from job)</option>
                             </select>
                             <p
                               id={`${field.name}-description`}
                               className="mt-1 text-xs text-slate-500"
                             >
                               {field.state.value === 'after_completion'
-                                ? 'Responds with the final output state after the run completes. (Note that depending on your queue size and the duration of the workflow itself, this could take a long time.)'
-                                : 'Responds immediately with the enqueued work order ID.'}
+                                ? 'Responds with the final output state after the run completes. You can customise the HTTP status codes returned below.'
+                                : field.state.value === 'custom'
+                                  ? 'The job code itself sends the HTTP response using the send() function.'
+                                  : 'Responds immediately with the enqueued work order ID.'}
                             </p>
                             {field.state.meta.errors.map(error => (
                               <p
@@ -438,6 +442,137 @@ export function TriggerForm({ trigger }: TriggerFormProps) {
                           </div>
                         )}
                       </form.Field>
+
+                      {/* Conditional response code fields for after_completion */}
+                      <form.Field name="webhook_reply">
+                        {replyField => {
+                          if (replyField.state.value !== 'after_completion') {
+                            return null;
+                          }
+
+                          return (
+                            <div className="space-y-4 animate-in fade-in slide-in-from-top-2 duration-200">
+                              {/* Success Status Code */}
+                              <form.Field
+                                name="webhook_response_success_code"
+                                validators={{
+                                  onChange: createZodValidator(TriggerSchema),
+                                }}
+                              >
+                                {field => (
+                                  <div>
+                                    <label
+                                      htmlFor={field.name}
+                                      className="block text-sm font-medium text-slate-800 mb-1"
+                                    >
+                                      Success status code
+                                    </label>
+                                    <input
+                                      id={field.name}
+                                      type="number"
+                                      min="100"
+                                      max="599"
+                                      value={
+                                        (field.state.value as number | null) ??
+                                        ''
+                                      }
+                                      onChange={e =>
+                                        field.handleChange(
+                                          e.target.value === ''
+                                            ? null
+                                            : parseInt(e.target.value, 10)
+                                        )
+                                      }
+                                      onBlur={field.handleBlur}
+                                      disabled={isReadOnly}
+                                      className={cn(
+                                        'block w-full px-3 py-2',
+                                        'border rounded-md text-sm',
+                                        field.state.meta.errors.length > 0
+                                          ? 'border-red-300 text-red-900 focus:border-red-500 focus:ring-red-500'
+                                          : 'border-slate-300 focus:border-indigo-500 focus:ring-indigo-500',
+                                        'focus:outline-none focus:ring-1',
+                                        'disabled:opacity-50 disabled:cursor-not-allowed'
+                                      )}
+                                    />
+                                    <p className="mt-1 text-xs text-slate-500">
+                                      HTTP status code returned when the run
+                                      succeeds (default: 200)
+                                    </p>
+                                    {field.state.meta.errors.map(error => (
+                                      <p
+                                        key={error}
+                                        className="mt-1 text-xs text-red-600"
+                                      >
+                                        {error}
+                                      </p>
+                                    ))}
+                                  </div>
+                                )}
+                              </form.Field>
+
+                              {/* Error Status Code */}
+                              <form.Field
+                                name="webhook_response_error_code"
+                                validators={{
+                                  onChange: createZodValidator(TriggerSchema),
+                                }}
+                              >
+                                {field => (
+                                  <div>
+                                    <label
+                                      htmlFor={field.name}
+                                      className="block text-sm font-medium text-slate-800 mb-1"
+                                    >
+                                      Error status code
+                                    </label>
+                                    <input
+                                      id={field.name}
+                                      type="number"
+                                      min="100"
+                                      max="599"
+                                      value={
+                                        (field.state.value as number | null) ??
+                                        ''
+                                      }
+                                      onChange={e =>
+                                        field.handleChange(
+                                          e.target.value === ''
+                                            ? null
+                                            : parseInt(e.target.value, 10)
+                                        )
+                                      }
+                                      onBlur={field.handleBlur}
+                                      disabled={isReadOnly}
+                                      className={cn(
+                                        'block w-full px-3 py-2',
+                                        'border rounded-md text-sm',
+                                        field.state.meta.errors.length > 0
+                                          ? 'border-red-300 text-red-900 focus:border-red-500 focus:ring-red-500'
+                                          : 'border-slate-300 focus:border-indigo-500 focus:ring-indigo-500',
+                                        'focus:outline-none focus:ring-1',
+                                        'disabled:opacity-50 disabled:cursor-not-allowed'
+                                      )}
+                                    />
+                                    <p className="mt-1 text-xs text-slate-500">
+                                      HTTP status code returned when the run
+                                      fails (default: 400)
+                                    </p>
+                                    {field.state.meta.errors.map(error => (
+                                      <p
+                                        key={error}
+                                        className="mt-1 text-xs text-red-600"
+                                      >
+                                        {error}
+                                      </p>
+                                    ))}
+                                  </div>
+                                )}
+                              </form.Field>
+                            </div>
+                          );
+                        }}
+                      </form.Field>
                     </div>
                   </div>
                 );
diff --git a/assets/js/collaborative-editor/types/session.ts b/assets/js/collaborative-editor/types/session.ts
index 3c418b7bcfb..e56a339a11e 100644
--- a/assets/js/collaborative-editor/types/session.ts
+++ b/assets/js/collaborative-editor/types/session.ts
@@ -70,7 +70,9 @@ export namespace Session {
     enabled: boolean;
     cron_expression: string | null;
     has_auth_method: boolean;
-    webhook_reply: 'before_start' | 'after_completion' | null;
+    webhook_reply: 'before_start' | 'after_completion' | 'custom' | null;
+    webhook_response_success_code: number | null;
+    webhook_response_error_code: number | null;
     webhook_auth_methods: Array<{
       id: string;
       name: string;
diff --git a/assets/js/collaborative-editor/types/trigger.ts b/assets/js/collaborative-editor/types/trigger.ts
index 6605f9f212f..1f6dfd209eb 100644
--- a/assets/js/collaborative-editor/types/trigger.ts
+++ b/assets/js/collaborative-editor/types/trigger.ts
@@ -21,9 +21,23 @@ const webhookTriggerSchema = baseTriggerSchema.extend({
   cron_cursor_job_id: z.null().default(null),
   kafka_configuration: z.null().default(null),
   webhook_reply: z
-    .enum(['before_start', 'after_completion'])
+    .enum(['before_start', 'after_completion', 'custom'])
     .nullable()
     .default('before_start'),
+  webhook_response_success_code: z
+    .number()
+    .int()
+    .min(100)
+    .max(599)
+    .nullable()
+    .default(null),
+  webhook_response_error_code: z
+    .number()
+    .int()
+    .min(100)
+    .max(599)
+    .nullable()
+    .default(null),
 });
 
 // Cron trigger schema with professional validation using cron-validator
@@ -137,6 +151,8 @@ export const createDefaultTrigger = (
         cron_cursor_job_id: null,
         kafka_configuration: null,
         webhook_reply: 'before_start' as const,
+        webhook_response_success_code: null,
+        webhook_response_error_code: null,
       };
 
     case 'cron':
diff --git a/assets/js/yaml/types.ts b/assets/js/yaml/types.ts
index 321d29ffffa..7a5f42b307c 100644
--- a/assets/js/yaml/types.ts
+++ b/assets/js/yaml/types.ts
@@ -29,6 +29,8 @@ export type StateWebhookTrigger = {
   enabled: boolean;
   type: 'webhook';
   webhook_reply: 'before_start' | 'after_completion' | 'custom' | null;
+  webhook_response_success_code?: number | null;
+  webhook_response_error_code?: number | null;
 };
 
 export type StateKafkaTrigger = {
diff --git a/lib/lightning/collaboration/workflow_serializer.ex b/lib/lightning/collaboration/workflow_serializer.ex
index c65a2215e62..08e7a594a38 100644
--- a/lib/lightning/collaboration/workflow_serializer.ex
+++ b/lib/lightning/collaboration/workflow_serializer.ex
@@ -228,7 +228,10 @@ defmodule Lightning.Collaboration.WorkflowSerializer do
           "id" => trigger.id,
           "type" => trigger.type |> to_string(),
           "webhook_reply" =>
-            trigger.webhook_reply && to_string(trigger.webhook_reply)
+            trigger.webhook_reply && to_string(trigger.webhook_reply),
+          "webhook_response_success_code" =>
+            trigger.webhook_response_success_code,
+          "webhook_response_error_code" => trigger.webhook_response_error_code
         })
 
       Yex.Array.push(triggers_array, trigger_map)
@@ -274,9 +277,11 @@ defmodule Lightning.Collaboration.WorkflowSerializer do
     |> Enum.map(fn trigger ->
       trigger
       |> Map.take(
-        ~w(id type enabled cron_expression cron_cursor_job_id webhook_reply kafka_configuration)
+        ~w(id type enabled cron_expression cron_cursor_job_id webhook_reply
+           kafka_configuration webhook_response_success_code webhook_response_error_code)
       )
       |> normalize_kafka_configuration()
+      |> normalize_response_codes()
     end)
   end
 
@@ -299,6 +304,19 @@ defmodule Lightning.Collaboration.WorkflowSerializer do
 
   defp normalize_kafka_configuration(trigger), do: trigger
 
+  defp normalize_response_codes(trigger) do
+    trigger
+    |> normalize_integer_field("webhook_response_success_code")
+    |> normalize_integer_field("webhook_response_error_code")
+  end
+
+  defp normalize_integer_field(map, key) do
+    case Map.fetch(map, key) do
+      {:ok, value} when is_float(value) -> Map.put(map, key, trunc(value))
+      _ -> map
+    end
+  end
+
   defp extract_positions(positions_map) do
     Yex.Map.to_json(positions_map)
   end
diff --git a/lib/lightning/workflows/trigger.ex b/lib/lightning/workflows/trigger.ex
index 60b7b79362e..1cd9328cd2b 100644
--- a/lib/lightning/workflows/trigger.ex
+++ b/lib/lightning/workflows/trigger.ex
@@ -55,8 +55,8 @@ defmodule Lightning.Workflows.Trigger do
 
     field :delete, :boolean, virtual: true
     field :has_auth_method, :boolean, virtual: true
-    field :webhook_response_success_code, :integer, virtual: true, default: 200
-    field :webhook_response_error_code, :integer, virtual: true, default: 400
+    field :webhook_response_success_code, :integer
+    field :webhook_response_error_code, :integer
 
     many_to_many :webhook_auth_methods, Lightning.Workflows.WebhookAuthMethod,
       join_through: "trigger_webhook_auth_methods",
@@ -106,7 +106,9 @@ defmodule Lightning.Workflows.Trigger do
       :cron_expression,
       :cron_cursor_job_id,
       :has_auth_method,
-      :webhook_reply
+      :webhook_reply,
+      :webhook_response_success_code,
+      :webhook_response_error_code
     ])
   end
 
@@ -143,6 +145,7 @@ defmodule Lightning.Workflows.Trigger do
         |> put_change(:cron_cursor_job_id, nil)
         |> put_change(:kafka_configuration, nil)
         |> put_default(:webhook_reply, :before_start)
+        |> maybe_reset_response_codes()
 
       :cron ->
         changeset
@@ -150,6 +153,8 @@ defmodule Lightning.Workflows.Trigger do
         |> validate_cron()
         |> put_change(:kafka_configuration, nil)
         |> put_change(:webhook_reply, nil)
+        |> put_change(:webhook_response_success_code, nil)
+        |> put_change(:webhook_response_error_code, nil)
 
       :kafka ->
         changeset
@@ -157,12 +162,28 @@ defmodule Lightning.Workflows.Trigger do
         |> put_change(:cron_cursor_job_id, nil)
         |> validate_required([:kafka_configuration])
         |> put_change(:webhook_reply, nil)
+        |> put_change(:webhook_response_success_code, nil)
+        |> put_change(:webhook_response_error_code, nil)
 
       nil ->
         changeset
     end
   end
 
+  defp maybe_reset_response_codes(changeset) do
+    case fetch_field!(changeset, :webhook_reply) do
+      :after_completion ->
+        changeset
+        |> put_default(:webhook_response_success_code, 200)
+        |> put_default(:webhook_response_error_code, 400)
+
+      _ ->
+        changeset
+        |> put_change(:webhook_response_success_code, nil)
+        |> put_change(:webhook_response_error_code, nil)
+    end
+  end
+
   defp put_default(changeset, field, value) do
     changeset
     |> get_field(field)
diff --git a/lib/lightning_web/channels/run_channel.ex b/lib/lightning_web/channels/run_channel.ex
index c7df66b0d04..fbc9b399092 100644
--- a/lib/lightning_web/channels/run_channel.ex
+++ b/lib/lightning_web/channels/run_channel.ex
@@ -365,10 +365,10 @@ defmodule LightningWeb.RunChannel do
   end
 
   defp determine_status_code(:success, trigger),
-    do: trigger.webhook_response_success_code
+    do: trigger.webhook_response_success_code || 200
 
   defp determine_status_code(_state, trigger),
-    do: trigger.webhook_response_error_code
+    do: trigger.webhook_response_error_code || 400
 
   defp update_scrubber(nil, samples, basic_auth) do
     Scrubber.start_link(samples: samples, basic_auth: basic_auth)
diff --git a/priv/repo/migrations/20260422052858_add_webhook_response_codes_to_triggers.exs b/priv/repo/migrations/20260422052858_add_webhook_response_codes_to_triggers.exs
new file mode 100644
index 00000000000..828169cbaa0
--- /dev/null
+++ b/priv/repo/migrations/20260422052858_add_webhook_response_codes_to_triggers.exs
@@ -0,0 +1,10 @@
+defmodule Lightning.Repo.Migrations.AddWebhookResponseCodesToTriggers do
+  use Ecto.Migration
+
+  def change do
+    alter table(:triggers) do
+      add :webhook_response_success_code, :integer, null: true
+      add :webhook_response_error_code, :integer, null: true
+    end
+  end
+end

From 5dd0bfe6446ee9e58eddf548a93b13a72acd3354 Mon Sep 17 00:00:00 2001
From: Frank Midigo <midigofrank@gmail.com>
Date: Wed, 22 Apr 2026 09:08:20 +0300
Subject: [PATCH 03/21] add fields to snapshot

---
 lib/lightning/workflows/snapshot.ex | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/lib/lightning/workflows/snapshot.ex b/lib/lightning/workflows/snapshot.ex
index 07108390739..468b9b2196d 100644
--- a/lib/lightning/workflows/snapshot.ex
+++ b/lib/lightning/workflows/snapshot.ex
@@ -64,6 +64,9 @@ defmodule Lightning.Workflows.Snapshot do
         values: [:before_start, :after_completion, :custom],
         default: :before_start
 
+      field :webhook_response_success_code, :integer
+      field :webhook_response_error_code, :integer
+
       many_to_many :webhook_auth_methods, WebhookAuthMethod,
         join_through: "trigger_webhook_auth_methods",
         on_replace: :delete

From 54535d165e42a4f886b921e48ba0f20882f05a32 Mon Sep 17 00:00:00 2001
From: Frank Midigo <midigofrank@gmail.com>
Date: Fri, 24 Apr 2026 07:48:45 +0300
Subject: [PATCH 04/21] use jsonb config

---
 .../adapters/YAMLStateToYDoc.ts               |   8 +-
 .../components/inspector/TriggerForm.tsx      | 247 +++++++++---------
 .../js/collaborative-editor/types/session.ts  |   8 +-
 .../js/collaborative-editor/types/trigger.ts  |  22 +-
 assets/js/yaml/types.ts                       |   8 +-
 .../collaboration/workflow_serializer.ex      |  43 +--
 lib/lightning/workflows/trigger.ex            |  47 ++--
 .../triggers/sync_webhook_response_config.ex  |  25 ++
 lib/lightning_web/channels/run_channel.ex     |  88 +++----
 ...dd_webhook_response_codes_to_triggers.exs} |   3 +-
 10 files changed, 261 insertions(+), 238 deletions(-)
 create mode 100644 lib/lightning/workflows/triggers/sync_webhook_response_config.ex
 rename priv/repo/migrations/{20260422052858_add_webhook_response_codes_to_triggers.exs => 20260422052859_add_webhook_response_codes_to_triggers.exs} (56%)

diff --git a/assets/js/collaborative-editor/adapters/YAMLStateToYDoc.ts b/assets/js/collaborative-editor/adapters/YAMLStateToYDoc.ts
index f3f946f62f4..c62ab4fcf86 100644
--- a/assets/js/collaborative-editor/adapters/YAMLStateToYDoc.ts
+++ b/assets/js/collaborative-editor/adapters/YAMLStateToYDoc.ts
@@ -78,12 +78,8 @@ export class YAMLStateToYDoc {
     if (trigger.type === 'webhook') {
       triggerMap.set('webhook_reply', trigger.webhook_reply ?? null);
       triggerMap.set(
-        'webhook_response_success_code',
-        trigger.webhook_response_success_code ?? null
-      );
-      triggerMap.set(
-        'webhook_response_error_code',
-        trigger.webhook_response_error_code ?? null
+        'sync_webhook_response_config',
+        trigger.sync_webhook_response_config ?? null
       );
     }
 
diff --git a/assets/js/collaborative-editor/components/inspector/TriggerForm.tsx b/assets/js/collaborative-editor/components/inspector/TriggerForm.tsx
index 01e336f8527..06dbb1ffc0c 100644
--- a/assets/js/collaborative-editor/components/inspector/TriggerForm.tsx
+++ b/assets/js/collaborative-editor/components/inspector/TriggerForm.tsx
@@ -398,7 +398,6 @@ export function TriggerForm({ trigger }: TriggerFormProps) {
                                   e.target.value as
                                     | 'before_start'
                                     | 'after_completion'
-                                    | 'custom'
                                 )
                               }
                               onBlur={field.handleBlur}
@@ -419,17 +418,14 @@ export function TriggerForm({ trigger }: TriggerFormProps) {
                                 Async (default)
                               </option>
                               <option value="after_completion">Sync</option>
-                              <option value="custom">Custom (from job)</option>
                             </select>
                             <p
                               id={`${field.name}-description`}
                               className="mt-1 text-xs text-slate-500"
                             >
                               {field.state.value === 'after_completion'
-                                ? 'Responds with the final output state after the run completes. You can customise the HTTP status codes returned below.'
-                                : field.state.value === 'custom'
-                                  ? 'The job code itself sends the HTTP response using the send() function.'
-                                  : 'Responds immediately with the enqueued work order ID.'}
+                                ? 'Holds the HTTP connection open and responds when the run completes. Jobs can send an early response using setWebhookResponse().'
+                                : 'Responds immediately with the enqueued work order ID.'}
                             </p>
                             {field.state.meta.errors.map(error => (
                               <p
@@ -443,7 +439,7 @@ export function TriggerForm({ trigger }: TriggerFormProps) {
                         )}
                       </form.Field>
 
-                      {/* Conditional response code fields for after_completion */}
+                      {/* Conditional config fields for after_completion */}
                       <form.Field name="webhook_reply">
                         {replyField => {
                           if (replyField.state.value !== 'after_completion') {
@@ -451,125 +447,136 @@ export function TriggerForm({ trigger }: TriggerFormProps) {
                           }
 
                           return (
-                            <div className="space-y-4 animate-in fade-in slide-in-from-top-2 duration-200">
-                              {/* Success Status Code */}
-                              <form.Field
-                                name="webhook_response_success_code"
-                                validators={{
-                                  onChange: createZodValidator(TriggerSchema),
-                                }}
-                              >
-                                {field => (
-                                  <div>
-                                    <label
-                                      htmlFor={field.name}
-                                      className="block text-sm font-medium text-slate-800 mb-1"
-                                    >
-                                      Success status code
-                                    </label>
-                                    <input
-                                      id={field.name}
-                                      type="number"
-                                      min="100"
-                                      max="599"
-                                      value={
-                                        (field.state.value as number | null) ??
-                                        ''
-                                      }
-                                      onChange={e =>
-                                        field.handleChange(
-                                          e.target.value === ''
-                                            ? null
-                                            : parseInt(e.target.value, 10)
-                                        )
-                                      }
-                                      onBlur={field.handleBlur}
-                                      disabled={isReadOnly}
-                                      className={cn(
-                                        'block w-full px-3 py-2',
-                                        'border rounded-md text-sm',
-                                        field.state.meta.errors.length > 0
-                                          ? 'border-red-300 text-red-900 focus:border-red-500 focus:ring-red-500'
-                                          : 'border-slate-300 focus:border-indigo-500 focus:ring-indigo-500',
-                                        'focus:outline-none focus:ring-1',
-                                        'disabled:opacity-50 disabled:cursor-not-allowed'
-                                      )}
-                                    />
-                                    <p className="mt-1 text-xs text-slate-500">
-                                      HTTP status code returned when the run
-                                      succeeds (default: 200)
-                                    </p>
-                                    {field.state.meta.errors.map(error => (
-                                      <p
-                                        key={error}
-                                        className="mt-1 text-xs text-red-600"
+                            <form.Field name="sync_webhook_response_config">
+                              {field => {
+                                const config = field.state.value as {
+                                  code: number | null;
+                                  body: Record<string, unknown> | null;
+                                } | null;
+
+                                return (
+                                  <div className="space-y-4 animate-in fade-in slide-in-from-top-2 duration-200">
+                                    {/* Status Code */}
+                                    <div>
+                                      <label
+                                        htmlFor={`${field.name}-code`}
+                                        className="block text-sm font-medium text-slate-800 mb-1"
                                       >
-                                        {error}
+                                        Status code
+                                      </label>
+                                      <input
+                                        id={`${field.name}-code`}
+                                        type="number"
+                                        value={config?.code ?? ''}
+                                        onChange={e => {
+                                          const raw = e.target.value;
+                                          const parsed =
+                                            raw === ''
+                                              ? null
+                                              : parseInt(raw, 10);
+                                          field.handleChange({
+                                            ...(config ?? { body: null }),
+                                            code: parsed,
+                                          });
+                                        }}
+                                        onBlur={field.handleBlur}
+                                        disabled={isReadOnly}
+                                        className={cn(
+                                          'block w-full px-3 py-2',
+                                          'border rounded-md text-sm',
+                                          field.state.meta.errors.length > 0
+                                            ? 'border-red-300 text-red-900 ' +
+                                                'focus:border-red-500 ' +
+                                                'focus:ring-red-500'
+                                            : 'border-slate-300 ' +
+                                                'focus:border-indigo-500 ' +
+                                                'focus:ring-indigo-500',
+                                          'focus:outline-none focus:ring-1',
+                                          'disabled:opacity-50 ' +
+                                            'disabled:cursor-not-allowed'
+                                        )}
+                                      />
+                                      <p className="mt-1 text-xs text-slate-500">
+                                        HTTP status code returned to the caller
+                                        (default: 200 for success, 400
+                                        otherwise).
                                       </p>
-                                    ))}
-                                  </div>
-                                )}
-                              </form.Field>
+                                    </div>
 
-                              {/* Error Status Code */}
-                              <form.Field
-                                name="webhook_response_error_code"
-                                validators={{
-                                  onChange: createZodValidator(TriggerSchema),
-                                }}
-                              >
-                                {field => (
-                                  <div>
-                                    <label
-                                      htmlFor={field.name}
-                                      className="block text-sm font-medium text-slate-800 mb-1"
-                                    >
-                                      Error status code
-                                    </label>
-                                    <input
-                                      id={field.name}
-                                      type="number"
-                                      min="100"
-                                      max="599"
-                                      value={
-                                        (field.state.value as number | null) ??
-                                        ''
-                                      }
-                                      onChange={e =>
-                                        field.handleChange(
-                                          e.target.value === ''
-                                            ? null
-                                            : parseInt(e.target.value, 10)
-                                        )
-                                      }
-                                      onBlur={field.handleBlur}
-                                      disabled={isReadOnly}
-                                      className={cn(
-                                        'block w-full px-3 py-2',
-                                        'border rounded-md text-sm',
-                                        field.state.meta.errors.length > 0
-                                          ? 'border-red-300 text-red-900 focus:border-red-500 focus:ring-red-500'
-                                          : 'border-slate-300 focus:border-indigo-500 focus:ring-indigo-500',
-                                        'focus:outline-none focus:ring-1',
-                                        'disabled:opacity-50 disabled:cursor-not-allowed'
-                                      )}
-                                    />
-                                    <p className="mt-1 text-xs text-slate-500">
-                                      HTTP status code returned when the run
-                                      fails (default: 400)
-                                    </p>
-                                    {field.state.meta.errors.map(error => (
-                                      <p
-                                        key={error}
-                                        className="mt-1 text-xs text-red-600"
+                                    {/* Response Body (JSON) */}
+                                    <div>
+                                      <label
+                                        htmlFor={`${field.name}-body`}
+                                        className="block text-sm font-medium text-slate-800 mb-1"
                                       >
-                                        {error}
+                                        Response body (JSON)
+                                      </label>
+                                      <textarea
+                                        id={`${field.name}-body`}
+                                        rows={5}
+                                        defaultValue={
+                                          config?.body != null
+                                            ? JSON.stringify(
+                                                config.body,
+                                                null,
+                                                2
+                                              )
+                                            : ''
+                                        }
+                                        onBlur={e => {
+                                          const raw = e.target.value.trim();
+                                          if (raw === '') {
+                                            field.handleChange({
+                                              ...(config ?? { code: null }),
+                                              body: null,
+                                            });
+                                            return;
+                                          }
+                                          try {
+                                            const parsed = JSON.parse(
+                                              raw
+                                            ) as Record<string, unknown>;
+                                            field.handleChange({
+                                              ...(config ?? { code: null }),
+                                              body: parsed,
+                                            });
+                                          } catch {
+                                            // Invalid JSON — leave previous value
+                                          }
+                                        }}
+                                        disabled={isReadOnly}
+                                        className={cn(
+                                          'block w-full px-3 py-2',
+                                          'border rounded-md text-sm font-mono',
+                                          field.state.meta.errors.length > 0
+                                            ? 'border-red-300 text-red-900 ' +
+                                                'focus:border-red-500 ' +
+                                                'focus:ring-red-500'
+                                            : 'border-slate-300 ' +
+                                                'focus:border-indigo-500 ' +
+                                                'focus:ring-indigo-500',
+                                          'focus:outline-none focus:ring-1',
+                                          'disabled:opacity-50 ' +
+                                            'disabled:cursor-not-allowed'
+                                        )}
+                                      />
+                                      <p className="mt-1 text-xs text-slate-500">
+                                        Optional JSON to return. Defaults to the
+                                        run&apos;s final state.
                                       </p>
-                                    ))}
+                                      {field.state.meta.errors.map(error => (
+                                        <p
+                                          key={String(error)}
+                                          className="mt-1 text-xs text-red-600"
+                                        >
+                                          {String(error)}
+                                        </p>
+                                      ))}
+                                    </div>
                                   </div>
-                                )}
-                              </form.Field>
-                            </div>
+                                );
+                              }}
+                            </form.Field>
                           );
                         }}
                       </form.Field>
diff --git a/assets/js/collaborative-editor/types/session.ts b/assets/js/collaborative-editor/types/session.ts
index e56a339a11e..a4772440576 100644
--- a/assets/js/collaborative-editor/types/session.ts
+++ b/assets/js/collaborative-editor/types/session.ts
@@ -70,9 +70,11 @@ export namespace Session {
     enabled: boolean;
     cron_expression: string | null;
     has_auth_method: boolean;
-    webhook_reply: 'before_start' | 'after_completion' | 'custom' | null;
-    webhook_response_success_code: number | null;
-    webhook_response_error_code: number | null;
+    webhook_reply: 'before_start' | 'after_completion' | null;
+    sync_webhook_response_config: {
+      code: number | null;
+      body: Record<string, unknown> | null;
+    } | null;
     webhook_auth_methods: Array<{
       id: string;
       name: string;
diff --git a/assets/js/collaborative-editor/types/trigger.ts b/assets/js/collaborative-editor/types/trigger.ts
index 1f6dfd209eb..69db4035961 100644
--- a/assets/js/collaborative-editor/types/trigger.ts
+++ b/assets/js/collaborative-editor/types/trigger.ts
@@ -21,21 +21,14 @@ const webhookTriggerSchema = baseTriggerSchema.extend({
   cron_cursor_job_id: z.null().default(null),
   kafka_configuration: z.null().default(null),
   webhook_reply: z
-    .enum(['before_start', 'after_completion', 'custom'])
+    .enum(['before_start', 'after_completion'])
     .nullable()
     .default('before_start'),
-  webhook_response_success_code: z
-    .number()
-    .int()
-    .min(100)
-    .max(599)
-    .nullable()
-    .default(null),
-  webhook_response_error_code: z
-    .number()
-    .int()
-    .min(100)
-    .max(599)
+  sync_webhook_response_config: z
+    .object({
+      code: z.number().int().nullable().default(null),
+      body: z.record(z.string(), z.unknown()).nullable().default(null),
+    })
     .nullable()
     .default(null),
 });
@@ -151,8 +144,7 @@ export const createDefaultTrigger = (
         cron_cursor_job_id: null,
         kafka_configuration: null,
         webhook_reply: 'before_start' as const,
-        webhook_response_success_code: null,
-        webhook_response_error_code: null,
+        sync_webhook_response_config: null,
       };
 
     case 'cron':
diff --git a/assets/js/yaml/types.ts b/assets/js/yaml/types.ts
index 7a5f42b307c..90b4eef9e13 100644
--- a/assets/js/yaml/types.ts
+++ b/assets/js/yaml/types.ts
@@ -28,9 +28,11 @@ export type StateWebhookTrigger = {
   id: string;
   enabled: boolean;
   type: 'webhook';
-  webhook_reply: 'before_start' | 'after_completion' | 'custom' | null;
-  webhook_response_success_code?: number | null;
-  webhook_response_error_code?: number | null;
+  webhook_reply: 'before_start' | 'after_completion' | null | undefined;
+  sync_webhook_response_config?: {
+    code?: number | null;
+    body?: Record<string, unknown> | null;
+  } | null;
 };
 
 export type StateKafkaTrigger = {
diff --git a/lib/lightning/collaboration/workflow_serializer.ex b/lib/lightning/collaboration/workflow_serializer.ex
index 08e7a594a38..c7ed9790971 100644
--- a/lib/lightning/collaboration/workflow_serializer.ex
+++ b/lib/lightning/collaboration/workflow_serializer.ex
@@ -229,9 +229,17 @@ defmodule Lightning.Collaboration.WorkflowSerializer do
           "type" => trigger.type |> to_string(),
           "webhook_reply" =>
             trigger.webhook_reply && to_string(trigger.webhook_reply),
-          "webhook_response_success_code" =>
-            trigger.webhook_response_success_code,
-          "webhook_response_error_code" => trigger.webhook_response_error_code
+          "sync_webhook_response_config" =>
+            case trigger.sync_webhook_response_config do
+              nil ->
+                nil
+
+              config ->
+                Yex.MapPrelim.from(%{
+                  "code" => config.code,
+                  "body" => config.body
+                })
+            end
         })
 
       Yex.Array.push(triggers_array, trigger_map)
@@ -278,10 +286,10 @@ defmodule Lightning.Collaboration.WorkflowSerializer do
       trigger
       |> Map.take(
         ~w(id type enabled cron_expression cron_cursor_job_id webhook_reply
-           kafka_configuration webhook_response_success_code webhook_response_error_code)
+           kafka_configuration sync_webhook_response_config)
       )
       |> normalize_kafka_configuration()
-      |> normalize_response_codes()
+      |> normalize_sync_webhook_response_config()
     end)
   end
 
@@ -304,19 +312,24 @@ defmodule Lightning.Collaboration.WorkflowSerializer do
 
   defp normalize_kafka_configuration(trigger), do: trigger
 
-  defp normalize_response_codes(trigger) do
-    trigger
-    |> normalize_integer_field("webhook_response_success_code")
-    |> normalize_integer_field("webhook_response_error_code")
-  end
+  # Y.Doc serialises numbers as floats; convert code back to an integer.
+  defp normalize_sync_webhook_response_config(
+         %{"sync_webhook_response_config" => %{} = config} = trigger
+       ) do
+    normalized =
+      case Map.fetch(config, "code") do
+        {:ok, value} when is_float(value) ->
+          Map.put(config, "code", trunc(value))
 
-  defp normalize_integer_field(map, key) do
-    case Map.fetch(map, key) do
-      {:ok, value} when is_float(value) -> Map.put(map, key, trunc(value))
-      _ -> map
-    end
+        _ ->
+          config
+      end
+
+    Map.put(trigger, "sync_webhook_response_config", normalized)
   end
 
+  defp normalize_sync_webhook_response_config(trigger), do: trigger
+
   defp extract_positions(positions_map) do
     Yex.Map.to_json(positions_map)
   end
diff --git a/lib/lightning/workflows/trigger.ex b/lib/lightning/workflows/trigger.ex
index 1cd9328cd2b..1f13cdb8f2b 100644
--- a/lib/lightning/workflows/trigger.ex
+++ b/lib/lightning/workflows/trigger.ex
@@ -16,6 +16,7 @@ defmodule Lightning.Workflows.Trigger do
 
   alias Lightning.Workflows.Job
   alias Lightning.Workflows.Triggers.KafkaConfiguration
+  alias Lightning.Workflows.Triggers.SyncWebhookResponseConfig
   alias Lightning.Workflows.Workflow
 
   @type t :: %__MODULE__{
@@ -25,7 +26,7 @@ defmodule Lightning.Workflows.Trigger do
   @type trigger_type :: :webhook | :cron
 
   @trigger_types [:webhook, :cron, :kafka]
-  @webhook_reply_types [:before_start, :after_completion, :custom]
+  @webhook_reply_types [:before_start, :after_completion]
 
   @derive {Jason.Encoder,
            only: [
@@ -55,8 +56,6 @@ defmodule Lightning.Workflows.Trigger do
 
     field :delete, :boolean, virtual: true
     field :has_auth_method, :boolean, virtual: true
-    field :webhook_response_success_code, :integer
-    field :webhook_response_error_code, :integer
 
     many_to_many :webhook_auth_methods, Lightning.Workflows.WebhookAuthMethod,
       join_through: "trigger_webhook_auth_methods",
@@ -64,6 +63,9 @@ defmodule Lightning.Workflows.Trigger do
 
     embeds_one :kafka_configuration, KafkaConfiguration, on_replace: :update
 
+    embeds_one :sync_webhook_response_config, SyncWebhookResponseConfig,
+      on_replace: :update
+
     timestamps()
   end
 
@@ -77,21 +79,21 @@ defmodule Lightning.Workflows.Trigger do
   (i.e., the HTTP connection is held open waiting for a response).
   """
   @spec synchronous?(t()) :: boolean()
-  def synchronous?(%__MODULE__{webhook_reply: reply})
-      when reply in [:after_completion, :custom],
-      do: true
-
+  def synchronous?(%__MODULE__{webhook_reply: :after_completion}), do: true
   def synchronous?(%__MODULE__{}), do: false
 
   @doc false
   def changeset(trigger, attrs) do
     trigger
     |> cast_changeset(attrs)
-    |> cast_embed(
-      :kafka_configuration,
+    |> cast_embed(:kafka_configuration,
       required: false,
       with: &KafkaConfiguration.changeset/2
     )
+    |> cast_embed(:sync_webhook_response_config,
+      required: false,
+      with: &SyncWebhookResponseConfig.changeset/2
+    )
     |> validate()
   end
 
@@ -106,9 +108,7 @@ defmodule Lightning.Workflows.Trigger do
       :cron_expression,
       :cron_cursor_job_id,
       :has_auth_method,
-      :webhook_reply,
-      :webhook_response_success_code,
-      :webhook_response_error_code
+      :webhook_reply
     ])
   end
 
@@ -145,7 +145,7 @@ defmodule Lightning.Workflows.Trigger do
         |> put_change(:cron_cursor_job_id, nil)
         |> put_change(:kafka_configuration, nil)
         |> put_default(:webhook_reply, :before_start)
-        |> maybe_reset_response_codes()
+        |> maybe_clear_sync_config()
 
       :cron ->
         changeset
@@ -153,8 +153,7 @@ defmodule Lightning.Workflows.Trigger do
         |> validate_cron()
         |> put_change(:kafka_configuration, nil)
         |> put_change(:webhook_reply, nil)
-        |> put_change(:webhook_response_success_code, nil)
-        |> put_change(:webhook_response_error_code, nil)
+        |> put_change(:sync_webhook_response_config, nil)
 
       :kafka ->
         changeset
@@ -162,25 +161,19 @@ defmodule Lightning.Workflows.Trigger do
         |> put_change(:cron_cursor_job_id, nil)
         |> validate_required([:kafka_configuration])
         |> put_change(:webhook_reply, nil)
-        |> put_change(:webhook_response_success_code, nil)
-        |> put_change(:webhook_response_error_code, nil)
+        |> put_change(:sync_webhook_response_config, nil)
 
       nil ->
         changeset
     end
   end
 
-  defp maybe_reset_response_codes(changeset) do
+  # Keep the config when reply mode is after_completion; clear it otherwise
+  # so stale config doesn't persist across mode switches.
+  defp maybe_clear_sync_config(changeset) do
     case fetch_field!(changeset, :webhook_reply) do
-      :after_completion ->
-        changeset
-        |> put_default(:webhook_response_success_code, 200)
-        |> put_default(:webhook_response_error_code, 400)
-
-      _ ->
-        changeset
-        |> put_change(:webhook_response_success_code, nil)
-        |> put_change(:webhook_response_error_code, nil)
+      :after_completion -> changeset
+      _ -> put_change(changeset, :sync_webhook_response_config, nil)
     end
   end
 
diff --git a/lib/lightning/workflows/triggers/sync_webhook_response_config.ex b/lib/lightning/workflows/triggers/sync_webhook_response_config.ex
new file mode 100644
index 00000000000..a7c3506b5c2
--- /dev/null
+++ b/lib/lightning/workflows/triggers/sync_webhook_response_config.ex
@@ -0,0 +1,25 @@
+defmodule Lightning.Workflows.Triggers.SyncWebhookResponseConfig do
+  @moduledoc """
+  Embedded schema for the default webhook response sent on run completion.
+
+  When a trigger's `webhook_reply` is `:after_completion`, this config controls
+  the HTTP response returned to the caller:
+
+  - `code` — HTTP status code. Falls back to 200 (success) or 400 (any other
+    terminal state) when nil.
+  - `body` — Custom response body. Falls back to the run's final state when nil.
+  """
+
+  use Ecto.Schema
+  import Ecto.Changeset
+
+  @primary_key false
+  embedded_schema do
+    field :code, :integer
+    field :body, :map
+  end
+
+  def changeset(config, attrs) do
+    cast(config, attrs, [:code, :body])
+  end
+end
diff --git a/lib/lightning_web/channels/run_channel.ex b/lib/lightning_web/channels/run_channel.ex
index fbc9b399092..d76dddee5e4 100644
--- a/lib/lightning_web/channels/run_channel.ex
+++ b/lib/lightning_web/channels/run_channel.ex
@@ -120,7 +120,7 @@ defmodule LightningWeb.RunChannel do
         run_with_preloads
         |> Lightning.FailureAlerter.alert_on_failure()
 
-        # Broadcast webhook response if after_completion is enabled
+        # Broadcast webhook response for after_completion mode
         maybe_broadcast_webhook_response(run_with_preloads, payload)
 
         socket |> assign(run: run) |> reply_with({:ok, nil})
@@ -210,7 +210,6 @@ defmodule LightningWeb.RunChannel do
         reply_with(socket, {:error, changeset})
 
       {:ok, step} ->
-        maybe_broadcast_custom_webhook_response(socket.assigns.run, payload)
         reply_with(socket, {:ok, %{step_id: step.id}})
     end
   end
@@ -307,32 +306,6 @@ defmodule LightningWeb.RunChannel do
   # Ignore other messages
   def handle_info(_msg, socket), do: {:noreply, socket}
 
-  defp maybe_broadcast_custom_webhook_response(run, payload) do
-    case payload["webhook_response"] do
-      nil ->
-        :ok
-
-      webhook_response ->
-        run_with_preloads = Repo.preload(run, work_order: [:trigger])
-        trigger = run_with_preloads.work_order.trigger
-
-        if trigger && trigger.type == :webhook &&
-             trigger.webhook_reply == :custom do
-          topic =
-            "work_order:#{run_with_preloads.work_order.id}:webhook_response"
-
-          status_code = webhook_response["code"] || 200
-          body = webhook_response["body"] || %{}
-
-          Phoenix.PubSub.broadcast(
-            Lightning.PubSub,
-            topic,
-            {:webhook_response, status_code, body}
-          )
-        end
-    end
-  end
-
   defp maybe_broadcast_webhook_response(run, payload) do
     work_order = run.work_order
     trigger = work_order.trigger
@@ -340,21 +313,37 @@ defmodule LightningWeb.RunChannel do
     if trigger && trigger.type == :webhook &&
          trigger.webhook_reply == :after_completion do
       topic = "work_order:#{work_order.id}:webhook_response"
-      status_code = determine_status_code(run.state, trigger)
-
-      body = %{
-        data: payload["final_state"],
-        meta: %{
-          work_order_id: work_order.id,
-          run_id: run.id,
-          state: run.state,
-          error_type: run.error_type,
-          inserted_at: run.inserted_at,
-          started_at: run.started_at,
-          claimed_at: run.claimed_at,
-          finished_at: run.finished_at
-        }
-      }
+      final_state = payload["final_state"]
+      config = trigger.sync_webhook_response_config
+
+      # _webhookResponse in the final state takes priority over the trigger config.
+      state_override =
+        case final_state do
+          %{"_webhookResponse" => override} when is_map(override) -> override
+          _ -> nil
+        end
+
+      status_code =
+        state_override_code(state_override) ||
+          (config && config.code) ||
+          default_status_code(run.state)
+
+      body =
+        Map.get(state_override || %{}, "body") ||
+          (config && config.body) ||
+          %{
+            data: final_state,
+            meta: %{
+              work_order_id: work_order.id,
+              run_id: run.id,
+              state: run.state,
+              error_type: run.error_type,
+              inserted_at: run.inserted_at,
+              started_at: run.started_at,
+              claimed_at: run.claimed_at,
+              finished_at: run.finished_at
+            }
+          }
 
       Phoenix.PubSub.broadcast(
         Lightning.PubSub,
@@ -364,11 +353,16 @@ defmodule LightningWeb.RunChannel do
     end
   end
 
-  defp determine_status_code(:success, trigger),
-    do: trigger.webhook_response_success_code || 200
+  # Normalise the code from _webhookResponse — JSON numbers arrive as floats.
+  defp state_override_code(%{"code" => code}) when is_integer(code), do: code
+
+  defp state_override_code(%{"code" => code}) when is_float(code),
+    do: trunc(code)
+
+  defp state_override_code(_), do: nil
 
-  defp determine_status_code(_state, trigger),
-    do: trigger.webhook_response_error_code || 400
+  defp default_status_code(:success), do: 200
+  defp default_status_code(_), do: 400
 
   defp update_scrubber(nil, samples, basic_auth) do
     Scrubber.start_link(samples: samples, basic_auth: basic_auth)
diff --git a/priv/repo/migrations/20260422052858_add_webhook_response_codes_to_triggers.exs b/priv/repo/migrations/20260422052859_add_webhook_response_codes_to_triggers.exs
similarity index 56%
rename from priv/repo/migrations/20260422052858_add_webhook_response_codes_to_triggers.exs
rename to priv/repo/migrations/20260422052859_add_webhook_response_codes_to_triggers.exs
index 828169cbaa0..8508270c69f 100644
--- a/priv/repo/migrations/20260422052858_add_webhook_response_codes_to_triggers.exs
+++ b/priv/repo/migrations/20260422052859_add_webhook_response_codes_to_triggers.exs
@@ -3,8 +3,7 @@ defmodule Lightning.Repo.Migrations.AddWebhookResponseCodesToTriggers do
 
   def change do
     alter table(:triggers) do
-      add :webhook_response_success_code, :integer, null: true
-      add :webhook_response_error_code, :integer, null: true
+      add :sync_webhook_response_config, :jsonb, null: true
     end
   end
 end

From 2f817e695903784839101f2ea17dcf53562cbab0 Mon Sep 17 00:00:00 2001
From: Frank Midigo <midigofrank@gmail.com>
Date: Fri, 24 Apr 2026 18:53:27 +0300
Subject: [PATCH 05/21] refactor webhook config to allow for error and success
 status

---
 .../components/inspector/TriggerForm.tsx      | 272 +++++++++++-------
 .../js/collaborative-editor/types/session.ts  |   3 +-
 .../js/collaborative-editor/types/trigger.ts  |   3 +-
 assets/js/yaml/types.ts                       |   3 +-
 .../collaboration/workflow_serializer.ex      |  22 +-
 lib/lightning/workflows/snapshot.ex           |  19 +-
 lib/lightning/workflows/trigger.ex            |   5 +-
 .../triggers/sync_webhook_response_config.ex  |  13 +-
 lib/lightning_web/channels/run_channel.ex     | 129 ++++++---
 .../controllers/webhooks_controller.ex        |  18 +-
 10 files changed, 310 insertions(+), 177 deletions(-)

diff --git a/assets/js/collaborative-editor/components/inspector/TriggerForm.tsx b/assets/js/collaborative-editor/components/inspector/TriggerForm.tsx
index 06dbb1ffc0c..585b8ffde7e 100644
--- a/assets/js/collaborative-editor/components/inspector/TriggerForm.tsx
+++ b/assets/js/collaborative-editor/components/inspector/TriggerForm.tsx
@@ -1,5 +1,7 @@
 import { useCallback, useEffect, useState } from 'react';
 
+import { MonacoEditor } from '../../../monaco';
+
 import { useCopyToClipboard } from '#/collaborative-editor/hooks/useCopyToClipboard';
 import {
   createDefaultTrigger,
@@ -424,7 +426,7 @@ export function TriggerForm({ trigger }: TriggerFormProps) {
                               className="mt-1 text-xs text-slate-500"
                             >
                               {field.state.value === 'after_completion'
-                                ? 'Holds the HTTP connection open and responds when the run completes. Jobs can send an early response using setWebhookResponse().'
+                                ? 'Holds the HTTP connection open and responds when the run completes.'
                                 : 'Responds immediately with the enqueued work order ID.'}
                             </p>
                             {field.state.meta.errors.map(error => (
@@ -450,129 +452,197 @@ export function TriggerForm({ trigger }: TriggerFormProps) {
                             <form.Field name="sync_webhook_response_config">
                               {field => {
                                 const config = field.state.value as {
-                                  code: number | null;
+                                  success_code: number | null;
+                                  error_code: number | null;
                                   body: Record<string, unknown> | null;
                                 } | null;
 
+                                const baseConfig = config ?? {
+                                  success_code: null,
+                                  error_code: null,
+                                  body: null,
+                                };
+
+                                const bodyType =
+                                  config?.body != null
+                                    ? 'raw_json'
+                                    : 'final_state';
+
+                                const inputClass = cn(
+                                  'block w-full px-3 py-2',
+                                  'border rounded-md text-sm',
+                                  'border-slate-300',
+                                  'focus:border-indigo-500 focus:ring-indigo-500',
+                                  'focus:outline-none focus:ring-1',
+                                  'disabled:opacity-50 disabled:cursor-not-allowed'
+                                );
+
                                 return (
                                   <div className="space-y-4 animate-in fade-in slide-in-from-top-2 duration-200">
-                                    {/* Status Code */}
+                                    {/* Status Codes */}
                                     <div>
-                                      <label
-                                        htmlFor={`${field.name}-code`}
-                                        className="block text-sm font-medium text-slate-800 mb-1"
-                                      >
-                                        Status code
+                                      <label className="block text-sm font-medium text-slate-800 mb-2">
+                                        Status codes
                                       </label>
-                                      <input
-                                        id={`${field.name}-code`}
-                                        type="number"
-                                        value={config?.code ?? ''}
-                                        onChange={e => {
-                                          const raw = e.target.value;
-                                          const parsed =
-                                            raw === ''
-                                              ? null
-                                              : parseInt(raw, 10);
-                                          field.handleChange({
-                                            ...(config ?? { body: null }),
-                                            code: parsed,
-                                          });
-                                        }}
-                                        onBlur={field.handleBlur}
-                                        disabled={isReadOnly}
-                                        className={cn(
-                                          'block w-full px-3 py-2',
-                                          'border rounded-md text-sm',
-                                          field.state.meta.errors.length > 0
-                                            ? 'border-red-300 text-red-900 ' +
-                                                'focus:border-red-500 ' +
-                                                'focus:ring-red-500'
-                                            : 'border-slate-300 ' +
-                                                'focus:border-indigo-500 ' +
-                                                'focus:ring-indigo-500',
-                                          'focus:outline-none focus:ring-1',
-                                          'disabled:opacity-50 ' +
-                                            'disabled:cursor-not-allowed'
-                                        )}
-                                      />
-                                      <p className="mt-1 text-xs text-slate-500">
-                                        HTTP status code returned to the caller
-                                        (default: 200 for success, 400
-                                        otherwise).
+                                      <div className="grid grid-cols-2 gap-3">
+                                        <div>
+                                          <label
+                                            htmlFor={`${field.name}-success-code`}
+                                            className="block text-xs text-slate-600 mb-1"
+                                          >
+                                            Success
+                                          </label>
+                                          <input
+                                            id={`${field.name}-success-code`}
+                                            type="number"
+                                            placeholder="201"
+                                            value={config?.success_code ?? ''}
+                                            onChange={e => {
+                                              const raw = e.target.value;
+                                              field.handleChange({
+                                                ...baseConfig,
+                                                success_code:
+                                                  raw === ''
+                                                    ? null
+                                                    : parseInt(raw, 10),
+                                              });
+                                            }}
+                                            onBlur={field.handleBlur}
+                                            disabled={isReadOnly}
+                                            className={inputClass}
+                                          />
+                                        </div>
+                                        <div>
+                                          <label
+                                            htmlFor={`${field.name}-error-code`}
+                                            className="block text-xs text-slate-600 mb-1"
+                                          >
+                                            Error
+                                          </label>
+                                          <input
+                                            id={`${field.name}-error-code`}
+                                            type="number"
+                                            placeholder="201"
+                                            value={config?.error_code ?? ''}
+                                            onChange={e => {
+                                              const raw = e.target.value;
+                                              field.handleChange({
+                                                ...baseConfig,
+                                                error_code:
+                                                  raw === ''
+                                                    ? null
+                                                    : parseInt(raw, 10),
+                                              });
+                                            }}
+                                            onBlur={field.handleBlur}
+                                            disabled={isReadOnly}
+                                            className={inputClass}
+                                          />
+                                        </div>
+                                      </div>
+                                      <p className="mt-2 text-xs text-slate-500">
+                                        Both default to 201 when not set.
                                       </p>
                                     </div>
 
-                                    {/* Response Body (JSON) */}
+                                    {/* Response Body */}
                                     <div>
-                                      <label
-                                        htmlFor={`${field.name}-body`}
-                                        className="block text-sm font-medium text-slate-800 mb-1"
-                                      >
-                                        Response body (JSON)
+                                      <label className="block text-sm font-medium text-slate-800 mb-1">
+                                        Response body
                                       </label>
-                                      <textarea
-                                        id={`${field.name}-body`}
-                                        rows={5}
-                                        defaultValue={
-                                          config?.body != null
-                                            ? JSON.stringify(
-                                                config.body,
-                                                null,
-                                                2
-                                              )
-                                            : ''
-                                        }
-                                        onBlur={e => {
-                                          const raw = e.target.value.trim();
-                                          if (raw === '') {
+                                      <select
+                                        value={bodyType}
+                                        onChange={e => {
+                                          if (
+                                            e.target.value === 'final_state'
+                                          ) {
                                             field.handleChange({
-                                              ...(config ?? { code: null }),
+                                              ...baseConfig,
                                               body: null,
                                             });
-                                            return;
-                                          }
-                                          try {
-                                            const parsed = JSON.parse(
-                                              raw
-                                            ) as Record<string, unknown>;
+                                          } else {
                                             field.handleChange({
-                                              ...(config ?? { code: null }),
-                                              body: parsed,
+                                              ...baseConfig,
+                                              body: config?.body ?? {},
                                             });
-                                          } catch {
-                                            // Invalid JSON — leave previous value
                                           }
                                         }}
                                         disabled={isReadOnly}
-                                        className={cn(
-                                          'block w-full px-3 py-2',
-                                          'border rounded-md text-sm font-mono',
-                                          field.state.meta.errors.length > 0
-                                            ? 'border-red-300 text-red-900 ' +
-                                                'focus:border-red-500 ' +
-                                                'focus:ring-red-500'
-                                            : 'border-slate-300 ' +
-                                                'focus:border-indigo-500 ' +
-                                                'focus:ring-indigo-500',
-                                          'focus:outline-none focus:ring-1',
-                                          'disabled:opacity-50 ' +
-                                            'disabled:cursor-not-allowed'
-                                        )}
-                                      />
+                                        className={cn(inputClass, 'mb-2')}
+                                      >
+                                        <option value="final_state">
+                                          Final state (success only)
+                                        </option>
+                                        <option value="raw_json">
+                                          Custom JSON
+                                        </option>
+                                      </select>
+
+                                      {bodyType === 'raw_json' && (
+                                        <div className="rounded-md overflow-hidden border border-slate-300">
+                                          <MonacoEditor
+                                            language="json"
+                                            height="160px"
+                                            value={
+                                              config?.body != null
+                                                ? JSON.stringify(
+                                                    config.body,
+                                                    null,
+                                                    2
+                                                  )
+                                                : '{}'
+                                            }
+                                            onChange={(
+                                              value: string | undefined
+                                            ) => {
+                                              if (value === undefined) return;
+                                              try {
+                                                const parsed = JSON.parse(
+                                                  value
+                                                ) as Record<string, unknown>;
+                                                field.handleChange({
+                                                  ...baseConfig,
+                                                  body: parsed,
+                                                });
+                                              } catch {
+                                                // Invalid JSON — don't update
+                                              }
+                                            }}
+                                            options={{
+                                              minimap: { enabled: false },
+                                              lineNumbers: 'off',
+                                              scrollBeyondLastLine: false,
+                                              fontSize: 12,
+                                              wordWrap: 'on',
+                                              readOnly: isReadOnly,
+                                              overviewRulerLanes: 0,
+                                              hideCursorInOverviewRuler: true,
+                                              scrollbar: {
+                                                vertical: 'hidden',
+                                                horizontal: 'hidden',
+                                              },
+                                            }}
+                                          />
+                                        </div>
+                                      )}
+
                                       <p className="mt-1 text-xs text-slate-500">
-                                        Optional JSON to return. Defaults to the
-                                        run&apos;s final state.
+                                        {bodyType === 'final_state'
+                                          ? 'The final job state is returned on success. No body is sent on error to avoid exposing error details.'
+                                          : 'This JSON is returned for both success and error runs.'}
                                       </p>
-                                      {field.state.meta.errors.map(error => (
-                                        <p
-                                          key={String(error)}
-                                          className="mt-1 text-xs text-red-600"
-                                        >
-                                          {String(error)}
-                                        </p>
-                                      ))}
                                     </div>
+
+                                    {/* Runtime override note */}
+                                    <p className="text-xs text-slate-500 border-t border-slate-200 pt-3">
+                                      To override both the status code and body
+                                      at runtime, write to{' '}
+                                      <code className="font-mono text-slate-700">
+                                        _webhookResponse
+                                      </code>{' '}
+                                      in the job state. When present, it takes
+                                      full priority over these defaults.
+                                    </p>
                                   </div>
                                 );
                               }}
diff --git a/assets/js/collaborative-editor/types/session.ts b/assets/js/collaborative-editor/types/session.ts
index a4772440576..f43ce4b8a15 100644
--- a/assets/js/collaborative-editor/types/session.ts
+++ b/assets/js/collaborative-editor/types/session.ts
@@ -72,7 +72,8 @@ export namespace Session {
     has_auth_method: boolean;
     webhook_reply: 'before_start' | 'after_completion' | null;
     sync_webhook_response_config: {
-      code: number | null;
+      success_code: number | null;
+      error_code: number | null;
       body: Record<string, unknown> | null;
     } | null;
     webhook_auth_methods: Array<{
diff --git a/assets/js/collaborative-editor/types/trigger.ts b/assets/js/collaborative-editor/types/trigger.ts
index 69db4035961..253d9f705c0 100644
--- a/assets/js/collaborative-editor/types/trigger.ts
+++ b/assets/js/collaborative-editor/types/trigger.ts
@@ -26,7 +26,8 @@ const webhookTriggerSchema = baseTriggerSchema.extend({
     .default('before_start'),
   sync_webhook_response_config: z
     .object({
-      code: z.number().int().nullable().default(null),
+      success_code: z.number().int().nullable().default(null),
+      error_code: z.number().int().nullable().default(null),
       body: z.record(z.string(), z.unknown()).nullable().default(null),
     })
     .nullable()
diff --git a/assets/js/yaml/types.ts b/assets/js/yaml/types.ts
index 90b4eef9e13..4804aaced89 100644
--- a/assets/js/yaml/types.ts
+++ b/assets/js/yaml/types.ts
@@ -30,7 +30,8 @@ export type StateWebhookTrigger = {
   type: 'webhook';
   webhook_reply: 'before_start' | 'after_completion' | null | undefined;
   sync_webhook_response_config?: {
-    code?: number | null;
+    success_code?: number | null;
+    error_code?: number | null;
     body?: Record<string, unknown> | null;
   } | null;
 };
diff --git a/lib/lightning/collaboration/workflow_serializer.ex b/lib/lightning/collaboration/workflow_serializer.ex
index c7ed9790971..963bfb0b580 100644
--- a/lib/lightning/collaboration/workflow_serializer.ex
+++ b/lib/lightning/collaboration/workflow_serializer.ex
@@ -236,7 +236,8 @@ defmodule Lightning.Collaboration.WorkflowSerializer do
 
               config ->
                 Yex.MapPrelim.from(%{
-                  "code" => config.code,
+                  "success_code" => config.success_code,
+                  "error_code" => config.error_code,
                   "body" => config.body
                 })
             end
@@ -312,24 +313,27 @@ defmodule Lightning.Collaboration.WorkflowSerializer do
 
   defp normalize_kafka_configuration(trigger), do: trigger
 
-  # Y.Doc serialises numbers as floats; convert code back to an integer.
+  # Y.Doc serialises numbers as floats; convert integer codes back.
   defp normalize_sync_webhook_response_config(
          %{"sync_webhook_response_config" => %{} = config} = trigger
        ) do
     normalized =
-      case Map.fetch(config, "code") do
-        {:ok, value} when is_float(value) ->
-          Map.put(config, "code", trunc(value))
-
-        _ ->
-          config
-      end
+      config
+      |> normalize_integer_field("success_code")
+      |> normalize_integer_field("error_code")
 
     Map.put(trigger, "sync_webhook_response_config", normalized)
   end
 
   defp normalize_sync_webhook_response_config(trigger), do: trigger
 
+  defp normalize_integer_field(map, key) do
+    case Map.fetch(map, key) do
+      {:ok, value} when is_float(value) -> Map.put(map, key, trunc(value))
+      _ -> map
+    end
+  end
+
   defp extract_positions(positions_map) do
     Yex.Map.to_json(positions_map)
   end
diff --git a/lib/lightning/workflows/snapshot.ex b/lib/lightning/workflows/snapshot.ex
index 468b9b2196d..bb2982c62ac 100644
--- a/lib/lightning/workflows/snapshot.ex
+++ b/lib/lightning/workflows/snapshot.ex
@@ -13,6 +13,7 @@ defmodule Lightning.Workflows.Snapshot do
   alias Lightning.Credentials.KeychainCredential
   alias Lightning.Projects.ProjectCredential
   alias Lightning.Repo
+  alias Lightning.Workflows.Triggers.SyncWebhookResponseConfig
   alias Lightning.Workflows.WebhookAuthMethod
   alias Lightning.Workflows.Workflow
 
@@ -61,11 +62,12 @@ defmodule Lightning.Workflows.Snapshot do
       field :has_auth_method, :boolean, virtual: true
 
       field :webhook_reply, Ecto.Enum,
-        values: [:before_start, :after_completion, :custom],
+        values: [:before_start, :after_completion],
         default: :before_start
 
-      field :webhook_response_success_code, :integer
-      field :webhook_response_error_code, :integer
+      embeds_one :sync_webhook_response_config, SyncWebhookResponseConfig,
+        on_replace: :update,
+        primary_key: false
 
       many_to_many :webhook_auth_methods, WebhookAuthMethod,
         join_through: "trigger_webhook_auth_methods",
@@ -127,6 +129,10 @@ defmodule Lightning.Workflows.Snapshot do
     schema
     |> cast(params, @trigger_fields)
     |> validate_required([:id, :inserted_at, :updated_at])
+    |> cast_embed(:sync_webhook_response_config,
+      required: false,
+      with: &SyncWebhookResponseConfig.changeset/2
+    )
   end
 
   defp edge_changeset(schema, params) do
@@ -135,7 +141,12 @@ defmodule Lightning.Workflows.Snapshot do
     |> validate_required([:id, :inserted_at, :updated_at])
   end
 
-  @associations_to_include [:jobs, :triggers, :edges]
+  @associations_to_include [
+    :jobs,
+    :triggers,
+    :edges,
+    :sync_webhook_response_config
+  ]
 
   @spec build(Workflow.t()) :: Ecto.Changeset.t()
   def build(%Workflow{} = workflow) do
diff --git a/lib/lightning/workflows/trigger.ex b/lib/lightning/workflows/trigger.ex
index 1f13cdb8f2b..43a6713216c 100644
--- a/lib/lightning/workflows/trigger.ex
+++ b/lib/lightning/workflows/trigger.ex
@@ -64,7 +64,8 @@ defmodule Lightning.Workflows.Trigger do
     embeds_one :kafka_configuration, KafkaConfiguration, on_replace: :update
 
     embeds_one :sync_webhook_response_config, SyncWebhookResponseConfig,
-      on_replace: :update
+      on_replace: :update,
+      primary_key: false
 
     timestamps()
   end
@@ -168,8 +169,6 @@ defmodule Lightning.Workflows.Trigger do
     end
   end
 
-  # Keep the config when reply mode is after_completion; clear it otherwise
-  # so stale config doesn't persist across mode switches.
   defp maybe_clear_sync_config(changeset) do
     case fetch_field!(changeset, :webhook_reply) do
       :after_completion -> changeset
diff --git a/lib/lightning/workflows/triggers/sync_webhook_response_config.ex b/lib/lightning/workflows/triggers/sync_webhook_response_config.ex
index a7c3506b5c2..1baacb8659a 100644
--- a/lib/lightning/workflows/triggers/sync_webhook_response_config.ex
+++ b/lib/lightning/workflows/triggers/sync_webhook_response_config.ex
@@ -5,9 +5,11 @@ defmodule Lightning.Workflows.Triggers.SyncWebhookResponseConfig do
   When a trigger's `webhook_reply` is `:after_completion`, this config controls
   the HTTP response returned to the caller:
 
-  - `code` — HTTP status code. Falls back to 200 (success) or 400 (any other
-    terminal state) when nil.
-  - `body` — Custom response body. Falls back to the run's final state when nil.
+  - `success_code` — HTTP status code when the run succeeds. Defaults to 201.
+  - `error_code` — HTTP status code for any non-success terminal state
+    (failed, crashed, exception, killed, cancelled). Defaults to 201.
+  - `body` — Custom response body (JSON). Falls back to the run's final state
+    when nil.
   """
 
   use Ecto.Schema
@@ -15,11 +17,12 @@ defmodule Lightning.Workflows.Triggers.SyncWebhookResponseConfig do
 
   @primary_key false
   embedded_schema do
-    field :code, :integer
+    field :success_code, :integer
+    field :error_code, :integer
     field :body, :map
   end
 
   def changeset(config, attrs) do
-    cast(config, attrs, [:code, :body])
+    cast(config, attrs, [:success_code, :error_code, :body])
   end
 end
diff --git a/lib/lightning_web/channels/run_channel.ex b/lib/lightning_web/channels/run_channel.ex
index d76dddee5e4..a759fff7c18 100644
--- a/lib/lightning_web/channels/run_channel.ex
+++ b/lib/lightning_web/channels/run_channel.ex
@@ -121,7 +121,10 @@ defmodule LightningWeb.RunChannel do
         |> Lightning.FailureAlerter.alert_on_failure()
 
         # Broadcast webhook response for after_completion mode
-        maybe_broadcast_webhook_response(run_with_preloads, payload)
+        maybe_broadcast_webhook_response(
+          run_with_preloads,
+          payload["final_state"]
+        )
 
         socket |> assign(run: run) |> reply_with({:ok, nil})
 
@@ -306,63 +309,95 @@ defmodule LightningWeb.RunChannel do
   # Ignore other messages
   def handle_info(_msg, socket), do: {:noreply, socket}
 
-  defp maybe_broadcast_webhook_response(run, payload) do
-    work_order = run.work_order
-    trigger = work_order.trigger
-
-    if trigger && trigger.type == :webhook &&
-         trigger.webhook_reply == :after_completion do
-      topic = "work_order:#{work_order.id}:webhook_response"
-      final_state = payload["final_state"]
-      config = trigger.sync_webhook_response_config
-
-      # _webhookResponse in the final state takes priority over the trigger config.
-      state_override =
-        case final_state do
-          %{"_webhookResponse" => override} when is_map(override) -> override
-          _ -> nil
-        end
-
-      status_code =
-        state_override_code(state_override) ||
-          (config && config.code) ||
-          default_status_code(run.state)
-
-      body =
-        Map.get(state_override || %{}, "body") ||
-          (config && config.body) ||
-          %{
-            data: final_state,
-            meta: %{
-              work_order_id: work_order.id,
-              run_id: run.id,
-              state: run.state,
-              error_type: run.error_type,
-              inserted_at: run.inserted_at,
-              started_at: run.started_at,
-              claimed_at: run.claimed_at,
-              finished_at: run.finished_at
-            }
-          }
+  defp maybe_broadcast_webhook_response(
+         run,
+         final_state
+       ) do
+    if run.work_order.trigger.webhook_reply == :after_completion do
+      {status_code, body} =
+        determine_webhook_response(
+          run,
+          final_state,
+          run.work_order.trigger.sync_webhook_response_config
+        )
 
       Phoenix.PubSub.broadcast(
         Lightning.PubSub,
-        topic,
+        "work_order:#{run.work_order_id}:webhook_response",
         {:webhook_response, status_code, body}
       )
     end
   end
 
-  # Normalise the code from _webhookResponse — JSON numbers arrive as floats.
-  defp state_override_code(%{"code" => code}) when is_integer(code), do: code
+  defp determine_webhook_response(run, final_state, config) do
+    (final_state || %{})
+    |> Map.get("_webhookResponse")
+    |> case do
+      resp when is_nil(resp) or resp == %{} ->
+        build_default_response(run, final_state, config)
 
-  defp state_override_code(%{"code" => code}) when is_float(code),
-    do: trunc(code)
+      resp ->
+        build_response_from_state(resp)
+    end
+  end
 
-  defp state_override_code(_), do: nil
+  defp build_default_response(run, final_state, config) do
+    {default_response_status(run.state, config),
+     default_response_body(run.state, final_state, config)}
+  end
+
+  defp default_response_status(:success, %{success_code: code})
+       when is_integer(code),
+       do: code
+
+  defp default_response_status(_run_status, %{error_code: code})
+       when is_integer(code),
+       do: code
+
+  defp default_response_status(_run_status, _config), do: 201
 
-  defp default_status_code(:success), do: 200
-  defp default_status_code(_), do: 400
+  defp default_response_body(_run_status, _final_state, %{body: body})
+       when is_map(body),
+       do: body
+
+  defp default_response_body(:success, final_state, %{body: nil}),
+    do: final_state
+
+  defp default_response_body(run_status, _final_state, _config) do
+    %{
+      message:
+        "Run completed with status: #{run_status}. As a security policy, OpenFn does not send state data when the run errors out to avoid leaking sensitive information"
+    }
+  end
+
+  defp build_response_from_state(%{"status" => status, "body" => body})
+       when is_map(body) and is_integer(status) do
+    {status, body}
+  end
+
+  defp build_response_from_state(%{"status" => status, "body" => _} = response)
+       when is_float(status) do
+    response
+    |> Map.put("status", trunc(status))
+    |> build_response_from_state()
+  end
+
+  defp build_response_from_state(%{"status" => status}) do
+    malformed_response("status needs to be an integer, got: #{inspect(status)}")
+  end
+
+  defp build_response_from_state(%{"body" => body}) do
+    malformed_response("body needs to be json object, got: #{inspect(body)}")
+  end
+
+  defp build_response_from_state(_webhook_response) do
+    malformed_response("no status or body was defined")
+  end
+
+  defp malformed_response(reason) do
+    {201,
+     %{message: "Run completed, but _webhookResponse was malformed: #{reason}"}}
+  end
 
   defp update_scrubber(nil, samples, basic_auth) do
     Scrubber.start_link(samples: samples, basic_auth: basic_auth)
diff --git a/lib/lightning_web/controllers/webhooks_controller.ex b/lib/lightning_web/controllers/webhooks_controller.ex
index 1a5fc8e500b..bb624b87244 100644
--- a/lib/lightning_web/controllers/webhooks_controller.ex
+++ b/lib/lightning_web/controllers/webhooks_controller.ex
@@ -63,6 +63,19 @@ defmodule LightningWeb.WebhooksController do
       )
       |> case do
         {:ok, work_order} ->
+          conn =
+            conn
+            |> put_resp_header("x-meta-work_order_id", work_order.id)
+            |> then(fn conn ->
+              case work_order do
+                %{runs: [run]} ->
+                  put_resp_header(conn, "x-meta-run_id", run.id)
+
+                _ ->
+                  conn
+              end
+            end)
+
           if Workflows.Trigger.synchronous?(trigger) do
             handle_delayed_response(conn, work_order)
           else
@@ -131,11 +144,6 @@ defmodule LightningWeb.WebhooksController do
         conn
         |> put_status(status_code)
         |> json(body)
-
-      {:webhook_error, status_code, error} ->
-        conn
-        |> put_status(status_code)
-        |> json(%{error: error})
     after
       Lightning.Config.webhook_response_timeout_ms() ->
         Logger.warning(

From e356ad1014e652b210759c6c9cd8d60d85facab8 Mon Sep 17 00:00:00 2001
From: Frank Midigo <midigofrank@gmail.com>
Date: Mon, 27 Apr 2026 07:18:12 +0300
Subject: [PATCH 06/21] add tests and fix bugs for configurable webhook
 responses

- Fix snapshot serialization to recursively handle embedded schemas
  using Ecto.embedded_dump + __schema__(:embeds), excluding
  :sync_webhook_response_config from the flat cast field list
- Drop incorrect primary_key: false from sync_webhook_response_config embed
- Fix default_response_body/3 nil-config clause so success runs
  without a configured body correctly return the final state
- Rename webhook response headers to hyphenated form:
  x-meta-work-order-id, x-meta-run-id
- Add run_channel tests covering all webhook response dispatch paths:
  _webhookResponse override, configured status codes/body, malformed
  responses, before_start triggers
- Rewrite webhooks_controller delayed-response tests to use
  WorkOrders.Events for synchronisation instead of Process.sleep,
  and assert on x-meta-* response headers
- Fix integration tests that incorrectly asserted data/meta wrapping
  on the response body; add integration tests for configured
  success_code, error_code, custom body, and _webhookResponse override
---
 lib/lightning/workflows/snapshot.ex           |  48 ++-
 lib/lightning/workflows/trigger.ex            |   3 +-
 lib/lightning_web/channels/run_channel.ex     |   2 +-
 .../controllers/webhooks_controller.ex        |   4 +-
 test/integration/web_and_worker_test.exs      | 207 ++++++++--
 .../channels/run_channel_test.exs             | 356 ++++++++++++++++++
 .../controllers/webhooks_controller_test.exs  | 156 +++-----
 7 files changed, 623 insertions(+), 153 deletions(-)

diff --git a/lib/lightning/workflows/snapshot.ex b/lib/lightning/workflows/snapshot.ex
index bb2982c62ac..09fab828648 100644
--- a/lib/lightning/workflows/snapshot.ex
+++ b/lib/lightning/workflows/snapshot.ex
@@ -66,8 +66,7 @@ defmodule Lightning.Workflows.Snapshot do
         default: :before_start
 
       embeds_one :sync_webhook_response_config, SyncWebhookResponseConfig,
-        on_replace: :update,
-        primary_key: false
+        on_replace: :update
 
       many_to_many :webhook_auth_methods, WebhookAuthMethod,
         join_through: "trigger_webhook_auth_methods",
@@ -116,7 +115,7 @@ defmodule Lightning.Workflows.Snapshot do
 
   @job_fields Lightning.Workflows.Job.__schema__(:fields) -- [:workflow_id]
   @trigger_fields Lightning.Workflows.Trigger.__schema__(:fields) --
-                    [:workflow_id]
+                    [:workflow_id, :sync_webhook_response_config]
   @edge_fields Lightning.Workflows.Edge.__schema__(:fields) -- [:workflow_id]
 
   defp job_changeset(schema, params) do
@@ -141,12 +140,7 @@ defmodule Lightning.Workflows.Snapshot do
     |> validate_required([:id, :inserted_at, :updated_at])
   end
 
-  @associations_to_include [
-    :jobs,
-    :triggers,
-    :edges,
-    :sync_webhook_response_config
-  ]
+  @associations_to_include [:jobs, :triggers, :edges]
 
   @spec build(Workflow.t()) :: Ecto.Changeset.t()
   def build(%Workflow{} = workflow) do
@@ -156,7 +150,7 @@ defmodule Lightning.Workflows.Snapshot do
     |> Enum.into(%{}, fn {field, value} ->
       case field do
         field when field in @associations_to_include ->
-          {field, Enum.map(value, &Map.from_struct/1)}
+          {field, assoc_to_map(field, value)}
 
         field when field in [:name, :lock_version, :positions] ->
           {field, value}
@@ -171,6 +165,40 @@ defmodule Lightning.Workflows.Snapshot do
     |> new()
   end
 
+  defp assoc_to_map(field, structs) when is_list(structs) do
+    Enum.map(structs, &assoc_to_map(field, &1))
+  end
+
+  defp assoc_to_map(:triggers, %module{} = struct) do
+    base = Ecto.embedded_dump(struct, :json)
+
+    module.__schema__(:embeds)
+    |> Enum.reduce(base, fn field, acc ->
+      embed = Map.get(struct, field)
+      Map.put(acc, field, embed_to_map(embed))
+    end)
+  end
+
+  defp assoc_to_map(_, %_{} = struct) do
+    Ecto.embedded_dump(struct, :json)
+  end
+
+  defp embed_to_map(%module{} = struct) do
+    base = Ecto.embedded_dump(struct, :json)
+
+    module.__schema__(:embeds)
+    |> Enum.reduce(base, fn field, acc ->
+      embed = Map.get(struct, field)
+      Map.put(acc, field, embed_to_map(embed))
+    end)
+  end
+
+  defp embed_to_map(embeds) when is_list(embeds) do
+    Enum.map(embeds, &embed_to_map/1)
+  end
+
+  defp embed_to_map(nil), do: nil
+
   @spec create(Workflow.t()) ::
           {:ok, t()} | {:error, Ecto.Changeset.t()}
   def create(%Workflow{} = workflow) do
diff --git a/lib/lightning/workflows/trigger.ex b/lib/lightning/workflows/trigger.ex
index 43a6713216c..35662429cf4 100644
--- a/lib/lightning/workflows/trigger.ex
+++ b/lib/lightning/workflows/trigger.ex
@@ -64,8 +64,7 @@ defmodule Lightning.Workflows.Trigger do
     embeds_one :kafka_configuration, KafkaConfiguration, on_replace: :update
 
     embeds_one :sync_webhook_response_config, SyncWebhookResponseConfig,
-      on_replace: :update,
-      primary_key: false
+      on_replace: :update
 
     timestamps()
   end
diff --git a/lib/lightning_web/channels/run_channel.ex b/lib/lightning_web/channels/run_channel.ex
index a759fff7c18..63f28352f1b 100644
--- a/lib/lightning_web/channels/run_channel.ex
+++ b/lib/lightning_web/channels/run_channel.ex
@@ -360,7 +360,7 @@ defmodule LightningWeb.RunChannel do
        when is_map(body),
        do: body
 
-  defp default_response_body(:success, final_state, %{body: nil}),
+  defp default_response_body(:success, final_state, _config),
     do: final_state
 
   defp default_response_body(run_status, _final_state, _config) do
diff --git a/lib/lightning_web/controllers/webhooks_controller.ex b/lib/lightning_web/controllers/webhooks_controller.ex
index bb624b87244..ec0985812a3 100644
--- a/lib/lightning_web/controllers/webhooks_controller.ex
+++ b/lib/lightning_web/controllers/webhooks_controller.ex
@@ -65,11 +65,11 @@ defmodule LightningWeb.WebhooksController do
         {:ok, work_order} ->
           conn =
             conn
-            |> put_resp_header("x-meta-work_order_id", work_order.id)
+            |> put_resp_header("x-meta-work-order-id", work_order.id)
             |> then(fn conn ->
               case work_order do
                 %{runs: [run]} ->
-                  put_resp_header(conn, "x-meta-run_id", run.id)
+                  put_resp_header(conn, "x-meta-run-id", run.id)
 
                 _ ->
                   conn
diff --git a/test/integration/web_and_worker_test.exs b/test/integration/web_and_worker_test.exs
index be2544e0ca8..5c71dddfe16 100644
--- a/test/integration/web_and_worker_test.exs
+++ b/test/integration/web_and_worker_test.exs
@@ -12,6 +12,7 @@ defmodule Lightning.WebAndWorkerTest do
   alias Lightning.Runtime.RuntimeManager
   alias Lightning.WorkOrders
   alias Lightning.Workflows.Snapshot
+  alias Lightning.Workflows.Triggers.SyncWebhookResponseConfig
 
   setup :set_mox_from_context
   setup :verify_on_exit!
@@ -469,33 +470,8 @@ defmodule Lightning.WebAndWorkerTest do
       # Wait for the workflow to complete (up to 10 seconds)
       response = Task.await(task, 10_000)
 
-      # Should return 201 with the final state
       assert response.status == 201
-
-      # The response body should be the final state from the job inside a "data"
-      # key and the metadata inside a "meta" key.
-      assert %{
-               "data" => %{"data" => %{"value" => 10}, "result" => "success"},
-               "meta" => meta
-             } = response.body
-
-      # Verify meta fields exist with correct types and values
-      assert meta["error_type"] == nil
-      assert meta["state"] == "success"
-      assert is_binary(meta["run_id"])
-      assert is_binary(meta["work_order_id"])
-
-      # Verify datetime fields are present and valid ISO8601 strings
-      assert is_binary(meta["claimed_at"])
-      assert is_binary(meta["finished_at"])
-      assert is_binary(meta["inserted_at"])
-      assert is_binary(meta["started_at"])
-
-      # Verify datetime fields match ISO8601 format
-      assert meta["claimed_at"] =~ ~r/^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}/
-      assert meta["finished_at"] =~ ~r/^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}/
-      assert meta["inserted_at"] =~ ~r/^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}/
-      assert meta["started_at"] =~ ~r/^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}/
+      assert %{"data" => %{"value" => 10}, "result" => "success"} = response.body
 
       # Verify the work order completed successfully
       work_order =
@@ -717,9 +693,7 @@ defmodule Lightning.WebAndWorkerTest do
 
       assert response.status == 201
 
-      assert %{"data" => final_state, "meta" => meta} = response.body
-
-      assert meta["state"] == "success"
+      final_state = response.body
 
       # The final_state is keyed by job ID. When the same job is reached
       # twice (step 5), the second entry gets a "-1" suffix.
@@ -744,6 +718,181 @@ defmodule Lightning.WebAndWorkerTest do
       assert Enum.count(steps) == 6
       assert Enum.all?(steps, fn step -> step.exit_reason == "success" end)
     end
+
+    @tag :integration
+    @tag timeout: 120_000
+    test "uses configured success_code when workflow succeeds", %{uri: uri} do
+      project = insert(:project)
+      trigger = build(:trigger, type: :webhook, enabled: true)
+
+      job =
+        build(:job,
+          adaptor: "@openfn/language-common@latest",
+          body: "fn(state => state);",
+          name: "job"
+        )
+
+      workflow =
+        build(:workflow, project: project)
+        |> with_trigger(trigger)
+        |> with_job(job)
+        |> with_edge({trigger, job}, condition_type: :always)
+        |> insert()
+
+      [trigger] = workflow.triggers
+
+      trigger
+      |> Ecto.Changeset.change(webhook_reply: :after_completion)
+      |> Ecto.Changeset.put_embed(
+        :sync_webhook_response_config,
+        %SyncWebhookResponseConfig{success_code: 200}
+      )
+      |> Repo.update!()
+
+      Snapshot.create(workflow |> Repo.reload!())
+
+      response =
+        build_tesla_client(uri)
+        |> Tesla.post!("/i/#{trigger.id}", %{"value" => 1})
+
+      assert response.status == 200
+    end
+
+    @tag :integration
+    @tag timeout: 120_000
+    test "uses configured error_code when workflow fails", %{uri: uri} do
+      project = insert(:project)
+      trigger = build(:trigger, type: :webhook, enabled: true)
+
+      job =
+        build(:job,
+          adaptor: "@openfn/language-common@latest",
+          body: "fn(state => { throw new Error('forced failure'); });",
+          name: "job"
+        )
+
+      workflow =
+        build(:workflow, project: project)
+        |> with_trigger(trigger)
+        |> with_job(job)
+        |> with_edge({trigger, job}, condition_type: :always)
+        |> insert()
+
+      [trigger] = workflow.triggers
+
+      trigger
+      |> Ecto.Changeset.change(webhook_reply: :after_completion)
+      |> Ecto.Changeset.put_embed(
+        :sync_webhook_response_config,
+        %SyncWebhookResponseConfig{error_code: 500}
+      )
+      |> Repo.update!()
+
+      Snapshot.create(workflow |> Repo.reload!())
+
+      response =
+        build_tesla_client(uri)
+        |> Tesla.post!("/i/#{trigger.id}", %{})
+
+      assert response.status == 500
+      assert %{"message" => msg} = response.body
+      assert msg =~ "security policy"
+    end
+
+    @tag :integration
+    @tag timeout: 120_000
+    test "uses configured body for both success and error runs", %{uri: uri} do
+      project = insert(:project)
+      custom_body = %{"ack" => true, "ref" => "custom-response"}
+
+      for {job_body, label} <- [
+            {"fn(state => state);", "success"},
+            {"fn(state => { throw new Error('fail'); });", "error"}
+          ] do
+        trigger = build(:trigger, type: :webhook, enabled: true)
+
+        job =
+          build(:job,
+            adaptor: "@openfn/language-common@latest",
+            body: job_body,
+            name: label
+          )
+
+        workflow =
+          build(:workflow, project: project)
+          |> with_trigger(trigger)
+          |> with_job(job)
+          |> with_edge({trigger, job}, condition_type: :always)
+          |> insert()
+
+        [trigger] = workflow.triggers
+
+        trigger
+        |> Ecto.Changeset.change(webhook_reply: :after_completion)
+        |> Ecto.Changeset.put_embed(
+          :sync_webhook_response_config,
+          %SyncWebhookResponseConfig{body: custom_body}
+        )
+        |> Repo.update!()
+
+        Snapshot.create(workflow |> Repo.reload!())
+
+        response =
+          build_tesla_client(uri)
+          |> Tesla.post!("/i/#{trigger.id}", %{})
+
+        assert response.body == custom_body,
+               "expected custom body for #{label} run, got: #{inspect(response.body)}"
+      end
+    end
+
+    @tag :integration
+    @tag timeout: 120_000
+    test "honours _webhookResponse set in final state", %{uri: uri} do
+      project = insert(:project)
+      trigger = build(:trigger, type: :webhook, enabled: true)
+
+      job =
+        build(:job,
+          adaptor: "@openfn/language-common@latest",
+          body: """
+          fn(state => ({
+            ...state,
+            _webhookResponse: { status: 200, body: { ack: true, received: state.data.value } }
+          }));
+          """,
+          name: "responding-job"
+        )
+
+      workflow =
+        build(:workflow, project: project)
+        |> with_trigger(trigger)
+        |> with_job(job)
+        |> with_edge({trigger, job}, condition_type: :always)
+        |> insert()
+
+      [trigger] = workflow.triggers
+
+      trigger
+      |> Ecto.Changeset.change(webhook_reply: :after_completion)
+      |> Repo.update!()
+
+      Snapshot.create(workflow |> Repo.reload!())
+
+      response =
+        build_tesla_client(uri)
+        |> Tesla.post!("/i/#{trigger.id}", %{"value" => 42})
+
+      assert response.status == 200
+      assert response.body == %{"ack" => true, "received" => 42}
+    end
+  end
+
+  defp build_tesla_client(uri) do
+    Tesla.client(
+      [{Tesla.Middleware.BaseUrl, uri}, Tesla.Middleware.JSON],
+      {Tesla.Adapter.Finch, name: Lightning.Finch}
+    )
   end
 
   defp webhook_expression do
diff --git a/test/lightning_web/channels/run_channel_test.exs b/test/lightning_web/channels/run_channel_test.exs
index d4e75643904..266f088fc2a 100644
--- a/test/lightning_web/channels/run_channel_test.exs
+++ b/test/lightning_web/channels/run_channel_test.exs
@@ -1766,6 +1766,362 @@ defmodule LightningWeb.RunChannelTest do
     end
   end
 
+  describe "webhook response broadcasting" do
+    setup [:create_user, :create_project]
+
+    setup %{project: project} do
+      dataclip = insert(:http_request_dataclip, project: project)
+
+      trigger =
+        build(:trigger,
+          type: :webhook,
+          enabled: true,
+          webhook_reply: :after_completion
+        )
+
+      job = build(:job)
+
+      %{triggers: [trigger]} =
+        workflow =
+        build(:workflow, project: project)
+        |> with_trigger(trigger)
+        |> with_job(job)
+        |> with_edge({trigger, job}, condition_type: :always)
+        |> insert()
+
+      work_order =
+        insert(:workorder,
+          workflow: workflow,
+          trigger: trigger,
+          dataclip: dataclip
+        )
+
+      run =
+        insert(:run,
+          work_order: work_order,
+          starting_trigger: trigger,
+          dataclip: dataclip,
+          state: :started,
+          options:
+            Lightning.Extensions.MockUsageLimiter.get_run_options(%Context{
+              project_id: project.id
+            })
+            |> Map.new()
+        )
+
+      %{run: run, work_order: work_order, trigger: trigger}
+    end
+
+    setup [:create_socket, :join_run_channel]
+
+    test "does not broadcast when webhook_reply is not :after_completion", %{
+      socket: socket,
+      work_order: work_order,
+      trigger: trigger
+    } do
+      trigger
+      |> Ecto.Changeset.change(webhook_reply: :before_start)
+      |> Repo.update!()
+
+      Phoenix.PubSub.subscribe(
+        Lightning.PubSub,
+        "work_order:#{work_order.id}:webhook_response"
+      )
+
+      ref =
+        push(socket, "run:complete", %{
+          "reason" => "success",
+          "final_state" => %{"data" => "ok"}
+        })
+
+      assert_reply ref, :ok, nil
+      refute_receive {:webhook_response, _, _}
+    end
+
+    test "broadcasts final state as body on success with no config", %{
+      socket: socket,
+      work_order: work_order
+    } do
+      Phoenix.PubSub.subscribe(
+        Lightning.PubSub,
+        "work_order:#{work_order.id}:webhook_response"
+      )
+
+      final_state = %{"data" => %{"result" => "ok"}}
+
+      ref =
+        push(socket, "run:complete", %{
+          "reason" => "success",
+          "final_state" => final_state
+        })
+
+      assert_reply ref, :ok, nil
+      assert_receive {:webhook_response, 201, ^final_state}
+    end
+
+    test "broadcasts security message on error with no config", %{
+      socket: socket,
+      work_order: work_order
+    } do
+      Phoenix.PubSub.subscribe(
+        Lightning.PubSub,
+        "work_order:#{work_order.id}:webhook_response"
+      )
+
+      ref =
+        push(socket, "run:complete", %{
+          "reason" => "fail",
+          "error_type" => "UserError",
+          "error_message" => nil
+        })
+
+      assert_reply ref, :ok, nil
+
+      assert_receive {:webhook_response, 201, %{message: message}}
+      assert message =~ "failed"
+      assert message =~ "security policy"
+    end
+
+    test "uses configured success_code on success", %{
+      socket: socket,
+      work_order: work_order,
+      trigger: trigger
+    } do
+      put_webhook_config(trigger, success_code: 200)
+
+      Phoenix.PubSub.subscribe(
+        Lightning.PubSub,
+        "work_order:#{work_order.id}:webhook_response"
+      )
+
+      final_state = %{"data" => "ok"}
+
+      ref =
+        push(socket, "run:complete", %{
+          "reason" => "success",
+          "final_state" => final_state
+        })
+
+      assert_reply ref, :ok, nil
+      assert_receive {:webhook_response, 200, ^final_state}
+    end
+
+    test "uses configured error_code on error", %{
+      socket: socket,
+      work_order: work_order,
+      trigger: trigger
+    } do
+      put_webhook_config(trigger, error_code: 422)
+
+      Phoenix.PubSub.subscribe(
+        Lightning.PubSub,
+        "work_order:#{work_order.id}:webhook_response"
+      )
+
+      ref =
+        push(socket, "run:complete", %{
+          "reason" => "fail",
+          "error_type" => "UserError",
+          "error_message" => nil
+        })
+
+      assert_reply ref, :ok, nil
+      assert_receive {:webhook_response, 422, %{message: _}}
+    end
+
+    test "uses configured body on success, overriding final state", %{
+      socket: socket,
+      work_order: work_order,
+      trigger: trigger
+    } do
+      custom_body = %{"custom" => true}
+      put_webhook_config(trigger, body: custom_body)
+
+      Phoenix.PubSub.subscribe(
+        Lightning.PubSub,
+        "work_order:#{work_order.id}:webhook_response"
+      )
+
+      ref =
+        push(socket, "run:complete", %{
+          "reason" => "success",
+          "final_state" => %{"data" => "should be ignored"}
+        })
+
+      assert_reply ref, :ok, nil
+      assert_receive {:webhook_response, 201, ^custom_body}
+    end
+
+    test "uses configured body on error, overriding security policy", %{
+      socket: socket,
+      work_order: work_order,
+      trigger: trigger
+    } do
+      custom_body = %{"error_detail" => "safe to expose"}
+      put_webhook_config(trigger, body: custom_body)
+
+      Phoenix.PubSub.subscribe(
+        Lightning.PubSub,
+        "work_order:#{work_order.id}:webhook_response"
+      )
+
+      ref =
+        push(socket, "run:complete", %{
+          "reason" => "fail",
+          "error_type" => "UserError",
+          "error_message" => nil
+        })
+
+      assert_reply ref, :ok, nil
+      assert_receive {:webhook_response, 201, ^custom_body}
+    end
+
+    test "valid _webhookResponse overrides config entirely", %{
+      socket: socket,
+      work_order: work_order,
+      trigger: trigger
+    } do
+      put_webhook_config(trigger, success_code: 999, body: %{"ignored" => true})
+
+      Phoenix.PubSub.subscribe(
+        Lightning.PubSub,
+        "work_order:#{work_order.id}:webhook_response"
+      )
+
+      override_body = %{"custom" => "response"}
+
+      ref =
+        push(socket, "run:complete", %{
+          "reason" => "success",
+          "final_state" => %{
+            "_webhookResponse" => %{"status" => 200, "body" => override_body}
+          }
+        })
+
+      assert_reply ref, :ok, nil
+      assert_receive {:webhook_response, 200, ^override_body}
+    end
+
+    test "float status in _webhookResponse is normalised to integer", %{
+      socket: socket,
+      work_order: work_order
+    } do
+      Phoenix.PubSub.subscribe(
+        Lightning.PubSub,
+        "work_order:#{work_order.id}:webhook_response"
+      )
+
+      override_body = %{"ok" => true}
+
+      ref =
+        push(socket, "run:complete", %{
+          "reason" => "success",
+          "final_state" => %{
+            "_webhookResponse" => %{"status" => 200.0, "body" => override_body}
+          }
+        })
+
+      assert_reply ref, :ok, nil
+      assert_receive {:webhook_response, 200, ^override_body}
+    end
+
+    test "empty _webhookResponse map falls back to default behaviour", %{
+      socket: socket,
+      work_order: work_order
+    } do
+      Phoenix.PubSub.subscribe(
+        Lightning.PubSub,
+        "work_order:#{work_order.id}:webhook_response"
+      )
+
+      final_state = %{"_webhookResponse" => %{}, "data" => "ok"}
+
+      ref =
+        push(socket, "run:complete", %{
+          "reason" => "success",
+          "final_state" => final_state
+        })
+
+      assert_reply ref, :ok, nil
+      assert_receive {:webhook_response, 201, ^final_state}
+    end
+
+    test "_webhookResponse without body key is malformed", %{
+      socket: socket,
+      work_order: work_order
+    } do
+      Phoenix.PubSub.subscribe(
+        Lightning.PubSub,
+        "work_order:#{work_order.id}:webhook_response"
+      )
+
+      ref =
+        push(socket, "run:complete", %{
+          "reason" => "success",
+          "final_state" => %{"_webhookResponse" => %{"status" => 200}}
+        })
+
+      assert_reply ref, :ok, nil
+
+      assert_receive {:webhook_response, 201, %{message: message}}
+      assert message =~ "malformed"
+    end
+
+    test "_webhookResponse without status key is malformed", %{
+      socket: socket,
+      work_order: work_order
+    } do
+      Phoenix.PubSub.subscribe(
+        Lightning.PubSub,
+        "work_order:#{work_order.id}:webhook_response"
+      )
+
+      ref =
+        push(socket, "run:complete", %{
+          "reason" => "success",
+          "final_state" => %{
+            "_webhookResponse" => %{"body" => %{"data" => "ok"}}
+          }
+        })
+
+      assert_reply ref, :ok, nil
+
+      assert_receive {:webhook_response, 201, %{message: message}}
+      assert message =~ "malformed"
+    end
+
+    test "non-map _webhookResponse value is malformed", %{
+      socket: socket,
+      work_order: work_order
+    } do
+      Phoenix.PubSub.subscribe(
+        Lightning.PubSub,
+        "work_order:#{work_order.id}:webhook_response"
+      )
+
+      ref =
+        push(socket, "run:complete", %{
+          "reason" => "success",
+          "final_state" => %{"_webhookResponse" => "not a map"}
+        })
+
+      assert_reply ref, :ok, nil
+
+      assert_receive {:webhook_response, 201, %{message: message}}
+      assert message =~ "malformed"
+    end
+  end
+
+  defp put_webhook_config(trigger, attrs) do
+    alias Lightning.Workflows.Triggers.SyncWebhookResponseConfig
+    config = struct(SyncWebhookResponseConfig, attrs)
+
+    trigger
+    |> Ecto.Changeset.change()
+    |> Ecto.Changeset.put_embed(:sync_webhook_response_config, config)
+    |> Repo.update!()
+  end
+
   defp create_socket_and_run(context) do
     merge_setups(context, [
       :create_project,
diff --git a/test/lightning_web/controllers/webhooks_controller_test.exs b/test/lightning_web/controllers/webhooks_controller_test.exs
index f9731191909..4d3aa91adae 100644
--- a/test/lightning_web/controllers/webhooks_controller_test.exs
+++ b/test/lightning_web/controllers/webhooks_controller_test.exs
@@ -402,89 +402,60 @@ defmodule LightningWeb.WebhooksControllerTest do
   describe "delayed webhook response (webhook_reply: :after_completion)" do
     setup [:stub_rate_limiter_ok, :stub_usage_limiter_ok]
 
-    test "waits for and returns the final state on success", %{conn: conn} do
-      %{triggers: [trigger]} =
+    test "waits for and returns the broadcast response body and status code", %{
+      conn: conn
+    } do
+      %{triggers: [trigger], project_id: project_id} =
         insert(:simple_workflow)
         |> Lightning.Repo.preload(:triggers)
         |> with_snapshot()
 
-      # Update trigger to use after_completion
       trigger =
         trigger
         |> Ecto.Changeset.change(webhook_reply: :after_completion)
         |> Repo.update!()
 
-      message = %{"foo" => "bar"}
+      Lightning.WorkOrders.Events.subscribe(project_id)
 
-      # Spawn a task that will post to the webhook
-      # This task will be blocked waiting for the webhook response
       test_pid = self()
 
       task =
         Task.async(fn ->
-          conn = post(conn, "/i/#{trigger.id}", message)
+          conn = post(conn, "/i/#{trigger.id}", %{"foo" => "bar"})
           send(test_pid, {:response, conn})
         end)
 
-      # Wait for the work order to be created
-      Process.sleep(100)
-
-      # Find the work order
-      work_order =
-        Lightning.Repo.one(
-          from wo in Lightning.WorkOrder,
-            where: wo.trigger_id == ^trigger.id,
-            order_by: [desc: wo.inserted_at],
-            limit: 1
-        )
-
-      assert work_order
-
-      # Get the run for metadata
-      run =
-        Lightning.Repo.one(
-          from r in Lightning.Run,
-            where: r.work_order_id == ^work_order.id,
-            limit: 1
-        )
-
-      # Simulate the worker completing the run with final state
-      final_state_data = %{"result" => "success", "data" => %{"x" => 42}}
-
-      response_body = %{
-        data: final_state_data,
-        meta: %{
-          work_order_id: work_order.id,
-          run_id: run.id,
-          state: :success,
-          error_type: nil,
-          inserted_at: run.inserted_at,
-          started_at: run.started_at,
-          claimed_at: run.claimed_at,
-          finished_at: run.finished_at
-        }
+      assert_receive %Lightning.WorkOrders.Events.WorkOrderCreated{
+        work_order: work_order
       }
 
+      assert_receive %Lightning.WorkOrders.Events.RunCreated{run: run}
+
+      body = %{"result" => "success", "value" => 42}
+
       Phoenix.PubSub.broadcast(
         Lightning.PubSub,
         "work_order:#{work_order.id}:webhook_response",
-        {:webhook_response, 200, response_body}
+        {:webhook_response, 200, body}
       )
 
-      # Now the task should complete with the response
       assert_receive {:response, response_conn}, 5_000
 
-      response = json_response(response_conn, 200)
-      assert response["data"] == final_state_data
-      assert response["meta"]["work_order_id"] == work_order.id
-      assert response["meta"]["run_id"] == run.id
-      assert response["meta"]["state"] == "success"
+      assert json_response(response_conn, 200) == body
+
+      assert get_resp_header(response_conn, "x-meta-work-order-id") == [
+               work_order.id
+             ]
+
+      assert get_resp_header(response_conn, "x-meta-run-id") == [run.id]
 
       Task.await(task)
     end
 
-    test "waits for and returns error state on failure", %{conn: conn} do
-      %{triggers: [trigger]} =
+    test "passes through any status code from the broadcast message", %{
+      conn: conn
+    } do
+      %{triggers: [trigger], project_id: project_id} =
         insert(:simple_workflow)
         |> Lightning.Repo.preload(:triggers)
         |> with_snapshot()
@@ -494,65 +465,39 @@ defmodule LightningWeb.WebhooksControllerTest do
         |> Ecto.Changeset.change(webhook_reply: :after_completion)
         |> Repo.update!()
 
-      message = %{"foo" => "bar"}
+      Lightning.WorkOrders.Events.subscribe(project_id)
+
       test_pid = self()
 
       task =
         Task.async(fn ->
-          conn = post(conn, "/i/#{trigger.id}", message)
+          conn = post(conn, "/i/#{trigger.id}", %{"foo" => "bar"})
           send(test_pid, {:response, conn})
         end)
 
-      Process.sleep(100)
-
-      work_order =
-        Lightning.Repo.one(
-          from wo in Lightning.WorkOrder,
-            where: wo.trigger_id == ^trigger.id,
-            order_by: [desc: wo.inserted_at],
-            limit: 1
-        )
-
-      assert work_order
-
-      # Get the run for metadata
-      run =
-        Lightning.Repo.one(
-          from r in Lightning.Run,
-            where: r.work_order_id == ^work_order.id,
-            limit: 1
-        )
-
-      error_data = %{"error" => "Something went wrong"}
-
-      response_body = %{
-        data: error_data,
-        meta: %{
-          work_order_id: work_order.id,
-          run_id: run.id,
-          state: :failed,
-          error_type: "RuntimeError",
-          inserted_at: run.inserted_at,
-          started_at: run.started_at,
-          claimed_at: run.claimed_at,
-          finished_at: run.finished_at
-        }
+      assert_receive %Lightning.WorkOrders.Events.WorkOrderCreated{
+        work_order: work_order
       }
 
+      assert_receive %Lightning.WorkOrders.Events.RunCreated{run: run}
+
+      body = %{"message" => "run failed"}
+
       Phoenix.PubSub.broadcast(
         Lightning.PubSub,
         "work_order:#{work_order.id}:webhook_response",
-        {:webhook_response, 422, response_body}
+        {:webhook_response, 422, body}
       )
 
       assert_receive {:response, response_conn}, 5_000
 
-      response = json_response(response_conn, 422)
-      assert response["data"] == error_data
-      assert response["meta"]["work_order_id"] == work_order.id
-      assert response["meta"]["run_id"] == run.id
-      assert response["meta"]["state"] == "failed"
-      assert response["meta"]["error_type"] == "RuntimeError"
+      assert json_response(response_conn, 422) == body
+
+      assert get_resp_header(response_conn, "x-meta-work-order-id") == [
+               work_order.id
+             ]
+
+      assert get_resp_header(response_conn, "x-meta-run-id") == [run.id]
 
       Task.await(task)
     end
@@ -560,7 +505,6 @@ defmodule LightningWeb.WebhooksControllerTest do
     test "returns timeout if workflow doesn't complete within timeout period", %{
       conn: conn
     } do
-      # Set a shorter timeout for this test (2 seconds instead of default)
       expect(Lightning.MockConfig, :webhook_response_timeout_ms, fn -> 2_000 end)
 
       %{triggers: [trigger]} =
@@ -573,19 +517,16 @@ defmodule LightningWeb.WebhooksControllerTest do
         |> Ecto.Changeset.change(webhook_reply: :after_completion)
         |> Repo.update!()
 
-      message = %{"foo" => "bar"}
+      conn = post(conn, "/i/#{trigger.id}", %{"foo" => "bar"})
 
-      # This will timeout since we never broadcast a response
-      conn = post(conn, "/i/#{trigger.id}", message)
+      [work_order_id] = get_resp_header(conn, "x-meta-work-order-id")
 
       assert json_response(conn, 504) == %{
                "error" => "timeout",
                "message" => "Workflow did not complete within timeout period",
-               "work_order_id" => json_response(conn, 504)["work_order_id"]
+               "work_order_id" => work_order_id
              }
 
-      # Verify work order was still created
-      work_order_id = json_response(conn, 504)["work_order_id"]
       assert WorkOrders.get(work_order_id)
     end
 
@@ -597,15 +538,12 @@ defmodule LightningWeb.WebhooksControllerTest do
         |> Lightning.Repo.preload(:triggers)
         |> with_snapshot()
 
-      # Ensure trigger is using default before_start
       assert trigger.webhook_reply == :before_start
 
-      message = %{"foo" => "bar"}
-
-      # Should return immediately
-      conn = post(conn, "/i/#{trigger.id}", message)
+      conn = post(conn, "/i/#{trigger.id}", %{"foo" => "bar"})
 
-      assert %{"work_order_id" => work_order_id} = json_response(conn, 200)
+      [work_order_id] = get_resp_header(conn, "x-meta-work-order-id")
+      assert %{"work_order_id" => ^work_order_id} = json_response(conn, 200)
       assert WorkOrders.get(work_order_id)
     end
   end

From e1702504c359c937a46cb2f49d29010ddcf3f293 Mon Sep 17 00:00:00 2001
From: Frank Midigo <midigofrank@gmail.com>
Date: Mon, 27 Apr 2026 11:57:18 +0300
Subject: [PATCH 07/21] handle webhook_response in YAML export, provisioning
 API, and import

- Serialize sync_webhook_response_config as webhook_response in YAML
  export; body is JSON-encoded as a literal block scalar matching how
  job.body is handled
- Expose webhook_response in the provisioning API GET response
- Accept webhook_response on provisioning import and remap it to
  sync_webhook_response_config; decode body if it arrives as a JSON
  string (from YAML literal block)
- Add Jason.Encoder derives so sync_webhook_response_config is included
  when the trigger is serialized for the session context
- Add tests covering export, API output, and import including the
  JSON-string body decoding path
---
 lib/lightning/export_utils.ex                 | 38 ++++++--
 lib/lightning/projects/provisioner.ex         | 29 +++++++
 lib/lightning/workflows/trigger.ex            |  3 +-
 .../triggers/sync_webhook_response_config.ex  |  2 +
 .../controllers/api/provisioning_json.ex      |  9 ++
 test/lightning/projects/provisioner_test.exs  | 87 +++++++++++++++++++
 test/lightning/projects_test.exs              | 55 ++++++++++++
 .../api/provisioning_controller_test.exs      | 75 ++++++++++++++++
 test/support/factories.ex                     |  4 +
 9 files changed, 296 insertions(+), 6 deletions(-)

diff --git a/lib/lightning/export_utils.ex b/lib/lightning/export_utils.ex
index b274485bbf7..7f83c28b1f8 100644
--- a/lib/lightning/export_utils.ex
+++ b/lib/lightning/export_utils.ex
@@ -31,6 +31,7 @@ defmodule Lightning.ExportUtils do
     trigger: [
       :type,
       :webhook_reply,
+      :webhook_response,
       :cron_expression,
       :cron_cursor_job,
       :enabled,
@@ -121,14 +122,38 @@ defmodule Lightning.ExportUtils do
         Map.put(base, :kafka_configuration, kafka_config)
 
       :webhook ->
-        if trigger.webhook_reply do
-          Map.put(base, :webhook_reply, Atom.to_string(trigger.webhook_reply))
-        else
-          base
-        end
+        base
+        |> maybe_put_webhook_reply(trigger.webhook_reply)
+        |> maybe_put_webhook_response(trigger.sync_webhook_response_config)
+    end
+  end
+
+  defp maybe_put_webhook_reply(map, reply) when is_atom(reply) do
+    Map.put(map, :webhook_reply, Atom.to_string(reply))
+  end
+
+  defp maybe_put_webhook_reply(map, _), do: map
+
+  defp maybe_put_webhook_response(map, %{} = config) do
+    webhook_response =
+      Map.reject(
+        %{
+          success_code: config.success_code,
+          error_code: config.error_code,
+          body: config.body && Jason.encode!(config.body, pretty: true)
+        },
+        fn {_k, v} -> is_nil(v) end
+      )
+
+    if map_size(webhook_response) > 0 do
+      Map.put(map, :webhook_response, webhook_response)
+    else
+      map
     end
   end
 
+  defp maybe_put_webhook_response(map, _), do: map
+
   defp edge_to_treenode(%{source_job_id: nil} = edge, triggers, jobs) do
     source_trigger =
       Enum.find(triggers, fn t -> t.id == edge.source_trigger_id end)
@@ -205,6 +230,9 @@ defmodule Lightning.ExportUtils do
       :body ->
         "body: |\n#{indent_multiline_value(v, i)}"
 
+      :webhook_response ->
+        "webhook_response: |\n#{indent_multiline_value(v, i)}"
+
       :description ->
         "description: |\n#{indent_multiline_value(v, i)}"
 
diff --git a/lib/lightning/projects/provisioner.ex b/lib/lightning/projects/provisioner.ex
index 9d10373154b..5016fafe54f 100644
--- a/lib/lightning/projects/provisioner.ex
+++ b/lib/lightning/projects/provisioner.ex
@@ -32,6 +32,7 @@ defmodule Lightning.Projects.Provisioner do
   alias Lightning.Workflows.Snapshot
   alias Lightning.Workflows.Trigger
   alias Lightning.Workflows.Triggers.KafkaConfiguration
+  alias Lightning.Workflows.Triggers.SyncWebhookResponseConfig
   alias Lightning.Workflows.Workflow
   alias Lightning.Workflows.WorkflowUsageLimiter
   alias Lightning.WorkflowVersions
@@ -455,6 +456,8 @@ defmodule Lightning.Projects.Provisioner do
   end
 
   defp trigger_changeset(trigger, attrs) do
+    attrs = remap_webhook_response(attrs)
+
     trigger
     |> Trigger.cast_changeset(attrs)
     |> cast_embed(
@@ -462,6 +465,11 @@ defmodule Lightning.Projects.Provisioner do
       required: false,
       with: &kafka_config_changeset/2
     )
+    |> cast_embed(
+      :sync_webhook_response_config,
+      required: false,
+      with: &SyncWebhookResponseConfig.changeset/2
+    )
     |> Trigger.validate()
     |> cast(attrs, [:delete])
     |> validate_required([:id])
@@ -470,6 +478,27 @@ defmodule Lightning.Projects.Provisioner do
     |> maybe_mark_for_deletion()
   end
 
+  defp remap_webhook_response(attrs) do
+    case Map.pop(attrs, "webhook_response") do
+      {nil, attrs} ->
+        attrs
+
+      {config, attrs} ->
+        config = decode_webhook_response_body(config)
+        Map.put(attrs, "sync_webhook_response_config", config)
+    end
+  end
+
+  defp decode_webhook_response_body(%{"body" => body} = config)
+       when is_binary(body) do
+    case Jason.decode(body) do
+      {:ok, decoded} -> Map.put(config, "body", decoded)
+      _ -> config
+    end
+  end
+
+  defp decode_webhook_response_body(config), do: config
+
   defp kafka_config_changeset(kafka_config, attrs) do
     kafka_config
     |> KafkaConfiguration.changeset(attrs)
diff --git a/lib/lightning/workflows/trigger.ex b/lib/lightning/workflows/trigger.ex
index 35662429cf4..ca050bb2f96 100644
--- a/lib/lightning/workflows/trigger.ex
+++ b/lib/lightning/workflows/trigger.ex
@@ -37,7 +37,8 @@ defmodule Lightning.Workflows.Trigger do
              :cron_cursor_job_id,
              :type,
              :enabled,
-             :webhook_reply
+             :webhook_reply,
+             :sync_webhook_response_config
            ]}
   schema "triggers" do
     field :comment, :string
diff --git a/lib/lightning/workflows/triggers/sync_webhook_response_config.ex b/lib/lightning/workflows/triggers/sync_webhook_response_config.ex
index 1baacb8659a..d77633b0db7 100644
--- a/lib/lightning/workflows/triggers/sync_webhook_response_config.ex
+++ b/lib/lightning/workflows/triggers/sync_webhook_response_config.ex
@@ -15,6 +15,8 @@ defmodule Lightning.Workflows.Triggers.SyncWebhookResponseConfig do
   use Ecto.Schema
   import Ecto.Changeset
 
+  @derive {Jason.Encoder, only: [:success_code, :error_code, :body]}
+
   @primary_key false
   embedded_schema do
     field :success_code, :integer
diff --git a/lib/lightning_web/controllers/api/provisioning_json.ex b/lib/lightning_web/controllers/api/provisioning_json.ex
index 3db39601d1c..4c01cb62865 100644
--- a/lib/lightning_web/controllers/api/provisioning_json.ex
+++ b/lib/lightning_web/controllers/api/provisioning_json.ex
@@ -102,11 +102,20 @@ defmodule LightningWeb.API.ProvisioningJSON do
           ~w(hosts topics initial_offset_reset_policy connect_timeout)a
         )
 
+    webhook_response =
+      trigger.sync_webhook_response_config &&
+        Map.take(trigger.sync_webhook_response_config, [
+          :success_code,
+          :error_code,
+          :body
+        ])
+
     trigger
     |> Map.take(
       ~w(id type cron_expression enabled webhook_reply cron_cursor_job_id)a
     )
     |> Map.put(:kafka_configuration, kafka_configuration)
+    |> Map.put(:webhook_response, webhook_response)
     |> drop_keys_with_nil_value()
   end
 
diff --git a/test/lightning/projects/provisioner_test.exs b/test/lightning/projects/provisioner_test.exs
index 34fa8202824..9f63f4e5336 100644
--- a/test/lightning/projects/provisioner_test.exs
+++ b/test/lightning/projects/provisioner_test.exs
@@ -361,6 +361,93 @@ defmodule Lightning.Projects.ProvisionerTest do
       assert trigger.webhook_reply == :after_completion
     end
 
+    test "imports trigger with webhook_response field" do
+      Mox.verify_on_exit!()
+      user = insert(:user)
+
+      %{body: %{"workflows" => [workflow]} = body, project_id: project_id} =
+        valid_document()
+
+      updated_triggers =
+        Enum.map(workflow["triggers"], fn trigger ->
+          Map.merge(trigger, %{
+            "type" => "webhook",
+            "webhook_reply" => "after_completion",
+            "webhook_response" => %{
+              "success_code" => 200,
+              "error_code" => 500,
+              "body" => %{"status" => "ok"}
+            }
+          })
+        end)
+
+      body =
+        Map.put(body, "workflows", [
+          Map.put(workflow, "triggers", updated_triggers)
+        ])
+
+      Mox.stub(
+        Lightning.Extensions.MockUsageLimiter,
+        :limit_action,
+        fn _action, _context -> :ok end
+      )
+
+      {:ok, project} =
+        Provisioner.import_document(
+          %Lightning.Projects.Project{},
+          user,
+          body
+        )
+
+      assert %{id: ^project_id, workflows: [%{triggers: [trigger]}]} = project
+      assert trigger.webhook_reply == :after_completion
+      assert trigger.sync_webhook_response_config.success_code == 200
+      assert trigger.sync_webhook_response_config.error_code == 500
+      assert trigger.sync_webhook_response_config.body == %{"status" => "ok"}
+    end
+
+    test "imports trigger with webhook_response body as a JSON string (from YAML)" do
+      Mox.verify_on_exit!()
+      user = insert(:user)
+
+      %{body: %{"workflows" => [workflow]} = body, project_id: project_id} =
+        valid_document()
+
+      updated_triggers =
+        Enum.map(workflow["triggers"], fn trigger ->
+          Map.merge(trigger, %{
+            "type" => "webhook",
+            "webhook_reply" => "after_completion",
+            "webhook_response" => %{
+              "success_code" => 200,
+              "body" => ~s({"status": "ok"})
+            }
+          })
+        end)
+
+      body =
+        Map.put(body, "workflows", [
+          Map.put(workflow, "triggers", updated_triggers)
+        ])
+
+      Mox.stub(
+        Lightning.Extensions.MockUsageLimiter,
+        :limit_action,
+        fn _action, _context -> :ok end
+      )
+
+      {:ok, project} =
+        Provisioner.import_document(
+          %Lightning.Projects.Project{},
+          user,
+          body
+        )
+
+      assert %{id: ^project_id, workflows: [%{triggers: [trigger]}]} = project
+      assert trigger.sync_webhook_response_config.success_code == 200
+      assert trigger.sync_webhook_response_config.body == %{"status" => "ok"}
+    end
+
     test "imports cron trigger with cron_cursor_job_id field" do
       Mox.verify_on_exit!()
       user = insert(:user)
diff --git a/test/lightning/projects_test.exs b/test/lightning/projects_test.exs
index 19577d1e40e..36bbcff2f2b 100644
--- a/test/lightning/projects_test.exs
+++ b/test/lightning/projects_test.exs
@@ -780,6 +780,61 @@ defmodule Lightning.ProjectsTest do
       assert generated_yaml =~ expected_yaml_trigger
     end
 
+    test "webhook_response config is included in the export" do
+      project = insert(:project, name: "project 1")
+
+      trigger =
+        build(:trigger,
+          type: :webhook,
+          enabled: true,
+          webhook_reply: :after_completion,
+          sync_webhook_response_config:
+            build(:sync_webhook_response_config,
+              success_code: 200,
+              error_code: 500,
+              body: %{"status" => "ok"}
+            )
+        )
+
+      job =
+        build(:job,
+          body: ~s[fn(state => state)]
+        )
+
+      build(:workflow, name: "workflow 1", project: project)
+      |> with_trigger(trigger)
+      |> with_job(job)
+      |> with_edge({trigger, job}, condition_type: :always)
+      |> insert()
+
+      assert {:ok, generated_yaml} = Projects.export_project(:yaml, project.id)
+
+      assert generated_yaml =~ "webhook_reply: after_completion"
+
+      assert generated_yaml =~ "webhook_response:"
+      assert generated_yaml =~ "success_code: 200"
+      assert generated_yaml =~ "error_code: 500"
+      assert generated_yaml =~ "body:"
+    end
+
+    test "webhook_response is omitted when sync_webhook_response_config is nil" do
+      project = insert(:project, name: "project 2")
+
+      trigger = build(:trigger, type: :webhook, enabled: true)
+
+      job = build(:job, body: ~s[fn(state => state)])
+
+      build(:workflow, name: "workflow 1", project: project)
+      |> with_trigger(trigger)
+      |> with_job(job)
+      |> with_edge({trigger, job}, condition_type: :always)
+      |> insert()
+
+      assert {:ok, generated_yaml} = Projects.export_project(:yaml, project.id)
+
+      refute generated_yaml =~ "webhook_response"
+    end
+
     test "exports canonical project" do
       project =
         canonical_project_fixture(
diff --git a/test/lightning_web/controllers/api/provisioning_controller_test.exs b/test/lightning_web/controllers/api/provisioning_controller_test.exs
index 47c8bbee57b..ef26c506d75 100644
--- a/test/lightning_web/controllers/api/provisioning_controller_test.exs
+++ b/test/lightning_web/controllers/api/provisioning_controller_test.exs
@@ -594,6 +594,81 @@ defmodule LightningWeb.API.ProvisioningControllerTest do
              } = trigger_json
     end
 
+    test "returns webhook_response when sync_webhook_response_config is set", %{
+      conn: conn,
+      user: user
+    } do
+      project = insert(:project, project_users: [%{user_id: user.id}])
+
+      trigger =
+        build(:trigger,
+          type: :webhook,
+          webhook_reply: :after_completion,
+          sync_webhook_response_config:
+            build(:sync_webhook_response_config,
+              success_code: 200,
+              error_code: 500,
+              body: %{"status" => "ok"}
+            )
+        )
+
+      job = build(:job)
+
+      %{triggers: [%{id: trigger_id}]} =
+        build(:workflow, project: project)
+        |> with_trigger(trigger)
+        |> with_job(job)
+        |> with_edge({trigger, job}, condition_type: :always)
+        |> insert()
+
+      conn = get(conn, ~p"/api/provision/#{project.id}")
+      response = json_response(conn, 200)
+
+      assert %{
+               "workflows" => [
+                 %{
+                   "triggers" => [trigger_json]
+                 }
+               ]
+             } = response["data"]
+
+      assert %{
+               "id" => ^trigger_id,
+               "type" => "webhook",
+               "webhook_reply" => "after_completion",
+               "webhook_response" => %{
+                 "success_code" => 200,
+                 "error_code" => 500,
+                 "body" => %{"status" => "ok"}
+               }
+             } = trigger_json
+    end
+
+    test "omits webhook_response when sync_webhook_response_config is nil", %{
+      conn: conn,
+      user: user
+    } do
+      project = insert(:project, project_users: [%{user_id: user.id}])
+
+      trigger = build(:trigger, type: :webhook)
+      job = build(:job)
+
+      build(:workflow, project: project)
+      |> with_trigger(trigger)
+      |> with_job(job)
+      |> with_edge({trigger, job}, condition_type: :always)
+      |> insert()
+
+      conn = get(conn, ~p"/api/provision/#{project.id}")
+      response = json_response(conn, 200)
+
+      assert %{
+               "workflows" => [%{"triggers" => [trigger_json]}]
+             } = response["data"]
+
+      refute Map.has_key?(trigger_json, "webhook_response")
+    end
+
     test "returns a cron trigger with cron_cursor_job_id in the response", %{
       conn: conn,
       user: user
diff --git a/test/support/factories.ex b/test/support/factories.ex
index ffa99da33d0..68e7134deab 100644
--- a/test/support/factories.ex
+++ b/test/support/factories.ex
@@ -345,6 +345,10 @@ defmodule Lightning.Factories do
     }
   end
 
+  def sync_webhook_response_config_factory do
+    %Lightning.Workflows.Triggers.SyncWebhookResponseConfig{}
+  end
+
   def triggers_kafka_configuration_factory do
     %Lightning.Workflows.Triggers.KafkaConfiguration{
       group_id: "arb_group_id",

From 9d82ae922e80bc6224ff394e9bafa20d168ce5f8 Mon Sep 17 00:00:00 2001
From: Frank Midigo <midigofrank@gmail.com>
Date: Mon, 27 Apr 2026 11:57:29 +0300
Subject: [PATCH 08/21] handle webhook_response in YAML code view and unsaved
 changes detection

- Export sync_webhook_response_config as webhook_response in YAML code
  view, omitting null fields
- Import webhook_response back to sync_webhook_response_config when
  applying a YAML spec; JSON-parse body if it arrives as a string from
  the literal block
- Include sync_webhook_response_config in transformTrigger so status
  code edits trigger the unsaved changes indicator
- Add WebhookResponseConfig type and webhook_response field to
  SpecWebhookTrigger; add webhook_response schema to workflow-spec.json
---
 .../hooks/useUnsavedChanges.ts                |  2 ++
 .../js/collaborative-editor/types/trigger.ts  |  2 ++
 assets/js/yaml/schema/workflow-spec.json      |  9 ++++++
 assets/js/yaml/types.ts                       |  7 +++++
 assets/js/yaml/util.ts                        | 29 +++++++++++++++++++
 5 files changed, 49 insertions(+)

diff --git a/assets/js/collaborative-editor/hooks/useUnsavedChanges.ts b/assets/js/collaborative-editor/hooks/useUnsavedChanges.ts
index bffa8d11577..0c4e142e697 100644
--- a/assets/js/collaborative-editor/hooks/useUnsavedChanges.ts
+++ b/assets/js/collaborative-editor/hooks/useUnsavedChanges.ts
@@ -106,6 +106,8 @@ function transformTrigger(trigger: Trigger) {
       break;
     case 'webhook':
       output.webhook_reply = trigger.webhook_reply ?? 'before_start';
+      output.sync_webhook_response_config =
+        trigger.sync_webhook_response_config ?? null;
       break;
   }
   return output;
diff --git a/assets/js/collaborative-editor/types/trigger.ts b/assets/js/collaborative-editor/types/trigger.ts
index 253d9f705c0..53170d96c22 100644
--- a/assets/js/collaborative-editor/types/trigger.ts
+++ b/assets/js/collaborative-editor/types/trigger.ts
@@ -57,6 +57,7 @@ const cronTriggerSchema = baseTriggerSchema.extend({
     ),
   cron_cursor_job_id: z.string().uuid().nullable().default(null),
   kafka_configuration: z.null().default(null),
+  sync_webhook_response_config: z.null().default(null),
   webhook_reply: z.null().default(null).catch(null),
 });
 
@@ -111,6 +112,7 @@ const kafkaTriggerSchema = baseTriggerSchema.extend({
   cron_expression: z.null().default(null),
   cron_cursor_job_id: z.null().default(null),
   kafka_configuration: kafkaConfigSchema,
+  sync_webhook_response_config: z.null().default(null),
   webhook_reply: z.null().default(null).catch(null),
 });
 
diff --git a/assets/js/yaml/schema/workflow-spec.json b/assets/js/yaml/schema/workflow-spec.json
index f6385428593..19a2d82f35a 100644
--- a/assets/js/yaml/schema/workflow-spec.json
+++ b/assets/js/yaml/schema/workflow-spec.json
@@ -62,6 +62,15 @@
               "type": ["string", "null"],
               "enum": ["before_start", "after_completion", "custom", null]
             },
+            "webhook_response": {
+              "type": ["object", "null"],
+              "properties": {
+                "success_code": { "type": ["integer", "null"] },
+                "error_code": { "type": ["integer", "null"] },
+                "body": { "type": ["object", "null"] }
+              },
+              "additionalProperties": false
+            },
             "pos": {
               "type": "object",
               "properties": {
diff --git a/assets/js/yaml/types.ts b/assets/js/yaml/types.ts
index 4804aaced89..1cbb163d6c1 100644
--- a/assets/js/yaml/types.ts
+++ b/assets/js/yaml/types.ts
@@ -92,11 +92,18 @@ export type SpecCronTrigger = {
   pos: Position | undefined;
 };
 
+export type WebhookResponseConfig = {
+  success_code?: number | null;
+  error_code?: number | null;
+  body?: Record<string, unknown> | null;
+};
+
 export type SpecWebhookTrigger = {
   id?: string;
   type: 'webhook';
   enabled: boolean;
   webhook_reply: string | null;
+  webhook_response?: WebhookResponseConfig | null;
   pos: Position | undefined;
 };
 
diff --git a/assets/js/yaml/util.ts b/assets/js/yaml/util.ts
index 381b3ec4b1e..3fabc090ab3 100644
--- a/assets/js/yaml/util.ts
+++ b/assets/js/yaml/util.ts
@@ -82,6 +82,21 @@ export const convertWorkflowStateToSpec = (
 
     if (trigger.type === 'webhook') {
       triggerDetails.webhook_reply = trigger.webhook_reply ?? null;
+      const config = trigger.sync_webhook_response_config;
+      if (
+        config &&
+        (config.success_code != null ||
+          config.error_code != null ||
+          config.body != null)
+      ) {
+        triggerDetails.webhook_response = {
+          ...(config.success_code != null && {
+            success_code: config.success_code,
+          }),
+          ...(config.error_code != null && { error_code: config.error_code }),
+          ...(config.body != null && { body: config.body }),
+        };
+      }
     }
 
     // TODO: handle kafka config
@@ -186,6 +201,9 @@ export const convertWorkflowSpecToState = (
         type: 'webhook',
         enabled,
         webhook_reply: specTrigger.webhook_reply,
+        sync_webhook_response_config: parseWebhookResponseConfig(
+          specTrigger.webhook_response
+        ),
       };
     } else {
       trigger = {
@@ -251,6 +269,17 @@ export const convertWorkflowSpecToState = (
   return workflowState;
 };
 
+function parseWebhookResponseConfig(
+  config: import('./types').WebhookResponseConfig | null | undefined
+): import('./types').WebhookResponseConfig | null {
+  if (!config) return null;
+  const body =
+    typeof config.body === 'string'
+      ? (JSON.parse(config.body) as Record<string, unknown>)
+      : config.body;
+  return { ...config, body };
+}
+
 export const extractJobCredentials = (jobs: Workflow.Job[]): JobCredentials => {
   const credentials: JobCredentials = {};
   for (const job of jobs) {

From dd55b653baa499b768e8f61b11edc546296d701e Mon Sep 17 00:00:00 2001
From: Frank Midigo <midigofrank@gmail.com>
Date: Mon, 27 Apr 2026 12:17:05 +0300
Subject: [PATCH 09/21] Give an example on how _webhookResponse key will look
 like

---
 .../components/inspector/TriggerForm.tsx      | 55 ++++++++++++++++---
 1 file changed, 46 insertions(+), 9 deletions(-)

diff --git a/assets/js/collaborative-editor/components/inspector/TriggerForm.tsx b/assets/js/collaborative-editor/components/inspector/TriggerForm.tsx
index 585b8ffde7e..6c8a12e4f4d 100644
--- a/assets/js/collaborative-editor/components/inspector/TriggerForm.tsx
+++ b/assets/js/collaborative-editor/components/inspector/TriggerForm.tsx
@@ -35,6 +35,21 @@ interface TriggerFormProps {
 
 const logger = _logger.ns('TriggerForm').seal();
 
+function hasResponseConfig(
+  config: {
+    success_code: number | null;
+    error_code: number | null;
+    body: Record<string, unknown> | null;
+  } | null
+): boolean {
+  if (!config) return false;
+  return (
+    config.success_code != null ||
+    config.error_code != null ||
+    config.body != null
+  );
+}
+
 /**
  * Pure form component for trigger configuration.
  * Handles trigger type, enabled toggle, and type-specific fields
@@ -429,6 +444,15 @@ export function TriggerForm({ trigger }: TriggerFormProps) {
                                 ? 'Holds the HTTP connection open and responds when the run completes.'
                                 : 'Responds immediately with the enqueued work order ID.'}
                             </p>
+                            {field.state.value === 'after_completion' &&
+                              hasResponseConfig(
+                                trigger.sync_webhook_response_config
+                              ) && (
+                                <p className="mt-1 text-xs text-amber-600">
+                                  Switching to async will clear your response
+                                  configuration.
+                                </p>
+                              )}
                             {field.state.meta.errors.map(error => (
                               <p
                                 key={error}
@@ -634,15 +658,28 @@ export function TriggerForm({ trigger }: TriggerFormProps) {
                                     </div>
 
                                     {/* Runtime override note */}
-                                    <p className="text-xs text-slate-500 border-t border-slate-200 pt-3">
-                                      To override both the status code and body
-                                      at runtime, write to{' '}
-                                      <code className="font-mono text-slate-700">
-                                        _webhookResponse
-                                      </code>{' '}
-                                      in the job state. When present, it takes
-                                      full priority over these defaults.
-                                    </p>
+                                    <div className="border-t border-slate-200 pt-3 space-y-1.5">
+                                      <p className="text-xs text-slate-500">
+                                        To override the response at runtime, set{' '}
+                                        <code className="font-mono text-slate-700">
+                                          _webhookResponse
+                                        </code>{' '}
+                                        in the final job state:
+                                      </p>
+                                      <pre className="text-xs font-mono bg-slate-50 border border-slate-200 rounded px-2 py-1.5 text-slate-700 whitespace-pre-wrap overflow-x-auto">
+                                        {`fn(state => ({\n  ...state,\n  _webhookResponse: {\n    status: 200,\n    body: { ack: true, received: state.data.value }\n  }\n}));`}
+                                      </pre>
+                                      <p className="text-xs text-slate-500">
+                                        Both{' '}
+                                        <code className="font-mono">
+                                          status
+                                        </code>{' '}
+                                        and{' '}
+                                        <code className="font-mono">body</code>{' '}
+                                        are required. When present, takes full
+                                        priority over the defaults above.
+                                      </p>
+                                    </div>
                                   </div>
                                 );
                               }}

From a66a35b4c1cabb124a0d84a01ae58196ad9c3ae4 Mon Sep 17 00:00:00 2001
From: Frank Midigo <midigofrank@gmail.com>
Date: Mon, 27 Apr 2026 13:21:36 +0300
Subject: [PATCH 10/21] fix failing tests

---
 lib/lightning/export_utils.ex                            | 4 ++--
 lib/lightning/workflows/snapshot.ex                      | 2 +-
 lib/lightning/workflows/trigger.ex                       | 7 +++++--
 .../lightning/collaboration/workflow_serializer_test.exs | 9 ++++++---
 4 files changed, 14 insertions(+), 8 deletions(-)

diff --git a/lib/lightning/export_utils.ex b/lib/lightning/export_utils.ex
index 7f83c28b1f8..7866704862e 100644
--- a/lib/lightning/export_utils.ex
+++ b/lib/lightning/export_utils.ex
@@ -128,12 +128,12 @@ defmodule Lightning.ExportUtils do
     end
   end
 
+  defp maybe_put_webhook_reply(map, nil), do: map
+
   defp maybe_put_webhook_reply(map, reply) when is_atom(reply) do
     Map.put(map, :webhook_reply, Atom.to_string(reply))
   end
 
-  defp maybe_put_webhook_reply(map, _), do: map
-
   defp maybe_put_webhook_response(map, %{} = config) do
     webhook_response =
       Map.reject(
diff --git a/lib/lightning/workflows/snapshot.ex b/lib/lightning/workflows/snapshot.ex
index 09fab828648..bede4ec5646 100644
--- a/lib/lightning/workflows/snapshot.ex
+++ b/lib/lightning/workflows/snapshot.ex
@@ -62,7 +62,7 @@ defmodule Lightning.Workflows.Snapshot do
       field :has_auth_method, :boolean, virtual: true
 
       field :webhook_reply, Ecto.Enum,
-        values: [:before_start, :after_completion],
+        values: [:before_start, :after_completion, :custom],
         default: :before_start
 
       embeds_one :sync_webhook_response_config, SyncWebhookResponseConfig,
diff --git a/lib/lightning/workflows/trigger.ex b/lib/lightning/workflows/trigger.ex
index ca050bb2f96..48d309ea8bd 100644
--- a/lib/lightning/workflows/trigger.ex
+++ b/lib/lightning/workflows/trigger.ex
@@ -26,7 +26,7 @@ defmodule Lightning.Workflows.Trigger do
   @type trigger_type :: :webhook | :cron
 
   @trigger_types [:webhook, :cron, :kafka]
-  @webhook_reply_types [:before_start, :after_completion]
+  @webhook_reply_types [:before_start, :after_completion, :custom]
 
   @derive {Jason.Encoder,
            only: [
@@ -80,7 +80,10 @@ defmodule Lightning.Workflows.Trigger do
   (i.e., the HTTP connection is held open waiting for a response).
   """
   @spec synchronous?(t()) :: boolean()
-  def synchronous?(%__MODULE__{webhook_reply: :after_completion}), do: true
+  def synchronous?(%__MODULE__{webhook_reply: reply})
+      when reply in [:after_completion, :custom],
+      do: true
+
   def synchronous?(%__MODULE__{}), do: false
 
   @doc false
diff --git a/test/lightning/collaboration/workflow_serializer_test.exs b/test/lightning/collaboration/workflow_serializer_test.exs
index 3df6484e57d..e6325b1b5d2 100644
--- a/test/lightning/collaboration/workflow_serializer_test.exs
+++ b/test/lightning/collaboration/workflow_serializer_test.exs
@@ -761,7 +761,8 @@ defmodule Lightning.Collaboration.WorkflowSerializerTest do
                "cron_expression" => nil,
                "cron_cursor_job_id" => nil,
                "kafka_configuration" => nil,
-               "webhook_reply" => "before_start"
+               "webhook_reply" => "before_start",
+               "sync_webhook_response_config" => nil
              } == extracted_trigger
 
       assert is_nil(extracted["positions"])
@@ -983,7 +984,8 @@ defmodule Lightning.Collaboration.WorkflowSerializerTest do
                "cron_expression" => original_trigger.cron_expression,
                "cron_cursor_job_id" => original_trigger.cron_cursor_job_id,
                "kafka_configuration" => nil,
-               "webhook_reply" => nil
+               "webhook_reply" => nil,
+               "sync_webhook_response_config" => nil
              } == extracted_trigger
 
       # Positions
@@ -1294,7 +1296,8 @@ defmodule Lightning.Collaboration.WorkflowSerializerTest do
                "cron_expression" => "0 */6 * * *",
                "cron_cursor_job_id" => original_trigger.cron_cursor_job_id,
                "kafka_configuration" => nil,
-               "webhook_reply" => nil
+               "webhook_reply" => nil,
+               "sync_webhook_response_config" => nil
              } == trigger
     end
 

From 8c9081300ce9a34cd261ceb2b392a8702d6299d2 Mon Sep 17 00:00:00 2001
From: Frank Midigo <midigofrank@gmail.com>
Date: Tue, 28 Apr 2026 11:31:22 +0300
Subject: [PATCH 11/21] remove body from configuration

---
 .../components/inspector/TriggerForm.tsx      | 486 ++++++++++--------
 .../js/collaborative-editor/types/session.ts  |   1 -
 .../js/collaborative-editor/types/trigger.ts  |   1 -
 assets/js/yaml/schema/workflow-spec.json      |   3 +-
 assets/js/yaml/types.ts                       |   2 -
 assets/js/yaml/util.ts                        |  11 +-
 lib/lightning/export_utils.ex                 |   6 +-
 .../triggers/sync_webhook_response_config.ex  |   7 +-
 lib/lightning_web/channels/run_channel.ex     |  75 +--
 .../controllers/api/provisioning_json.ex      |   3 +-
 test/integration/web_and_worker_test.exs      |  47 --
 test/lightning/projects/provisioner_test.exs  |  46 +-
 test/lightning/projects_test.exs              |   4 +-
 .../channels/run_channel_test.exs             | 112 ++--
 .../api/provisioning_controller_test.exs      |   6 +-
 15 files changed, 388 insertions(+), 422 deletions(-)

diff --git a/assets/js/collaborative-editor/components/inspector/TriggerForm.tsx b/assets/js/collaborative-editor/components/inspector/TriggerForm.tsx
index 6c8a12e4f4d..4afd32c6e0b 100644
--- a/assets/js/collaborative-editor/components/inspector/TriggerForm.tsx
+++ b/assets/js/collaborative-editor/components/inspector/TriggerForm.tsx
@@ -1,7 +1,5 @@
 import { useCallback, useEffect, useState } from 'react';
 
-import { MonacoEditor } from '../../../monaco';
-
 import { useCopyToClipboard } from '#/collaborative-editor/hooks/useCopyToClipboard';
 import {
   createDefaultTrigger,
@@ -39,15 +37,10 @@ function hasResponseConfig(
   config: {
     success_code: number | null;
     error_code: number | null;
-    body: Record<string, unknown> | null;
   } | null
 ): boolean {
   if (!config) return false;
-  return (
-    config.success_code != null ||
-    config.error_code != null ||
-    config.body != null
-  );
+  return config.success_code != null || config.error_code != null;
 }
 
 /**
@@ -62,6 +55,17 @@ export function TriggerForm({ trigger }: TriggerFormProps) {
   const { copyText, copyToClipboard } = useCopyToClipboard();
   const [showAdvancedSettings, setShowAdvancedSettings] = useState(false);
   const [showAuthModal, setShowAuthModal] = useState(false);
+  const [hasResponseStatus, setHasResponseStatus] = useState(() => {
+    const cfg = trigger.sync_webhook_response_config;
+    return cfg != null && (cfg.success_code != null || cfg.error_code != null);
+  });
+  const [showResponseStatus, setShowResponseStatus] = useState(true);
+  const [shownSuccessCode, setShownSuccessCode] = useState(
+    () => trigger.sync_webhook_response_config?.success_code != null
+  );
+  const [shownErrorCode, setShownErrorCode] = useState(
+    () => trigger.sync_webhook_response_config?.error_code != null
+  );
   const sessionContext = useSessionContext();
   const { provider } = useSession();
   const channel = provider?.channel;
@@ -432,9 +436,11 @@ export function TriggerForm({ trigger }: TriggerFormProps) {
                               )}
                             >
                               <option value="before_start">
-                                Async (default)
+                                Async (Before Start)
+                              </option>
+                              <option value="after_completion">
+                                Sync (After Completion)
                               </option>
-                              <option value="after_completion">Sync</option>
                             </select>
                             <p
                               id={`${field.name}-description`}
@@ -473,217 +479,275 @@ export function TriggerForm({ trigger }: TriggerFormProps) {
                           }
 
                           return (
-                            <form.Field name="sync_webhook_response_config">
-                              {field => {
-                                const config = field.state.value as {
-                                  success_code: number | null;
-                                  error_code: number | null;
-                                  body: Record<string, unknown> | null;
-                                } | null;
+                            <div className="space-y-3 animate-in fade-in slide-in-from-top-2 duration-200">
+                              {/* Options header */}
+                              <div className="flex items-center">
+                                <span className="text-sm font-medium text-slate-700">
+                                  Options
+                                </span>
+                              </div>
 
-                                const baseConfig = config ?? {
-                                  success_code: null,
-                                  error_code: null,
-                                  body: null,
-                                };
+                              {/* Response Status block */}
+                              {hasResponseStatus && (
+                                <form.Field name="sync_webhook_response_config">
+                                  {field => {
+                                    const config = field.state.value as {
+                                      success_code: number | null;
+                                      error_code: number | null;
+                                    } | null;
 
-                                const bodyType =
-                                  config?.body != null
-                                    ? 'raw_json'
-                                    : 'final_state';
+                                    const baseConfig = config ?? {
+                                      success_code: null,
+                                      error_code: null,
+                                    };
 
-                                const inputClass = cn(
-                                  'block w-full px-3 py-2',
-                                  'border rounded-md text-sm',
-                                  'border-slate-300',
-                                  'focus:border-indigo-500 focus:ring-indigo-500',
-                                  'focus:outline-none focus:ring-1',
-                                  'disabled:opacity-50 disabled:cursor-not-allowed'
-                                );
+                                    const inputClass = cn(
+                                      'block w-full px-3 py-2',
+                                      'border rounded-md text-sm',
+                                      'border-slate-300',
+                                      'focus:border-indigo-500 focus:ring-indigo-500',
+                                      'focus:outline-none focus:ring-1',
+                                      'disabled:opacity-50 disabled:cursor-not-allowed'
+                                    );
 
-                                return (
-                                  <div className="space-y-4 animate-in fade-in slide-in-from-top-2 duration-200">
-                                    {/* Status Codes */}
-                                    <div>
-                                      <label className="block text-sm font-medium text-slate-800 mb-2">
-                                        Status codes
-                                      </label>
-                                      <div className="grid grid-cols-2 gap-3">
-                                        <div>
-                                          <label
-                                            htmlFor={`${field.name}-success-code`}
-                                            className="block text-xs text-slate-600 mb-1"
-                                          >
-                                            Success
-                                          </label>
-                                          <input
-                                            id={`${field.name}-success-code`}
-                                            type="number"
-                                            placeholder="201"
-                                            value={config?.success_code ?? ''}
-                                            onChange={e => {
-                                              const raw = e.target.value;
-                                              field.handleChange({
-                                                ...baseConfig,
-                                                success_code:
-                                                  raw === ''
-                                                    ? null
-                                                    : parseInt(raw, 10),
-                                              });
-                                            }}
-                                            onBlur={field.handleBlur}
-                                            disabled={isReadOnly}
-                                            className={inputClass}
-                                          />
-                                        </div>
-                                        <div>
-                                          <label
-                                            htmlFor={`${field.name}-error-code`}
-                                            className="block text-xs text-slate-600 mb-1"
-                                          >
-                                            Error
-                                          </label>
-                                          <input
-                                            id={`${field.name}-error-code`}
-                                            type="number"
-                                            placeholder="201"
-                                            value={config?.error_code ?? ''}
-                                            onChange={e => {
-                                              const raw = e.target.value;
-                                              field.handleChange({
-                                                ...baseConfig,
-                                                error_code:
-                                                  raw === ''
-                                                    ? null
-                                                    : parseInt(raw, 10),
-                                              });
-                                            }}
-                                            onBlur={field.handleBlur}
-                                            disabled={isReadOnly}
-                                            className={inputClass}
-                                          />
-                                        </div>
-                                      </div>
-                                      <p className="mt-2 text-xs text-slate-500">
-                                        Both default to 201 when not set.
-                                      </p>
-                                    </div>
-
-                                    {/* Response Body */}
-                                    <div>
-                                      <label className="block text-sm font-medium text-slate-800 mb-1">
-                                        Response body
-                                      </label>
-                                      <select
-                                        value={bodyType}
-                                        onChange={e => {
-                                          if (
-                                            e.target.value === 'final_state'
-                                          ) {
-                                            field.handleChange({
-                                              ...baseConfig,
-                                              body: null,
-                                            });
-                                          } else {
-                                            field.handleChange({
-                                              ...baseConfig,
-                                              body: config?.body ?? {},
-                                            });
-                                          }
-                                        }}
-                                        disabled={isReadOnly}
-                                        className={cn(inputClass, 'mb-2')}
-                                      >
-                                        <option value="final_state">
-                                          Final state (success only)
-                                        </option>
-                                        <option value="raw_json">
-                                          Custom JSON
-                                        </option>
-                                      </select>
-
-                                      {bodyType === 'raw_json' && (
-                                        <div className="rounded-md overflow-hidden border border-slate-300">
-                                          <MonacoEditor
-                                            language="json"
-                                            height="160px"
-                                            value={
-                                              config?.body != null
-                                                ? JSON.stringify(
-                                                    config.body,
-                                                    null,
-                                                    2
-                                                  )
-                                                : '{}'
+                                    return (
+                                      <div className="rounded-md border border-slate-200 overflow-hidden animate-in fade-in slide-in-from-top-1 duration-150">
+                                        {/* Response Status header row */}
+                                        <div className="flex items-center px-3 py-2 bg-slate-50 border-b border-slate-200">
+                                          <button
+                                            type="button"
+                                            onClick={() =>
+                                              setShowResponseStatus(
+                                                !showResponseStatus
+                                              )
                                             }
-                                            onChange={(
-                                              value: string | undefined
-                                            ) => {
-                                              if (value === undefined) return;
-                                              try {
-                                                const parsed = JSON.parse(
-                                                  value
-                                                ) as Record<string, unknown>;
+                                            className="flex flex-1 items-center gap-1.5 text-sm font-medium text-slate-700 text-left focus:outline-none"
+                                          >
+                                            <span
+                                              className={cn(
+                                                'h-3.5 w-3.5 transition-transform',
+                                                showResponseStatus
+                                                  ? 'hero-chevron-down-mini'
+                                                  : 'hero-chevron-right-mini'
+                                              )}
+                                            />
+                                            Response Status
+                                          </button>
+                                          {!isReadOnly && (
+                                            <button
+                                              type="button"
+                                              title="Remove"
+                                              onClick={() => {
+                                                setHasResponseStatus(false);
+                                                setShownSuccessCode(false);
+                                                setShownErrorCode(false);
                                                 field.handleChange({
-                                                  ...baseConfig,
-                                                  body: parsed,
+                                                  success_code: null,
+                                                  error_code: null,
                                                 });
-                                              } catch {
-                                                // Invalid JSON — don't update
-                                              }
-                                            }}
-                                            options={{
-                                              minimap: { enabled: false },
-                                              lineNumbers: 'off',
-                                              scrollBeyondLastLine: false,
-                                              fontSize: 12,
-                                              wordWrap: 'on',
-                                              readOnly: isReadOnly,
-                                              overviewRulerLanes: 0,
-                                              hideCursorInOverviewRuler: true,
-                                              scrollbar: {
-                                                vertical: 'hidden',
-                                                horizontal: 'hidden',
-                                              },
-                                            }}
-                                          />
+                                              }}
+                                              className="p-0.5 text-slate-400 hover:text-red-500 rounded transition-colors focus:outline-none"
+                                            >
+                                              <span className="hero-x-mark-mini h-3.5 w-3.5" />
+                                            </button>
+                                          )}
                                         </div>
-                                      )}
 
-                                      <p className="mt-1 text-xs text-slate-500">
-                                        {bodyType === 'final_state'
-                                          ? 'The final job state is returned on success. No body is sent on error to avoid exposing error details.'
-                                          : 'This JSON is returned for both success and error runs.'}
-                                      </p>
-                                    </div>
+                                        {/* Response Status content */}
+                                        {showResponseStatus && (
+                                          <div className="p-3 space-y-3">
+                                            {/* Success Status Code row */}
+                                            {shownSuccessCode && (
+                                              <div className="flex items-end gap-2">
+                                                <div className="flex-1">
+                                                  <label
+                                                    htmlFor={`${field.name}-success-code`}
+                                                    className="block text-xs font-medium text-slate-600 mb-1"
+                                                  >
+                                                    Success Status Code
+                                                  </label>
+                                                  <input
+                                                    id={`${field.name}-success-code`}
+                                                    type="number"
+                                                    placeholder="201"
+                                                    value={
+                                                      config?.success_code ?? ''
+                                                    }
+                                                    onChange={e => {
+                                                      const raw =
+                                                        e.target.value;
+                                                      field.handleChange({
+                                                        ...baseConfig,
+                                                        success_code:
+                                                          raw === ''
+                                                            ? null
+                                                            : parseInt(raw, 10),
+                                                      });
+                                                    }}
+                                                    onBlur={field.handleBlur}
+                                                    disabled={isReadOnly}
+                                                    className={inputClass}
+                                                  />
+                                                </div>
+                                                {!isReadOnly && (
+                                                  <button
+                                                    type="button"
+                                                    title="Remove"
+                                                    onClick={() => {
+                                                      setShownSuccessCode(
+                                                        false
+                                                      );
+                                                      field.handleChange({
+                                                        ...baseConfig,
+                                                        success_code: null,
+                                                      });
+                                                    }}
+                                                    className="mb-0.5 p-1.5 text-slate-400 hover:text-red-500 rounded transition-colors"
+                                                  >
+                                                    <span className="hero-trash-mini h-4 w-4" />
+                                                  </button>
+                                                )}
+                                              </div>
+                                            )}
 
-                                    {/* Runtime override note */}
-                                    <div className="border-t border-slate-200 pt-3 space-y-1.5">
-                                      <p className="text-xs text-slate-500">
-                                        To override the response at runtime, set{' '}
-                                        <code className="font-mono text-slate-700">
-                                          _webhookResponse
-                                        </code>{' '}
-                                        in the final job state:
-                                      </p>
-                                      <pre className="text-xs font-mono bg-slate-50 border border-slate-200 rounded px-2 py-1.5 text-slate-700 whitespace-pre-wrap overflow-x-auto">
-                                        {`fn(state => ({\n  ...state,\n  _webhookResponse: {\n    status: 200,\n    body: { ack: true, received: state.data.value }\n  }\n}));`}
-                                      </pre>
-                                      <p className="text-xs text-slate-500">
-                                        Both{' '}
-                                        <code className="font-mono">
-                                          status
-                                        </code>{' '}
-                                        and{' '}
-                                        <code className="font-mono">body</code>{' '}
-                                        are required. When present, takes full
-                                        priority over the defaults above.
-                                      </p>
-                                    </div>
-                                  </div>
-                                );
-                              }}
-                            </form.Field>
+                                            {/* Error Status Code row */}
+                                            {shownErrorCode && (
+                                              <div className="flex items-end gap-2">
+                                                <div className="flex-1">
+                                                  <label
+                                                    htmlFor={`${field.name}-error-code`}
+                                                    className="block text-xs font-medium text-slate-600 mb-1"
+                                                  >
+                                                    Error Status Code
+                                                  </label>
+                                                  <input
+                                                    id={`${field.name}-error-code`}
+                                                    type="number"
+                                                    placeholder="201"
+                                                    value={
+                                                      config?.error_code ?? ''
+                                                    }
+                                                    onChange={e => {
+                                                      const raw =
+                                                        e.target.value;
+                                                      field.handleChange({
+                                                        ...baseConfig,
+                                                        error_code:
+                                                          raw === ''
+                                                            ? null
+                                                            : parseInt(raw, 10),
+                                                      });
+                                                    }}
+                                                    onBlur={field.handleBlur}
+                                                    disabled={isReadOnly}
+                                                    className={inputClass}
+                                                  />
+                                                </div>
+                                                {!isReadOnly && (
+                                                  <button
+                                                    type="button"
+                                                    title="Remove"
+                                                    onClick={() => {
+                                                      setShownErrorCode(false);
+                                                      field.handleChange({
+                                                        ...baseConfig,
+                                                        error_code: null,
+                                                      });
+                                                    }}
+                                                    className="mb-0.5 p-1.5 text-slate-400 hover:text-red-500 rounded transition-colors"
+                                                  >
+                                                    <span className="hero-trash-mini h-4 w-4" />
+                                                  </button>
+                                                )}
+                                              </div>
+                                            )}
+
+                                            {/* Add individual status code buttons */}
+                                            {!isReadOnly &&
+                                              (!shownSuccessCode ||
+                                                !shownErrorCode) && (
+                                                <div className="flex flex-wrap gap-x-3 gap-y-1">
+                                                  {!shownSuccessCode && (
+                                                    <button
+                                                      type="button"
+                                                      onClick={() =>
+                                                        setShownSuccessCode(
+                                                          true
+                                                        )
+                                                      }
+                                                      className="flex items-center gap-1 text-xs text-indigo-600 hover:text-indigo-700 font-medium"
+                                                    >
+                                                      <span className="hero-plus-mini h-3.5 w-3.5" />
+                                                      Success Status Code
+                                                    </button>
+                                                  )}
+                                                  {!shownErrorCode && (
+                                                    <button
+                                                      type="button"
+                                                      onClick={() =>
+                                                        setShownErrorCode(true)
+                                                      }
+                                                      className="flex items-center gap-1 text-xs text-indigo-600 hover:text-indigo-700 font-medium"
+                                                    >
+                                                      <span className="hero-plus-mini h-3.5 w-3.5" />
+                                                      Error Status Code
+                                                    </button>
+                                                  )}
+                                                </div>
+                                              )}
+                                          </div>
+                                        )}
+                                      </div>
+                                    );
+                                  }}
+                                </form.Field>
+                              )}
+
+                              {/* Configure Response Status (when not yet added) */}
+                              {!hasResponseStatus && !isReadOnly && (
+                                <button
+                                  type="button"
+                                  onClick={() => {
+                                    setHasResponseStatus(true);
+                                    setShowResponseStatus(true);
+                                  }}
+                                  className="flex items-center gap-1.5 text-sm text-slate-500 hover:text-slate-700 border border-dashed border-slate-300 rounded-md px-3 py-1.5 w-full transition-colors"
+                                >
+                                  <span className="hero-adjustments-horizontal-mini h-4 w-4" />
+                                  Configure Response Status
+                                </button>
+                              )}
+
+                              {/* Response Body */}
+                              <div>
+                                <p className="text-sm font-medium text-slate-800 mb-1.5">
+                                  Response Body
+                                </p>
+                                <p className="text-xs text-slate-500">
+                                  The final run state is returned as the
+                                  response body.
+                                </p>
+                                <div className="mt-2 flex gap-2 rounded-md bg-blue-50 border border-blue-100 px-3 py-2">
+                                  <span className="hero-information-circle-mini mt-0.5 h-3.5 w-3.5 shrink-0 text-blue-400" />
+                                  <p className="text-xs text-blue-700">
+                                    To return a custom body or status code from
+                                    your job, set{' '}
+                                    <code className="font-mono">
+                                      _webhookResponse
+                                    </code>{' '}
+                                    in the final run state.{' '}
+                                    <a
+                                      href="https://docs.openfn.org/documentation/build/triggers#webhook-response"
+                                      target="_blank"
+                                      rel="noopener noreferrer"
+                                      className="underline hover:text-blue-900"
+                                    >
+                                      Learn more
+                                    </a>
+                                  </p>
+                                </div>
+                              </div>
+                            </div>
                           );
                         }}
                       </form.Field>
diff --git a/assets/js/collaborative-editor/types/session.ts b/assets/js/collaborative-editor/types/session.ts
index f43ce4b8a15..64f0edbcb7d 100644
--- a/assets/js/collaborative-editor/types/session.ts
+++ b/assets/js/collaborative-editor/types/session.ts
@@ -74,7 +74,6 @@ export namespace Session {
     sync_webhook_response_config: {
       success_code: number | null;
       error_code: number | null;
-      body: Record<string, unknown> | null;
     } | null;
     webhook_auth_methods: Array<{
       id: string;
diff --git a/assets/js/collaborative-editor/types/trigger.ts b/assets/js/collaborative-editor/types/trigger.ts
index 53170d96c22..d51152d33f3 100644
--- a/assets/js/collaborative-editor/types/trigger.ts
+++ b/assets/js/collaborative-editor/types/trigger.ts
@@ -28,7 +28,6 @@ const webhookTriggerSchema = baseTriggerSchema.extend({
     .object({
       success_code: z.number().int().nullable().default(null),
       error_code: z.number().int().nullable().default(null),
-      body: z.record(z.string(), z.unknown()).nullable().default(null),
     })
     .nullable()
     .default(null),
diff --git a/assets/js/yaml/schema/workflow-spec.json b/assets/js/yaml/schema/workflow-spec.json
index 19a2d82f35a..d677757d15a 100644
--- a/assets/js/yaml/schema/workflow-spec.json
+++ b/assets/js/yaml/schema/workflow-spec.json
@@ -66,8 +66,7 @@
               "type": ["object", "null"],
               "properties": {
                 "success_code": { "type": ["integer", "null"] },
-                "error_code": { "type": ["integer", "null"] },
-                "body": { "type": ["object", "null"] }
+                "error_code": { "type": ["integer", "null"] }
               },
               "additionalProperties": false
             },
diff --git a/assets/js/yaml/types.ts b/assets/js/yaml/types.ts
index 1cbb163d6c1..db99b798e25 100644
--- a/assets/js/yaml/types.ts
+++ b/assets/js/yaml/types.ts
@@ -32,7 +32,6 @@ export type StateWebhookTrigger = {
   sync_webhook_response_config?: {
     success_code?: number | null;
     error_code?: number | null;
-    body?: Record<string, unknown> | null;
   } | null;
 };
 
@@ -95,7 +94,6 @@ export type SpecCronTrigger = {
 export type WebhookResponseConfig = {
   success_code?: number | null;
   error_code?: number | null;
-  body?: Record<string, unknown> | null;
 };
 
 export type SpecWebhookTrigger = {
diff --git a/assets/js/yaml/util.ts b/assets/js/yaml/util.ts
index 3fabc090ab3..3a00a8ec5e5 100644
--- a/assets/js/yaml/util.ts
+++ b/assets/js/yaml/util.ts
@@ -85,16 +85,13 @@ export const convertWorkflowStateToSpec = (
       const config = trigger.sync_webhook_response_config;
       if (
         config &&
-        (config.success_code != null ||
-          config.error_code != null ||
-          config.body != null)
+        (config.success_code != null || config.error_code != null)
       ) {
         triggerDetails.webhook_response = {
           ...(config.success_code != null && {
             success_code: config.success_code,
           }),
           ...(config.error_code != null && { error_code: config.error_code }),
-          ...(config.body != null && { body: config.body }),
         };
       }
     }
@@ -273,11 +270,7 @@ function parseWebhookResponseConfig(
   config: import('./types').WebhookResponseConfig | null | undefined
 ): import('./types').WebhookResponseConfig | null {
   if (!config) return null;
-  const body =
-    typeof config.body === 'string'
-      ? (JSON.parse(config.body) as Record<string, unknown>)
-      : config.body;
-  return { ...config, body };
+  return config;
 }
 
 export const extractJobCredentials = (jobs: Workflow.Job[]): JobCredentials => {
diff --git a/lib/lightning/export_utils.ex b/lib/lightning/export_utils.ex
index 7866704862e..06c89214dea 100644
--- a/lib/lightning/export_utils.ex
+++ b/lib/lightning/export_utils.ex
@@ -139,8 +139,7 @@ defmodule Lightning.ExportUtils do
       Map.reject(
         %{
           success_code: config.success_code,
-          error_code: config.error_code,
-          body: config.body && Jason.encode!(config.body, pretty: true)
+          error_code: config.error_code
         },
         fn {_k, v} -> is_nil(v) end
       )
@@ -230,9 +229,6 @@ defmodule Lightning.ExportUtils do
       :body ->
         "body: |\n#{indent_multiline_value(v, i)}"
 
-      :webhook_response ->
-        "webhook_response: |\n#{indent_multiline_value(v, i)}"
-
       :description ->
         "description: |\n#{indent_multiline_value(v, i)}"
 
diff --git a/lib/lightning/workflows/triggers/sync_webhook_response_config.ex b/lib/lightning/workflows/triggers/sync_webhook_response_config.ex
index d77633b0db7..5e2091678cd 100644
--- a/lib/lightning/workflows/triggers/sync_webhook_response_config.ex
+++ b/lib/lightning/workflows/triggers/sync_webhook_response_config.ex
@@ -8,23 +8,20 @@ defmodule Lightning.Workflows.Triggers.SyncWebhookResponseConfig do
   - `success_code` — HTTP status code when the run succeeds. Defaults to 201.
   - `error_code` — HTTP status code for any non-success terminal state
     (failed, crashed, exception, killed, cancelled). Defaults to 201.
-  - `body` — Custom response body (JSON). Falls back to the run's final state
-    when nil.
   """
 
   use Ecto.Schema
   import Ecto.Changeset
 
-  @derive {Jason.Encoder, only: [:success_code, :error_code, :body]}
+  @derive {Jason.Encoder, only: [:success_code, :error_code]}
 
   @primary_key false
   embedded_schema do
     field :success_code, :integer
     field :error_code, :integer
-    field :body, :map
   end
 
   def changeset(config, attrs) do
-    cast(config, attrs, [:success_code, :error_code, :body])
+    cast(config, attrs, [:success_code, :error_code])
   end
 end
diff --git a/lib/lightning_web/channels/run_channel.ex b/lib/lightning_web/channels/run_channel.ex
index 63f28352f1b..a3521a18b32 100644
--- a/lib/lightning_web/channels/run_channel.ex
+++ b/lib/lightning_web/channels/run_channel.ex
@@ -336,8 +336,51 @@ defmodule LightningWeb.RunChannel do
       resp when is_nil(resp) or resp == %{} ->
         build_default_response(run, final_state, config)
 
-      resp ->
-        build_response_from_state(resp)
+      resp when is_map(resp) ->
+        build_response_from_state(resp, run, final_state, config)
+
+      _non_map ->
+        build_default_response(run, final_state, config)
+    end
+  end
+
+  defp build_response_from_state(webhook_response, run, final_state, config) do
+    with {:ok, custom_status} <- parse_webhook_status(webhook_response),
+         {:ok, custom_body} <- parse_webhook_body(webhook_response) do
+      status = custom_status || default_response_status(run.state, config)
+      body = custom_body || default_response_body(run.state, final_state, config)
+      {status, body}
+    else
+      {:error, reason} -> malformed_response(reason)
+    end
+  end
+
+  defp parse_webhook_status(webhook_response) do
+    case Map.fetch(webhook_response, "status") do
+      :error ->
+        {:ok, nil}
+
+      {:ok, status} when is_integer(status) ->
+        {:ok, status}
+
+      {:ok, status} when is_float(status) ->
+        {:ok, trunc(status)}
+
+      {:ok, status} ->
+        {:error, "status needs to be an integer, got: #{inspect(status)}"}
+    end
+  end
+
+  defp parse_webhook_body(webhook_response) do
+    case Map.fetch(webhook_response, "body") do
+      :error ->
+        {:ok, nil}
+
+      {:ok, body} when is_map(body) ->
+        {:ok, body}
+
+      {:ok, body} ->
+        {:error, "body needs to be a JSON object, got: #{inspect(body)}"}
     end
   end
 
@@ -356,10 +399,6 @@ defmodule LightningWeb.RunChannel do
 
   defp default_response_status(_run_status, _config), do: 201
 
-  defp default_response_body(_run_status, _final_state, %{body: body})
-       when is_map(body),
-       do: body
-
   defp default_response_body(:success, final_state, _config),
     do: final_state
 
@@ -370,30 +409,6 @@ defmodule LightningWeb.RunChannel do
     }
   end
 
-  defp build_response_from_state(%{"status" => status, "body" => body})
-       when is_map(body) and is_integer(status) do
-    {status, body}
-  end
-
-  defp build_response_from_state(%{"status" => status, "body" => _} = response)
-       when is_float(status) do
-    response
-    |> Map.put("status", trunc(status))
-    |> build_response_from_state()
-  end
-
-  defp build_response_from_state(%{"status" => status}) do
-    malformed_response("status needs to be an integer, got: #{inspect(status)}")
-  end
-
-  defp build_response_from_state(%{"body" => body}) do
-    malformed_response("body needs to be json object, got: #{inspect(body)}")
-  end
-
-  defp build_response_from_state(_webhook_response) do
-    malformed_response("no status or body was defined")
-  end
-
   defp malformed_response(reason) do
     {201,
      %{message: "Run completed, but _webhookResponse was malformed: #{reason}"}}
diff --git a/lib/lightning_web/controllers/api/provisioning_json.ex b/lib/lightning_web/controllers/api/provisioning_json.ex
index 4c01cb62865..62e27e7a5de 100644
--- a/lib/lightning_web/controllers/api/provisioning_json.ex
+++ b/lib/lightning_web/controllers/api/provisioning_json.ex
@@ -106,8 +106,7 @@ defmodule LightningWeb.API.ProvisioningJSON do
       trigger.sync_webhook_response_config &&
         Map.take(trigger.sync_webhook_response_config, [
           :success_code,
-          :error_code,
-          :body
+          :error_code
         ])
 
     trigger
diff --git a/test/integration/web_and_worker_test.exs b/test/integration/web_and_worker_test.exs
index 5c71dddfe16..2a3467538ea 100644
--- a/test/integration/web_and_worker_test.exs
+++ b/test/integration/web_and_worker_test.exs
@@ -799,53 +799,6 @@ defmodule Lightning.WebAndWorkerTest do
       assert msg =~ "security policy"
     end
 
-    @tag :integration
-    @tag timeout: 120_000
-    test "uses configured body for both success and error runs", %{uri: uri} do
-      project = insert(:project)
-      custom_body = %{"ack" => true, "ref" => "custom-response"}
-
-      for {job_body, label} <- [
-            {"fn(state => state);", "success"},
-            {"fn(state => { throw new Error('fail'); });", "error"}
-          ] do
-        trigger = build(:trigger, type: :webhook, enabled: true)
-
-        job =
-          build(:job,
-            adaptor: "@openfn/language-common@latest",
-            body: job_body,
-            name: label
-          )
-
-        workflow =
-          build(:workflow, project: project)
-          |> with_trigger(trigger)
-          |> with_job(job)
-          |> with_edge({trigger, job}, condition_type: :always)
-          |> insert()
-
-        [trigger] = workflow.triggers
-
-        trigger
-        |> Ecto.Changeset.change(webhook_reply: :after_completion)
-        |> Ecto.Changeset.put_embed(
-          :sync_webhook_response_config,
-          %SyncWebhookResponseConfig{body: custom_body}
-        )
-        |> Repo.update!()
-
-        Snapshot.create(workflow |> Repo.reload!())
-
-        response =
-          build_tesla_client(uri)
-          |> Tesla.post!("/i/#{trigger.id}", %{})
-
-        assert response.body == custom_body,
-               "expected custom body for #{label} run, got: #{inspect(response.body)}"
-      end
-    end
-
     @tag :integration
     @tag timeout: 120_000
     test "honours _webhookResponse set in final state", %{uri: uri} do
diff --git a/test/lightning/projects/provisioner_test.exs b/test/lightning/projects/provisioner_test.exs
index 9f63f4e5336..7a66b27a875 100644
--- a/test/lightning/projects/provisioner_test.exs
+++ b/test/lightning/projects/provisioner_test.exs
@@ -375,8 +375,7 @@ defmodule Lightning.Projects.ProvisionerTest do
             "webhook_reply" => "after_completion",
             "webhook_response" => %{
               "success_code" => 200,
-              "error_code" => 500,
-              "body" => %{"status" => "ok"}
+              "error_code" => 500
             }
           })
         end)
@@ -403,49 +402,6 @@ defmodule Lightning.Projects.ProvisionerTest do
       assert trigger.webhook_reply == :after_completion
       assert trigger.sync_webhook_response_config.success_code == 200
       assert trigger.sync_webhook_response_config.error_code == 500
-      assert trigger.sync_webhook_response_config.body == %{"status" => "ok"}
-    end
-
-    test "imports trigger with webhook_response body as a JSON string (from YAML)" do
-      Mox.verify_on_exit!()
-      user = insert(:user)
-
-      %{body: %{"workflows" => [workflow]} = body, project_id: project_id} =
-        valid_document()
-
-      updated_triggers =
-        Enum.map(workflow["triggers"], fn trigger ->
-          Map.merge(trigger, %{
-            "type" => "webhook",
-            "webhook_reply" => "after_completion",
-            "webhook_response" => %{
-              "success_code" => 200,
-              "body" => ~s({"status": "ok"})
-            }
-          })
-        end)
-
-      body =
-        Map.put(body, "workflows", [
-          Map.put(workflow, "triggers", updated_triggers)
-        ])
-
-      Mox.stub(
-        Lightning.Extensions.MockUsageLimiter,
-        :limit_action,
-        fn _action, _context -> :ok end
-      )
-
-      {:ok, project} =
-        Provisioner.import_document(
-          %Lightning.Projects.Project{},
-          user,
-          body
-        )
-
-      assert %{id: ^project_id, workflows: [%{triggers: [trigger]}]} = project
-      assert trigger.sync_webhook_response_config.success_code == 200
-      assert trigger.sync_webhook_response_config.body == %{"status" => "ok"}
     end
 
     test "imports cron trigger with cron_cursor_job_id field" do
diff --git a/test/lightning/projects_test.exs b/test/lightning/projects_test.exs
index 36bbcff2f2b..c9273efc2f6 100644
--- a/test/lightning/projects_test.exs
+++ b/test/lightning/projects_test.exs
@@ -791,8 +791,7 @@ defmodule Lightning.ProjectsTest do
           sync_webhook_response_config:
             build(:sync_webhook_response_config,
               success_code: 200,
-              error_code: 500,
-              body: %{"status" => "ok"}
+              error_code: 500
             )
         )
 
@@ -814,7 +813,6 @@ defmodule Lightning.ProjectsTest do
       assert generated_yaml =~ "webhook_response:"
       assert generated_yaml =~ "success_code: 200"
       assert generated_yaml =~ "error_code: 500"
-      assert generated_yaml =~ "body:"
     end
 
     test "webhook_response is omitted when sync_webhook_response_config is nil" do
diff --git a/test/lightning_web/channels/run_channel_test.exs b/test/lightning_web/channels/run_channel_test.exs
index 266f088fc2a..1eab6594bb5 100644
--- a/test/lightning_web/channels/run_channel_test.exs
+++ b/test/lightning_web/channels/run_channel_test.exs
@@ -1929,80 +1929,77 @@ defmodule LightningWeb.RunChannelTest do
       assert_receive {:webhook_response, 422, %{message: _}}
     end
 
-    test "uses configured body on success, overriding final state", %{
+    test "valid _webhookResponse overrides config entirely", %{
       socket: socket,
       work_order: work_order,
       trigger: trigger
     } do
-      custom_body = %{"custom" => true}
-      put_webhook_config(trigger, body: custom_body)
+      put_webhook_config(trigger, success_code: 999)
 
       Phoenix.PubSub.subscribe(
         Lightning.PubSub,
         "work_order:#{work_order.id}:webhook_response"
       )
 
+      override_body = %{"custom" => "response"}
+
       ref =
         push(socket, "run:complete", %{
           "reason" => "success",
-          "final_state" => %{"data" => "should be ignored"}
+          "final_state" => %{
+            "_webhookResponse" => %{"status" => 200, "body" => override_body}
+          }
         })
 
       assert_reply ref, :ok, nil
-      assert_receive {:webhook_response, 201, ^custom_body}
+      assert_receive {:webhook_response, 200, ^override_body}
     end
 
-    test "uses configured body on error, overriding security policy", %{
+    test "float status in _webhookResponse is normalised to integer", %{
       socket: socket,
-      work_order: work_order,
-      trigger: trigger
+      work_order: work_order
     } do
-      custom_body = %{"error_detail" => "safe to expose"}
-      put_webhook_config(trigger, body: custom_body)
-
       Phoenix.PubSub.subscribe(
         Lightning.PubSub,
         "work_order:#{work_order.id}:webhook_response"
       )
 
+      override_body = %{"ok" => true}
+
       ref =
         push(socket, "run:complete", %{
-          "reason" => "fail",
-          "error_type" => "UserError",
-          "error_message" => nil
+          "reason" => "success",
+          "final_state" => %{
+            "_webhookResponse" => %{"status" => 200.0, "body" => override_body}
+          }
         })
 
       assert_reply ref, :ok, nil
-      assert_receive {:webhook_response, 201, ^custom_body}
+      assert_receive {:webhook_response, 200, ^override_body}
     end
 
-    test "valid _webhookResponse overrides config entirely", %{
+    test "empty _webhookResponse map falls back to default behaviour", %{
       socket: socket,
-      work_order: work_order,
-      trigger: trigger
+      work_order: work_order
     } do
-      put_webhook_config(trigger, success_code: 999, body: %{"ignored" => true})
-
       Phoenix.PubSub.subscribe(
         Lightning.PubSub,
         "work_order:#{work_order.id}:webhook_response"
       )
 
-      override_body = %{"custom" => "response"}
+      final_state = %{"_webhookResponse" => %{}, "data" => "ok"}
 
       ref =
         push(socket, "run:complete", %{
           "reason" => "success",
-          "final_state" => %{
-            "_webhookResponse" => %{"status" => 200, "body" => override_body}
-          }
+          "final_state" => final_state
         })
 
       assert_reply ref, :ok, nil
-      assert_receive {:webhook_response, 200, ^override_body}
+      assert_receive {:webhook_response, 201, ^final_state}
     end
 
-    test "float status in _webhookResponse is normalised to integer", %{
+    test "_webhookResponse with only status uses default body", %{
       socket: socket,
       work_order: work_order
     } do
@@ -2011,30 +2008,32 @@ defmodule LightningWeb.RunChannelTest do
         "work_order:#{work_order.id}:webhook_response"
       )
 
-      override_body = %{"ok" => true}
+      final_state = %{"_webhookResponse" => %{"status" => 200}, "data" => "ok"}
 
       ref =
         push(socket, "run:complete", %{
           "reason" => "success",
-          "final_state" => %{
-            "_webhookResponse" => %{"status" => 200.0, "body" => override_body}
-          }
+          "final_state" => final_state
         })
 
       assert_reply ref, :ok, nil
-      assert_receive {:webhook_response, 200, ^override_body}
+      assert_receive {:webhook_response, 200, ^final_state}
     end
 
-    test "empty _webhookResponse map falls back to default behaviour", %{
-      socket: socket,
-      work_order: work_order
-    } do
+    test "_webhookResponse with only status uses config status code over its own default",
+         %{
+           socket: socket,
+           work_order: work_order,
+           trigger: trigger
+         } do
+      put_webhook_config(trigger, success_code: 999)
+
       Phoenix.PubSub.subscribe(
         Lightning.PubSub,
         "work_order:#{work_order.id}:webhook_response"
       )
 
-      final_state = %{"_webhookResponse" => %{}, "data" => "ok"}
+      final_state = %{"_webhookResponse" => %{"status" => 200}, "data" => "ok"}
 
       ref =
         push(socket, "run:complete", %{
@@ -2043,31 +2042,36 @@ defmodule LightningWeb.RunChannelTest do
         })
 
       assert_reply ref, :ok, nil
-      assert_receive {:webhook_response, 201, ^final_state}
+
+      # _webhookResponse.status (200) wins over config success_code (999)
+      assert_receive {:webhook_response, 200, ^final_state}
     end
 
-    test "_webhookResponse without body key is malformed", %{
+    test "_webhookResponse with only body uses config status code", %{
       socket: socket,
-      work_order: work_order
+      work_order: work_order,
+      trigger: trigger
     } do
+      put_webhook_config(trigger, success_code: 202)
+
       Phoenix.PubSub.subscribe(
         Lightning.PubSub,
         "work_order:#{work_order.id}:webhook_response"
       )
 
+      custom_body = %{"data" => "ok"}
+
       ref =
         push(socket, "run:complete", %{
           "reason" => "success",
-          "final_state" => %{"_webhookResponse" => %{"status" => 200}}
+          "final_state" => %{"_webhookResponse" => %{"body" => custom_body}}
         })
 
       assert_reply ref, :ok, nil
-
-      assert_receive {:webhook_response, 201, %{message: message}}
-      assert message =~ "malformed"
+      assert_receive {:webhook_response, 202, ^custom_body}
     end
 
-    test "_webhookResponse without status key is malformed", %{
+    test "_webhookResponse with only body falls back to 201 when no config", %{
       socket: socket,
       work_order: work_order
     } do
@@ -2076,21 +2080,19 @@ defmodule LightningWeb.RunChannelTest do
         "work_order:#{work_order.id}:webhook_response"
       )
 
+      custom_body = %{"data" => "ok"}
+
       ref =
         push(socket, "run:complete", %{
           "reason" => "success",
-          "final_state" => %{
-            "_webhookResponse" => %{"body" => %{"data" => "ok"}}
-          }
+          "final_state" => %{"_webhookResponse" => %{"body" => custom_body}}
         })
 
       assert_reply ref, :ok, nil
-
-      assert_receive {:webhook_response, 201, %{message: message}}
-      assert message =~ "malformed"
+      assert_receive {:webhook_response, 201, ^custom_body}
     end
 
-    test "non-map _webhookResponse value is malformed", %{
+    test "non-map _webhookResponse falls back to default behaviour", %{
       socket: socket,
       work_order: work_order
     } do
@@ -2099,16 +2101,16 @@ defmodule LightningWeb.RunChannelTest do
         "work_order:#{work_order.id}:webhook_response"
       )
 
+      final_state = %{"_webhookResponse" => "not a map", "data" => "ok"}
+
       ref =
         push(socket, "run:complete", %{
           "reason" => "success",
-          "final_state" => %{"_webhookResponse" => "not a map"}
+          "final_state" => final_state
         })
 
       assert_reply ref, :ok, nil
-
-      assert_receive {:webhook_response, 201, %{message: message}}
-      assert message =~ "malformed"
+      assert_receive {:webhook_response, 201, ^final_state}
     end
   end
 
diff --git a/test/lightning_web/controllers/api/provisioning_controller_test.exs b/test/lightning_web/controllers/api/provisioning_controller_test.exs
index ef26c506d75..ad77ed189cc 100644
--- a/test/lightning_web/controllers/api/provisioning_controller_test.exs
+++ b/test/lightning_web/controllers/api/provisioning_controller_test.exs
@@ -607,8 +607,7 @@ defmodule LightningWeb.API.ProvisioningControllerTest do
           sync_webhook_response_config:
             build(:sync_webhook_response_config,
               success_code: 200,
-              error_code: 500,
-              body: %{"status" => "ok"}
+              error_code: 500
             )
         )
 
@@ -638,8 +637,7 @@ defmodule LightningWeb.API.ProvisioningControllerTest do
                "webhook_reply" => "after_completion",
                "webhook_response" => %{
                  "success_code" => 200,
-                 "error_code" => 500,
-                 "body" => %{"status" => "ok"}
+                 "error_code" => 500
                }
              } = trigger_json
     end

From de52d6294f80214c82c0fcda8508c03c2e484101 Mon Sep 17 00:00:00 2001
From: Frank Midigo <midigofrank@gmail.com>
Date: Tue, 28 Apr 2026 16:57:53 +0300
Subject: [PATCH 12/21] remove left over code

---
 .../collaborative-editor/components/inspector/TriggerForm.tsx  | 2 +-
 lib/lightning/collaboration/workflow_serializer.ex             | 3 +--
 2 files changed, 2 insertions(+), 3 deletions(-)

diff --git a/assets/js/collaborative-editor/components/inspector/TriggerForm.tsx b/assets/js/collaborative-editor/components/inspector/TriggerForm.tsx
index 4afd32c6e0b..9d9d8c98851 100644
--- a/assets/js/collaborative-editor/components/inspector/TriggerForm.tsx
+++ b/assets/js/collaborative-editor/components/inspector/TriggerForm.tsx
@@ -737,7 +737,7 @@ export function TriggerForm({ trigger }: TriggerFormProps) {
                                     </code>{' '}
                                     in the final run state.{' '}
                                     <a
-                                      href="https://docs.openfn.org/documentation/build/triggers#webhook-response"
+                                      href="https://docs.openfn.org/documentation/build/triggers"
                                       target="_blank"
                                       rel="noopener noreferrer"
                                       className="underline hover:text-blue-900"
diff --git a/lib/lightning/collaboration/workflow_serializer.ex b/lib/lightning/collaboration/workflow_serializer.ex
index 963bfb0b580..297c4f1a4ad 100644
--- a/lib/lightning/collaboration/workflow_serializer.ex
+++ b/lib/lightning/collaboration/workflow_serializer.ex
@@ -237,8 +237,7 @@ defmodule Lightning.Collaboration.WorkflowSerializer do
               config ->
                 Yex.MapPrelim.from(%{
                   "success_code" => config.success_code,
-                  "error_code" => config.error_code,
-                  "body" => config.body
+                  "error_code" => config.error_code
                 })
             end
         })

From 9f357d1f0f2af9b9ef70ca015ad07a20de9b2c97 Mon Sep 17 00:00:00 2001
From: Frank Midigo <midigofrank@gmail.com>
Date: Tue, 28 Apr 2026 17:15:41 +0300
Subject: [PATCH 13/21] fix failing tests

---
 .../components/inspector/TriggerForm.test.tsx             | 8 +++++---
 1 file changed, 5 insertions(+), 3 deletions(-)

diff --git a/assets/test/collaborative-editor/components/inspector/TriggerForm.test.tsx b/assets/test/collaborative-editor/components/inspector/TriggerForm.test.tsx
index bf09a049943..2d1960b9bac 100644
--- a/assets/test/collaborative-editor/components/inspector/TriggerForm.test.tsx
+++ b/assets/test/collaborative-editor/components/inspector/TriggerForm.test.tsx
@@ -192,9 +192,11 @@ describe('TriggerForm - Response Mode Field', () => {
 
     // Check both options exist (use exact text to avoid "Async" matching "sync")
     expect(
-      screen.getByRole('option', { name: 'Async (default)' })
+      screen.getByRole('option', { name: 'Async (Before Start)' })
+    ).toBeInTheDocument();
+    expect(
+      screen.getByRole('option', { name: 'Sync (After Completion)' })
     ).toBeInTheDocument();
-    expect(screen.getByRole('option', { name: 'Sync' })).toBeInTheDocument();
   });
 
   test('shows Async as default selected value', async () => {
@@ -261,7 +263,7 @@ describe('TriggerForm - Response Mode Field', () => {
     await waitFor(() => {
       expect(
         screen.getByText(
-          /responds with the final output state after the run completes/i
+          /holds the http connection open and responds when the run completes/i
         )
       ).toBeInTheDocument();
     });

From 1294869dac0b6c4a322c46347cf59015e2c405b3 Mon Sep 17 00:00:00 2001
From: Frank Midigo <midigofrank@gmail.com>
Date: Wed, 29 Apr 2026 14:08:15 +0300
Subject: [PATCH 14/21] remove leftover body references in the provisioner

---
 lib/lightning/projects/provisioner.ex | 11 -----------
 1 file changed, 11 deletions(-)

diff --git a/lib/lightning/projects/provisioner.ex b/lib/lightning/projects/provisioner.ex
index 5016fafe54f..d2e087470c9 100644
--- a/lib/lightning/projects/provisioner.ex
+++ b/lib/lightning/projects/provisioner.ex
@@ -484,21 +484,10 @@ defmodule Lightning.Projects.Provisioner do
         attrs
 
       {config, attrs} ->
-        config = decode_webhook_response_body(config)
         Map.put(attrs, "sync_webhook_response_config", config)
     end
   end
 
-  defp decode_webhook_response_body(%{"body" => body} = config)
-       when is_binary(body) do
-    case Jason.decode(body) do
-      {:ok, decoded} -> Map.put(config, "body", decoded)
-      _ -> config
-    end
-  end
-
-  defp decode_webhook_response_body(config), do: config
-
   defp kafka_config_changeset(kafka_config, attrs) do
     kafka_config
     |> KafkaConfiguration.changeset(attrs)

From 8f23d2068bf3fdb8db11f860f9c901e28fbc097e Mon Sep 17 00:00:00 2001
From: Farhan Yahaya <yahyafarhan48@gmail.com>
Date: Tue, 5 May 2026 03:00:55 +0000
Subject: [PATCH 15/21] feat: support undo/redo

---
 .../components/inspector/TriggerForm.tsx            | 13 +++++++++++++
 1 file changed, 13 insertions(+)

diff --git a/assets/js/collaborative-editor/components/inspector/TriggerForm.tsx b/assets/js/collaborative-editor/components/inspector/TriggerForm.tsx
index 9d9d8c98851..8414e964432 100644
--- a/assets/js/collaborative-editor/components/inspector/TriggerForm.tsx
+++ b/assets/js/collaborative-editor/components/inspector/TriggerForm.tsx
@@ -80,6 +80,19 @@ export function TriggerForm({ trigger }: TriggerFormProps) {
     state => state.activeTriggerAuthMethods
   );
 
+  useEffect(() => {
+    const cfg = trigger.sync_webhook_response_config;
+    if (cfg == null) {
+      setHasResponseStatus(false);
+      setShownSuccessCode(false);
+      setShownErrorCode(false);
+    } else {
+      setHasResponseStatus(true);
+      setShownSuccessCode(cfg.success_code != null);
+      setShownErrorCode(cfg.error_code != null);
+    }
+  }, [trigger.sync_webhook_response_config]);
+
   // Request auth methods when trigger is selected
   useEffect(() => {
     if (trigger.id) {

From 48215b74bcc0c2ba9dac75d9b8ba4a7e4f4411a1 Mon Sep 17 00:00:00 2001
From: Frank Midigo <midigofrank@gmail.com>
Date: Fri, 8 May 2026 19:35:00 +0300
Subject: [PATCH 16/21] Source webhook_response from step:complete instead of
 run:complete final state

The worker now sends webhook_response on each step:complete rather than
embedding _webhookResponse in the final state at run:complete. Lightning
captures the latest value into a WebhookResponse struct held on the run
channel socket, then resolves and broadcasts it on run:complete for
after_completion mode (last step:complete with a value wins).

The broadcast helper is split: build_webhook_response resolves status and
body against the trigger config, maybe_broadcast_webhook_response only
broadcasts and stamps sent_at, gated on whether a response has already
been sent. This sets up future modes (before_start, after_job_completion)
without reworking the broadcast path.

The integration test is updated to the new contract and will fail until
@openfn/ws-worker is updated to forward webhook_response on step:complete.
---
 lib/lightning_web/channels/run_channel.ex     | 150 +++++++----
 test/integration/web_and_worker_test.exs      |   4 +-
 .../channels/run_channel_test.exs             | 251 ++++++++++--------
 3 files changed, 229 insertions(+), 176 deletions(-)

diff --git a/lib/lightning_web/channels/run_channel.ex b/lib/lightning_web/channels/run_channel.ex
index a3521a18b32..d573df4949a 100644
--- a/lib/lightning_web/channels/run_channel.ex
+++ b/lib/lightning_web/channels/run_channel.ex
@@ -18,6 +18,10 @@ defmodule LightningWeb.RunChannel do
   require Jason.Helpers
   require Logger
 
+  defmodule WebhookResponse do
+    defstruct status: nil, body: nil, step_id: nil, sent_at: nil
+  end
+
   @impl true
   def join(
         "run:" <> id,
@@ -39,7 +43,8 @@ defmodule LightningWeb.RunChannel do
          id: id,
          run: run,
          project_id: project_id,
-         scrubber: nil
+         scrubber: nil,
+         webhook_response: nil
        })}
     else
       {:error, :not_found} ->
@@ -120,11 +125,12 @@ defmodule LightningWeb.RunChannel do
         run_with_preloads
         |> Lightning.FailureAlerter.alert_on_failure()
 
-        # Broadcast webhook response for after_completion mode
-        maybe_broadcast_webhook_response(
-          run_with_preloads,
-          payload["final_state"]
-        )
+        socket =
+          maybe_send_after_completion_response(
+            socket,
+            run_with_preloads,
+            payload["final_state"]
+          )
 
         socket |> assign(run: run) |> reply_with({:ok, nil})
 
@@ -213,7 +219,9 @@ defmodule LightningWeb.RunChannel do
         reply_with(socket, {:error, changeset})
 
       {:ok, step} ->
-        reply_with(socket, {:ok, %{step_id: step.id}})
+        socket
+        |> put_webhook_response(payload)
+        |> reply_with({:ok, %{step_id: step.id}})
     end
   end
 
@@ -309,80 +317,104 @@ defmodule LightningWeb.RunChannel do
   # Ignore other messages
   def handle_info(_msg, socket), do: {:noreply, socket}
 
-  defp maybe_broadcast_webhook_response(
-         run,
-         final_state
-       ) do
-    if run.work_order.trigger.webhook_reply == :after_completion do
-      {status_code, body} =
-        determine_webhook_response(
+  defp put_webhook_response(socket, payload) do
+    if already_sent?(socket.assigns.webhook_response) do
+      socket
+    else
+      case Map.get(payload, "webhook_response") do
+        %{} = wr ->
+          assign(socket, :webhook_response, %WebhookResponse{
+            status: Map.get(wr, "status"),
+            body: Map.get(wr, "body"),
+            step_id: Map.get(payload, "step_id")
+          })
+
+        _ ->
+          socket
+      end
+    end
+  end
+
+  defp already_sent?(%WebhookResponse{sent_at: %DateTime{}}), do: true
+  defp already_sent?(_), do: false
+
+  defp maybe_send_after_completion_response(socket, run, final_state) do
+    trigger = run.work_order.trigger
+
+    if trigger.webhook_reply == :after_completion do
+      webhook_response =
+        build_webhook_response(
           run,
           final_state,
-          run.work_order.trigger.sync_webhook_response_config
+          trigger.sync_webhook_response_config,
+          socket.assigns.webhook_response
         )
 
+      socket
+      |> assign(:webhook_response, webhook_response)
+      |> maybe_broadcast_webhook_response()
+    else
+      socket
+    end
+  end
+
+  defp maybe_broadcast_webhook_response(socket) do
+    %{run: run, webhook_response: %WebhookResponse{} = webhook_response} =
+      socket.assigns
+
+    if already_sent?(webhook_response) do
+      socket
+    else
       Phoenix.PubSub.broadcast(
         Lightning.PubSub,
         "work_order:#{run.work_order_id}:webhook_response",
-        {:webhook_response, status_code, body}
+        {:webhook_response, webhook_response.status, webhook_response.body}
       )
+
+      assign(socket, :webhook_response, %{
+        webhook_response
+        | sent_at: DateTime.utc_now()
+      })
     end
   end
 
-  defp determine_webhook_response(run, final_state, config) do
-    (final_state || %{})
-    |> Map.get("_webhookResponse")
-    |> case do
-      resp when is_nil(resp) or resp == %{} ->
-        build_default_response(run, final_state, config)
-
-      resp when is_map(resp) ->
-        build_response_from_state(resp, run, final_state, config)
-
-      _non_map ->
-        build_default_response(run, final_state, config)
-    end
+  defp build_webhook_response(run, final_state, config, nil) do
+    {status, body} = build_default_response(run, final_state, config)
+    %WebhookResponse{status: status, body: body}
   end
 
-  defp build_response_from_state(webhook_response, run, final_state, config) do
-    with {:ok, custom_status} <- parse_webhook_status(webhook_response),
-         {:ok, custom_body} <- parse_webhook_body(webhook_response) do
+  defp build_webhook_response(
+         run,
+         final_state,
+         config,
+         %WebhookResponse{} = webhook_response
+       ) do
+    with {:ok, custom_status} <- parse_webhook_status(webhook_response.status),
+         {:ok, custom_body} <- parse_webhook_body(webhook_response.body) do
       status = custom_status || default_response_status(run.state, config)
       body = custom_body || default_response_body(run.state, final_state, config)
-      {status, body}
+      %{webhook_response | status: status, body: body}
     else
-      {:error, reason} -> malformed_response(reason)
+      {:error, reason} ->
+        {status, body} = malformed_response(reason)
+        %{webhook_response | status: status, body: body}
     end
   end
 
-  defp parse_webhook_status(webhook_response) do
-    case Map.fetch(webhook_response, "status") do
-      :error ->
-        {:ok, nil}
-
-      {:ok, status} when is_integer(status) ->
-        {:ok, status}
-
-      {:ok, status} when is_float(status) ->
-        {:ok, trunc(status)}
+  defp parse_webhook_status(nil), do: {:ok, nil}
+  defp parse_webhook_status(status) when is_integer(status), do: {:ok, status}
 
-      {:ok, status} ->
-        {:error, "status needs to be an integer, got: #{inspect(status)}"}
-    end
-  end
+  defp parse_webhook_status(status) when is_float(status),
+    do: {:ok, trunc(status)}
 
-  defp parse_webhook_body(webhook_response) do
-    case Map.fetch(webhook_response, "body") do
-      :error ->
-        {:ok, nil}
+  defp parse_webhook_status(status),
+    do: {:error, "status needs to be an integer, got: #{inspect(status)}"}
 
-      {:ok, body} when is_map(body) ->
-        {:ok, body}
+  defp parse_webhook_body(nil), do: {:ok, nil}
+  defp parse_webhook_body(body) when is_map(body), do: {:ok, body}
 
-      {:ok, body} ->
-        {:error, "body needs to be a JSON object, got: #{inspect(body)}"}
-    end
-  end
+  defp parse_webhook_body(body),
+    do: {:error, "body needs to be a JSON object, got: #{inspect(body)}"}
 
   defp build_default_response(run, final_state, config) do
     {default_response_status(run.state, config),
@@ -411,7 +443,7 @@ defmodule LightningWeb.RunChannel do
 
   defp malformed_response(reason) do
     {201,
-     %{message: "Run completed, but _webhookResponse was malformed: #{reason}"}}
+     %{message: "Run completed, but webhook_response was malformed: #{reason}"}}
   end
 
   defp update_scrubber(nil, samples, basic_auth) do
diff --git a/test/integration/web_and_worker_test.exs b/test/integration/web_and_worker_test.exs
index 2a3467538ea..e29d9d69b94 100644
--- a/test/integration/web_and_worker_test.exs
+++ b/test/integration/web_and_worker_test.exs
@@ -801,7 +801,7 @@ defmodule Lightning.WebAndWorkerTest do
 
     @tag :integration
     @tag timeout: 120_000
-    test "honours _webhookResponse set in final state", %{uri: uri} do
+    test "honours webhook_response sent on step:complete", %{uri: uri} do
       project = insert(:project)
       trigger = build(:trigger, type: :webhook, enabled: true)
 
@@ -811,7 +811,7 @@ defmodule Lightning.WebAndWorkerTest do
           body: """
           fn(state => ({
             ...state,
-            _webhookResponse: { status: 200, body: { ack: true, received: state.data.value } }
+            webhook_response: { status: 200, body: { ack: true, received: state.data.value } }
           }));
           """,
           name: "responding-job"
diff --git a/test/lightning_web/channels/run_channel_test.exs b/test/lightning_web/channels/run_channel_test.exs
index cd0165df5a1..bd9bc634131 100644
--- a/test/lightning_web/channels/run_channel_test.exs
+++ b/test/lightning_web/channels/run_channel_test.exs
@@ -1783,7 +1783,7 @@ defmodule LightningWeb.RunChannelTest do
 
       job = build(:job)
 
-      %{triggers: [trigger]} =
+      %{triggers: [trigger], jobs: [job]} =
         workflow =
         build(:workflow, project: project)
         |> with_trigger(trigger)
@@ -1811,23 +1811,32 @@ defmodule LightningWeb.RunChannelTest do
             |> Map.new()
         )
 
-      %{run: run, work_order: work_order, trigger: trigger}
+      %{run: run, work_order: work_order, trigger: trigger, job: job}
     end
 
     setup [:create_socket, :join_run_channel]
 
+    setup %{work_order: work_order} do
+      Phoenix.PubSub.subscribe(
+        Lightning.PubSub,
+        "work_order:#{work_order.id}:webhook_response"
+      )
+
+      :ok
+    end
+
     test "does not broadcast when webhook_reply is not :after_completion", %{
       socket: socket,
-      work_order: work_order,
+      run: run,
+      job: job,
       trigger: trigger
     } do
       trigger
       |> Ecto.Changeset.change(webhook_reply: :before_start)
       |> Repo.update!()
 
-      Phoenix.PubSub.subscribe(
-        Lightning.PubSub,
-        "work_order:#{work_order.id}:webhook_response"
+      complete_step(socket, run, job,
+        webhook_response: %{"status" => 200, "body" => %{"data" => "ok"}}
       )
 
       ref =
@@ -1840,15 +1849,10 @@ defmodule LightningWeb.RunChannelTest do
       refute_receive {:webhook_response, _, _}
     end
 
-    test "broadcasts final state as body on success with no config", %{
-      socket: socket,
-      work_order: work_order
-    } do
-      Phoenix.PubSub.subscribe(
-        Lightning.PubSub,
-        "work_order:#{work_order.id}:webhook_response"
-      )
-
+    test "broadcasts final state as body on success with no captured response",
+         %{
+           socket: socket
+         } do
       final_state = %{"data" => %{"result" => "ok"}}
 
       ref =
@@ -1861,15 +1865,9 @@ defmodule LightningWeb.RunChannelTest do
       assert_receive {:webhook_response, 201, ^final_state}
     end
 
-    test "broadcasts security message on error with no config", %{
-      socket: socket,
-      work_order: work_order
+    test "broadcasts security message on error with no captured response", %{
+      socket: socket
     } do
-      Phoenix.PubSub.subscribe(
-        Lightning.PubSub,
-        "work_order:#{work_order.id}:webhook_response"
-      )
-
       ref =
         push(socket, "run:complete", %{
           "reason" => "fail",
@@ -1886,16 +1884,10 @@ defmodule LightningWeb.RunChannelTest do
 
     test "uses configured success_code on success", %{
       socket: socket,
-      work_order: work_order,
       trigger: trigger
     } do
       put_webhook_config(trigger, success_code: 200)
 
-      Phoenix.PubSub.subscribe(
-        Lightning.PubSub,
-        "work_order:#{work_order.id}:webhook_response"
-      )
-
       final_state = %{"data" => "ok"}
 
       ref =
@@ -1910,16 +1902,10 @@ defmodule LightningWeb.RunChannelTest do
 
     test "uses configured error_code on error", %{
       socket: socket,
-      work_order: work_order,
       trigger: trigger
     } do
       put_webhook_config(trigger, error_code: 422)
 
-      Phoenix.PubSub.subscribe(
-        Lightning.PubSub,
-        "work_order:#{work_order.id}:webhook_response"
-      )
-
       ref =
         push(socket, "run:complete", %{
           "reason" => "fail",
@@ -1931,111 +1917,109 @@ defmodule LightningWeb.RunChannelTest do
       assert_receive {:webhook_response, 422, %{message: _}}
     end
 
-    test "valid _webhookResponse overrides config entirely", %{
+    test "captured webhook_response from step:complete overrides config", %{
       socket: socket,
-      work_order: work_order,
+      run: run,
+      job: job,
       trigger: trigger
     } do
       put_webhook_config(trigger, success_code: 999)
 
-      Phoenix.PubSub.subscribe(
-        Lightning.PubSub,
-        "work_order:#{work_order.id}:webhook_response"
-      )
-
       override_body = %{"custom" => "response"}
 
+      complete_step(socket, run, job,
+        webhook_response: %{"status" => 200, "body" => override_body}
+      )
+
       ref =
         push(socket, "run:complete", %{
           "reason" => "success",
-          "final_state" => %{
-            "_webhookResponse" => %{"status" => 200, "body" => override_body}
-          }
+          "final_state" => %{"data" => "ok"}
         })
 
       assert_reply ref, :ok, nil
       assert_receive {:webhook_response, 200, ^override_body}
     end
 
-    test "float status in _webhookResponse is normalised to integer", %{
-      socket: socket,
-      work_order: work_order
-    } do
-      Phoenix.PubSub.subscribe(
-        Lightning.PubSub,
-        "work_order:#{work_order.id}:webhook_response"
+    test "last step:complete with a webhook_response wins (last-write-wins)",
+         %{
+           socket: socket,
+           run: run,
+           job: job
+         } do
+      complete_step(socket, run, job,
+        webhook_response: %{"status" => 201, "body" => %{"first" => true}}
       )
 
-      override_body = %{"ok" => true}
+      last_body = %{"last" => true}
+
+      complete_step(socket, run, job,
+        webhook_response: %{"status" => 202, "body" => last_body}
+      )
 
       ref =
         push(socket, "run:complete", %{
           "reason" => "success",
-          "final_state" => %{
-            "_webhookResponse" => %{"status" => 200.0, "body" => override_body}
-          }
+          "final_state" => %{"data" => "ok"}
         })
 
       assert_reply ref, :ok, nil
-      assert_receive {:webhook_response, 200, ^override_body}
+      assert_receive {:webhook_response, 202, ^last_body}
     end
 
-    test "empty _webhookResponse map falls back to default behaviour", %{
-      socket: socket,
-      work_order: work_order
-    } do
-      Phoenix.PubSub.subscribe(
-        Lightning.PubSub,
-        "work_order:#{work_order.id}:webhook_response"
+    test "step without webhook_response does not clear a previously captured one",
+         %{
+           socket: socket,
+           run: run,
+           job: job
+         } do
+      captured_body = %{"captured" => true}
+
+      complete_step(socket, run, job,
+        webhook_response: %{"status" => 200, "body" => captured_body}
       )
 
-      final_state = %{"_webhookResponse" => %{}, "data" => "ok"}
+      complete_step(socket, run, job, [])
 
       ref =
         push(socket, "run:complete", %{
           "reason" => "success",
-          "final_state" => final_state
+          "final_state" => %{"data" => "ok"}
         })
 
       assert_reply ref, :ok, nil
-      assert_receive {:webhook_response, 201, ^final_state}
+      assert_receive {:webhook_response, 200, ^captured_body}
     end
 
-    test "_webhookResponse with only status uses default body", %{
+    test "float status in webhook_response is normalised to integer", %{
       socket: socket,
-      work_order: work_order
+      run: run,
+      job: job
     } do
-      Phoenix.PubSub.subscribe(
-        Lightning.PubSub,
-        "work_order:#{work_order.id}:webhook_response"
-      )
+      override_body = %{"ok" => true}
 
-      final_state = %{"_webhookResponse" => %{"status" => 200}, "data" => "ok"}
+      complete_step(socket, run, job,
+        webhook_response: %{"status" => 200.0, "body" => override_body}
+      )
 
       ref =
         push(socket, "run:complete", %{
           "reason" => "success",
-          "final_state" => final_state
+          "final_state" => %{"data" => "ok"}
         })
 
       assert_reply ref, :ok, nil
-      assert_receive {:webhook_response, 200, ^final_state}
+      assert_receive {:webhook_response, 200, ^override_body}
     end
 
-    test "_webhookResponse with only status uses config status code over its own default",
-         %{
-           socket: socket,
-           work_order: work_order,
-           trigger: trigger
-         } do
-      put_webhook_config(trigger, success_code: 999)
-
-      Phoenix.PubSub.subscribe(
-        Lightning.PubSub,
-        "work_order:#{work_order.id}:webhook_response"
-      )
+    test "webhook_response with only status uses default body", %{
+      socket: socket,
+      run: run,
+      job: job
+    } do
+      final_state = %{"data" => "ok"}
 
-      final_state = %{"_webhookResponse" => %{"status" => 200}, "data" => "ok"}
+      complete_step(socket, run, job, webhook_response: %{"status" => 200})
 
       ref =
         push(socket, "run:complete", %{
@@ -2044,75 +2028,92 @@ defmodule LightningWeb.RunChannelTest do
         })
 
       assert_reply ref, :ok, nil
-
-      # _webhookResponse.status (200) wins over config success_code (999)
       assert_receive {:webhook_response, 200, ^final_state}
     end
 
-    test "_webhookResponse with only body uses config status code", %{
+    test "webhook_response with only body uses config status code", %{
       socket: socket,
-      work_order: work_order,
+      run: run,
+      job: job,
       trigger: trigger
     } do
       put_webhook_config(trigger, success_code: 202)
 
-      Phoenix.PubSub.subscribe(
-        Lightning.PubSub,
-        "work_order:#{work_order.id}:webhook_response"
-      )
-
       custom_body = %{"data" => "ok"}
 
+      complete_step(socket, run, job, webhook_response: %{"body" => custom_body})
+
       ref =
         push(socket, "run:complete", %{
           "reason" => "success",
-          "final_state" => %{"_webhookResponse" => %{"body" => custom_body}}
+          "final_state" => %{"data" => "ok"}
         })
 
       assert_reply ref, :ok, nil
       assert_receive {:webhook_response, 202, ^custom_body}
     end
 
-    test "_webhookResponse with only body falls back to 201 when no config", %{
+    test "webhook_response with only body falls back to 201 when no config", %{
       socket: socket,
-      work_order: work_order
+      run: run,
+      job: job
     } do
-      Phoenix.PubSub.subscribe(
-        Lightning.PubSub,
-        "work_order:#{work_order.id}:webhook_response"
-      )
-
       custom_body = %{"data" => "ok"}
 
+      complete_step(socket, run, job, webhook_response: %{"body" => custom_body})
+
       ref =
         push(socket, "run:complete", %{
           "reason" => "success",
-          "final_state" => %{"_webhookResponse" => %{"body" => custom_body}}
+          "final_state" => %{"data" => "ok"}
         })
 
       assert_reply ref, :ok, nil
       assert_receive {:webhook_response, 201, ^custom_body}
     end
 
-    test "non-map _webhookResponse falls back to default behaviour", %{
+    test "malformed status in webhook_response yields 201 with explanation", %{
       socket: socket,
-      work_order: work_order
+      run: run,
+      job: job
     } do
-      Phoenix.PubSub.subscribe(
-        Lightning.PubSub,
-        "work_order:#{work_order.id}:webhook_response"
+      complete_step(socket, run, job,
+        webhook_response: %{"status" => "two hundred"}
       )
 
-      final_state = %{"_webhookResponse" => "not a map", "data" => "ok"}
+      ref =
+        push(socket, "run:complete", %{
+          "reason" => "success",
+          "final_state" => %{"data" => "ok"}
+        })
+
+      assert_reply ref, :ok, nil
+
+      assert_receive {:webhook_response, 201, %{message: message}}
+      assert message =~ "webhook_response was malformed"
+      assert message =~ "status"
+    end
+
+    test "malformed body in webhook_response yields 201 with explanation", %{
+      socket: socket,
+      run: run,
+      job: job
+    } do
+      complete_step(socket, run, job,
+        webhook_response: %{"body" => "not a json object"}
+      )
 
       ref =
         push(socket, "run:complete", %{
           "reason" => "success",
-          "final_state" => final_state
+          "final_state" => %{"data" => "ok"}
         })
 
       assert_reply ref, :ok, nil
-      assert_receive {:webhook_response, 201, ^final_state}
+
+      assert_receive {:webhook_response, 201, %{message: message}}
+      assert message =~ "webhook_response was malformed"
+      assert message =~ "body"
     end
   end
 
@@ -2126,6 +2127,26 @@ defmodule LightningWeb.RunChannelTest do
     |> Repo.update!()
   end
 
+  defp complete_step(socket, run, job, opts) do
+    step = insert(:step, runs: [run], job: job)
+
+    payload =
+      %{
+        "step_id" => step.id,
+        "output_dataclip_id" => Ecto.UUID.generate(),
+        "output_dataclip" => ~s({"foo": "bar"}),
+        "reason" => "normal"
+      }
+      |> maybe_put("webhook_response", Keyword.get(opts, :webhook_response))
+
+    ref = push(socket, "step:complete", payload)
+    assert_reply ref, :ok, %{step_id: _}
+    step
+  end
+
+  defp maybe_put(map, _key, nil), do: map
+  defp maybe_put(map, key, value), do: Map.put(map, key, value)
+
   defp create_socket_and_run(context) do
     merge_setups(context, [
       :create_project,

From 15793d83e0cb0103ae98117c0613b47ed684c665 Mon Sep 17 00:00:00 2001
From: Frank Midigo <midigofrank@gmail.com>
Date: Mon, 11 May 2026 11:53:04 +0300
Subject: [PATCH 17/21] Fix after-completion webhook response for manual runs
 and success-with-only-error_code

- Source the trigger from run.starting_trigger and guard against nil so
  manual runs (no starting trigger) no longer crash on run:complete.
- Add a :success fallback to default_response_status/2 so a run that
  succeeds returns 201 instead of the configured error_code when only
  error_code is set.
---
 lib/lightning_web/channels/run_channel.ex     | 23 +++++------
 .../channels/run_channel_test.exs             | 40 +++++++++++++++++++
 2 files changed, 51 insertions(+), 12 deletions(-)

diff --git a/lib/lightning_web/channels/run_channel.ex b/lib/lightning_web/channels/run_channel.ex
index d573df4949a..a9b6e4059e3 100644
--- a/lib/lightning_web/channels/run_channel.ex
+++ b/lib/lightning_web/channels/run_channel.ex
@@ -120,19 +120,15 @@ defmodule LightningWeb.RunChannel do
         # instead of blocking the channel.
         run_with_preloads =
           run
-          |> Repo.preload([:log_lines, work_order: [:workflow, :trigger]])
+          |> Repo.preload([:log_lines, work_order: [:workflow]])
 
         run_with_preloads
         |> Lightning.FailureAlerter.alert_on_failure()
 
-        socket =
-          maybe_send_after_completion_response(
-            socket,
-            run_with_preloads,
-            payload["final_state"]
-          )
-
-        socket |> assign(run: run) |> reply_with({:ok, nil})
+        socket
+        |> assign(run: run)
+        |> maybe_send_after_completion_response(payload["final_state"])
+        |> reply_with({:ok, nil})
 
       {:error, changeset} ->
         reply_with(socket, {:error, changeset})
@@ -338,10 +334,11 @@ defmodule LightningWeb.RunChannel do
   defp already_sent?(%WebhookResponse{sent_at: %DateTime{}}), do: true
   defp already_sent?(_), do: false
 
-  defp maybe_send_after_completion_response(socket, run, final_state) do
-    trigger = run.work_order.trigger
+  defp maybe_send_after_completion_response(socket, final_state) do
+    run = Repo.preload(socket.assigns.run, :starting_trigger)
+    trigger = run.starting_trigger
 
-    if trigger.webhook_reply == :after_completion do
+    if trigger && trigger.webhook_reply == :after_completion do
       webhook_response =
         build_webhook_response(
           run,
@@ -425,6 +422,8 @@ defmodule LightningWeb.RunChannel do
        when is_integer(code),
        do: code
 
+  defp default_response_status(:success, _config), do: 201
+
   defp default_response_status(_run_status, %{error_code: code})
        when is_integer(code),
        do: code
diff --git a/test/lightning_web/channels/run_channel_test.exs b/test/lightning_web/channels/run_channel_test.exs
index bd9bc634131..5621d2d10f8 100644
--- a/test/lightning_web/channels/run_channel_test.exs
+++ b/test/lightning_web/channels/run_channel_test.exs
@@ -1917,6 +1917,46 @@ defmodule LightningWeb.RunChannelTest do
       assert_receive {:webhook_response, 422, %{message: _}}
     end
 
+    test "uses 201 on success when only error_code is configured", %{
+      socket: socket,
+      trigger: trigger
+    } do
+      put_webhook_config(trigger, error_code: 422)
+
+      final_state = %{"data" => "ok"}
+
+      ref =
+        push(socket, "run:complete", %{
+          "reason" => "success",
+          "final_state" => final_state
+        })
+
+      assert_reply ref, :ok, nil
+      assert_receive {:webhook_response, 201, ^final_state}
+    end
+
+    test "does not broadcast for runs with no starting trigger", %{
+      socket: socket,
+      run: run,
+      job: job
+    } do
+      run
+      |> Ecto.Changeset.change(
+        starting_trigger_id: nil,
+        starting_job_id: job.id
+      )
+      |> Repo.update!()
+
+      ref =
+        push(socket, "run:complete", %{
+          "reason" => "success",
+          "final_state" => %{"data" => "ok"}
+        })
+
+      assert_reply ref, :ok, nil
+      refute_receive {:webhook_response, _, _}
+    end
+
     test "captured webhook_response from step:complete overrides config", %{
       socket: socket,
       run: run,

From efcf39cfa3a269a85c4ddcbe7ec88d66377d818c Mon Sep 17 00:00:00 2001
From: Frank Midigo <midigofrank@gmail.com>
Date: Mon, 11 May 2026 11:59:58 +0300
Subject: [PATCH 18/21] update old references of _webhookResponse

---
 .../collaborative-editor/components/inspector/TriggerForm.tsx   | 2 +-
 test/integration/web_and_worker_test.exs                        | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/assets/js/collaborative-editor/components/inspector/TriggerForm.tsx b/assets/js/collaborative-editor/components/inspector/TriggerForm.tsx
index 5433492266c..0760d13c2a7 100644
--- a/assets/js/collaborative-editor/components/inspector/TriggerForm.tsx
+++ b/assets/js/collaborative-editor/components/inspector/TriggerForm.tsx
@@ -746,7 +746,7 @@ export function TriggerForm({ trigger }: TriggerFormProps) {
                                     To return a custom body or status code from
                                     your job, set{' '}
                                     <code className="font-mono">
-                                      _webhookResponse
+                                      webhookResponse
                                     </code>{' '}
                                     in the final run state.{' '}
                                     <a
diff --git a/test/integration/web_and_worker_test.exs b/test/integration/web_and_worker_test.exs
index e29d9d69b94..0a3197e42ff 100644
--- a/test/integration/web_and_worker_test.exs
+++ b/test/integration/web_and_worker_test.exs
@@ -811,7 +811,7 @@ defmodule Lightning.WebAndWorkerTest do
           body: """
           fn(state => ({
             ...state,
-            webhook_response: { status: 200, body: { ack: true, received: state.data.value } }
+            webhookResponse: { status: 200, body: { ack: true, received: state.data.value } }
           }));
           """,
           name: "responding-job"

From 18aaa0972ec765698405d0f14e2884e34e1db90e Mon Sep 17 00:00:00 2001
From: Frank Midigo <midigofrank@gmail.com>
Date: Mon, 11 May 2026 12:24:55 +0300
Subject: [PATCH 19/21] return 500 on error/crash by default

---
 .../collaborative-editor/components/inspector/TriggerForm.tsx | 4 ++--
 lib/lightning_web/channels/run_channel.ex                     | 2 +-
 test/lightning_web/channels/run_channel_test.exs              | 2 +-
 3 files changed, 4 insertions(+), 4 deletions(-)

diff --git a/assets/js/collaborative-editor/components/inspector/TriggerForm.tsx b/assets/js/collaborative-editor/components/inspector/TriggerForm.tsx
index 0760d13c2a7..0a6fed60867 100644
--- a/assets/js/collaborative-editor/components/inspector/TriggerForm.tsx
+++ b/assets/js/collaborative-editor/components/inspector/TriggerForm.tsx
@@ -636,7 +636,7 @@ export function TriggerForm({ trigger }: TriggerFormProps) {
                                                   <input
                                                     id={`${field.name}-error-code`}
                                                     type="number"
-                                                    placeholder="201"
+                                                    placeholder="500"
                                                     value={
                                                       config?.error_code ?? ''
                                                     }
@@ -748,7 +748,7 @@ export function TriggerForm({ trigger }: TriggerFormProps) {
                                     <code className="font-mono">
                                       webhookResponse
                                     </code>{' '}
-                                    in the final run state.{' '}
+                                    in the job code.{' '}
                                     <a
                                       href="https://docs.openfn.org/documentation/build/triggers"
                                       target="_blank"
diff --git a/lib/lightning_web/channels/run_channel.ex b/lib/lightning_web/channels/run_channel.ex
index a9b6e4059e3..6ead6409c46 100644
--- a/lib/lightning_web/channels/run_channel.ex
+++ b/lib/lightning_web/channels/run_channel.ex
@@ -428,7 +428,7 @@ defmodule LightningWeb.RunChannel do
        when is_integer(code),
        do: code
 
-  defp default_response_status(_run_status, _config), do: 201
+  defp default_response_status(_run_status, _config), do: 500
 
   defp default_response_body(:success, final_state, _config),
     do: final_state
diff --git a/test/lightning_web/channels/run_channel_test.exs b/test/lightning_web/channels/run_channel_test.exs
index 5621d2d10f8..77cee65fe9d 100644
--- a/test/lightning_web/channels/run_channel_test.exs
+++ b/test/lightning_web/channels/run_channel_test.exs
@@ -1877,7 +1877,7 @@ defmodule LightningWeb.RunChannelTest do
 
       assert_reply ref, :ok, nil
 
-      assert_receive {:webhook_response, 201, %{message: message}}
+      assert_receive {:webhook_response, 500, %{message: message}}
       assert message =~ "failed"
       assert message =~ "security policy"
     end

From 78b5f42aa6e853d453b2bf9f2126397b83ae3c57 Mon Sep 17 00:00:00 2001
From: Frank Midigo <midigofrank@gmail.com>
Date: Mon, 11 May 2026 12:25:08 +0300
Subject: [PATCH 20/21] update changelog

---
 CHANGELOG.md | 5 +++++
 1 file changed, 5 insertions(+)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index d6864f5be56..53bf3b3f8fd 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -17,11 +17,16 @@ and this project adheres to
 
 ### Added
 
+- Allow users to respond back with custom webhook responses via the
+  `webhookResponse` field in the job state.
+  [#3102](https://github.com/OpenFn/lightning/issues/3102)
+
 ### Changed
 
 ### Fixed
 
 ## [2.16.3] - 2026-05-07
+
 ## [2.16.3-pre3] - 2026-05-07
 
 ### Fixed

From a6350ea53779493d230f3437bc1ccb04fe6f366c Mon Sep 17 00:00:00 2001
From: Frank Midigo <midigofrank@gmail.com>
Date: Mon, 11 May 2026 12:38:13 +0300
Subject: [PATCH 21/21] credo

---
 lib/lightning_web/channels/run_channel.ex | 1 +
 1 file changed, 1 insertion(+)

diff --git a/lib/lightning_web/channels/run_channel.ex b/lib/lightning_web/channels/run_channel.ex
index 6ead6409c46..67410893c6f 100644
--- a/lib/lightning_web/channels/run_channel.ex
+++ b/lib/lightning_web/channels/run_channel.ex
@@ -19,6 +19,7 @@ defmodule LightningWeb.RunChannel do
   require Logger
 
   defmodule WebhookResponse do
+    @moduledoc false
     defstruct status: nil, body: nil, step_id: nil, sent_at: nil
   end