@agent-native/core 0.7.4 → 0.7.7

package/dist/server/agent-chat-plugin.js

@@ -3,14 +3,14 @@ import { getSetting, putSetting } from "../settings/store.js";
 import { getH3App } from "./framework-request-handler.js";
 import { createProductionAgentHandler, runAgentLoop, actionsToEngineTools, getActiveRunForThreadAsync, abortRun, subscribeToRun, } from "../agent/production-agent.js";
 import { resolveEngine, createAnthropicEngine } from "../agent/engine/index.js";
-import { McpClientManager, loadMcpConfig, autoDetectMcpConfig, mcpToolsToActionEntries, } from "../mcp-client/index.js";
+import { McpClientManager, loadMcpConfig, autoDetectMcpConfig, mcpToolsToActionEntries, syncMcpActionEntries, mountMcpServersRoutes, mountMcpHubRoutes, buildMergedConfig, getHubStatus, isHubServeEnabled, } from "../mcp-client/index.js";
 import { discoverAgents } from "./agent-discovery.js";
 import { loadSchemaPromptBlock } from "./schema-prompt.js";
 import { buildAssistantMessage, extractThreadMeta, } from "../agent/thread-data-builder.js";
-import { defineEventHandler, setResponseStatus, setResponseHeader, getMethod, getQuery, } from "h3";
+import { defineEventHandler, setResponseStatus, setResponseHeader, getMethod, getQuery, getHeader, } from "h3";
 import { getSession } from "./auth.js";
 import { getOrigin } from "./google-oauth.js";
-import { createThread, getThread, listThreads, searchThreads, updateThreadData, deleteThread, } from "../chat-threads/store.js";
+import { createThread, getThread, listThreads, searchThreads, updateThreadData, withThreadDataLock, deleteThread, setThreadQueuedMessages, } from "../chat-threads/store.js";
 import { resourceListAccessible, resourceList, resourceGet, resourceGetByPath, ensurePersonalDefaults, SHARED_OWNER, } from "../resources/store.js";
 import nodePath from "node:path";
 import { readBody } from "./h3-helpers.js";
@@ -907,6 +907,8 @@ Resources can be personal (per-user) or shared (team-wide). By default, resource
 
 When the user gives instructions that should apply to all users/sessions, update the shared "AGENTS.md" resource.
 
