nodal-agents 0.1.5 → 0.1.6

package/README.md

@@ -1,81 +1,211 @@
-# Nodal-Agents
-
-Local-first AI agent platform. Self-host on Mac, PC, Linux, VPS, or NAS in 3 commands.
-
-## Install in 30 seconds (Docker)
-
-Works on any host with Docker — Mac, PC, Linux, VPS, Synology / Unraid / TrueNAS NAS, Raspberry Pi.
-
-```bash
-curl -O https://raw.githubusercontent.com/Kwintspiracy/nodal-agents/main/docker-compose.yml
-docker compose up -d
-```
-
-Open <http://localhost:3000> — Nodal-Agents is running. Configure your LLM provider from **Settings → LLM keys** in the dashboard.
-
-Data (config, postgres, logs) lives in the `nodal-data` Docker volume. To wipe everything: `docker compose down -v`.
-
-The image is published to `ghcr.io/kwintspiracy/nodal-agents:latest` (multi-arch: amd64 + arm64). To pin a version, replace `latest` with a release tag (e.g. `v0.1.0`).
-
-### Build the image locally
-
-If you'd rather build from source instead of pulling the published image:
-
-```bash
-git clone https://github.com/Kwintspiracy/nodal-agents.git
-cd nodal-agents
-docker compose build
-docker compose up -d
-```
-
-(Comment the `image:` line and uncomment `build: .` in `docker-compose.yml`.)
-
-## Developer setup (monorepo)
-
-```bash
-pnpm install
-pnpm typecheck
-pnpm lint
-pnpm test
-pnpm --filter nodal-agents dev   # CLI in tsx watch mode
-```
-
-## Monorepo structure
-
-- `apps/web` — Next.js dashboard (UI)
-- `apps/runner` — Agent runtime (HTTP API, job execution, cron ticker)
-- `apps/cli` — `nodal-agents` install + ops command
-- `packages/db` — Drizzle schema + migrations + client (only place that imports postgres)
-- `packages/shared` — Zod types and constants shared across web + runner
-- `packages/llm` — Vercel AI SDK wrapper, multi-provider abstraction
-- `packages/tools` — Tool registration + execution + approval gates
-- `packages/memory` — Agent memory CRUD + embeddings
-- `packages/orchestration` — Router + Planner patterns (delegation, task board)
-- `packages/runner-adapters` — Connectors: notion, drive, gmail, sheets, etc.
-- `packages/delivery` — Telegram, email, future Slack/Discord
-- `packages/auth` — Pluggable auth provider (local-trust default, better-auth opt-in, bearer-token for LAN)
-
-## Architecture rules (enforced by `dependency-cruiser`)
-
-- `apps/*` may import `packages/*`, never the reverse
-- `apps/web` and `apps/runner` cannot import each other (DB or HTTP only)
-- Only `packages/db` may import postgres clients (`pg`, `postgres`, `drizzle-orm`)
-- `packages/runner-adapters/*` may only import from `packages/tools` and `packages/shared`
-- No circular dependencies
-
-Run `pnpm deps:check` locally before pushing.
-
-## Stack
-
-- **Runtime:** Node 22+, TypeScript strict
-- **Monorepo:** pnpm workspaces + Turborepo
-- **DB:** embedded-postgres (local + Docker), Drizzle ORM, pgvector
-- **Validation:** Zod
-- **HTTP server:** Hono (runner)
-- **LLM:** Vercel AI SDK
-- **Auth:** local-trust (single-user loopback) / local-auth (better-auth, multi-user LAN) / bearer-token
-- **Tests:** Vitest (unit), Playwright (e2e), dependency-cruiser (architecture)
-
-## License
-
-TBD.
+# Nodal-Agents
+
+> **Your AI agents. Your data. Your machine.**
+> Self-hosted, local-first AI agent platform — install in two commands.
+
+[![npm](https://img.shields.io/npm/v/nodal-agents?color=cb3837&label=npm&logo=npm)](https://www.npmjs.com/package/nodal-agents)
+[![Node](https://img.shields.io/badge/node-22%2B-339933?logo=node.js&logoColor=white)](https://nodejs.org)
+[![TypeScript](https://img.shields.io/badge/typescript-strict-3178c6?logo=typescript&logoColor=white)](https://www.typescriptlang.org)
+
+Build and orchestrate AI agents on your own hardware. Multi-LLM,
+multi-channel, multi-connector — **no SaaS lock-in, no per-token markup,
+no cloud roundtrip.** Runs on any machine with Node 22+ — Mac, PC, Linux.
+
+---
+
+## Why Nodal-Agents
+
+| | |
+| --- | --- |
+| 🏠 &nbsp;**Local-first** | Single binary, embedded Postgres, zero cloud dependency. Your conversations, memory, and credentials stay on your machine. |
+| 🔌 &nbsp;**LLM-agnostic** | Anthropic, OpenAI, Google, Groq, Mistral, OpenRouter, or any OpenAI-compatible local model (LM Studio, Ollama). Per-agent key, swap providers without code changes. |
+| 🧠 &nbsp;**Memory that compounds** | Persistent facts (entity-scoped, auto-injected into every job) and chat-thread continuity (your agent remembers what it said 30 seconds ago — and what it said yesterday). |
+| 🤝 &nbsp;**Orchestrators that finish** | Router and planner orchestrators delegate to specialist sub-agents. Hard guards against runaway loops — turn caps, chain caps, per-slug delegation budgets, smart retry on side-effect-free failures. |
+| 🔧 &nbsp;**Multi-instance connectors** | Gmail perso *and* Gmail boulot on the same install. OAuth *and* API-key supported. Active list + Marketplace UI in the dashboard. |
+| 📡 &nbsp;**MCP support** | Connect Streamable HTTP MCP servers — per-job tool discovery, tool whitelisting, multi-instance. |
+| 💬 &nbsp;**Telegram out of the box** | Long-polling, multi-agent routing (`/ask <slug>`), group-chat filters, conversation continuity, delegation gracefulness on Telegram. |
+| ⚙️ &nbsp;**Real engineering** | TypeScript strict, dependency-cruiser-enforced architecture, full unit + integration suite, Playwright e2e, idempotent migrations, encryption at rest for keys. |
+
+---
+
+## Install
+
+```bash
+npm install -g nodal-agents
+nodal-agents up
+```
+
+Open <http://localhost:3000>. The CLI spawns an embedded Postgres on a
+free port, applies migrations, seeds the system skills, and starts the
+runner (`:3001`) and dashboard (`:3000`). Configure your LLM provider
+from **Settings → LLM Keys** in the dashboard.
+
+> Requires Node 22+. No external Postgres, no Redis, no cloud config.
+> Data lives at `~/.nodalai/` — wipe with `rm -rf ~/.nodalai`.
+
+To stop the stack: `nodal-agents down`.
+
+### Build from source
+
+```bash
+git clone https://github.com/Kwintspiracy/nodal-agents.git
+cd nodal-agents
+pnpm install
+pnpm --filter nodal-agents exec tsx src/index.ts --dev
+```
+
+Dev mode runs `next dev` so the dashboard hot-reloads on file changes.
+
+---
+
+## How it works
+
+```
+   ┌─────────────┐    Telegram /     ┌────────────────────────────────┐
+   │   Channel   │   Dashboard  ───▶ │         Runner (Hono)          │
+   │  (telegram, │    POST /api  ◀── │  • Job queue + executor        │
+   │   web …)    │                   │  • Anti-runaway guards          │
+   └─────────────┘                   │  • Per-agent tool whitelist     │
+                                     │  • Memory auto-injection        │
+                                     │  • Session-thread continuity    │
+                                     └─────────┬──────────┬────────────┘
+                                               │          │
+                                       ┌───────▼───┐  ┌───▼─────────────┐
+                                       │    LLM    │  │  Connectors /   │
+                                       │  client   │  │  MCP servers    │
+                                       │ (multi-   │  │  (Gmail, Drive, │
+                                       │ provider) │  │   Notion, Cogni │
+                                       └───────────┘  │   Cortex …)     │
+                                                      └─────────────────┘
+```
+
+Every agent is a row in Postgres — personality, skills, connectors,
+memory budget, team assignments live in the database. The runtime is
+generic: **zero hardcoded agent metadata.** Adding capabilities means
+inserting rows, not editing code.
+
+A user message via Telegram becomes an `agent_jobs` row. The runner
+loads the agent's prior chat-thread history, injects relevant
+persistent memories, dispatches to the LLM, executes any tool calls
+emitted, and finalizes via `telegram_send_message` + `return_result`.
+Delegations create child jobs that resume the parent on completion.
+
+---
+
+## Dashboard
+
+| Route | Purpose |
+| --- | --- |
+| `/agents` | Create, edit, assign skills + connectors + MCP servers to agents. |
+| `/jobs` | Live job stream — task, agent, status, full transcript, tool I/O. |
+| `/connectors` | Active connector instances + Marketplace (multi-instance, OAuth or API-key). |
+| `/mcp` | Active MCP servers + Marketplace (HTTP transport). |
+| `/memories` | Persistent facts per entity — search, edit, archive. |
+| `/skills` | Procedural memory blocks — shipped with the product, user-overridable. |
+| `/logs` | Tool-call audit — input/output JSON per call, filterable by tool name. |
+| `/approvals` | Human-in-the-loop gates for risky tools. |
+| `/automations` | Cron-scheduled agent triggers. |
+| `/settings` | LLM keys, auth mode, network (loopback / LAN), bot tokens. |
+
+---
+
+## Stack
+
+| Layer | Tech |
+| --- | --- |
+| Runtime | Node 22+, TypeScript strict (no `any`, no `@ts-ignore` without comment) |
+| Monorepo | pnpm workspaces + Turborepo |
+| Database | embedded-postgres (Win / Mac / Linux), Drizzle ORM, idempotent migrations |
+| Validation | Zod everywhere |
+| HTTP server | Hono (runner), Next.js 16 (dashboard) |
+| LLM | Vercel AI SDK — multi-provider with retry + timeout + tolerant parsing |
+| Auth | local-trust (single-user loopback) / better-auth (multi-user LAN) / bearer-token |
+| Encryption | AES-256-GCM at rest for API keys, master key in `~/.nodalai/secrets.key` |
+| Tests | Vitest (unit + integration), Playwright (e2e), dependency-cruiser (architecture) |
+
+---
+
+## Monorepo
+
+```
+apps/
+├── cli              nodal-agents CLI: install, up, down, ops
+├── runner           Hono server: job execution, cron, channel pollers
+└── web              Next.js dashboard
+
+packages/
+├── db               Drizzle schema + migrations + client (only postgres importer)
+├── shared           Zod types + constants shared across web + runner
+├── llm              Vercel AI SDK wrapper, retry, timeout, native tool-call parsers
+├── tools            Tool registration + execution + approval gates
+├── memory           Persistent memory CRUD + sanitation + dedup + auto-injection
+├── orchestration    Router / Planner patterns, delegation, chain counters
+├── adapters         Connector packages (gmail, drive, sheets, docs, notion,
+│                    airtable, apify, firecrawl, tavily, MCP)
+├── runner-adapters  Adapter registry, agent ↔ tool wiring
+├── delivery         Telegram, email
+├── auth             Pluggable auth provider
+├── catalog          Shipped system skills (telegram-responder, obsidian,
+│                    research-scope-discipline, claude-html-design)
+└── secrets          AES-256-GCM key vault
+```
+
+---
+
+## Architecture rules (enforced by `dependency-cruiser`)
+
+- `apps/*` may import `packages/*` — never the reverse.
+- `apps/web` and `apps/runner` cannot import each other (DB or HTTP only).
+- Only `packages/db` may import `postgres` / `drizzle-orm` / `pg`.
+- `packages/runner-adapters/*` may only import from `packages/tools` and
+  `packages/shared`.
+- No circular dependencies.
+
+```bash
+pnpm deps:check   # runs locally and in CI before every release
+```
+
+---
+
+## Status
+
+**Current release:** `0.1.5` on npm `latest`. Used daily by the
+maintainer, stable enough for personal production. Pre-1.0 — breaking
+changes are still possible between minors.
+
+### Shipped and working
+
+- Multi-LLM provider routing with per-agent keys
+- Persistent memory (sanitation, dedup, importance ranking, auto-injection,
+  feedback loop)
+- Session-thread continuity on chat channels (Telegram today)
+- Orchestrator (router + planner) with delegation chains and anti-runaway
+  caps
+- Multi-instance connectors with OAuth (Gmail, Drive, Sheets, Docs, Notion,
+  Airtable) and API-key (Notion, Airtable, Apify, Firecrawl, Tavily)
+- MCP Streamable HTTP catalog with API-key auth
+- Telegram delivery (long-poll, group filters, multi-agent routing,
+  delegation gracefulness)
+- Approval gates for risky tools
+- Cron scheduling
+- Encryption at rest for LLM keys + MCP keys
+- Embedded Postgres distribution via npm (no external DB to install)
+
+### On the roadmap (genuine, not vaporware)
+
+- **MCP OAuth flow** → unlocks Linear, Notion remote, GitHub remote,
+  Atlassian, Sentry, and the rest of the SaaS-as-MCP ecosystem.
+- **MCP stdio transport** → unlocks the Anthropic reference servers
+  (filesystem, sqlite, brave-search, GitHub stdio…) and the community
+  catalog.
+- **pgvector binaries bundled in the npm pack** → semantic memory search
+  active out-of-the-box. Today, installs without pgvector fall back to
+  keyword search (which works, just less smart for cross-vocabulary
+  recall).
+- Data migration tools from the legacy Python stack.
+
+---
+
+## License
+
+TBD.

package/cli.js

@@ -12990,7 +12990,7 @@ var init_mcp = __esm({
         check("mcp_servers_transport_check", sql`${table.transport} IN ('http','stdio')`),
         check(
           "mcp_servers_auth_scheme_check",
-          sql`${table.authScheme} IN ('header','query') OR ${table.authScheme} IS NULL`
+          sql`${table.authScheme} IN ('header','query','bearer') OR ${table.authScheme} IS NULL`
         )
         // Multi-instance brique (migration 0017): the (entity_id, slug) UNIQUE
         // index was dropped to allow multiple instances of the same MCP server
@@ -13464,10 +13464,11 @@ function buildEnvForWeb(config, databaseUrl) {
     // readConfig() guarantees this is set (auto-mints on first read).
     NEXT_SERVER_ACTIONS_ENCRYPTION_KEY: config.serverActionsKey ?? "",
     // The Next.js standalone server reads HOSTNAME for its listener bind
-    // (defaults to '0.0.0.0' when unset). Docker sets HOSTNAME to the
-    // container ID, which Next interprets as the hostname to bind on —
-    // resolving via /etc/hosts to 127.0.0.1 only, breaking port forwarding
-    // and the `localhost:3000` healthcheck. Pin to the loopback/lan choice.
+    // (defaults to '0.0.0.0' when unset). Some host environments set
+    // HOSTNAME to an arbitrary identifier (e.g. a runner ID), which Next
+    // would interpret as the hostname to bind on — usually resolving via
+    // /etc/hosts to 127.0.0.1 only, breaking port forwarding and the
+    // `localhost:3000` healthcheck. Pin to the loopback/lan choice.
     HOSTNAME: bind
   };
   if (config.llm) {

package/migrations/0018_mcp_servers_bearer_auth.sql

@@ -0,0 +1,12 @@
+-- Migration 0018 — relax mcp_servers.auth_scheme to allow 'bearer'.
+--
+-- Brique A v3 (MCP catalog enrichment): adds the 'bearer' auth scheme so
+-- catalog entries for servers expecting `Authorization: Bearer <token>`
+-- (Stripe, OpenAI, etc.) can be represented and connected without a
+-- bespoke per-server hack. The adapter injects the literal "Bearer "
+-- prefix when this scheme is selected; authParamName is ignored.
+
+ALTER TABLE "mcp_servers" DROP CONSTRAINT IF EXISTS "mcp_servers_auth_scheme_check";
+--> statement-breakpoint
+ALTER TABLE "mcp_servers" ADD CONSTRAINT "mcp_servers_auth_scheme_check"
+  CHECK ("auth_scheme" IN ('header','query','bearer') OR "auth_scheme" IS NULL);

package/migrations/meta/_journal.json

@@ -127,6 +127,13 @@
       "when": 1779700000000,
       "tag": "0017_drop_mcp_server_entity_slug_unique",
       "breakpoints": true
+    },
+    {
+      "idx": 18,
+      "version": "7",
+      "when": 1779800000000,
+      "tag": "0018_mcp_servers_bearer_auth",
+      "breakpoints": true
     }
   ]
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nodal-agents",
-  "version": "0.1.5",
+  "version": "0.1.6",
   "description": "Local-first AI agent platform — self-host on Mac, PC, Linux, VPS, or NAS.",
   "license": "MIT",
   "repository": {

package/runner.js

@@ -1858,7 +1858,7 @@ var init_mcp = __esm({
         check11("mcp_servers_transport_check", sql13`${table.transport} IN ('http','stdio')`),
         check11(
           "mcp_servers_auth_scheme_check",
-          sql13`${table.authScheme} IN ('header','query') OR ${table.authScheme} IS NULL`
+          sql13`${table.authScheme} IN ('header','query','bearer') OR ${table.authScheme} IS NULL`
         )
         // Multi-instance brique (migration 0017): the (entity_id, slug) UNIQUE
         // index was dropped to allow multiple instances of the same MCP server
@@ -81026,15 +81026,22 @@ function buildMcpRequest(opts) {
   const url2 = new URL(opts.url);
   const headers = {};
   if (opts.apiKey) {
-    if (!opts.authScheme || !opts.authParamName) {
-      throw new Error(
-        "buildMcpRequest: authScheme and authParamName are required when apiKey is set"
-      );
+    if (!opts.authScheme) {
+      throw new Error("buildMcpRequest: authScheme is required when apiKey is set");
     }
-    if (opts.authScheme === "query") {
-      url2.searchParams.set(opts.authParamName, opts.apiKey);
+    if (opts.authScheme === "bearer") {
+      headers["Authorization"] = `Bearer ${opts.apiKey}`;
     } else {
-      headers[opts.authParamName] = opts.apiKey;
+      if (!opts.authParamName) {
+        throw new Error(
+          `buildMcpRequest: authParamName is required when authScheme is '${opts.authScheme}'`
+        );
+      }
+      if (opts.authScheme === "query") {
+        url2.searchParams.set(opts.authParamName, opts.apiKey);
+      } else {
+        headers[opts.authParamName] = opts.apiKey;
+      }
     }
   }
   return { url: url2, headers };
@@ -81373,6 +81380,64 @@ async function generateAssignTools(parentAgentId, db) {
       skillMap.set(r.agentId, existing);
     }
   }
+  const connectorRows = await Promise.all(
+    childIds.map(
+      (id) => db.select({
+        agentId: agentConnectorAssignments.agentId,
+        slug: connectors.slug,
+        enabledOperations: agentConnectorAssignments.enabledOperations
+      }).from(agentConnectorAssignments).innerJoin(connectors, eq2(connectors.id, agentConnectorAssignments.connectorId)).where(eq2(agentConnectorAssignments.agentId, id))
+    )
+  );
+  const connectorMap = /* @__PURE__ */ new Map();
+  for (const batch of connectorRows) {
+    for (const r of batch) {
+      const entry = ADAPTER_REGISTRY[r.slug];
+      if (!entry) continue;
+      const allToolNames = entry.operations.map((o) => o.slug);
+      const toolNames = r.enabledOperations === null ? allToolNames : allToolNames.filter((n) => r.enabledOperations.includes(n));
+      if (toolNames.length === 0) continue;
+      const existing = connectorMap.get(r.agentId) ?? [];
+      existing.push({ slug: r.slug, toolNames });
+      connectorMap.set(r.agentId, existing);
+    }
+  }
+  const mcpRows = await Promise.all(
+    childIds.map(
+      (id) => db.select({
+        agentId: agentMcpServers.agentId,
+        serverSlug: mcpServers.slug,
+        enabledTools: agentMcpServers.enabledTools,
+        availableTools: mcpServers.availableTools,
+        serverActive: mcpServers.active
+      }).from(agentMcpServers).innerJoin(mcpServers, eq2(mcpServers.id, agentMcpServers.mcpServerId)).where(eq2(agentMcpServers.agentId, id))
+    )
+  );
+  const mcpMap = /* @__PURE__ */ new Map();
+  for (const batch of mcpRows) {
+    for (const r of batch) {
+      if (r.serverActive === false) continue;
+      const prefix = r.serverSlug.replace(/-/g, "_");
+      const available = Array.isArray(r.availableTools) ? r.availableTools.map((t) => t && typeof t.name === "string" ? t.name : null).filter((n) => n !== null) : [];
+      if (available.length === 0) continue;
+      const enabled = Array.isArray(r.enabledTools) ? new Set(r.enabledTools.filter((n) => typeof n === "string")) : null;
+      const kept = enabled === null ? available : available.filter((n) => enabled.has(n));
+      if (kept.length === 0) continue;
+      const toolNames = kept.map((n) => `${prefix}__${n}`);
+      const existing = mcpMap.get(r.agentId) ?? [];
+      existing.push({ slug: r.serverSlug, toolNames });
+      mcpMap.set(r.agentId, existing);
+    }
+  }
+  function formatToolsTag(subAgentId) {
+    const conn = connectorMap.get(subAgentId);
+    const mcp = mcpMap.get(subAgentId);
+    const parts = [];
+    if (conn) parts.push(...conn.map((c) => `${c.slug} (${c.toolNames.join(", ")})`));
+    if (mcp) parts.push(...mcp.map((c) => `${c.slug} (${c.toolNames.join(", ")})`));
+    if (parts.length === 0) return "";
+    return ` Tools: ${parts.join("; ")}.`;
+  }
   const tools = [];
   for (const row of rows) {
     const { subAgentId, instructions, agentName, agentSlug, agentRole } = row;
@@ -81380,9 +81445,10 @@ async function generateAssignTools(parentAgentId, db) {
     const toolName = `assign_${toolSlug}`;
     const skills = skillMap.get(subAgentId) ?? [];
     const skillsDesc = skills.length > 0 ? ` Skills: ${skills.join(", ")}.` : "";
+    const toolsDesc = formatToolsTag(subAgentId);
     const roleNote = agentRole === "orchestrator" ? " (orchestrator \u2014 manages their own team)" : "";
     const instrNote = instructions ? ` Instructions: ${instructions}` : "";
-    const description = `Assign a task to ${agentName}${roleNote}.${skillsDesc}${instrNote}`.trim();
+    const description = `Assign a task to ${agentName}${roleNote}.${skillsDesc}${toolsDesc}${instrNote}`.trim();
     const capturedSlug = agentSlug;
     const tool = {
       name: toolName,
@@ -81760,10 +81826,40 @@ async function buildTeamBlock(parentAgentId, db) {
       connectorMap.set(r.agentId, existing);
     }
   }
+  const mcpRows = await Promise.all(
+    childIds.map(
+      (id) => db.select({
+        agentId: agentMcpServers.agentId,
+        serverSlug: mcpServers.slug,
+        enabledTools: agentMcpServers.enabledTools,
+        availableTools: mcpServers.availableTools,
+        serverActive: mcpServers.active
+      }).from(agentMcpServers).innerJoin(mcpServers, eq2(mcpServers.id, agentMcpServers.mcpServerId)).where(eq2(agentMcpServers.agentId, id))
+    )
+  );
+  const mcpMap = /* @__PURE__ */ new Map();
+  for (const batch of mcpRows) {
+    for (const r of batch) {
+      if (r.serverActive === false) continue;
+      const prefix = r.serverSlug.replace(/-/g, "_");
+      const available = Array.isArray(r.availableTools) ? r.availableTools.map((t) => t && typeof t.name === "string" ? t.name : null).filter((n) => n !== null) : [];
+      if (available.length === 0) continue;
+      const enabled = Array.isArray(r.enabledTools) ? new Set(r.enabledTools.filter((n) => typeof n === "string")) : null;
+      const kept = enabled === null ? available : available.filter((n) => enabled.has(n));
+      if (kept.length === 0) continue;
+      const toolNames = kept.map((n) => `${prefix}__${n}`);
+      const existing = mcpMap.get(r.agentId) ?? [];
+      existing.push({ slug: r.serverSlug, toolNames });
+      mcpMap.set(r.agentId, existing);
+    }
+  }
   function formatConnectorsTag(subAgentId) {
-    const list = connectorMap.get(subAgentId);
-    if (!list || list.length === 0) return "";
-    const parts = list.map((c) => `${c.slug} (${c.toolNames.join(", ")})`);
+    const conn = connectorMap.get(subAgentId);
+    const mcp = mcpMap.get(subAgentId);
+    const parts = [];
+    if (conn) parts.push(...conn.map((c) => `${c.slug} (${c.toolNames.join(", ")})`));
+    if (mcp) parts.push(...mcp.map((c) => `${c.slug} (${c.toolNames.join(", ")})`));
+    if (parts.length === 0) return "";
     return `
   Tools: ${parts.join("; ")}`;
   }
@@ -81960,7 +82056,12 @@ async function loadThreadHistory(opts) {
   let nextSynthId = 0;
   const blocks = [];
   for (const row of chronological) {
-    const assistant = extractAssistantReply(row);
+    const assistant = extractAssistantReply({
+      task: row.task,
+      result: row.result,
+      messages: row.messages,
+      channel: row.channel
+    });
     if (assistant === null) continue;
     const sendTool = CHANNEL_SEND_TOOL[row.channel];
     if (sendTool) {
@@ -82009,7 +82110,18 @@ function extractAssistantReply(row) {
   if (row.result !== null && row.result !== void 0 && row.result.trim() !== "") {
     return row.result;
   }
-  const messages = Array.isArray(row.messages) ? row.messages : [];
+  const allMessages = Array.isArray(row.messages) ? row.messages : [];
+  let currentStart = 0;
+  for (let i = allMessages.length - 1; i >= 0; i--) {
+    const m = allMessages[i];
+    if (!m || m.role !== "user") continue;
+    const c = m.content;
+    if (typeof c === "string" && c === row.task) {
+      currentStart = i;
+      break;
+    }
+  }
+  const messages = allMessages.slice(currentStart);
   const sendTool = CHANNEL_SEND_TOOL[row.channel];
   if (sendTool) {
     const parts = [];

package/web/.next/BUILD_ID

@@ -1 +1 @@
-GnQaz2FhfFL1-PYQfExPD
+1HpaEqSrARPvyPllAmQtF

package/web/.next/app-path-routes-manifest.json

@@ -11,19 +11,19 @@
   "/page": "/",
   "/(dashboard)/billing/page": "/billing",
   "/(dashboard)/agents/[id]/edit/page": "/agents/[id]/edit",
-  "/(dashboard)/agents/page": "/agents",
   "/(dashboard)/agents/[id]/telegram/page": "/agents/[id]/telegram",
-  "/(dashboard)/automations/page": "/automations",
+  "/(dashboard)/agents/page": "/agents",
   "/(dashboard)/approvals/page": "/approvals",
+  "/(dashboard)/automations/page": "/automations",
+  "/(dashboard)/connectors/page": "/connectors",
   "/(dashboard)/credentials/page": "/credentials",
+  "/(dashboard)/jobs/[id]/page": "/jobs/[id]",
   "/(dashboard)/jobs/page": "/jobs",
-  "/(dashboard)/mcp/page": "/mcp",
   "/(dashboard)/logs/page": "/logs",
+  "/(dashboard)/mcp/page": "/mcp",
   "/(dashboard)/memories/page": "/memories",
+  "/(dashboard)/settings/page": "/settings",
   "/(dashboard)/skills/[id]/edit/page": "/skills/[id]/edit",
   "/(dashboard)/skills/page": "/skills",
-  "/(dashboard)/jobs/[id]/page": "/jobs/[id]",
-  "/(dashboard)/settings/page": "/settings",
-  "/(dashboard)/connectors/page": "/connectors",
   "/(dashboard)/stats/page": "/stats"
 }

package/web/.next/build-manifest.json

@@ -4,8 +4,8 @@
   ],
   "devFiles": [],
   "lowPriorityFiles": [
-    "static/GnQaz2FhfFL1-PYQfExPD/_buildManifest.js",
-    "static/GnQaz2FhfFL1-PYQfExPD/_ssgManifest.js"
+    "static/1HpaEqSrARPvyPllAmQtF/_buildManifest.js",
+    "static/1HpaEqSrARPvyPllAmQtF/_ssgManifest.js"
   ],
   "rootMainFiles": [
     "static/chunks/webpack-821bd0359b891822.js",