@poolzin/pool-bot 2026.2.23 → 2026.2.25

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

@@ -1,34 +1,220 @@
-import { randomUUID } from "node:crypto";
 import fs from "node:fs";
 import path from "node:path";
-import { CURRENT_SESSION_VERSION } from "@mariozechner/pi-coding-agent";
+import { CURRENT_SESSION_VERSION, SessionManager } from "@mariozechner/pi-coding-agent";
 import { resolveSessionAgentId } from "../../agents/agent-scope.js";
-import { resolveEffectiveMessagesConfig, resolveIdentityName } from "../../agents/identity.js";
 import { resolveThinkingDefault } from "../../agents/model-selection.js";
 import { resolveAgentTimeoutMs } from "../../agents/timeout.js";
 import { dispatchInboundMessage } from "../../auto-reply/dispatch.js";
 import { createReplyDispatcher } from "../../auto-reply/reply/reply-dispatcher.js";
-import { extractShortModelName, } from "../../auto-reply/reply/response-prefix-template.js";
+import { createReplyPrefixOptions } from "../../channels/reply-prefix.js";
+import { resolveSessionFilePath } from "../../config/sessions.js";
 import { resolveSendPolicy } from "../../sessions/send-policy.js";
 import { INTERNAL_MESSAGE_CHANNEL } from "../../utils/message-channel.js";
 import { abortChatRunById, abortChatRunsForSessionKey, isChatStopCommandText, resolveChatRunExpiresAtMs, } from "../chat-abort.js";
 import { parseMessageWithAttachments } from "../chat-attachments.js";
+import { stripEnvelopeFromMessages } from "../chat-sanitize.js";
+import { GATEWAY_CLIENT_CAPS, hasGatewayClientCap } from "../protocol/client-info.js";
 import { ErrorCodes, errorShape, formatValidationErrors, validateChatAbortParams, validateChatHistoryParams, validateChatInjectParams, validateChatSendParams, } from "../protocol/index.js";
 import { getMaxChatHistoryMessagesBytes } from "../server-constants.js";
 import { capArrayByJsonBytes, loadSessionEntry, readSessionMessages, resolveSessionModelRef, } from "../session-utils.js";
-import { stripEnvelopeFromMessages } from "../chat-sanitize.js";
 import { formatForLog } from "../ws-log.js";
