npm - madarx - Versions diffs - 2.16.3 → 2.18.0 - Mend

madarx 2.16.3 → 2.18.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (1373) hide show

package/app/api/orchestrator/stream/route.js CHANGED Viewed

@@ -6,6 +6,7 @@ import { getSystemPrompt, getModel, getModels, currentDateInstruction } from '@/
 import { brandInstructionText } from '@/lib/brand.js';
 import { agentMemoryContext } from '@/lib/agent-memory-context.js';
 import { runOllamaAgent, runClaudeCodeAgent, runCodexAgent } from '@/lib/agent-engines.js';
+import { thinkingBudgetTokens, getStreamVerbosity } from '@/lib/engine-verbosity.js';
 import {
   createChatSession,
   appendChatMessage,
@@ -510,7 +511,21 @@ export async function POST(req) {
           : baseUserContent) + attachmentPromptText;
         if (activeEngine === 'ollama') {
-          const output = await runOllamaAgent({ model: activeModel, systemPrompt, userMessage: userContent, maxTokens: 2048 });
+          emit('cli_status', { phase: 'starting', engine: 'ollama' });
+          // Stream tokens (and reasoning, on models that support it) for a live
+          // preview. The full output is still returned so the fabrication guard
+          // below runs on the complete text before anything is persisted.
+          const output = await runOllamaAgent({
+            model: activeModel,
+            systemPrompt,
+            userMessage: userContent,
+            maxTokens: 2048,
+            onChunk: (_piece, full) => {
+              const disp = full.replace(/```madarx-action[\s\S]*?```/gi, '').replace(/```madarx-action[\s\S]*$/i, '').trim();
+              if (disp) emit('cli_stream', { text: disp });
+            },
+            onThinking: (full) => { if (full) emit('cli_thinking', { text: full }); },
+          });
           // Ollama runs single-shot with NO madarX tool loop. A Hermes/Nous-template model
           // satisfies a tool task by role-playing the whole loop — emitting <tool_call> and a
           // fabricated <tool_response> in plain text. Never save that fiction as an artifact.
@@ -550,14 +565,36 @@ export async function POST(req) {
             if (displayText) emit('cli_stream', { text: displayText });
           };
           const ccOnAssistantText = (text) => {
-            const displayText = text.replace(/```madarx-action[\s\S]*?```/gi, '').trim();
-            if (displayText) emit('cli_stream', { text: displayText });
+            // Strip from the chat preview: (a) madarx-action blocks (complete +
+            // in-progress trailing fence) so half-streamed JSON never flashes, and
+            // (b) the HTML artifact body — it renders on the canvas, not as raw
+            // markup typing into the chat bubble. Also drops the huge re-sent HTML
+            // from every SSE tick. `building` tells the client to show a tasteful
+            // "designing the page…" placeholder when the turn is artifact-only.
+            const hadHtml = /```html|<!doctype html|<html[\s>]/i.test(text);
+            const displayText = text
+              .replace(/```madarx-action[\s\S]*?```/gi, '')
+              .replace(/```madarx-action[\s\S]*$/i, '')
+              .replace(/```html[\s\S]*?```/gi, '')
+              .replace(/```html[\s\S]*$/i, '')
+              .replace(/<!doctype html[\s\S]*$/i, '')
+              .replace(/<html[\s>][\s\S]*$/i, '')
+              .trim();
+            if (displayText || hadHtml) {
+              emit('cli_stream', { text: displayText, building: hadHtml && !displayText });
+            }
+          };
+          const ccOnThinking = (text) => {
+            if (text) emit('cli_thinking', { text });
+          };
+          const ccOnStatus = (phase) => {
+            emit('cli_status', { phase, engine: activeEngine });
           };
           const ccOnToolStart = ({ name, input }) => {
             emit('tool_start', { name, input });
           };
-          const ccOnToolResult = ({ name, isError }) => {
-            emit('tool_result', { name, output: { ok: !isError }, isError: Boolean(isError) });
+          const ccOnToolResult = ({ name, isError, durationMs, preview, lines, chars }) => {
+            emit('tool_result', { name, output: { ok: !isError, preview, lines, chars }, isError: Boolean(isError), durationMs });
           };
           const invokeCli = (userMessage) => activeEngine === 'claude-code'
             ? runClaudeCodeAgent({
@@ -566,13 +603,28 @@ export async function POST(req) {
                 allowedTools: [],
                 maxTurns: 5,
                 timeoutMs: Number(process.env.CLAUDE_CODE_CHAT_TIMEOUT_MS || 600000),
+                verbosity: getStreamVerbosity(),
                 onAssistantText: ccOnAssistantText,
+                onThinking: ccOnThinking,
+                onStatus: ccOnStatus,
                 onToolStart: ccOnToolStart,
                 onToolResult: ccOnToolResult,
               })
             : runCodexAgent({ systemPrompt, userMessage, onChunk: codexOnChunk });
+          // Heartbeat wrapper: the CLI can sit silent for seconds booting or inside
+          // a slow tool. Emit an elapsed status tick around each invocation so the
+          // user always sees it's alive, and clear it the instant the call returns.
+          const invokeCliWithHeartbeat = async (userMessage) => {
+            const startedAt = Date.now();
+            emit('cli_status', { phase: 'starting', engine: activeEngine });
+            const hb = setInterval(() => {
+              emit('cli_status', { phase: 'working', engine: activeEngine, elapsedMs: Date.now() - startedAt });
+            }, 3000);
+            try { return await invokeCli(userMessage); }
+            finally { clearInterval(hb); emit('cli_status', { phase: 'done', engine: activeEngine }); }
+          };
           try {
-            raw = await invokeCli(cliUserContent);
+            raw = await invokeCliWithHeartbeat(cliUserContent);
             emit('tool_result', { name: cliLabel, output: { ok: true }, isError: false });
           } catch (cliErr) {
             emit('tool_result', { name: cliLabel, output: { error: cliErr.message }, isError: true });
@@ -607,7 +659,7 @@ export async function POST(req) {
             emit('cli_stream', { text: 'No action ran on the first pass — retrying…' });
             let retryRaw = null;
             try {
-              retryRaw = await invokeCli(nudge);
+              retryRaw = await invokeCliWithHeartbeat(nudge);
             } catch (retryErr) {
               if (process.env.MADARX_DEBUG) console.error('[madarx] intent-nudge retry failed:', retryErr.message);
             }
@@ -909,6 +961,9 @@ Rules (non-negotiable):
         }
         let iterations = 0;
         const MAX_TURNS = 8;
+        // Extended-thinking budget for the Anthropic loop. Verbosity-gated and
+        // only applied to thinking-capable models (streamChatWithClaude guards).
+        const anthropicThinkingBudget = thinkingBudgetTokens();
         let artifactCreated = false;
         let totalAgentText = '';
         let totalInputTokens = 0;
@@ -924,7 +979,8 @@ Rules (non-negotiable):
             currentMessages,
             systemPrompt,
             getTools(),
-            loopModel
+            loopModel,
+            { thinkingBudget: anthropicThinkingBudget }
           );
           let textBuffer = '';
@@ -936,6 +992,13 @@ Rules (non-negotiable):
           let turnOutputTokens = 0;
           let turnCacheReadTokens = 0;
           let turnCacheCreationTokens = 0;
+          // Extended-thinking capture. Thinking/redacted_thinking blocks must be
+          // preserved (with their signatures) and replayed in the assistant turn
+          // when tool_use is present, or the API rejects the next request. They
+          // also drive the live "Thinking…" surface via the cli_thinking event.
+          let thinkingBlocks = [];
+          let currentThinking = null;
+          let thinkingLive = '';
           // Stream events from the Anthropic SDK stream object
           for await (const event of claudeStream) {
@@ -952,6 +1015,12 @@ Rules (non-negotiable):
                   input: {},
                 };
                 inputJsonBuffer = '';
+              } else if (event.content_block.type === 'thinking') {
+                currentThinking = { type: 'thinking', thinking: '', signature: '' };
+                emit('cli_status', { phase: 'thinking', engine: activeEngine });
+              } else if (event.content_block.type === 'redacted_thinking') {
+                // No deltas — the encrypted payload arrives whole. Preserve it for replay.
+                thinkingBlocks.push({ type: 'redacted_thinking', data: event.content_block.data });
               }
             } else if (event.type === 'content_block_delta') {
               if (event.delta.type === 'text_delta') {
@@ -959,6 +1028,12 @@ Rules (non-negotiable):
                 emit('text', { delta: event.delta.text });
               } else if (event.delta.type === 'input_json_delta') {
                 inputJsonBuffer += event.delta.partial_json;
+              } else if (event.delta.type === 'thinking_delta' && currentThinking) {
+                currentThinking.thinking += event.delta.thinking;
+                thinkingLive += event.delta.thinking;
+                emit('cli_thinking', { text: thinkingLive });
+              } else if (event.delta.type === 'signature_delta' && currentThinking) {
+                currentThinking.signature += event.delta.signature;
               }
             } else if (event.type === 'content_block_stop') {
               if (currentToolBlock) {
@@ -970,6 +1045,9 @@ Rules (non-negotiable):
                 toolUseBlocks.push(currentToolBlock);
                 currentToolBlock = null;
                 inputJsonBuffer = '';
+              } else if (currentThinking) {
+                thinkingBlocks.push(currentThinking);
+                currentThinking = null;
               }
             } else if (event.type === 'message_delta') {
               if (event.delta.stop_reason) stopReason = event.delta.stop_reason;
@@ -991,8 +1069,13 @@ Rules (non-negotiable):
             context: lastContextTokens,
           });
-          // Build the assistant message for the agentic loop
+          // Build the assistant message for the agentic loop. Thinking blocks
+          // come FIRST (the API requires them ahead of text/tool_use, with their
+          // signatures intact) so the next turn carrying tool_results validates.
           const assistantContent = [];
+          if (stopReason === 'tool_use') {
+            for (const tb of thinkingBlocks) assistantContent.push(tb);
+          }
           if (textBuffer) {
             assistantContent.push({ type: 'text', text: textBuffer });
           }

package/app/api/voice/realtime/session/route.js CHANGED Viewed

@@ -37,6 +37,10 @@ export async function POST(request) {
         ? body.instructions
         : undefined,
       tools: Array.isArray(body?.tools) ? body.tools : undefined,
+      // 'transport' = STT-only (orchestrator is the brain); 'realtime' = proven
+      // in-browser brain. Default to realtime; transport is opt-in until the
+      // GA session shape is verified against a live mic.
+      mode: body?.mode === 'transport' ? 'transport' : 'realtime',
       project_id: body?.project_id || null,
       agent_id: body?.agent_id || 'main',
       active_space: body?.active_space || null,

package/app/components/app-chrome.jsx CHANGED Viewed

@@ -3,6 +3,7 @@
 import { useMemo } from 'react';
 import { usePathname } from 'next/navigation';
 import SmartSearch from './smart-search';
+import AppTopbar from './app-topbar';
 const CHROMELESS_PREFIXES = ['/login', '/share'];
@@ -22,6 +23,7 @@ export default function AppChrome({ children, sidebar }) {
   return (
     <>
       <div className="app-shell">
+        <AppTopbar />
         <div className="app-rail">{sidebarNode}</div>
         <div className="app-content">{children}</div>
       </div>

package/app/components/app-topbar.jsx ADDED Viewed

@@ -0,0 +1,337 @@
+'use client';
+import { useEffect, useLayoutEffect, useMemo, useRef, useState } from 'react';
+import { createPortal } from 'react-dom';
+import { usePathname } from 'next/navigation';
+import { Search, Command, Activity } from 'lucide-react';
+import { subscribeAgentEvents } from '../agents/agent-events-bus.js';
+import { SpinnerIcon, CheckIcon, StepXIcon } from './dashboard/icons';
+import { toolStepDisplayName, toolStepSublabel } from './dashboard/tool-steps.js';
+// Pathname prefix → human section label. Longest-prefix wins via order: list
+// more specific paths before their parents.
+const SECTIONS = [
+  ['/agents', 'Agents'],
+  ['/tasks', 'Tasks'],
+  ['/approvals', 'Approvals'],
+  ['/marketplace', 'Marketplace'],
+  ['/tools', 'Tools'],
+  ['/schedules', 'Schedules'],
+  ['/reports', 'Reports'],
+  ['/activity', 'Activity'],
+  ['/runtime', 'Runtime'],
+  ['/workflows', 'Workflows'],
+  ['/brand', 'Brand'],
+  ['/team', 'Team'],
+  ['/whatsapp', 'WhatsApp'],
+  ['/settings', 'Settings'],
+  ['/help', 'Help'],
+];
+function sectionFor(pathname) {
+  if (!pathname || pathname === '/') return 'Overview';
+  const hit = SECTIONS.find(([prefix]) => pathname === prefix || pathname.startsWith(`${prefix}/`));
+  return hit ? hit[1] : 'madarX';
+}
+const STEP_CAP = 8;          // most recent tool steps kept per agent
+const LINGER_MS = 6000;      // keep a finished agent in the list briefly
+const ORPHAN_TTL_MS = 120000; // drop a "running" agent with no activity for 2m
+// Fold a single live event into the keyed-by-agent activity map. Mirrors the
+// dashboard's use-bg-agents reducer, kept inline here so the global topbar can
+// show background-agent detail on every page from the shared SSE bus.
+function reduceEvent(prev, event) {
+  const id = event.agent_id;
+  if (!id) return prev;
+  const existing = prev[id];
+  switch (event.type) {
+    case 'agent_run_start':
+      return {
+        ...prev,
+        [id]: {
+          agent_id: id,
+          agent_name: event.agent_name || id,
+          triggered_by: event.triggered_by || null,
+          status: 'running',
+          started_at: event.ts || Date.now(),
+          current_tool: null,
+          current_input: null,
+          last_activity: event.ts || Date.now(),
+          steps: existing?.steps?.slice(-4) ?? [],
+        },
+      };
+    case 'agent_tool_start': {
+      const base = existing || {
+        agent_id: id,
+        agent_name: event.agent_name || id,
+        triggered_by: null,
+        status: 'running',
+        started_at: Date.now(),
+        steps: [],
+      };
+      const ts = event.ts || Date.now();
+      return {
+        ...prev,
+        [id]: {
+          ...base,
+          agent_name: event.agent_name || base.agent_name,
+          status: 'running',
+          current_tool: event.tool,
+          current_input: event.input_summary ?? null,
+          last_activity: ts,
+          steps: [
+            ...base.steps,
+            { tool: event.tool, input: event.input_summary ?? null, status: 'running', ts },
+          ].slice(-STEP_CAP),
+        },
+      };
+    }
+    case 'agent_tool_result': {
+      if (!existing) return prev;
+      const steps = [...existing.steps];
+      for (let i = steps.length - 1; i >= 0; i--) {
+        if (steps[i].tool === event.tool && steps[i].status === 'running') {
+          steps[i] = { ...steps[i], status: event.isError ? 'error' : 'done' };
+          break;
+        }
+      }
+      return {
+        ...prev,
+        [id]: { ...existing, current_tool: null, last_activity: event.ts || Date.now(), steps },
+      };
+    }
+    case 'agent_run_complete':
+      if (!existing) return prev;
+      return {
+        ...prev,
+        [id]: {
+          ...existing,
+          status: event.isError ? 'failed' : 'complete',
+          finished_at: event.ts || Date.now(),
+          current_tool: null,
+        },
+      };
+    default:
+      return prev;
+  }
+}
+export default function AppTopbar() {
+  const pathname = usePathname();
+  const section = useMemo(() => sectionFor(pathname), [pathname]);
+  // Per-agent background activity, keyed by agent id. Fed by the shared SSE bus
+  // (same connection the Run buttons use) so the topbar reflects every
+  // sub-agent the Main Agent spawns, plus scheduled/heartbeat ticks.
+  const [agents, setAgents] = useState({});
+  const [open, setOpen] = useState(false);
+  const wrapRef = useRef(null);
+  useEffect(() => {
+    return subscribeAgentEvents((event) => {
+      setAgents((cur) => reduceEvent(cur, event));
+    });
+  }, []);
+  // Sweep: evict finished agents after a short linger, and orphaned "running"
+  // agents whose run-complete event we never received.
+  useEffect(() => {
+    const timer = setInterval(() => {
+      const now = Date.now();
+      setAgents((cur) => {
+        let changed = false;
+        const next = {};
+        for (const [id, a] of Object.entries(cur)) {
+          if (a.status !== 'running') {
+            if (a.finished_at && now - a.finished_at > LINGER_MS) { changed = true; continue; }
+          } else if ((a.last_activity || a.started_at || 0) < now - ORPHAN_TTL_MS) {
+            changed = true; continue;
+          }
+          next[id] = a;
+        }
+        return changed ? next : cur;
+      });
+    }, 4000);
+    return () => clearInterval(timer);
+  }, []);
+  // The popover renders in a body portal (so it escapes the topbar's
+  // backdrop-filter stacking context and paints above canvas artifacts).
+  // It's anchored to the button via the button's viewport rect.
+  const popRef = useRef(null);
+  const [coords, setCoords] = useState(null);
+  useLayoutEffect(() => {
+    if (!open) return;
+    function reposition() {
+      const el = wrapRef.current;
+      if (!el) return;
+      const r = el.getBoundingClientRect();
+      setCoords({ top: Math.round(r.bottom + 8), right: Math.round(window.innerWidth - r.right) });
+    }
+    reposition();
+    window.addEventListener('resize', reposition);
+    window.addEventListener('scroll', reposition, true);
+    return () => {
+      window.removeEventListener('resize', reposition);
+      window.removeEventListener('scroll', reposition, true);
+    };
+  }, [open]);
+  // Close the popover on navigation and on Escape.
+  useEffect(() => { setOpen(false); }, [pathname]);
+  useEffect(() => {
+    if (!open) return;
+    function onKey(e) { if (e.key === 'Escape') setOpen(false); }
+    function onClick(e) {
+      // Outside-click must account for the portaled popover, which lives
+      // outside wrapRef in the DOM tree.
+      const inTrigger = wrapRef.current && wrapRef.current.contains(e.target);
+      const inPop = popRef.current && popRef.current.contains(e.target);
+      if (!inTrigger && !inPop) setOpen(false);
+    }
+    document.addEventListener('keydown', onKey);
+    document.addEventListener('mousedown', onClick);
+    return () => {
+      document.removeEventListener('keydown', onKey);
+      document.removeEventListener('mousedown', onClick);
+    };
+  }, [open]);
+  const list = useMemo(
+    () => Object.values(agents).sort((a, b) => (b.started_at || 0) - (a.started_at || 0)),
+    [agents],
+  );
+  const running = list.filter((a) => a.status === 'running');
+  const runningCount = running.length;
+  // Pill summary: one agent → name · current tool; many → a count; idle → label
+  // that reads as a feature ("Activity") so the control is discoverable even
+  // when nothing is running.
+  let label = 'Activity';
+  if (runningCount === 1) {
+    const a = running[0];
+    label = a.current_tool ? `${a.agent_name} · ${toolStepDisplayName(a.current_tool)}` : a.agent_name;
+  } else if (runningCount > 1) {
+    label = `${runningCount} agents running`;
+  }
+  function openSearch() {
+    if (typeof window !== 'undefined') {
+      window.dispatchEvent(new CustomEvent('madarx:open-search'));
+    }
+  }
+  return (
+    <header className="app-topbar" role="banner">
+      <div className="app-topbar-left">
+        <span className="app-topbar-brand">madar<b>X</b></span>
+        <span className="app-topbar-sep" aria-hidden />
+        <span className="app-topbar-section">{section}</span>
+      </div>
+      <div className="app-topbar-right">
+        {/* Page-scoped action slot. The dashboard ("spaces") portals its canvas
+            controls (Approve & Run, Hermes, Runtime, Reset layout) in here so
+            there is ONE toolbar instead of two. Empty on every other page. */}
+        <div id="app-topbar-slot" className="app-topbar-slot" />
+        <div className="app-topbar-activity-wrap" ref={wrapRef}>
+          <button
+            type="button"
+            className={`app-topbar-activity is-clickable ${runningCount ? 'is-running' : ''}`}
+            title={runningCount ? `${runningCount} agent${runningCount === 1 ? '' : 's'} running — click for details` : 'Background agent activity'}
+            onClick={() => setOpen((v) => !v)}
+            aria-expanded={open}
+            aria-haspopup="dialog"
+          >
+            <Activity size={12} className="app-topbar-activity-glyph" aria-hidden />
+            <span className="app-topbar-dot" aria-hidden />
+            <span className="app-topbar-activity-label">{label}</span>
+          </button>
+          {open && typeof document !== 'undefined' && createPortal(
+            <div
+              className="bg-activity-pop"
+              role="dialog"
+              aria-label="Background agent activity"
+              ref={popRef}
+              style={coords ? { top: coords.top, right: coords.right } : { visibility: 'hidden' }}
+            >
+              <div className="bg-activity-head">
+                <b>Background agents</b>
+                <small>
+                  {runningCount
+                    ? `${runningCount} working now`
+                    : list.length
+                      ? 'Recently finished'
+                      : 'Live view of agents the Main Agent spawns'}
+                </small>
+              </div>
+              {list.length === 0 && (
+                <div className="bg-activity-empty">
+                  <Activity size={18} aria-hidden />
+                  <span>No background agents active right now.</span>
+                  <small>When the Main Agent calls a sub-agent, it shows here live.</small>
+                </div>
+              )}
+              <div className="bg-activity-list">
+                {list.map((a) => (
+                  <div key={a.agent_id} className={`bg-activity-agent bg-activity-agent--${a.status}`}>
+                    <div className="bg-activity-agent-head">
+                      <span className="bg-activity-agent-icon" aria-hidden>
+                        {a.status === 'running' && <SpinnerIcon />}
+                        {a.status === 'complete' && <CheckIcon />}
+                        {a.status === 'failed' && <StepXIcon />}
+                      </span>
+                      <span className="bg-activity-agent-name">{a.agent_name}</span>
+                      {a.triggered_by && (
+                        <span className="bg-activity-agent-by">via {a.triggered_by}</span>
+                      )}
+                      <span className="bg-activity-agent-status">
+                        {a.status === 'running'
+                          ? (a.current_tool ? toolStepDisplayName(a.current_tool) : 'working…')
+                          : a.status === 'complete' ? 'done' : 'failed'}
+                      </span>
+                    </div>
+                    {a.steps.length > 0 && (
+                      <div className="bg-activity-steps">
+                        {a.steps.slice(-5).map((s, i) => (
+                          <div key={i} className={`bg-activity-step bg-activity-step--${s.status}`}>
+                            <span className="bg-activity-step-icon" aria-hidden>
+                              {s.status === 'running' && <SpinnerIcon />}
+                              {s.status === 'done' && <CheckIcon />}
+                              {s.status === 'error' && <StepXIcon />}
+                            </span>
+                            <code className="bg-activity-step-name">{toolStepDisplayName(s.tool)}</code>
+                            {toolStepSublabel(s.tool, s.input) && (
+                              <span className="bg-activity-step-sub">{toolStepSublabel(s.tool, s.input)}</span>
+                            )}
+                          </div>
+                        ))}
+                      </div>
+                    )}
+                  </div>
+                ))}
+              </div>
+              <a className="bg-activity-foot" href="/activity">Open activity log →</a>
+            </div>,
+            document.body,
+          )}
+        </div>
+        <button type="button" className="app-topbar-search" onClick={openSearch} aria-label="Open search (Command K)">
+          <Search size={13} aria-hidden />
+          <span>Search</span>
+          <kbd><Command size={10} aria-hidden />K</kbd>
+        </button>
+      </div>
+    </header>
+  );
+}