@poolzin/pool-bot 2026.2.24 → 2026.2.26

package/dist/gateway/server-methods/agent.js

@@ -1,24 +1,99 @@
 import { randomUUID } from "node:crypto";
-import { agentCommand } from "../../commands/agent.js";
 import { listAgentIds } from "../../agents/agent-scope.js";
+import { BARE_SESSION_RESET_PROMPT } from "../../auto-reply/reply/session-reset-prompt.js";
+import { agentCommand } from "../../commands/agent.js";
 import { loadConfig } from "../../config/config.js";
 import { resolveAgentIdFromSessionKey, resolveExplicitAgentSessionKey, resolveAgentMainSessionKey, updateSessionStore, } from "../../config/sessions.js";
 import { registerAgentRunContext } from "../../infra/agent-events.js";
 import { resolveAgentDeliveryPlan, resolveAgentOutboundTarget, } from "../../infra/outbound/agent-delivery.js";
+import { classifySessionKeyShape, normalizeAgentId } from "../../routing/session-key.js";
 import { defaultRuntime } from "../../runtime.js";
+import { normalizeInputProvenance } from "../../sessions/input-provenance.js";
 import { resolveSendPolicy } from "../../sessions/send-policy.js";
 import { normalizeSessionDeliveryFields } from "../../utils/delivery-context.js";
 import { INTERNAL_MESSAGE_CHANNEL, isDeliverableMessageChannel, isGatewayMessageChannel, normalizeMessageChannel, } from "../../utils/message-channel.js";
-import { normalizeAgentId } from "../../routing/session-key.js";
+import { resolveAssistantIdentity } from "../assistant-identity.js";
 import { parseMessageWithAttachments } from "../chat-attachments.js";
+import { resolveAssistantAvatarUrl } from "../control-ui-shared.js";
+import { GATEWAY_CLIENT_CAPS, hasGatewayClientCap } from "../protocol/client-info.js";
 import { ErrorCodes, errorShape, formatValidationErrors, validateAgentIdentityParams, validateAgentParams, validateAgentWaitParams, } from "../protocol/index.js";
-import { loadSessionEntry } from "../session-utils.js";
+import { canonicalizeSpawnedByForAgent, loadSessionEntry, pruneLegacyStoreKeys, resolveGatewaySessionStoreTarget, } from "../session-utils.js";
 import { formatForLog } from "../ws-log.js";
-import { resolveAssistantIdentity } from "../assistant-identity.js";
-import { resolveAssistantAvatarUrl } from "../control-ui-shared.js";
 import { waitForAgentJob } from "./agent-job.js";