+import { injectTimestamp, timestampOptsFromConfig } from "./agent-timestamp.js";
+import { normalizeRpcAttachmentsToChatAttachments } from "./attachment-normalize.js";
+const CHAT_HISTORY_TEXT_MAX_CHARS = 12_000;
+const CHAT_HISTORY_MAX_SINGLE_MESSAGE_BYTES = 128 * 1024;
+const CHAT_HISTORY_OVERSIZED_PLACEHOLDER = "[chat.history omitted: message too large]";
+let chatHistoryPlaceholderEmitCount = 0;
+function stripDisallowedChatControlChars(message) {
+    let output = "";
+    for (const char of message) {
+        const code = char.charCodeAt(0);
+        if (code === 9 || code === 10 || code === 13 || (code >= 32 && code !== 127)) {
+            output += char;
+        }
+    }
+    return output;
+}
+export function sanitizeChatSendMessageInput(message) {
+    const normalized = message.normalize("NFC");
+    if (normalized.includes("\u0000")) {
+        return { ok: false, error: "message must not contain null bytes" };
+    }
+    return { ok: true, message: stripDisallowedChatControlChars(normalized) };
+}
+function truncateChatHistoryText(text) {
+    if (text.length <= CHAT_HISTORY_TEXT_MAX_CHARS) {
+        return { text, truncated: false };
+    }
+    return {
+        text: `${text.slice(0, CHAT_HISTORY_TEXT_MAX_CHARS)}\n...(truncated)...`,
+        truncated: true,
+    };
+}
+function sanitizeChatHistoryContentBlock(block) {
+    if (!block || typeof block !== "object") {
+        return { block, changed: false };
+    }
+    const entry = { ...block };
+    let changed = false;
+    if (typeof entry.text === "string") {
+        const res = truncateChatHistoryText(entry.text);
+        entry.text = res.text;
+        changed ||= res.truncated;
+    }
+    if (typeof entry.partialJson === "string") {
+        const res = truncateChatHistoryText(entry.partialJson);
+        entry.partialJson = res.text;
+        changed ||= res.truncated;
+    }
+    if (typeof entry.arguments === "string") {
+        const res = truncateChatHistoryText(entry.arguments);
+        entry.arguments = res.text;
+        changed ||= res.truncated;
+    }
+    if (typeof entry.thinking === "string") {
+        const res = truncateChatHistoryText(entry.thinking);
+        entry.thinking = res.text;
+        changed ||= res.truncated;
+    }
+    if ("thinkingSignature" in entry) {
+        delete entry.thinkingSignature;
+        changed = true;
+    }
+    const type = typeof entry.type === "string" ? entry.type : "";
+    if (type === "image" && typeof entry.data === "string") {
+        const bytes = Buffer.byteLength(entry.data, "utf8");
+        delete entry.data;
+        entry.omitted = true;
+        entry.bytes = bytes;
+        changed = true;
+    }
+    return { block: changed ? entry : block, changed };
+}
+function sanitizeChatHistoryMessage(message) {
+    if (!message || typeof message !== "object") {
+        return { message, changed: false };
+    }
+    const entry = { ...message };
+    let changed = false;
+    if ("details" in entry) {
+        delete entry.details;
+        changed = true;
+    }
+    if ("usage" in entry) {
+        delete entry.usage;
+        changed = true;
+    }
+    if ("cost" in entry) {
+        delete entry.cost;
+        changed = true;
+    }
+    if (typeof entry.content === "string") {
+        const res = truncateChatHistoryText(entry.content);
+        entry.content = res.text;
+        changed ||= res.truncated;
+    }
+    else if (Array.isArray(entry.content)) {
+        const updated = entry.content.map((block) => sanitizeChatHistoryContentBlock(block));
+        if (updated.some((item) => item.changed)) {
+            entry.content = updated.map((item) => item.block);
+            changed = true;
+        }
+    }
+    if (typeof entry.text === "string") {
+        const res = truncateChatHistoryText(entry.text);
+        entry.text = res.text;
+        changed ||= res.truncated;
+    }
+    return { message: changed ? entry : message, changed };
+}
+function sanitizeChatHistoryMessages(messages) {
+    if (messages.length === 0) {
+        return messages;
+    }
+    let changed = false;
+    const next = messages.map((message) => {
+        const res = sanitizeChatHistoryMessage(message);
+        changed ||= res.changed;
+        return res.message;
+    });
+    return changed ? next : messages;
+}
+function jsonUtf8Bytes(value) {
+    try {
+        return Buffer.byteLength(JSON.stringify(value), "utf8");
+    }
+    catch {
+        return Buffer.byteLength(String(value), "utf8");
+    }
+}
+function buildOversizedHistoryPlaceholder(message) {
+    const role = message &&
+        typeof message === "object" &&
+        typeof message.role === "string"
+        ? message.role
+        : "assistant";
+    const timestamp = message &&
+        typeof message === "object" &&
+        typeof message.timestamp === "number"
+        ? message.timestamp
+        : Date.now();
+    return {
+        role,
+        timestamp,
+        content: [{ type: "text", text: CHAT_HISTORY_OVERSIZED_PLACEHOLDER }],
+        __poolbot: { truncated: true, reason: "oversized" },
+    };
+}
+function replaceOversizedChatHistoryMessages(params) {
+    const { messages, maxSingleMessageBytes } = params;
+    if (messages.length === 0) {
+        return { messages, replacedCount: 0 };
+    }
+    let replacedCount = 0;
+    const next = messages.map((message) => {
+        if (jsonUtf8Bytes(message) <= maxSingleMessageBytes) {
+            return message;
+        }
+        replacedCount += 1;
+        return buildOversizedHistoryPlaceholder(message);
+    });
+    return { messages: replacedCount > 0 ? next : messages, replacedCount };
+}
+function enforceChatHistoryFinalBudget(params) {
+    const { messages, maxBytes } = params;
+    if (messages.length === 0) {
+        return { messages, placeholderCount: 0 };
+    }
+    if (jsonUtf8Bytes(messages) <= maxBytes) {
+        return { messages, placeholderCount: 0 };
+    }
+    const last = messages.at(-1);
+    if (last && jsonUtf8Bytes([last]) <= maxBytes) {
+        return { messages: [last], placeholderCount: 0 };
+    }
+    const placeholder = buildOversizedHistoryPlaceholder(last);
+    if (jsonUtf8Bytes([placeholder]) <= maxBytes) {
+        return { messages: [placeholder], placeholderCount: 1 };
+    }
+    return { messages: [], placeholderCount: 0 };
+}
 function resolveTranscriptPath(params) {
-    const { sessionId, storePath, sessionFile } = params;
-    if (sessionFile)
-        return sessionFile;
-    if (!storePath)
+    const { sessionId, storePath, sessionFile, agentId } = params;
+    if (!storePath && !sessionFile) {
         return null;
-    return path.join(path.dirname(storePath), `${sessionId}.jsonl`);
+    }
+    try {
+        const sessionsDir = storePath ? path.dirname(storePath) : undefined;
+        return resolveSessionFilePath(sessionId, sessionFile ? { sessionFile } : undefined, sessionsDir || agentId ? { sessionsDir, agentId } : undefined);
+    }
+    catch {
+        return null;
+    }
 }
 function ensureTranscriptFile(params) {
-    if (fs.existsSync(params.transcriptPath))
+    if (fs.existsSync(params.transcriptPath)) {
         return { ok: true };
+    }
     try {
         fs.mkdirSync(path.dirname(params.transcriptPath), { recursive: true });
         const header = {
@@ -38,18 +224,40 @@ function ensureTranscriptFile(params) {
             timestamp: new Date().toISOString(),
             cwd: process.cwd(),
         };
-        fs.writeFileSync(params.transcriptPath, `${JSON.stringify(header)}\n`, "utf-8");
+        fs.writeFileSync(params.transcriptPath, `${JSON.stringify(header)}\n`, {
+            encoding: "utf-8",
+            mode: 0o600,
+        });
         return { ok: true };
     }
     catch (err) {
         return { ok: false, error: err instanceof Error ? err.message : String(err) };
     }
 }
+function transcriptHasIdempotencyKey(transcriptPath, idempotencyKey) {
+    try {
+        const lines = fs.readFileSync(transcriptPath, "utf-8").split(/\r?\n/);
+        for (const line of lines) {
+            if (!line.trim()) {
+                continue;
+            }
+            const parsed = JSON.parse(line);
+            if (parsed?.message?.idempotencyKey === idempotencyKey) {
+                return true;
+            }
+        }
+        return false;
+    }
+    catch {
+        return false;
+    }
+}
 function appendAssistantTranscriptMessage(params) {
     const transcriptPath = resolveTranscriptPath({
         sessionId: params.sessionId,
         storePath: params.storePath,
         sessionFile: params.sessionFile,
+        agentId: params.agentId,
     });
     if (!transcriptPath) {
         return { ok: false, error: "transcript path not resolved" };
@@ -66,29 +274,134 @@ function appendAssistantTranscriptMessage(params) {
             return { ok: false, error: ensured.error ?? "failed to create transcript file" };
         }
     }
+    if (params.idempotencyKey && transcriptHasIdempotencyKey(transcriptPath, params.idempotencyKey)) {
+        return { ok: true };
+    }
     const now = Date.now();
-    const messageId = randomUUID().slice(0, 8);
     const labelPrefix = params.label ? `[${params.label}]\n\n` : "";
+    const usage = {
+        input: 0,
+        output: 0,
+        cacheRead: 0,
+        cacheWrite: 0,
+        totalTokens: 0,
+        cost: {
+            input: 0,
+            output: 0,
+            cacheRead: 0,
+            cacheWrite: 0,
+            total: 0,
+        },
+    };
     const messageBody = {
         role: "assistant",
         content: [{ type: "text", text: `${labelPrefix}${params.message}` }],
         timestamp: now,
-        stopReason: "injected",
-        usage: { input: 0, output: 0, totalTokens: 0 },
-    };
-    const transcriptEntry = {
-        type: "message",
-        id: messageId,
-        timestamp: new Date(now).toISOString(),
-        message: messageBody,
+        // Pi stopReason is a strict enum; this is not model output, but we still store it as a
+        // normal assistant message so it participates in the session parentId chain.
+        stopReason: "stop",
+        usage,
+        // Make these explicit so downstream tooling never treats this as model output.
+        api: "openai-responses",
+        provider: "poolbot",
+        model: "gateway-injected",
+        ...(params.idempotencyKey ? { idempotencyKey: params.idempotencyKey } : {}),
+        ...(params.abortMeta
+            ? {
+                poolbotAbort: {
+                    aborted: true,
+                    origin: params.abortMeta.origin,
+                    runId: params.abortMeta.runId,
+                },
+            }
+            : {}),
     };
     try {
-        fs.appendFileSync(transcriptPath, `${JSON.stringify(transcriptEntry)}\n`, "utf-8");
+        // IMPORTANT: Use SessionManager so the entry is attached to the current leaf via parentId.
+        // Raw jsonl appends break the parent chain and can hide compaction summaries from context.
+        const sessionManager = SessionManager.open(transcriptPath);
+        const messageId = sessionManager.appendMessage(messageBody);
+        return { ok: true, messageId, message: messageBody };
     }
     catch (err) {
         return { ok: false, error: err instanceof Error ? err.message : String(err) };
     }
-    return { ok: true, messageId, message: transcriptEntry.message };
+}
+function collectSessionAbortPartials(params) {
+    const out = [];
+    for (const [runId, active] of params.chatAbortControllers) {
+        if (active.sessionKey !== params.sessionKey) {
+            continue;
+        }
+        const text = params.chatRunBuffers.get(runId);
+        if (!text || !text.trim()) {
+            continue;
+        }
+        out.push({
+            runId,
+            sessionId: active.sessionId,
+            text,
+            abortOrigin: params.abortOrigin,
+        });
+    }
+    return out;
+}
+function persistAbortedPartials(params) {
+    if (params.snapshots.length === 0) {
+        return;
+    }
+    const { storePath, entry } = loadSessionEntry(params.sessionKey);
+    for (const snapshot of params.snapshots) {
+        const sessionId = entry?.sessionId ?? snapshot.sessionId ?? snapshot.runId;
+        const appended = appendAssistantTranscriptMessage({
+            message: snapshot.text,
+            sessionId,
+            storePath,
+            sessionFile: entry?.sessionFile,
+            createIfMissing: true,
+            idempotencyKey: `${snapshot.runId}:assistant`,
+            abortMeta: {
+                aborted: true,
+                origin: snapshot.abortOrigin,
+                runId: snapshot.runId,
+            },
+        });
+        if (!appended.ok) {
+            params.context.logGateway.warn(`chat.abort transcript append failed: ${appended.error ?? "unknown error"}`);
+        }
+    }
+}
+function createChatAbortOps(context) {
+    return {
+        chatAbortControllers: context.chatAbortControllers,
+        chatRunBuffers: context.chatRunBuffers,
+        chatDeltaSentAt: context.chatDeltaSentAt,
+        chatAbortedRuns: context.chatAbortedRuns,
+        removeChatRun: context.removeChatRun,
+        agentRunSeq: context.agentRunSeq,
+        broadcast: context.broadcast,
+        nodeSendToSession: context.nodeSendToSession,
+    };
+}
+function abortChatRunsForSessionKeyWithPartials(params) {
+    const snapshots = collectSessionAbortPartials({
+        chatAbortControllers: params.context.chatAbortControllers,
+        chatRunBuffers: params.context.chatRunBuffers,
+        sessionKey: params.sessionKey,
+        abortOrigin: params.abortOrigin,
+    });
+    const res = abortChatRunsForSessionKey(params.ops, {
+        sessionKey: params.sessionKey,
+        stopReason: params.stopReason,
+    });
+    if (res.aborted) {
+        persistAbortedPartials({
+            context: params.context,
+            sessionKey: params.sessionKey,
+            snapshots,
+        });
+    }
+    return res;
 }
 function nextChatSeq(context, runId) {
     const next = (context.agentRunSeq.get(runId) ?? 0) + 1;
@@ -106,6 +419,7 @@ function broadcastChatFinal(params) {
     };
     params.context.broadcast("chat", payload);
     params.context.nodeSendToSession(params.sessionKey, "chat", payload);
+    params.context.agentRunSeq.delete(params.runId);
 }
 function broadcastChatError(params) {
     const seq = nextChatSeq({ agentRunSeq: params.context.agentRunSeq }, params.runId);
@@ -118,6 +432,7 @@ function broadcastChatError(params) {
     };
     params.context.broadcast("chat", payload);
     params.context.nodeSendToSession(params.sessionKey, "chat", payload);
+    params.context.agentRunSeq.delete(params.runId);
 }
 export const chatHandlers = {
     "chat.history": async ({ params, respond, context }) => {
@@ -135,7 +450,20 @@ export const chatHandlers = {
         const max = Math.min(hardMax, requested);
         const sliced = rawMessages.length > max ? rawMessages.slice(-max) : rawMessages;
         const sanitized = stripEnvelopeFromMessages(sliced);
-        const capped = capArrayByJsonBytes(sanitized, getMaxChatHistoryMessagesBytes()).items;
+        const normalized = sanitizeChatHistoryMessages(sanitized);
+        const maxHistoryBytes = getMaxChatHistoryMessagesBytes();
+        const perMessageHardCap = Math.min(CHAT_HISTORY_MAX_SINGLE_MESSAGE_BYTES, maxHistoryBytes);
+        const replaced = replaceOversizedChatHistoryMessages({
+            messages: normalized,
+            maxSingleMessageBytes: perMessageHardCap,
+        });
+        const capped = capArrayByJsonBytes(replaced.messages, maxHistoryBytes).items;
+        const bounded = enforceChatHistoryFinalBudget({ messages: capped, maxBytes: maxHistoryBytes });
+        const placeholderCount = replaced.replacedCount + bounded.placeholderCount;
+        if (placeholderCount > 0) {
+            chatHistoryPlaceholderEmitCount += placeholderCount;
+            context.logGateway.debug(`chat.history omitted oversized payloads placeholders=${placeholderCount} total=${chatHistoryPlaceholderEmitCount}`);
+        }
         let thinkingLevel = entry?.thinkingLevel;
         if (!thinkingLevel) {
             const configured = cfg.agents?.defaults?.thinkingDefault;
@@ -143,7 +471,8 @@ export const chatHandlers = {
                 thinkingLevel = configured;
             }
             else {
-                const { provider, model } = resolveSessionModelRef(cfg, entry);
+                const sessionAgentId = resolveSessionAgentId({ sessionKey, config: cfg });
+                const { provider, model } = resolveSessionModelRef(cfg, entry, sessionAgentId);
                 const catalog = await context.loadGatewayModelCatalog();
                 thinkingLevel = resolveThinkingDefault({
                     cfg,
@@ -153,11 +482,13 @@ export const chatHandlers = {
                 });
             }
         }
+        const verboseLevel = entry?.verboseLevel ?? cfg.agents?.defaults?.verboseDefault;
         respond(true, {
             sessionKey,
             sessionId,
-            messages: capped,
+            messages: bounded.messages,
             thinkingLevel,
+            verboseLevel,
         });
     },
     "chat.abort": ({ params, respond, context }) => {
@@ -165,20 +496,14 @@ export const chatHandlers = {
             respond(false, undefined, errorShape(ErrorCodes.INVALID_REQUEST, `invalid chat.abort params: ${formatValidationErrors(validateChatAbortParams.errors)}`));
             return;
         }
-        const { sessionKey, runId } = params;
-        const ops = {
-            chatAbortControllers: context.chatAbortControllers,
-            chatRunBuffers: context.chatRunBuffers,
-            chatDeltaSentAt: context.chatDeltaSentAt,
-            chatAbortedRuns: context.chatAbortedRuns,
-            removeChatRun: context.removeChatRun,
-            agentRunSeq: context.agentRunSeq,
-            broadcast: context.broadcast,
-            nodeSendToSession: context.nodeSendToSession,
-        };
+        const { sessionKey: rawSessionKey, runId } = params;
+        const ops = createChatAbortOps(context);
         if (!runId) {
-            const res = abortChatRunsForSessionKey(ops, {
-                sessionKey,
+            const res = abortChatRunsForSessionKeyWithPartials({
+                context,
+                ops,
+                sessionKey: rawSessionKey,
+                abortOrigin: "rpc",
                 stopReason: "rpc",
             });
             respond(true, { ok: true, aborted: res.aborted, runIds: res.runIds });
@@ -189,15 +514,30 @@ export const chatHandlers = {
             respond(true, { ok: true, aborted: false, runIds: [] });
             return;
         }
-        if (active.sessionKey !== sessionKey) {
+        if (active.sessionKey !== rawSessionKey) {
             respond(false, undefined, errorShape(ErrorCodes.INVALID_REQUEST, "runId does not match sessionKey"));
             return;
         }
+        const partialText = context.chatRunBuffers.get(runId);
         const res = abortChatRunById(ops, {
             runId,
-            sessionKey,
+            sessionKey: rawSessionKey,
             stopReason: "rpc",
         });
+        if (res.aborted && partialText && partialText.trim()) {
+            persistAbortedPartials({
+                context,
+                sessionKey: rawSessionKey,
+                snapshots: [
+                    {
+                        runId,
+                        sessionId: active.sessionId,
+                        text: partialText,
+                        abortOrigin: "rpc",
+                    },
+                ],
+            });
+        }
         respond(true, {
             ok: true,
             aborted: res.aborted,
@@ -210,29 +550,24 @@ export const chatHandlers = {
             return;
         }
         const p = params;
-        const stopCommand = isChatStopCommandText(p.message);
-        const normalizedAttachments = p.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 rawMessage = p.message.trim();
+        const sanitizedMessageResult = sanitizeChatSendMessageInput(p.message);
+        if (!sanitizedMessageResult.ok) {
+            respond(false, undefined, errorShape(ErrorCodes.INVALID_REQUEST, sanitizedMessageResult.error));
+            return;
+        }
+        const inboundMessage = sanitizedMessageResult.message;
+        const stopCommand = isChatStopCommandText(inboundMessage);
+        const normalizedAttachments = normalizeRpcAttachmentsToChatAttachments(p.attachments);
+        const rawMessage = inboundMessage.trim();
         if (!rawMessage && normalizedAttachments.length === 0) {
             respond(false, undefined, errorShape(ErrorCodes.INVALID_REQUEST, "message or attachment required"));
             return;
         }
-        let parsedMessage = p.message;
+        let parsedMessage = inboundMessage;
         let parsedImages = [];
         if (normalizedAttachments.length > 0) {
             try {
-                const parsed = await parseMessageWithAttachments(p.message, normalizedAttachments, {
+                const parsed = await parseMessageWithAttachments(inboundMessage, normalizedAttachments, {
                     maxBytes: 5_000_000,
                     log: context.logGateway,
                 });
@@ -244,7 +579,8 @@ export const chatHandlers = {
                 return;
             }
         }
-        const { cfg, entry } = loadSessionEntry(p.sessionKey);
+        const rawSessionKey = p.sessionKey;
+        const { cfg, entry, canonicalKey: sessionKey } = loadSessionEntry(rawSessionKey);
         const timeoutMs = resolveAgentTimeoutMs({
             cfg,
             overrideMs: p.timeoutMs,
@@ -254,7 +590,7 @@ export const chatHandlers = {
         const sendPolicy = resolveSendPolicy({
             cfg,
             entry,
-            sessionKey: p.sessionKey,
+            sessionKey,
             channel: entry?.channel,
             chatType: entry?.chatType,
         });
@@ -263,16 +599,13 @@ export const chatHandlers = {
             return;
         }
         if (stopCommand) {
-            const res = abortChatRunsForSessionKey({
-                chatAbortControllers: context.chatAbortControllers,
-                chatRunBuffers: context.chatRunBuffers,
-                chatDeltaSentAt: context.chatDeltaSentAt,
-                chatAbortedRuns: context.chatAbortedRuns,
-                removeChatRun: context.removeChatRun,
-                agentRunSeq: context.agentRunSeq,
-                broadcast: context.broadcast,
-                nodeSendToSession: context.nodeSendToSession,
-            }, { sessionKey: p.sessionKey, stopReason: "stop" });
+            const res = abortChatRunsForSessionKeyWithPartials({
+                context,
+                ops: createChatAbortOps(context),
+                sessionKey: rawSessionKey,
+                abortOrigin: "stop-command",
+                stopReason: "stop",
+            });
             respond(true, { ok: true, aborted: res.aborted, runIds: res.runIds });
             return;
         }
@@ -296,7 +629,7 @@ export const chatHandlers = {
             context.chatAbortControllers.set(clientRunId, {
                 controller: abortController,
                 sessionId: entry?.sessionId ?? clientRunId,
-                sessionKey: p.sessionKey,
+                sessionKey: rawSessionKey,
                 startedAtMs: now,
                 expiresAtMs: resolveChatRunExpiresAtMs({ now, timeoutMs }),
             });
@@ -309,13 +642,17 @@ export const chatHandlers = {
             const injectThinking = Boolean(p.thinking && trimmedMessage && !trimmedMessage.startsWith("/"));
             const commandBody = injectThinking ? `/think ${p.thinking} ${parsedMessage}` : parsedMessage;
             const clientInfo = client?.connect?.client;
+            // Inject timestamp so agents know the current date/time.
+            // Only BodyForAgent gets the timestamp — Body stays raw for UI display.
+            // See: https://github.com/moltbot/moltbot/issues/3658
+            const stampedMessage = injectTimestamp(parsedMessage, timestampOptsFromConfig(cfg));
             const ctx = {
                 Body: parsedMessage,
-                BodyForAgent: parsedMessage,
+                BodyForAgent: stampedMessage,
                 BodyForCommands: commandBody,
                 RawBody: parsedMessage,
                 CommandBody: commandBody,
-                SessionKey: p.sessionKey,
+                SessionKey: sessionKey,
                 Provider: INTERNAL_MESSAGE_CHANNEL,
                 Surface: INTERNAL_MESSAGE_CHANNEL,
                 OriginatingChannel: INTERNAL_MESSAGE_CHANNEL,
@@ -325,27 +662,31 @@ export const chatHandlers = {
                 SenderId: clientInfo?.id,
                 SenderName: clientInfo?.displayName,
                 SenderUsername: clientInfo?.displayName,
+                GatewayClientScopes: client?.connect?.scopes,
             };
             const agentId = resolveSessionAgentId({
-                sessionKey: p.sessionKey,
+                sessionKey,
                 config: cfg,
             });
-            let prefixContext = {
-                identityName: resolveIdentityName(cfg, agentId),
-            };
+            const { onModelSelected, ...prefixOptions } = createReplyPrefixOptions({
+                cfg,
+                agentId,
+                channel: INTERNAL_MESSAGE_CHANNEL,
+            });
             const finalReplyParts = [];
             const dispatcher = createReplyDispatcher({
-                responsePrefix: resolveEffectiveMessagesConfig(cfg, agentId).responsePrefix,
-                responsePrefixContextProvider: () => prefixContext,
+                ...prefixOptions,
                 onError: (err) => {
                     context.logGateway.warn(`webchat dispatch failed: ${formatForLog(err)}`);
                 },
                 deliver: async (payload, info) => {
-                    if (info.kind !== "final")
+                    if (info.kind !== "final") {
                         return;
+                    }
                     const text = payload.text?.trim() ?? "";
-                    if (!text)
+                    if (!text) {
                         return;
+                    }
                     finalReplyParts.push(text);
                 },
             });
@@ -358,16 +699,23 @@ export const chatHandlers = {
                     runId: clientRunId,
                     abortSignal: abortController.signal,
                     images: parsedImages.length > 0 ? parsedImages : undefined,
-                    disableBlockStreaming: true,
-                    onAgentRunStart: () => {
+                    onAgentRunStart: (runId) => {
                         agentRunStarted = true;
+                        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 === p.sessionKey) {
+                                    context.registerToolEventRecipient(activeRunId, connId);
+                                }
+                            }
+                        }
                     },
-                    onModelSelected: (ctx) => {
-                        prefixContext.provider = ctx.provider;
-                        prefixContext.model = extractShortModelName(ctx.model);
-                        prefixContext.modelFull = `${ctx.provider}/${ctx.model}`;
-                        prefixContext.thinkingLevel = ctx.thinkLevel ?? "off";
-                    },
+                    onModelSelected,
                 },
             })
                 .then(() => {
@@ -379,13 +727,14 @@ export const chatHandlers = {
                         .trim();
                     let message;
                     if (combinedReply) {
-                        const { storePath: latestStorePath, entry: latestEntry } = loadSessionEntry(p.sessionKey);
+                        const { storePath: latestStorePath, entry: latestEntry } = loadSessionEntry(sessionKey);
                         const sessionId = latestEntry?.sessionId ?? entry?.sessionId ?? clientRunId;
                         const appended = appendAssistantTranscriptMessage({
                             message: combinedReply,
                             sessionId,
                             storePath: latestStorePath,
                             sessionFile: latestEntry?.sessionFile,
+                            agentId,
                             createIfMissing: true,
                         });
                         if (appended.ok) {
@@ -398,7 +747,9 @@ export const chatHandlers = {
                                 role: "assistant",
                                 content: [{ type: "text", text: combinedReply }],
                                 timestamp: now,
-                                stopReason: "injected",
+                                // Keep this compatible with Pi stopReason enums even though this message isn't
+                                // persisted to the transcript due to the append failure.
+                                stopReason: "stop",
                                 usage: { input: 0, output: 0, totalTokens: 0 },
                             };
                         }
@@ -406,7 +757,7 @@ export const chatHandlers = {
                     broadcastChatFinal({
                         context,
                         runId: clientRunId,
-                        sessionKey: p.sessionKey,
+                        sessionKey: rawSessionKey,
                         message,
                     });
                 }
@@ -431,7 +782,7 @@ export const chatHandlers = {
                 broadcastChatError({
                     context,
                     runId: clientRunId,
-                    sessionKey: p.sessionKey,
+                    sessionKey: rawSessionKey,
                     errorMessage: String(err),
                 });
             })
@@ -465,56 +816,36 @@ export const chatHandlers = {
         }
         const p = params;
         // Load session to find transcript file
-        const { storePath, entry } = loadSessionEntry(p.sessionKey);
+        const rawSessionKey = p.sessionKey;
+        const { cfg, storePath, entry } = loadSessionEntry(rawSessionKey);
         const sessionId = entry?.sessionId;
         if (!sessionId || !storePath) {
             respond(false, undefined, errorShape(ErrorCodes.INVALID_REQUEST, "session not found"));
             return;
         }
-        // Resolve transcript path
-        const transcriptPath = entry?.sessionFile
-            ? entry.sessionFile
-            : path.join(path.dirname(storePath), `${sessionId}.jsonl`);
-        if (!fs.existsSync(transcriptPath)) {
-            respond(false, undefined, errorShape(ErrorCodes.INVALID_REQUEST, "transcript file not found"));
-            return;
-        }
-        // Build transcript entry
-        const now = Date.now();
-        const messageId = randomUUID().slice(0, 8);
-        const labelPrefix = p.label ? `[${p.label}]\n\n` : "";
-        const messageBody = {
-            role: "assistant",
-            content: [{ type: "text", text: `${labelPrefix}${p.message}` }],
-            timestamp: now,
-            stopReason: "injected",
-            usage: { input: 0, output: 0, totalTokens: 0 },
-        };
-        const transcriptEntry = {
-            type: "message",
-            id: messageId,
-            timestamp: new Date(now).toISOString(),
-            message: messageBody,
-        };
-        // Append to transcript file
-        try {
-            fs.appendFileSync(transcriptPath, `${JSON.stringify(transcriptEntry)}\n`, "utf-8");
-        }
-        catch (err) {
-            const errMessage = err instanceof Error ? err.message : String(err);
-            respond(false, undefined, errorShape(ErrorCodes.UNAVAILABLE, `failed to write transcript: ${errMessage}`));
+        const appended = appendAssistantTranscriptMessage({
+            message: p.message,
+            label: p.label,
+            sessionId,
+            storePath,
+            sessionFile: entry?.sessionFile,
+            agentId: resolveSessionAgentId({ sessionKey: rawSessionKey, config: cfg }),
+            createIfMissing: false,
+        });
+        if (!appended.ok || !appended.messageId || !appended.message) {
+            respond(false, undefined, errorShape(ErrorCodes.UNAVAILABLE, `failed to write transcript: ${appended.error ?? "unknown error"}`));
             return;
         }
         // Broadcast to webchat for immediate UI update
         const chatPayload = {
-            runId: `inject-${messageId}`,
-            sessionKey: p.sessionKey,
+            runId: `inject-${appended.messageId}`,
+            sessionKey: rawSessionKey,
             seq: 0,
             state: "final",
-            message: transcriptEntry.message,
+            message: appended.message,
         };
         context.broadcast("chat", chatPayload);
-        context.nodeSendToSession(p.sessionKey, "chat", chatPayload);
-        respond(true, { ok: true, messageId });
+        context.nodeSendToSession(rawSessionKey, "chat", chatPayload);
+        respond(true, { ok: true, messageId: appended.messageId });
     },
 };