+**Resources are NOT an agent scratchpad.** Never use \`resource-write\` to store executable scripts, task plans, retry notes, or work-in-progress files you're writing to yourself. Specifically, do NOT create resources under \`scripts/\` or \`tasks/\` unless the user explicitly asked for a file at that path, or a tool (like \`create-job\` or \`spawn-task\`) writes there as part of its contract. If you can't complete a task with the tools you have, say so — don't improvise by leaving behind \`FINAL-*.md\`, \`EXECUTE-NOW-*.js\`, or similar artifacts. Resources are visible to the user in the workspace sidebar; every file you write is something they'll see and have to clean up.
+
 ### Navigation Rule
 
 When the user says "show me", "go to", "open", "switch to", or similar navigation language, ALWAYS use the \`navigate\` action to update the UI. The user expects to SEE the result in the main app, not just read it in chat. Navigate first, then fetch/display data.
@@ -1357,6 +1359,22 @@ export function createAgentChatPlugin(options) {
         // this, requests can race ahead of the bootstrap and hit the SSR catch-all.
         const { awaitBootstrap } = await import("./framework-request-handler.js");
         await awaitBootstrap(nitroApp);
+        // Reap phantom runs left over from the previous process (HMR restart,
+        // process crash, isolate eviction). Any run whose heartbeat is already
+        // stale by startup time had a dead producer; mark it errored so the
+        // next /runs/active check returns a terminal status and reconnecting
+        // clients don't spin on "Thinking...". Runs owned by OTHER live
+        // isolates are protected by their fresh heartbeats.
+        try {
+            const { reapAllStaleRuns } = await import("../agent/run-store.js");
+            const reaped = await reapAllStaleRuns();
+            if (reaped > 0) {
+                console.log(`[agent-chat] reaped ${reaped} stale run(s) on startup`);
+            }
+        }
+        catch {
+            // Best effort — don't block plugin init if SQL isn't ready yet.
+        }
         const env = process.env.NODE_ENV;
         // AGENT_MODE=production forces production agent constraints even in dev
         const canToggle = (env === "development" || env === "test") &&
@@ -1385,22 +1403,27 @@ export function createAgentChatPlugin(options) {
         // `canToggle` means "this environment allows toggling" (static); this
         // function means "the user currently has dev mode ON" (live).
         const isDevMode = () => currentDevMode;
-        // Initialize MCP client (connects to user-configured local MCP servers).
-        // Graceful-degrade: any failure yields zero MCP tools and agent-chat keeps
-        // working as before. No-op outside Node runtimes.
-        let mcpConfig = loadMcpConfig();
+        // Initialize MCP client. Merges file/env config + auto-detected binaries
+        // + any remote servers users have added through the settings UI (persisted
+        // in the settings table, scanned across all scopes so we never drop
+        // another user's entries). Graceful-degrade: any failure yields zero MCP
+        // tools and agent-chat keeps working as before.
+        let mcpConfig = await buildMergedConfig().catch((err) => {
+            console.warn(`[mcp-client] buildMergedConfig failed: ${err?.message ?? err}`);
+            return null;
+        });
         if (!mcpConfig) {
-            mcpConfig = autoDetectMcpConfig();
-            if (mcpConfig) {
-                const detected = Object.keys(mcpConfig.servers).join(", ");
-                console.log(`[mcp-client] auto-detected ${detected}, registering as MCP server — set AGENT_NATIVE_DISABLE_MCP_AUTODETECT=1 to opt out`);
+            const fileOrEnv = loadMcpConfig() ?? autoDetectMcpConfig();
+            mcpConfig = fileOrEnv;
+            if (mcpConfig?.source) {
+                console.log(`[mcp-client] loaded config from ${mcpConfig.source} (${Object.keys(mcpConfig.servers).length} server(s))`);
             }
             else {
-                console.log("[mcp-client] no mcp.config.json and no auto-detectable servers — skipping MCP tools");
+                console.log("[mcp-client] no configured MCP servers — skipping MCP tools");
             }
         }
         else if (mcpConfig.source) {
-            console.log(`[mcp-client] loaded config from ${mcpConfig.source} (${Object.keys(mcpConfig.servers).length} server(s))`);
+            console.log(`[mcp-client] merged config (${Object.keys(mcpConfig.servers).length} server(s), source: ${mcpConfig.source})`);
         }
         const mcpManager = new McpClientManager(mcpConfig);
         try {
@@ -1411,8 +1434,22 @@ export function createAgentChatPlugin(options) {
         }
         setGlobalMcpManager(mcpManager);
         const mcpActionEntries = mcpToolsToActionEntries(mcpManager);
-        // Mount status route so tooling/onboarding can inspect MCP state.
+        // Mount status + management routes so the settings UI can list / add /
+        // remove remote MCP servers and hot-reload the running manager.
         mountMcpStatusRoute(nitroApp, mcpManager);
+        mountMcpServersRoutes(nitroApp, mcpManager);
+        // Hub-serve: expose org-scope servers to other agent-native apps in the
+        // workspace when `AGENT_NATIVE_MCP_HUB_TOKEN` is set (dispatch, by
+        // convention). Gated by the env var so mounting is a no-op otherwise.
+        if (isHubServeEnabled()) {
+            mountMcpHubRoutes(nitroApp);
+            console.log("[mcp-client] hub serve enabled — other apps can pull org servers via /_agent-native/mcp/hub/servers");
+        }
+        const hubStatus = getHubStatus();
+        if (hubStatus.consuming) {
+            console.log(`[mcp-client] hub consume enabled — pulling from ${hubStatus.hubUrl}`);
+        }
+        mountMcpHubStatusRoute(nitroApp);
         // Ensure we tear down child processes if the host shuts down cleanly.
         if (typeof process !== "undefined" &&
             typeof process.once === "function" &&
@@ -1872,53 +1909,71 @@ export function createAgentChatPlugin(options) {
         const onRunComplete = async (run, threadId) => {
             if (!threadId)
                 return;
-            try {
-                const thread = await getThread(threadId);
-                if (!thread)
-                    return;
-                const assistantMsg = buildAssistantMessage(run.events ?? [], run.runId);
-                if (!assistantMsg) {
-                    // No content produced — just bump timestamp
-                    await updateThreadData(threadId, thread.threadData, thread.title, thread.preview, thread.messageCount);
-                    return;
-                }
-                // Parse existing thread_data, append assistant message only if
-                // the frontend hasn't already saved it (avoids duplicates when
-                // the client is still connected during a normal flow).
-                let repo;
+            // Serialize the read-modify-write against the same thread's other
+            // `thread_data` writers (setThreadQueuedMessages, setThreadEngineMeta,
+            // the frontend-triggered saves below). Without the lock, a concurrent
+            // queued-message save can clobber the assistant message we just
+            // appended here, or vice versa.
+            await withThreadDataLock(threadId, async () => {
                 try {
-                    repo = JSON.parse(thread.threadData || "{}");
+                    const thread = await getThread(threadId);
+                    if (!thread)
+                        return;
+                    const assistantMsg = buildAssistantMessage(run.events ?? [], run.runId);
+                    if (!assistantMsg) {
+                        // No content produced — just bump timestamp
+                        await updateThreadData(threadId, thread.threadData, thread.title, thread.preview, thread.messageCount);
+                        return;
+                    }
+                    // Parse existing thread_data, append assistant message only if
+                    // the frontend hasn't already saved it (avoids duplicates when
+                    // the client is still connected during a normal flow).
+                    let repo;
+                    try {
+                        repo = JSON.parse(thread.threadData || "{}");
+                    }
+                    catch {
+                        repo = {};
+                    }
+                    if (!Array.isArray(repo.messages))
+                        repo.messages = [];
+                    const lastMsg = repo.messages[repo.messages.length - 1];
+                    // Check both wrapped ({ message: { role } }) and unwrapped ({ role }) formats
+                    const lastRole = lastMsg?.message?.role ?? lastMsg?.role;
+                    const lastContent = lastMsg?.message?.content ?? lastMsg?.content;
+                    const lastContentIsEmpty = Array.isArray(lastContent)
+                        ? lastContent.length === 0
+                        : lastContent == null || lastContent === "";
+                    if (lastRole === "assistant" && !lastContentIsEmpty) {
+                        // Frontend already saved the assistant response — just bump timestamp
+                        await updateThreadData(threadId, thread.threadData, thread.title, thread.preview, thread.messageCount);
+                        return;
+                    }
+                    if (lastRole === "assistant" && lastContentIsEmpty) {
+                        // The frontend wrote an empty assistant placeholder before the stream
+                        // had any content (common when the user reloads mid-run, and the 5s
+                        // periodic save raced with the first text chunk). Replace it with
+                        // the server's reconstructed message so the turn isn't lost.
+                        repo.messages.pop();
+                    }
+                    // Determine if repo uses wrapped format ({ message, parentId }) or flat format
+                    const isWrapped = lastMsg && "message" in lastMsg;
+                    if (isWrapped) {
+                        const parentId = repo.messages.length > 0
+                            ? (repo.messages[repo.messages.length - 1].message?.id ?? null)
+                            : null;
+                        repo.messages.push({ message: assistantMsg, parentId });
+                    }
+                    else {
+                        repo.messages.push(assistantMsg);
+                    }
+                    const meta = extractThreadMeta(repo);
+                    await updateThreadData(threadId, JSON.stringify(repo), meta.title || thread.title, meta.preview || thread.preview, repo.messages.length);
                 }
                 catch {
-                    repo = {};
-                }
-                if (!Array.isArray(repo.messages))
-                    repo.messages = [];
-                const lastMsg = repo.messages[repo.messages.length - 1];
-                // Check both wrapped ({ message: { role } }) and unwrapped ({ role }) formats
-                const lastRole = lastMsg?.message?.role ?? lastMsg?.role;
-                if (lastRole === "assistant") {
-                    // Frontend already saved the assistant response — just bump timestamp
-                    await updateThreadData(threadId, thread.threadData, thread.title, thread.preview, thread.messageCount);
-                    return;
-                }
-                // Determine if repo uses wrapped format ({ message, parentId }) or flat format
-                const isWrapped = lastMsg && "message" in lastMsg;
-                if (isWrapped) {
-                    const parentId = repo.messages.length > 0
-                        ? (repo.messages[repo.messages.length - 1].message?.id ?? null)
-                        : null;
-                    repo.messages.push({ message: assistantMsg, parentId });
-                }
-                else {
-                    repo.messages.push(assistantMsg);
+                    // Best-effort — don't break cleanup
                 }
-                const meta = extractThreadMeta(repo);
-                await updateThreadData(threadId, JSON.stringify(repo), meta.title || thread.title, meta.preview || thread.preview, repo.messages.length);
-            }
-            catch {
-                // Best-effort — don't break cleanup
-            }
+            });
         };
         // ─── Agent Teams: per-run send reference ─────────────────────────
         // Team tools need to emit events to the parent chat's SSE stream.
@@ -1991,6 +2046,13 @@ export function createAgentChatPlugin(options) {
             ...browserTools,
             ...mcpActionEntries,
         };
+        // Keep the prod action dict's MCP entries in sync when the manager's
+        // server set changes at runtime (e.g. a user adds a remote MCP server
+        // through the settings UI). getEngineTools() in production-agent re-reads
+        // the registry per request, so updates here propagate without restart.
+        mcpManager.onChange(() => {
+            syncMcpActionEntries(mcpManager, prodActions);
+        });
         // Always build the production handler (includes resource tools + call-agent + team tools)
         // In production mode (!canToggle), enable usage tracking and limits
         const isHostedProd = !canToggle;
@@ -2006,6 +2068,11 @@ export function createAgentChatPlugin(options) {
                 return "";
             }
         };
+        const leanPrompt = options?.leanPrompt === true;
+        // Lean mode: use only the template's systemPrompt + actions list.
+        // Skip resource loading, schema block, and extraContext — those add
+        // DB round-trips and tokens that minimal/voice apps don't need.
+        const leanBasePrompt = (options?.systemPrompt ?? "") + prodActionsPrompt;
         const prodHandler = createProductionAgentHandler({
             actions: prodActions,
             systemPrompt: async (event) => {
@@ -2014,6 +2081,10 @@ export function createAgentChatPlugin(options) {
                 _currentRunOwner = owner;
                 const { getOwnerAnthropicApiKey } = await import("../agent/production-agent.js");
                 _currentRunUserApiKey = await getOwnerAnthropicApiKey(owner);
+                if (leanPrompt) {
+                    _currentRunSystemPrompt = leanBasePrompt;
+                    return _currentRunSystemPrompt;
+                }
                 const resources = await loadResourcesForPrompt(owner);
                 const schemaBlock = await buildSchemaBlock(owner, false);
                 const extra = await resolveExtraContext(event, owner);
@@ -2023,6 +2094,7 @@ export function createAgentChatPlugin(options) {
             model: options?.model ??
                 (isHostedProd ? "claude-haiku-4-5-20251001" : undefined),
             apiKey: options?.apiKey,
+            skipFilesContext: leanPrompt,
             onRunStart: (send, threadId) => {
                 _runSendByThread.set(threadId, send);
                 _currentRunThreadId = threadId;
@@ -2046,17 +2118,30 @@ export function createAgentChatPlugin(options) {
             // how Claude Code works locally and dramatically reduces the rate of
             // degenerate empty-object tool calls. The CLI syntax for each action is
             // listed in the dev system prompt's "Available Actions" section.
-            const devActions = {
-                ...resourceScripts,
-                ...docsScripts,
-                ...chatScripts,
-                ...callAgentScript,
-                ...teamTools,
-                ...jobTools,
-                ...browserTools,
-                ...mcpActionEntries,
-                ...(await createDevScriptRegistry()),
-            };
+            // In lean mode, expose the template's actions directly as native tools
+            // instead of routing through shell — the lean system prompt has no
+            // shell-usage guidance, so shell-based action invocation would break.
+            const devActions = leanPrompt
+                ? prodActions
+                : {
+                    ...resourceScripts,
+                    ...docsScripts,
+                    ...chatScripts,
+                    ...callAgentScript,
+                    ...teamTools,
+                    ...jobTools,
+                    ...browserTools,
+                    ...mcpActionEntries,
+                    ...(await createDevScriptRegistry()),
+                };
+            // Keep dev action dict in sync with runtime MCP additions. When
+            // leanPrompt is true, devActions === prodActions so the prod listener
+            // already covers it.
+            if (devActions !== prodActions) {
+                mcpManager.onChange(() => {
+                    syncMcpActionEntries(mcpManager, devActions);
+                });
+            }
             devHandler = createProductionAgentHandler({
                 actions: devActions,
                 systemPrompt: async (event) => {
@@ -2065,6 +2150,10 @@ export function createAgentChatPlugin(options) {
                     _currentRunOwner = owner;
                     const { getOwnerAnthropicApiKey } = await import("../agent/production-agent.js");
                     _currentRunUserApiKey = await getOwnerAnthropicApiKey(owner);
+                    if (leanPrompt) {
+                        _currentRunSystemPrompt = leanBasePrompt;
+                        return _currentRunSystemPrompt;
+                    }
                     const resources = await loadResourcesForPrompt(owner);
                     const schemaBlock = await buildSchemaBlock(owner, true);
                     const extra = await resolveExtraContext(event, owner);
@@ -2073,6 +2162,7 @@ export function createAgentChatPlugin(options) {
                 },
                 model: options?.model,
                 apiKey: options?.apiKey,
+                skipFilesContext: leanPrompt,
                 onRunStart: (send, threadId) => {
                     _runSendByThread.set(threadId, send);
                     _currentRunThreadId = threadId;
@@ -2624,6 +2714,7 @@ export function createAgentChatPlugin(options) {
                     runId: run.runId,
                     threadId: run.threadId,
                     status: run.status,
+                    heartbeatAt: run.heartbeatAt,
                 };
             }
             setResponseStatus(event, 405);
@@ -2657,13 +2748,60 @@ export function createAgentChatPlugin(options) {
                     return thread;
                 }
                 if (method === "PUT") {
+                    // Hold the thread_data lock for the full read-modify-write so
+                    // periodic saves from the frontend don't race with
+                    // onRunComplete / setThreadQueuedMessages / setThreadEngineMeta.
+                    // Without the lock, a client save that lands during an agent
+                    // run could clobber the assistant message the server just
+                    // appended (and vice versa).
+                    return await withThreadDataLock(threadId, async () => {
+                        const thread = await getThread(threadId);
+                        if (!thread || thread.ownerEmail !== owner) {
+                            setResponseStatus(event, 404);
+                            return { error: "Thread not found" };
+                        }
+                        const body = await readBody(event);
+                        let newThreadData = body.threadData || thread.threadData;
+                        // Preserve queuedMessages from the existing thread_data when the
+                        // incoming blob doesn't include it. Periodic full-thread saves
+                        // (exported via threadRuntime.export) don't carry the queue, and
+                        // we don't want them to clobber queued-message state persisted
+                        // via POST /threads/:id/queued.
+                        if (body.threadData) {
+                            try {
+                                const existing = JSON.parse(thread.threadData);
+                                if (existing.queuedMessages !== undefined) {
+                                    const incoming = JSON.parse(newThreadData);
+                                    if (incoming.queuedMessages === undefined) {
+                                        incoming.queuedMessages = existing.queuedMessages;
+                                        newThreadData = JSON.stringify(incoming);
+                                    }
+                                }
+                            }
+                            catch {
+                                // Invalid JSON in either side — fall back to raw body blob.
+                            }
+                        }
+                        await updateThreadData(threadId, newThreadData, body.title ?? thread.title, body.preview ?? thread.preview, body.messageCount || thread.messageCount);
+                        return { ok: true };
+                    });
+                }
+                // POST /threads/:id/queued — debounced writes from the client
+                // when the user adds/removes/dequeues a queued message. Keeps
+                // queued messages durable across reloads without piggybacking
+                // on full-thread saves.
+                if (method === "POST" &&
+                    /\/threads\/[^/?]+\/queued/.test(event.node?.req?.url || event.path || "")) {
                     const thread = await getThread(threadId);
                     if (!thread || thread.ownerEmail !== owner) {
                         setResponseStatus(event, 404);
                         return { error: "Thread not found" };
                     }
                     const body = await readBody(event);
-                    await updateThreadData(threadId, body.threadData || thread.threadData, body.title ?? thread.title, body.preview ?? thread.preview, body.messageCount || thread.messageCount);
+                    const queued = Array.isArray(body?.queuedMessages)
+                        ? body.queuedMessages
+                        : [];
+                    await setThreadQueuedMessages(threadId, queued);
                     return { ok: true };
                 }
                 if (method === "DELETE") {
@@ -2739,7 +2877,18 @@ export function createAgentChatPlugin(options) {
             else {
                 delete process.env.AGENT_ORG_ID;
             }
-            return runWithRequestContext({ userEmail: owner, orgId: resolvedOrgId }, () => {
+            // Propagate the caller's IANA timezone from `x-user-timezone` so that
+            // tool calls made by the agent (e.g. log-meal with no explicit date)
+            // resolve "today" in the user's local timezone instead of server UTC.
+            const tzRaw = getHeader(event, "x-user-timezone");
+            const timezone = typeof tzRaw === "string" &&
+                tzRaw.trim().length > 0 &&
+                tzRaw.trim().length < 64
+                ? tzRaw.trim()
+                : undefined;
+            if (timezone)
+                process.env.AGENT_USER_TIMEZONE = timezone;
+            return runWithRequestContext({ userEmail: owner, orgId: resolvedOrgId, timezone }, () => {
                 const handler = currentDevMode && devHandler ? devHandler : prodHandler;
                 return handler(event);
             });
@@ -2800,6 +2949,24 @@ function setGlobalMcpManager(manager) {
 export function getGlobalMcpManager() {
     return _globalMcpManager;
 }
+function mountMcpHubStatusRoute(nitroApp) {
+    if (globalThis.__agentNativeMcpHubStatusMounted)
+        return;
+    globalThis.__agentNativeMcpHubStatusMounted = true;
+    try {
+        getH3App(nitroApp).use("/_agent-native/mcp/hub/status", defineEventHandler(async (event) => {
+            if (getMethod(event) !== "GET") {
+                setResponseStatus(event, 405);
+                return { error: "Method not allowed" };
+            }
+            setResponseHeader(event, "Content-Type", "application/json");
+            return getHubStatus();
+        }));
+    }
+    catch (err) {
+        console.warn(`[mcp-client] Failed to mount /_agent-native/mcp/hub/status: ${err?.message ?? err}`);
+    }
+}
 function mountMcpStatusRoute(nitroApp, manager) {
     // Idempotent — agent-chat-plugin can be invoked once per process; guard anyway.
     if (globalThis.__agentNativeMcpStatusMounted)