+import { injectTimestamp, timestampOptsFromConfig } from "./agent-timestamp.js";
+import { normalizeRpcAttachmentsToChatAttachments } from "./attachment-normalize.js";
+import { sessionsHandlers } from "./sessions.js";
+const RESET_COMMAND_RE = /^\/(new|reset)(?:\s+([\s\S]*))?$/i;
+function isGatewayErrorShape(value) {
+    if (!value || typeof value !== "object") {
+        return false;
+    }
+    const candidate = value;
+    return typeof candidate.code === "string" && typeof candidate.message === "string";
+}
+async function runSessionResetFromAgent(params) {
+    return await new Promise((resolve) => {
+        let settled = false;
+        const settle = (result) => {
+            if (settled) {
+                return;
+            }
+            settled = true;
+            resolve(result);
+        };
+        const respond = (ok, payload, error) => {
+            if (!ok) {
+                settle({
+                    ok: false,
+                    error: isGatewayErrorShape(error)
+                        ? error
+                        : errorShape(ErrorCodes.UNAVAILABLE, String(error ?? "sessions.reset failed")),
+                });
+                return;
+            }
+            const payloadObj = payload;
+            const key = typeof payloadObj?.key === "string" ? payloadObj.key : params.key;
+            const sessionId = payloadObj?.entry && typeof payloadObj.entry.sessionId === "string"
+                ? payloadObj.entry.sessionId
+                : undefined;
+            settle({ ok: true, key, sessionId });
+        };
+        const resetResult = sessionsHandlers["sessions.reset"]({
+            req: {
+                type: "req",
+                id: `${params.idempotencyKey}:reset`,
+                method: "sessions.reset",
+            },
+            params: {
+                key: params.key,
+                reason: params.reason,
+            },
+            context: params.context,
+            client: params.client,
+            isWebchatConnect: params.isWebchatConnect,
+            respond,
+        });
+        void (async () => {
+            try {
+                await resetResult;
+                if (!settled) {
+                    settle({
+                        ok: false,
+                        error: errorShape(ErrorCodes.UNAVAILABLE, "sessions.reset completed without returning a response"),
+                    });
+                }
+            }
+            catch (err) {
+                settle({
+                    ok: false,
+                    error: errorShape(ErrorCodes.UNAVAILABLE, String(err)),
+                });
+            }
+        })();
+    });
+}
 export const agentHandlers = {
-    agent: async ({ params, respond, context }) => {
+    agent: async ({ params, respond, context, client, isWebchatConnect }) => {
         const p = params;
         if (!validateAgentParams(p)) {
             respond(false, undefined, errorShape(ErrorCodes.INVALID_REQUEST, `invalid agent params: ${formatValidationErrors(validateAgentParams.errors)}`));
@@ -34,6 +109,7 @@ export const agentHandlers = {
         let resolvedGroupChannel = groupChannelRaw || undefined;
         let resolvedGroupSpace = groupSpaceRaw || undefined;
         let spawnedByValue = typeof request.spawnedBy === "string" ? request.spawnedBy.trim() : undefined;
+        const inputProvenance = normalizeInputProvenance(request.inputProvenance);
         const cached = context.dedupe.get(`agent:${idem}`);
         if (cached) {
             respond(cached.ok, cached.payload, cached.error, {
@@ -41,18 +117,7 @@ export const agentHandlers = {
             });
             return;
         }
-        const normalizedAttachments = request.attachments
-            ?.map((a) => ({
-            type: typeof a?.type === "string" ? a.type : undefined,
-            mimeType: typeof a?.mimeType === "string" ? a.mimeType : undefined,
-            fileName: typeof a?.fileName === "string" ? a.fileName : undefined,
-            content: typeof a?.content === "string"
-                ? a.content
-                : ArrayBuffer.isView(a?.content)
-                    ? Buffer.from(a.content.buffer, a.content.byteOffset, a.content.byteLength).toString("base64")
-                    : undefined,
-        }))
-            .filter((a) => a.content) ?? [];
+        const normalizedAttachments = normalizeRpcAttachmentsToChatAttachments(request.attachments);
         let message = request.message.trim();
         let images = [];
         if (normalizedAttachments.length > 0) {
@@ -93,7 +158,12 @@ export const agentHandlers = {
         const requestedSessionKeyRaw = typeof request.sessionKey === "string" && request.sessionKey.trim()
             ? request.sessionKey.trim()
             : undefined;
-        const requestedSessionKey = requestedSessionKeyRaw ??
+        if (requestedSessionKeyRaw &&
+            classifySessionKeyShape(requestedSessionKeyRaw) === "malformed_agent") {
+            respond(false, undefined, errorShape(ErrorCodes.INVALID_REQUEST, `invalid agent params: malformed session key "${requestedSessionKeyRaw}"`));
+            return;
+        }
+        let requestedSessionKey = requestedSessionKeyRaw ??
             resolveExplicitAgentSessionKey({
                 cfg,
                 agentId,
@@ -109,13 +179,51 @@ export const agentHandlers = {
         let sessionEntry;
         let bestEffortDeliver = false;
         let cfgForAgent;
+        let resolvedSessionKey = requestedSessionKey;
+        let skipTimestampInjection = false;
+        const resetCommandMatch = message.match(RESET_COMMAND_RE);
+        if (resetCommandMatch && requestedSessionKey) {
+            const resetReason = resetCommandMatch[1]?.toLowerCase() === "new" ? "new" : "reset";
+            const resetResult = await runSessionResetFromAgent({
+                key: requestedSessionKey,
+                reason: resetReason,
+                idempotencyKey: idem,
+                context,
+                client,
+                isWebchatConnect,
+            });
+            if (!resetResult.ok) {
+                respond(false, undefined, resetResult.error);
+                return;
+            }
+            requestedSessionKey = resetResult.key;
+            resolvedSessionId = resetResult.sessionId ?? resolvedSessionId;
+            const postResetMessage = resetCommandMatch[2]?.trim() ?? "";
+            if (postResetMessage) {
+                message = postResetMessage;
+            }
+            else {
+                // Keep bare /new and /reset behavior aligned with chat.send:
+                // reset first, then run a fresh-session greeting prompt in-place.
+                message = BARE_SESSION_RESET_PROMPT;
+                skipTimestampInjection = true;
+            }
+        }
+        // Inject timestamp into user-authored messages that don't already have one.
+        // Channel messages (Discord, Telegram, etc.) get timestamps via envelope
+        // formatting in a separate code path — they never reach this handler.
+        // See: https://github.com/moltbot/moltbot/issues/3658
+        if (!skipTimestampInjection) {
+            message = injectTimestamp(message, timestampOptsFromConfig(cfg));
+        }
         if (requestedSessionKey) {
             const { cfg, storePath, entry, canonicalKey } = loadSessionEntry(requestedSessionKey);
             cfgForAgent = cfg;
             const now = Date.now();
             const sessionId = entry?.sessionId ?? randomUUID();
             const labelValue = request.label?.trim() || entry?.label;
-            spawnedByValue = spawnedByValue || entry?.spawnedBy;
+            const sessionAgent = resolveAgentIdFromSessionKey(canonicalKey);
+            spawnedByValue = canonicalizeSpawnedByForAgent(cfg, sessionAgent, spawnedByValue || entry?.spawnedBy);
             let inheritedGroup;
             if (spawnedByValue && (!resolvedGroupId || !resolvedGroupChannel || !resolvedGroupSpace)) {
                 try {
@@ -151,6 +259,7 @@ export const agentHandlers = {
                 providerOverride: entry?.providerOverride,
                 label: labelValue,
                 spawnedBy: spawnedByValue,
+                spawnDepth: entry?.spawnDepth,
                 channel: entry?.channel ?? request.channel?.trim(),
                 groupId: resolvedGroupId ?? entry?.groupId,
                 groupChannel: resolvedGroupChannel ?? entry?.groupChannel,
@@ -162,7 +271,7 @@ export const agentHandlers = {
             const sendPolicy = resolveSendPolicy({
                 cfg,
                 entry,
-                sessionKey: requestedSessionKey,
+                sessionKey: canonicalKey,
                 channel: entry?.channel,
                 chatType: entry?.chatType,
             });
@@ -172,23 +281,47 @@ export const agentHandlers = {
             }
             resolvedSessionId = sessionId;
             const canonicalSessionKey = canonicalKey;
+            resolvedSessionKey = canonicalSessionKey;
             const agentId = resolveAgentIdFromSessionKey(canonicalSessionKey);
             const mainSessionKey = resolveAgentMainSessionKey({ cfg, agentId });
             if (storePath) {
                 await updateSessionStore(storePath, (store) => {
+                    const target = resolveGatewaySessionStoreTarget({
+                        cfg,
+                        key: requestedSessionKey,
+                        store,
+                    });
+                    pruneLegacyStoreKeys({
+                        store,
+                        canonicalKey: target.canonicalKey,
+                        candidates: target.storeKeys,
+                    });
                     store[canonicalSessionKey] = nextEntry;
                 });
             }
             if (canonicalSessionKey === mainSessionKey || canonicalSessionKey === "global") {
                 context.addChatRun(idem, {
-                    sessionKey: requestedSessionKey,
+                    sessionKey: canonicalSessionKey,
                     clientRunId: idem,
                 });
                 bestEffortDeliver = true;
             }
-            registerAgentRunContext(idem, { sessionKey: requestedSessionKey });
+            registerAgentRunContext(idem, { sessionKey: canonicalSessionKey });
         }
         const runId = idem;
+        const connId = typeof client?.connId === "string" ? client.connId : undefined;
+        const wantsToolEvents = hasGatewayClientCap(client?.connect?.caps, GATEWAY_CLIENT_CAPS.TOOL_EVENTS);
+        if (connId && wantsToolEvents) {
+            context.registerToolEventRecipient(runId, connId);
+            // Register for any other active runs *in the same session* so
+            // late-joining clients (e.g. page refresh mid-response) receive
+            // in-progress tool events without leaking cross-session data.
+            for (const [activeRunId, active] of context.chatAbortControllers) {
+                if (activeRunId !== runId && active.sessionKey === requestedSessionKey) {
+                    context.registerToolEventRecipient(activeRunId, connId);
+                }
+            }
+        }
         const wantsDelivery = request.deliver === true;
         const explicitTo = typeof request.replyTo === "string" && request.replyTo.trim()
             ? request.replyTo.trim()
@@ -241,7 +374,7 @@ export const agentHandlers = {
             images,
             to: resolvedTo,
             sessionId: resolvedSessionId,
-            sessionKey: requestedSessionKey,
+            sessionKey: resolvedSessionKey,
             thinking: request.thinking,
             deliver,
             deliveryTargetMode,
@@ -266,6 +399,7 @@ export const agentHandlers = {
             runId,
             lane: request.lane,
             extraSystemPrompt: request.extraSystemPrompt,
+            inputProvenance,
         }, defaultRuntime, context.deps)
             .then((result) => {
             const payload = {
@@ -312,6 +446,10 @@ export const agentHandlers = {
         const sessionKeyRaw = typeof p.sessionKey === "string" ? p.sessionKey.trim() : "";
         let agentId = agentIdRaw ? normalizeAgentId(agentIdRaw) : undefined;
         if (sessionKeyRaw) {
+            if (classifySessionKeyShape(sessionKeyRaw) === "malformed_agent") {
+                respond(false, undefined, errorShape(ErrorCodes.INVALID_REQUEST, `invalid agent.identity.get params: malformed session key "${sessionKeyRaw}"`));
+                return;
+            }
             const resolved = resolveAgentIdFromSessionKey(sessionKeyRaw);
             if (agentId && resolved !== agentId) {
                 respond(false, undefined, errorShape(ErrorCodes.INVALID_REQUEST, `invalid agent.identity.get params: agent "${agentIdRaw}" does not match session key agent "${resolved}"`));