ofiere-openclaw-plugin 4.54.2 → 4.55.0

package/src/tools.ts

@@ -7395,6 +7395,118 @@ function registerBrainExtractionHook(
           return;
         }
 
+        // FIX-A2A-LATE-REPLY — direct chief↔chief A2A late reply.
+        // Dashboard's relayToOpenClaw caps the synchronous wait at 45s; when
+        // the responding chief takes longer (e.g. while running its own tool
+        // calls), the dashboard WS closes and the eventual reply is dropped.
+        // dispatch_context was pre-written with { conversation_id,
+        // source_agent_id, a2a_pair_id } so we can route the late reply back:
+        //   1. Insert the assistant turn into conversation_messages for the
+        //      A2A conversation so reloading the page shows the reply.
+        //   2. POST a `chief_reply` webhook so the dashboard SSE can swap the
+        //      "still processing" placeholder bubble in the active chat UI.
+        // Guarded by: a2a_pair_id is set AND subagent_id is null AND task_id
+        // is null — so neither the staff nor the scheduled branches above
+        // can collide with this path.
+        const a2aPairId = dispatchCtxRow?.a2a_pair_id ?? null;
+        const a2aSourceAgentId = dispatchCtxRow?.source_agent_id ?? null;
+        const a2aConversationId = dispatchCtxRow?.conversation_id ?? null;
+        if (
+          a2aPairId &&
+          !staffDispatchSubagentId &&
+          !dispatchTaskIdFromCtx &&
+          a2aConversationId
+        ) {
+          (async () => {
+            try {
+              const excerpt = lastAssistant.slice(0, 4000);
+              if (!excerpt) {
+                api.logger.warn?.(`[ofiere-a2a-reply] empty assistant text — skipping late-reply persistence`);
+                return;
+              }
+
+              // Insert assistant turn into the A2A conversation. The
+              // dashboard's synchronous path also writes the assistant row
+              // when the reply lands in-window — UI dedup is by content +
+              // a2a_conversation_id so a duplicate from a race is benign.
+              try {
+                await supabase.from("conversation_messages").insert({
+                  conversation_id: a2aConversationId,
+                  user_id: userId,
+                  role: "assistant",
+                  content: excerpt,
+                  metadata: {
+                    sender_agent_id: resolvedAgentId,
+                    target_agent_id: a2aSourceAgentId,
+                    late_reply: true,
+                  },
+                  branch_id: "main",
+                });
+                await supabase.from("conversations")
+                  .update({ updated_at: new Date().toISOString() })
+                  .eq("id", a2aConversationId)
+                  .eq("user_id", userId);
+                // Best-effort message-count bump. RPC may not exist on older
+                // schemas — swallow the error if it 404s.
+                try {
+                  await supabase.rpc("increment_conversation_message_count", {
+                    conv_id: a2aConversationId,
+                  });
+                } catch { /* RPC missing — count drift is acceptable */ }
+              } catch (cmErr) {
+                api.logger.warn?.(`[ofiere-a2a-reply] conversation_messages insert failed: ${cmErr instanceof Error ? cmErr.message : String(cmErr)}`);
+              }
+
+              // Resolve responder agent name for the webhook payload so the
+              // UI bubble can be attributed correctly without another DB hit.
+              let responderName: string | null = null;
+              try {
+                const { data: agentRow } = await supabase
+                  .from("agents")
+                  .select("name")
+                  .eq("id", resolvedAgentId)
+                  .eq("user_id", userId)
+                  .maybeSingle();
+                responderName = (agentRow?.name as string | undefined) ?? null;
+              } catch { /* fall back to agent id */ }
+
+              const webhookUrl = process.env.OFIERE_DASHBOARD_WEBHOOK_URL || "";
+              const webhookSecret = process.env.OPENCLAW_WEBHOOK_SECRET || "";
+              if (webhookUrl && webhookSecret) {
+                try {
+                  await fetch(webhookUrl, {
+                    method: "POST",
+                    headers: {
+                      "content-type": "application/json",
+                      authorization: `Bearer ${webhookSecret}`,
+                    },
+                    body: JSON.stringify({
+                      type: "chief_reply",
+                      payload: {
+                        user_id: userId,
+                        source_agent_id: a2aSourceAgentId,
+                        target_agent_id: resolvedAgentId,
+                        target_agent_name: responderName,
+                        conversation_id: a2aConversationId,
+                        a2a_pair_id: a2aPairId,
+                        response: excerpt,
+                      },
+                    }),
+                  });
+                  api.logger.info?.(`[ofiere-a2a-reply] chief_reply webhook posted (conv=${a2aConversationId})`);
+                } catch (wErr) {
+                  api.logger.debug?.(`[ofiere-a2a-reply] webhook post failed: ${wErr instanceof Error ? wErr.message : String(wErr)}`);
+                }
+              }
+            } catch (aErr) {
+              api.logger.warn?.(`[ofiere-a2a-reply] failed: ${aErr instanceof Error ? aErr.message : String(aErr)}`);
+            }
+          })();
+          // Continue to brain extraction below — A2A late-reply is purely
+          // additive bookkeeping; the responding chief still owns the L1/L2
+          // memory writes for its own turn.
+        }
+
         // BUG 9 fix (BUGSHOOT-2): mark task_dispatch_log row complete for
         // non-staff scheduled dispatches too. Without this the log row stays
         // at 'dispatched' even after the chief finished the run.

package/src/types/openclaw.d.ts

@@ -1,8 +1,8 @@
-// Ambient declaration for the OpenClaw plugin SDK. The gateway resolves this
-// module at runtime; npm has no published types. Keep loose — the plugin only
-// uses a small surface (logger, on, registerTool, registerCommand, etc.).
-
-declare module "openclaw/plugin-sdk" {
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  export type OpenClawPluginApi = any;
-}
+// Ambient declaration for the OpenClaw plugin SDK. The gateway resolves this
+// module at runtime; npm has no published types. Keep loose — the plugin only
+// uses a small surface (logger, on, registerTool, registerCommand, etc.).
+
+declare module "openclaw/plugin-sdk" {
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  export type OpenClawPluginApi = any;
+}

package/src/types.ts

@@ -1,10 +1,10 @@
-export interface OfiereConfig {
-  enabled: boolean;
-  supabaseUrl: string;
-  serviceRoleKey: string;
-  userId: string;
-  /** Optional — if not set, agent identity is resolved at runtime from OpenClaw context */
-  agentId: string;
-  /** IANA timezone string for the user (e.g. 'Asia/Jakarta', 'America/New_York'). Default: 'Asia/Jakarta' */
-  timezone: string;
-}
+export interface OfiereConfig {
+  enabled: boolean;
+  supabaseUrl: string;
+  serviceRoleKey: string;
+  userId: string;
+  /** Optional — if not set, agent identity is resolved at runtime from OpenClaw context */
+  agentId: string;
+  /** IANA timezone string for the user (e.g. 'Asia/Jakarta', 'America/New_York'). Default: 'Asia/Jakarta' */
+  timezone: string;
+}