@elizaos/agent 2.0.0-beta.1 → 2.0.11-beta.5

package/dist/packages/agent/src/api/chat-routes.js

@@ -1,1841 +0,0 @@
-/**
- * Chat route handlers extracted from server.ts.
- *
- * Handles:
- *   POST /v1/chat/completions   – OpenAI-compatible
- *   POST /v1/messages           – Anthropic-compatible
- *   GET  /v1/models             – OpenAI model listing
- *   GET  /v1/models/:id         – OpenAI single model
- *
- * Also exports generateChatResponse() and supporting helpers so that
- * conversation-routes.ts (and server.ts itself) can reuse them.
- */
-import crypto from "node:crypto";
-import { ChannelType, composePrompt, createMessageMemory, logger, ModelType, mobileDirectReplyTemplate, runWithTrajectoryContext, stringToUuid, } from "@elizaos/core";
-import { getLocalInferenceChatStatus, handleLocalInferenceChatCommand, } from "@elizaos/plugin-local-inference";
-import { asRecord, normalizeCharacterLanguage, resolveStreamingUpdate, } from "@elizaos/shared";
-import { estimateTokenCount, withModelUsageCapture, } from "../runtime/prompt-optimization.js";
-import { resolveTrajectoryGrouping } from "../runtime/trajectory-internals.js";
-import { startTrajectoryStepInDatabase } from "../runtime/trajectory-storage.js";
-import { syncCharacterIntoConfig } from "../services/character-persistence.js";
-import { detectRuntimeModel } from "./agent-model.js";
-import { executeFallbackParsedActions, maybeHandleDirectBinanceSkillRequest, parseFallbackActionBlocks, } from "./binance-skill-helpers.js";
-import { isClientVisibleNoResponse, isNoResponsePlaceholder, } from "./chat-text-helpers.js";
-import { resolveClientChatAdminEntityId } from "./client-chat-admin.js";
-import { extractAnthropicSystemAndLastUser, extractCompatTextContent, extractOpenAiSystemAndLastUser, resolveCompatRoomKey, } from "./compat-utils.js";
-import { isInsufficientCreditsError, isInsufficientCreditsMessage, } from "./credit-detection.js";
-import { buildWalletActionNotExecutedReply, cloneWithoutBlockedObjectKeys, decodePathComponent, getErrorMessage, hasBlockedObjectKeyDeep, isWalletActionRequiredIntent, maybeAugmentChatMessageWithDocuments, maybeAugmentChatMessageWithLanguage, maybeAugmentChatMessageWithWalletContext, normalizeIncomingChatPrompt, resolveAppUserName, trimWalletProgressPrefix, validateChatImages, } from "./server-helpers.js";
-const CHAT_MAX_BODY_BYTES = 20 * 1024 * 1024; // 20 MB (image-capable)
-function resolveCallbackMergeMode(content, fallback = "replace") {
-    return content.merge === "append" || content.merge === "replace"
-        ? content.merge
-        : fallback;
-}
-function normalizeActionCallbackText(text) {
-    return text.trim();
-}
-function getLatestVisibleResponseMessageText(responseMessages) {
-    if (!Array.isArray(responseMessages) || responseMessages.length === 0) {
-        return "";
-    }
-    for (let index = responseMessages.length - 1; index >= 0; index -= 1) {
-        const content = responseMessages[index]?.content;
-        const text = typeof extractCompatTextContent(content) === "string"
-            ? extractCompatTextContent(content).trim()
-            : "";
-        if (!text || isNoResponsePlaceholder(text)) {
-            continue;
-        }
-        return text;
-    }
-    return "";
-}
-function isMobileLocalSimpleChat(message) {
-    const conversationMode = message.content
-        .conversationMode;
-    return (process.env.ELIZA_DEVICE_BRIDGE_ENABLED === "1" &&
-        conversationMode === "simple");
-}
-function sanitizeMobileLocalSimpleReply(text) {
-    const trimmed = text.trim();
-    if (!trimmed)
-        return "";
-    const withoutRole = trimmed
-        .replace(/^assistant\s*:\s*/i, "")
-        .replace(/^eliza\s*:\s*/i, "")
-        .trim();
-    const firstLine = withoutRole.split(/\r?\n/).find((line) => line.trim());
-    return (firstLine ?? withoutRole).trim();
-}
-function extractExactWordsReplyRequest(userText) {
-    const exactWords = /\bexact words?\s*:\s*["'“”‘’]?(.+?)["'“”‘’]?\s*$/i.exec(userText);
-    if (exactWords?.[1]?.trim()) {
-        return exactWords[1].trim();
-    }
-    const replyWith = /\breply\s+(?:briefly\s+)?with\s+["'“”‘’]([^"'“”‘’]+)["'“”‘’]/i.exec(userText);
-    if (replyWith?.[1]?.trim()) {
-        return replyWith[1].trim();
-    }
-    return null;
-}
-async function generateMobileLocalSimpleReply(runtime, message, agentName, opts) {
-    const userText = String(extractCompatTextContent(message.content) ?? "").trim();
-    if (!userText)
-        return null;
-    const exactReply = extractExactWordsReplyRequest(userText);
-    if (exactReply) {
-        opts?.onSnapshot?.(exactReply);
-        return {
-            text: exactReply,
-            agentName,
-            responseContent: {
-                text: exactReply,
-                simple: true,
-                actions: ["REPLY"],
-            },
-            responseMessages: [],
-        };
-    }
-    const system = typeof runtime.character.system === "string" &&
-        runtime.character.system.trim().length > 0
-        ? runtime.character.system.trim()
-        : `You are ${agentName}. Reply briefly and directly.`;
-    const prompt = composePrompt({
-        state: { system, userText, agentName },
-        template: mobileDirectReplyTemplate,
-    });
-    const raw = await runtime.useModel(ModelType.TEXT_SMALL, {
-        prompt,
-        maxTokens: 64,
-        temperature: 0.4,
-    });
-    const text = sanitizeMobileLocalSimpleReply(String(raw ?? ""));
-    if (!text)
-        return null;
-    opts?.onSnapshot?.(text);
-    return {
-        text,
-        agentName,
-        responseContent: {
-            text,
-            simple: true,
-            actions: ["REPLY"],
-        },
-        responseMessages: [],
-    };
-}
-const EXACT_GROUNDED_VALUE_REQUEST = /\b(?:exact|verbatim|copy|quoted?|identifier|codeword|return only|only the)\b/i;
-const DOCUMENT_VALUE_CAPTURE = /\b(?:codeword|identifier|token|value)\s*(?:is|=|:)\s*([A-Za-z0-9][A-Za-z0-9._-]{1,127})\b/gi;
-const UPPERCASE_IDENTIFIER_CAPTURE = /\b[A-Z0-9]+(?:[-_][A-Z0-9]+)+\b/g;
-const UUID_IDENTIFIER_CAPTURE = /\b[a-f0-9]{8}-[a-f0-9]{4}-[1-5][a-f0-9]{3}-[89ab][a-f0-9]{3}-[a-f0-9]{12}\b/gi;
-function uniqueMatches(matches) {
-    return Array.from(new Set(Array.from(matches).map((value) => value.trim()))).filter((value) => value.length > 0);
-}
-function collectRegexMatches(text, pattern, groupIndex) {
-    const regex = new RegExp(pattern.source, pattern.flags);
-    return Array.from(text.matchAll(regex), (match) => String(groupIndex === undefined ? match[0] : (match[groupIndex] ?? "")));
-}
-function extractExactGroundedValueFromText(messageText, documentText) {
-    if (!messageText || !EXACT_GROUNDED_VALUE_REQUEST.test(messageText)) {
-        return null;
-    }
-    if (!documentText) {
-        return null;
-    }
-    const capturedDocumentValues = uniqueMatches(collectRegexMatches(documentText, DOCUMENT_VALUE_CAPTURE, 1));
-    if (capturedDocumentValues.length === 1) {
-        return capturedDocumentValues[0];
-    }
-    const uppercaseCandidates = uniqueMatches(collectRegexMatches(documentText, UPPERCASE_IDENTIFIER_CAPTURE));
-    if (uppercaseCandidates.length === 1) {
-        return uppercaseCandidates[0];
-    }
-    const uuidCandidates = uniqueMatches(collectRegexMatches(documentText, UUID_IDENTIFIER_CAPTURE));
-    if (uuidCandidates.length === 1) {
-        return uuidCandidates[0];
-    }
-    return null;
-}
-async function resolveExactDocumentValueForChat(runtime, message) {
-    const messageText = typeof extractCompatTextContent(message.content) === "string"
-        ? extractCompatTextContent(message.content).trim()
-        : "";
-    if (!messageText || !EXACT_GROUNDED_VALUE_REQUEST.test(messageText)) {
-        return null;
-    }
-    const documentsService = runtime.getService?.("documents");
-    if (!documentsService ||
-        typeof documentsService.searchDocuments !== "function") {
-        return null;
-    }
-    try {
-        const matches = await documentsService.searchDocuments(message);
-        if (!Array.isArray(matches) || matches.length === 0) {
-            return null;
-        }
-        const uploadedMatches = matches.filter((match) => {
-            const metadata = match?.metadata && typeof match.metadata === "object"
-                ? match.metadata
-                : null;
-            return metadata?.source === "upload";
-        });
-        const preferredMatches = uploadedMatches.length > 0 ? uploadedMatches : matches;
-        const exactMatchCandidates = uniqueMatches(preferredMatches
-            .map((match) => typeof match?.content?.text === "string"
-            ? extractExactGroundedValueFromText(messageText, match.content.text.trim())
-            : null)
-            .filter((value) => typeof value === "string"));
-        if (exactMatchCandidates.length === 1) {
-            return exactMatchCandidates[0];
-        }
-        const documentsText = preferredMatches
-            .map((match) => typeof match?.content?.text === "string"
-            ? match.content.text.trim()
-            : "")
-            .filter((text) => text.length > 0)
-            .join("\n\n");
-        return extractExactGroundedValueFromText(messageText, documentsText);
-    }
-    catch {
-        return null;
-    }
-}
-// ---------------------------------------------------------------------------
-// Chat failure / no-response helpers
-// ---------------------------------------------------------------------------
-// Reserved for path #4 — actual generation throw caught by getChatFailureReply.
-// Do NOT use as the generic empty-response fallback; that mislabels every
-// IGNORE / empty-action / placeholder-text path as a provider failure.
-const PROVIDER_ISSUE_CHAT_REPLY = "Sorry, I'm having a provider issue";
-const INSUFFICIENT_CREDITS_CHAT_REPLY = "Eliza Cloud credits are depleted. Top up the cloud balance and try again.";
-// Used by paths #1-#3: planner picked IGNORE/NONE/empty REPLY, action ran but
-// emitted no text callback, or normalized text became a placeholder. None of
-// these are provider failures, so the message must not blame the provider.
-const NO_RESPONSE_FALLBACK_REPLY = "I don't have a reply for that — try rephrasing?";
-// Routed-model errors raised by the model router when no provider plugin is
-// loaded for a requested model class (e.g. TEXT_SMALL). Identifies the OOB
-// "no provider configured" case so chat routes can return a structured 503
-// instead of a generic 500 — UI clients gate on `error.type === "no_provider"`
-// to render a "Connect a provider" CTA instead of an opaque error toast.
-const NO_PROVIDER_ERROR_FRAGMENTS = [
-    "No provider registered for",
-    "No model registered for",
-];
-function isNoProviderError(err) {
-    const msg = err instanceof Error ? err.message : typeof err === "string" ? err : "";
-    return NO_PROVIDER_ERROR_FRAGMENTS.some((frag) => msg.includes(frag));
-}
-const NO_PROVIDER_CHAT_MESSAGE = "Connect an LLM provider to start chatting. Open Settings → Providers, " +
-    "or pick Eliza Cloud from the runtime picker.";
-const DEFAULT_CHAT_GENERATION_TIMEOUT_MS = 180_000;
-const NON_EXECUTABLE_FALLBACK_ACTIONS = new Set(["REPLY", "NONE", "IGNORE"]);
-function isExecutableFallbackAction(action) {
-    return !NON_EXECUTABLE_FALLBACK_ACTIONS.has(action.name);
-}
-function normalizeActionName(value) {
-    return typeof value === "string" ? value.trim().toUpperCase() : "";
-}
-function ensureMessageMemoryContent(content) {
-    return typeof content.text === "string"
-        ? { ...content, text: content.text }
-        : { ...content, text: "" };
-}
-function buildRuntimeActionNameLookup(runtime) {
-    const lookup = new Map();
-    const runtimeActions = Array.isArray(runtime.actions)
-        ? runtime.actions
-        : [];
-    for (const action of runtimeActions) {
-        const canonicalName = normalizeActionName(action?.name);
-        if (!canonicalName) {
-            continue;
-        }
-        lookup.set(canonicalName, canonicalName);
-        if (!Array.isArray(action?.similes)) {
-            continue;
-        }
-        for (const alias of action.similes) {
-            const normalizedAlias = normalizeActionName(alias);
-            if (normalizedAlias) {
-                lookup.set(normalizedAlias, canonicalName);
-            }
-        }
-    }
-    return lookup;
-}
-function listExecutedRuntimeActions(runtime, messageId) {
-    if (!messageId) {
-        return new Set();
-    }
-    const getActionResults = runtime.getActionResults;
-    if (typeof getActionResults !== "function") {
-        return new Set();
-    }
-    try {
-        return new Set(getActionResults(messageId)
-            .map((result) => {
-            if (typeof result === "string") {
-                return normalizeActionName(result);
-            }
-            if (!result || typeof result !== "object") {
-                return "";
-            }
-            const record = result;
-            if (typeof record.actionName === "string") {
-                return normalizeActionName(record.actionName);
-            }
-            const data = record.data && typeof record.data === "object"
-                ? record.data
-                : null;
-            return normalizeActionName(data?.actionName);
-        })
-            .filter((name) => name.length > 0));
-    }
-    catch {
-        return new Set();
-    }
-}
-function pickInsufficientCreditsChatReply() {
-    return INSUFFICIENT_CREDITS_CHAT_REPLY;
-}
-function findRecentInsufficientCreditsLog(logBuffer, lookbackMs = 60_000) {
-    const now = Date.now();
-    for (let i = logBuffer.length - 1; i >= 0; i--) {
-        const entry = logBuffer[i];
-        if (now - entry.timestamp > lookbackMs)
-            break;
-        if (isInsufficientCreditsMessage(entry.message)) {
-            return entry;
-        }
-    }
-    return null;
-}
-export function resolveNoResponseFallback(logBuffer, _runtime, _lang = "en") {
-    if (findRecentInsufficientCreditsLog(logBuffer)) {
-        return pickInsufficientCreditsChatReply();
-    }
-    return NO_RESPONSE_FALLBACK_REPLY;
-}
-function getProviderIssueChatReply() {
-    return PROVIDER_ISSUE_CHAT_REPLY;
-}
-function resolveChatGenerationTimeoutMs(explicit) {
-    if (typeof explicit === "number" &&
-        Number.isFinite(explicit) &&
-        explicit > 0) {
-        return Math.max(1, Math.floor(explicit));
-    }
-    const fromEnv = process.env.ELIZA_CHAT_GENERATION_TIMEOUT_MS?.trim();
-    if (!fromEnv)
-        return DEFAULT_CHAT_GENERATION_TIMEOUT_MS;
-    const parsed = Number.parseInt(fromEnv, 10);
-    if (!Number.isFinite(parsed) || parsed <= 0) {
-        return DEFAULT_CHAT_GENERATION_TIMEOUT_MS;
-    }
-    return Math.max(1_000, parsed);
-}
-function createChatGenerationTimeoutError(timeoutMs) {
-    return new Error(`Chat generation timed out after ${timeoutMs}ms`);
-}
-async function withTimeout(promise, timeoutMs, createError, onTimeout) {
-    let timeoutHandle;
-    try {
-        return await Promise.race([
-            promise,
-            new Promise((_resolve, reject) => {
-                timeoutHandle = setTimeout(() => {
-                    onTimeout?.();
-                    reject(createError());
-                }, timeoutMs);
-            }),
-        ]);
-    }
-    finally {
-        if (timeoutHandle) {
-            clearTimeout(timeoutHandle);
-        }
-    }
-}
-export function getChatFailureReply(err, logBuffer) {
-    if (isInsufficientCreditsError(err) ||
-        findRecentInsufficientCreditsLog(logBuffer)) {
-        return pickInsufficientCreditsChatReply();
-    }
-    if (isNoProviderError(err)) {
-        return NO_PROVIDER_CHAT_MESSAGE;
-    }
-    return getProviderIssueChatReply();
-}
-export function classifyChatFailure(err, logBuffer) {
-    if (isInsufficientCreditsError(err) ||
-        findRecentInsufficientCreditsLog(logBuffer)) {
-        return "insufficient_credits";
-    }
-    if (isNoProviderError(err)) {
-        return "no_provider";
-    }
-    if (isLocalInferenceError(err)) {
-        return "local_inference";
-    }
-    return "provider_issue";
-}
-function normalizeIntentText(text) {
-    return text
-        .toLowerCase()
-        .replace(/[`"'“”‘’]/g, "")
-        .replace(/[_-]+/g, " ")
-        .replace(/\s+/g, " ")
-        .trim();
-}
-function hasLocalInferenceMetadata(message) {
-    const contentMetadata = asRecord(message.content.metadata) ?? {};
-    const messageMetadata = asRecord(message.metadata) ?? {};
-    const metadata = { ...contentMetadata, ...messageMetadata };
-    const localValue = metadata.localInference ??
-        metadata.localInferenceContext ??
-        metadata.localModel ??
-        metadata.modelHub;
-    if (localValue === true)
-        return true;
-    if (typeof localValue === "string") {
-        return /^(1|true|yes|local|local-inference|model-hub)$/i.test(localValue.trim());
-    }
-    const context = typeof metadata.context === "string"
-        ? metadata.context
-        : typeof metadata.scope === "string"
-            ? metadata.scope
-            : "";
-    return /\blocal[-_\s]?inference\b|\bmodel[-_\s]?hub\b/i.test(context);
-}
-function hasLocalInferenceTopic(text) {
-    return (/\b(local|locally|on device|on-device|device model|local model|local inference|model hub|gguf|llama|inference|provider|runtime)\b/i.test(text) || /\bmodel\s+(?:download|install|load|setup)\b/i.test(text));
-}
-function isImperativeCloudOrLocalRouting(text) {
-    return /^(?:please\s+)?(?:use|switch|prefer|route|go|move)\s+(?:me\s+)?(?:to\s+)?(?:the\s+)?(?:cloud|local|on device|on-device)\b/i.test(text);
-}
-export function detectLocalInferenceCommandIntent(text, options = {}) {
-    const normalized = normalizeIntentText(text);
-    if (!normalized)
-        return null;
-    const explicitContext = options.localInferenceContext === true ||
-        hasLocalInferenceTopic(normalized) ||
-        isImperativeCloudOrLocalRouting(normalized);
-    if (!explicitContext)
-        return null;
-    if (/\b(?:use|switch|prefer|route|go|move)\s+(?:to\s+)?(?:the\s+)?cloud\b/.test(normalized) ||
-        /\bcloud\s+(?:mode|provider|inference|model|routing)\b/.test(normalized)) {
-        return "use_cloud";
-    }
-    if (/\b(?:use|switch|prefer|route|go|move)\s+(?:to\s+)?(?:the\s+)?(?:local|on device|on device model)\b/.test(normalized) ||
-        /\b(?:local|on device)\s+(?:mode|provider|inference|model|routing)\b/.test(normalized)) {
-        return "use_local";
-    }
-    if (/\b(?:smaller|smallest|tiny|lighter|lightweight|less memory|low ram|low memory)\b/.test(normalized) &&
-        /\b(?:switch|use|load|pick|select|change|model)\b/.test(normalized)) {
-        return "switch_smaller";
-    }
-    if (/\b(?:cancel|stop|abort|halt)\b/.test(normalized) &&
-        /\b(?:download|model|local|inference)\b/.test(normalized)) {
-        return "cancel";
-    }
-    if (/\b(?:re download|redownload|download again|fresh download)\b/.test(normalized)) {
-        return "redownload";
-    }
-    if (/\b(?:retry|try again|resume|continue|restart)\b/.test(normalized) &&
-        /\b(?:download|model|local|inference)\b/.test(normalized)) {
-        return normalized.includes("resume") || normalized.includes("continue")
-            ? "resume"
-            : "retry";
-    }
-    if (/\b(?:status|progress|state|ready|loaded|loading|how far|what model)\b/.test(normalized) &&
-        (options.localInferenceContext === true ||
-            /\b(?:download|model|local|inference|gguf|eliza-1|provider|runtime)\b/.test(normalized))) {
-        return "status";
-    }
-    if (/\b(?:download|install|get|fetch|pull)\b/.test(normalized) &&
-        (options.localInferenceContext === true ||
-            /\b(?:model|local|inference|gguf|eliza-1)\b/.test(normalized))) {
-        return "download";
-    }
-    return null;
-}
-export function isLocalInferenceError(err) {
-    const message = err instanceof Error ? err.message : typeof err === "string" ? err : "";
-    return /\b(?:local inference|local model|on-device|device bridge|llama|gguf|capacitor-llama|no local model|model download|enospc|no space left|disk full)\b/i.test(message);
-}
-export function normalizeChatResponseText(text, logBuffer, runtime) {
-    // Both fallback strings can hit this path; either should be re-routed to
-    // the insufficient-credits reply when a recent credits log explains why
-    // generation produced nothing.
-    const trimmed = text.trim();
-    if ((trimmed === PROVIDER_ISSUE_CHAT_REPLY ||
-        trimmed === NO_RESPONSE_FALLBACK_REPLY) &&
-        findRecentInsufficientCreditsLog(logBuffer)) {
-        return pickInsufficientCreditsChatReply();
-    }
-    if (!isClientVisibleNoResponse(text))
-        return text;
-    return resolveNoResponseFallback(logBuffer, runtime);
-}
-function listResponseActions(responseContent) {
-    if (!Array.isArray(responseContent?.actions)) {
-        return [];
-    }
-    return responseContent.actions
-        .map((action) => typeof action === "string" ? action.trim().toUpperCase() : "")
-        .filter((action) => action.length > 0);
-}
-function isIntentionalNoResponseResult(result, candidateText) {
-    if (!result)
-        return false;
-    const actions = listResponseActions(result.responseContent);
-    const hasSilentTerminalAction = actions.length === 1 && (actions[0] === "IGNORE" || actions[0] === "STOP");
-    const hasNoVisibleText = candidateText.trim().length === 0 ||
-        isClientVisibleNoResponse(candidateText);
-    return (hasNoVisibleText && (result.didRespond === false || hasSilentTerminalAction));
-}
-function buildUnexecutedActionPayloadReply(actionNames) {
-    const uniqueNames = [
-        ...new Set(actionNames.map((name) => normalizeActionName(name)).filter(Boolean)),
-    ];
-    const actionsLabel = uniqueNames.length > 0 ? uniqueNames.join(", ") : "unknown";
-    return [
-        "I could not complete that request because the model returned actions that were not executed.",
-        `Unexecuted actions: ${actionsLabel}.`,
-        "No side effects were applied.",
-    ].join("\n");
-}
-// ---------------------------------------------------------------------------
-// SSE helpers
-// ---------------------------------------------------------------------------
-export function initSse(res) {
-    res.writeHead(200, {
-        "Content-Type": "text/event-stream",
-        "Cache-Control": "no-cache, no-transform",
-        Connection: "keep-alive",
-        "X-Accel-Buffering": "no",
-    });
-}
-export function writeSse(res, payload) {
-    if (res.writableEnded || res.destroyed)
-        return;
-    res.write(`data: ${JSON.stringify(payload)}\n\n`);
-}
-export function writeChatTokenSse(res, text, fullText) {
-    writeSse(res, { type: "token", text, fullText });
-}
-export function writeSseData(res, data, event) {
-    if (res.writableEnded || res.destroyed)
-        return;
-    if (event)
-        res.write(`event: ${event}\n`);
-    res.write(`data: ${data}\n\n`);
-}
-export function writeSseJson(res, payload, event) {
-    writeSseData(res, JSON.stringify(payload), event);
-}
-// ---------------------------------------------------------------------------
-// Persistence helpers
-// ---------------------------------------------------------------------------
-function isDuplicateMemoryError(err) {
-    if (!(err instanceof Error))
-        return false;
-    const msg = err.message.toLowerCase();
-    return (msg.includes("duplicate") ||
-        msg.includes("already exists") ||
-        msg.includes("unique constraint"));
-}
-export async function persistConversationMemory(runtime, memory) {
-    try {
-        await runtime.createMemory(memory, "messages");
-    }
-    catch (err) {
-        if (isDuplicateMemoryError(err))
-            return;
-        throw err;
-    }
-}
-async function hasRecentAssistantMemory(runtime, roomId, text, sinceMs) {
-    const trimmed = text.trim();
-    if (!trimmed)
-        return false;
-    try {
-        const recent = await runtime.getMemories({
-            roomId,
-            tableName: "messages",
-            limit: 12,
-        });
-        return recent.some((memory) => {
-            const contentText = memory.content?.text?.trim();
-            const createdAt = memory.createdAt ?? 0;
-            return (memory.entityId === runtime.agentId &&
-                contentText === trimmed &&
-                createdAt >= sinceMs - 2000);
-        });
-    }
-    catch {
-        return false;
-    }
-}
-export async function hasRecentVisibleAssistantMemorySince(runtime, roomId, sinceMs) {
-    try {
-        const recent = await runtime.getMemories({
-            roomId,
-            tableName: "messages",
-            limit: 12,
-        });
-        return recent.some((memory) => {
-            const contentText = memory.content?.text?.trim();
-            const createdAt = memory.createdAt ?? 0;
-            return (memory.entityId === runtime.agentId &&
-                Boolean(contentText) &&
-                createdAt >= sinceMs - 2000);
-        });
-    }
-    catch {
-        return false;
-    }
-}
-export async function persistAssistantConversationMemory(runtime, roomId, content, channelType, dedupeSinceMs) {
-    const persistedContent = typeof content === "string"
-        ? {
-            text: content,
-            source: "client_chat",
-            channelType,
-        }
-        : {
-            ...content,
-            text: extractCompatTextContent(content) ?? "",
-            source: typeof content.source === "string" ? content.source : "client_chat",
-            channelType: typeof content.channelType === "string"
-                ? content.channelType
-                : channelType,
-        };
-    const trimmed = persistedContent.text.trim();
-    if (!trimmed)
-        return;
-    if (typeof dedupeSinceMs === "number") {
-        const alreadyPersisted = await hasRecentAssistantMemory(runtime, roomId, trimmed, dedupeSinceMs);
-        if (alreadyPersisted)
-            return;
-    }
-    await persistConversationMemory(runtime, createMessageMemory({
-        id: crypto.randomUUID(),
-        entityId: runtime.agentId,
-        agentId: runtime.agentId,
-        roomId,
-        content: persistedContent,
-    }));
-}
-// ---------------------------------------------------------------------------
-// Chat request parsing
-// ---------------------------------------------------------------------------
-const VALID_CHANNEL_TYPES = new Set(Object.values(ChannelType));
-const VALID_CONVERSATION_MODES = new Set(["simple", "power"]);
-function parseRequestChannelType(value, fallback = ChannelType.DM) {
-    if (value === undefined || value === null) {
-        return fallback;
-    }
-    if (typeof value !== "string") {
-        return null;
-    }
-    const normalized = value.trim().toUpperCase();
-    if (!VALID_CHANNEL_TYPES.has(normalized)) {
-        return null;
-    }
-    return normalized;
-}
-function parseConversationMode(value) {
-    if (value === undefined || value === null) {
-        return undefined;
-    }
-    if (typeof value !== "string") {
-        return null;
-    }
-    const normalized = value.trim().toLowerCase();
-    if (!VALID_CONVERSATION_MODES.has(normalized)) {
-        return null;
-    }
-    return normalized;
-}
-function readUiLanguageHeader(req) {
-    if (!req) {
-        return undefined;
-    }
-    const header = req.headers["x-eliza-ui-language"];
-    if (Array.isArray(header)) {
-        return header.find((value) => value.trim())?.trim();
-    }
-    return typeof header === "string" && header.trim()
-        ? header.trim()
-        : undefined;
-}
-export async function readChatRequestPayload(req, res, helpers, 
-/** Body size limit. Image-capable endpoints pass CHAT_MAX_BODY_BYTES (20 MB);
- *  legacy/cloud-proxy endpoints that don't process images pass MAX_BODY_BYTES (1 MB). */
-maxBytes = CHAT_MAX_BODY_BYTES) {
-    const body = await helpers.readJsonBody(req, res, { maxBytes });
-    if (!body)
-        return null;
-    const normalizedPrompt = normalizeIncomingChatPrompt(body.text, body.images);
-    if (!normalizedPrompt) {
-        helpers.error(res, "text is required");
-        return null;
-    }
-    const channelType = parseRequestChannelType(body.channelType, ChannelType.DM);
-    if (!channelType) {
-        helpers.error(res, "channelType is invalid", 400);
-        return null;
-    }
-    const conversationMode = parseConversationMode(body.conversationMode);
-    if (conversationMode === null) {
-        helpers.error(res, "conversationMode is invalid", 400);
-        return null;
-    }
-    const imageValidationError = validateChatImages(body.images);
-    if (imageValidationError) {
-        helpers.error(res, imageValidationError, 400);
-        return null;
-    }
-    const images = Array.isArray(body.images)
-        ? body.images.map((img) => ({
-            ...img,
-            mimeType: img.mimeType.toLowerCase(),
-        }))
-        : undefined;
-    const rawPreferredLanguage = (typeof body.language === "string" && body.language.trim()
-        ? body.language
-        : undefined) ?? readUiLanguageHeader(req);
-    const preferredLanguage = rawPreferredLanguage
-        ? normalizeCharacterLanguage(rawPreferredLanguage)
-        : undefined;
-    const source = typeof body.source === "string" && body.source.trim().length > 0
-        ? body.source.trim()
-        : undefined;
-    const metadata = body.metadata &&
-        typeof body.metadata === "object" &&
-        !Array.isArray(body.metadata)
-        ? body.metadata
-        : undefined;
-    return {
-        prompt: normalizedPrompt,
-        channelType,
-        images,
-        ...(conversationMode ? { conversationMode } : {}),
-        ...(preferredLanguage ? { preferredLanguage } : {}),
-        ...(source ? { source } : {}),
-        ...(metadata ? { metadata } : {}),
-    };
-}
-function readMessageTrajectoryStepId(message) {
-    const metadata = message.metadata;
-    if (!metadata || typeof metadata !== "object")
-        return null;
-    const stepId = metadata.trajectoryStepId;
-    return typeof stepId === "string" && stepId.trim().length > 0
-        ? stepId.trim()
-        : null;
-}
-function readMessageTrajectoryGrouping(message) {
-    const contentMetadata = asRecord(message.content.metadata) ?? {};
-    const evalMetadata = asRecord(contentMetadata.eval) ?? {};
-    const messageMetadata = asRecord(message.metadata) ?? {};
-    return resolveTrajectoryGrouping({
-        ...contentMetadata,
-        ...evalMetadata,
-        ...messageMetadata,
-    });
-}
-async function persistMessageTrajectoryGrouping(runtime, message) {
-    const stepId = readMessageTrajectoryStepId(message);
-    if (!stepId)
-        return;
-    const grouping = readMessageTrajectoryGrouping(message);
-    if (!grouping.scenarioId && !grouping.batchId)
-        return;
-    await startTrajectoryStepInDatabase({
-        runtime,
-        stepId,
-        source: typeof message.content.source === "string" &&
-            message.content.source.trim().length > 0
-            ? message.content.source
-            : undefined,
-        metadata: {
-            ...(grouping.scenarioId ? { scenarioId: grouping.scenarioId } : {}),
-            ...(grouping.batchId ? { batchId: grouping.batchId } : {}),
-        },
-    });
-}
-function buildChatUsage(runtime, message, finalText, capturedUsage) {
-    const model = capturedUsage?.model ?? detectRuntimeModel(runtime, undefined) ?? undefined;
-    if (capturedUsage) {
-        return {
-            promptTokens: capturedUsage.promptTokens,
-            completionTokens: capturedUsage.completionTokens,
-            totalTokens: capturedUsage.totalTokens,
-            ...(model ? { model } : {}),
-            ...(capturedUsage.provider ? { provider: capturedUsage.provider } : {}),
-            isEstimated: capturedUsage.isEstimated,
-            llmCalls: capturedUsage.llmCalls,
-        };
-    }
-    const promptText = extractCompatTextContent(message.content) ?? "";
-    const promptTokens = estimateTokenCount(promptText);
-    const completionTokens = estimateTokenCount(finalText);
-    return {
-        promptTokens,
-        completionTokens,
-        totalTokens: promptTokens + completionTokens,
-        ...(model ? { model } : {}),
-        isEstimated: true,
-        llmCalls: 0,
-    };
-}
-// ---------------------------------------------------------------------------
-// generateChatResponse
-// ---------------------------------------------------------------------------
-export async function generateChatResponse(runtime, message, agentName, opts) {
-    const generationTimeoutMs = resolveChatGenerationTimeoutMs(opts?.timeoutDuration);
-    let generationTimedOut = false;
-    if (generationTimeoutMs <= 1) {
-        generationTimedOut = true;
-        throw createChatGenerationTimeoutError(generationTimeoutMs);
-    }
-    try {
-        const originalUserText = String(extractCompatTextContent(message.content) ?? "");
-        let responseText = "";
-        let forcedWalletExecutionText = false;
-        let activeStreamSource = "unset";
-        const actionCallbackHistory = [];
-        // Snapshot of `responseText` at the moment the first action callback runs.
-        // WHY: LLM streaming genuinely appends token deltas. Action handlers that
-        // call HandlerCallback multiple times (Discord "progressive message" pattern)
-        // send unrelated status strings — merging them with mergeStreamingText would
-        // concatenate ("🔍…" + "✨…" + "Now playing…"). We preserve the streamed
-        // prefix and replace only the callback suffix so the dashboard SSE client
-        // gets snapshot fullText updates (same UX as editing one chat bubble).
-        let preCallbackText = null;
-        const messageSource = typeof message.content.source === "string" &&
-            message.content.source.trim().length > 0
-            ? message.content.source
-            : "api";
-        const emitChunk = (chunk) => {
-            if (!chunk)
-                return;
-            responseText += chunk;
-            opts?.onChunk?.(chunk);
-        };
-        const emitSnapshot = (text) => {
-            if (!text)
-                return;
-            responseText = text;
-            opts?.onSnapshot?.(text);
-        };
-        const claimStreamSource = (source) => {
-            if (activeStreamSource === "unset") {
-                activeStreamSource = source;
-                return true;
-            }
-            return activeStreamSource === source;
-        };
-        const appendIncomingText = (incoming) => {
-            const update = resolveStreamingUpdate(responseText, incoming);
-            if (update.kind === "noop")
-                return;
-            if (update.kind === "append") {
-                emitChunk(update.emittedText);
-                return;
-            }
-            emitSnapshot(update.nextText);
-        };
-        const captureCallbackBaseline = () => {
-            if (preCallbackText === null) {
-                preCallbackText = responseText;
-            }
-        };
-        const recordActionCallbackText = (incoming) => {
-            const normalized = normalizeActionCallbackText(incoming);
-            if (!normalized)
-                return;
-            if (actionCallbackHistory.at(-1) === normalized)
-                return;
-            actionCallbackHistory.push(normalized);
-        };
-        /** Latest action callback wins: replaces prior callback text, keeps LLM prefix. */
-        const replaceCallbackText = (incoming) => {
-            recordActionCallbackText(incoming);
-            captureCallbackBaseline();
-            const baseline = preCallbackText ?? "";
-            const separator = baseline.length > 0 ? "\n\n" : "";
-            const nextText = `${baseline}${separator}${incoming}`;
-            emitSnapshot(nextText);
-        };
-        const applyCallbackTextUpdate = (content, incoming) => {
-            captureCallbackBaseline();
-            if (resolveCallbackMergeMode(content) === "append") {
-                recordActionCallbackText(incoming);
-                appendIncomingText(incoming);
-                return;
-            }
-            replaceCallbackText(incoming);
-        };
-        // Emit inbound events so trajectory/session hooks run for API chat.
-        try {
-            if (typeof runtime.emitEvent === "function") {
-                await runtime.emitEvent("MESSAGE_RECEIVED", {
-                    message,
-                    source: messageSource,
-                });
-            }
-        }
-        catch (err) {
-            runtime.logger?.warn({
-                err,
-                src: "eliza-api",
-                messageId: message.id,
-                roomId: message.roomId,
-            }, "Failed to emit MESSAGE_RECEIVED event");
-        }
-        const trajectoryStepId = readMessageTrajectoryStepId(message);
-        const trajectoryContext = typeof trajectoryStepId === "string" && trajectoryStepId.trim().length > 0
-            ? { trajectoryStepId: trajectoryStepId.trim() }
-            : undefined;
-        let result;
-        let capturedUsage = null;
-        let actionCallbacksSeen = 0;
-        const seenActionTags = new Set();
-        const recordActionCallback = (actionTag, hasText) => {
-            actionCallbacksSeen += 1;
-            const normalizedActionTag = normalizeActionName(actionTag);
-            if (normalizedActionTag) {
-                seenActionTags.add(normalizedActionTag);
-            }
-            runtime.logger?.info({
-                src: "eliza-api",
-                action: normalizedActionTag || actionTag,
-                hasText,
-            }, `[eliza-api] Action callback fired: ${normalizedActionTag || actionTag}`);
-        };
-        const extractCallbackActionTag = (content) => {
-            const record = content;
-            if (typeof record.action === "string" && record.action.length > 0) {
-                return record.action;
-            }
-            if (Array.isArray(record.actions)) {
-                const firstAction = record.actions.find((action) => typeof action === "string" && action.trim().length > 0);
-                if (firstAction)
-                    return firstAction;
-            }
-            return "VISIBLE_CALLBACK";
-        };
-        const generationCapture = await withModelUsageCapture(runtime, () => withTimeout(Promise.resolve(runWithTrajectoryContext(trajectoryContext, async () => {
-            // Binance skill direct dispatch
-            const directSkillText = await maybeHandleDirectBinanceSkillRequest(runtime, message, replaceCallbackText, emitSnapshot);
-            if (directSkillText) {
-                const finalText = isClientVisibleNoResponse(directSkillText)
-                    ? directSkillText || "(no response)"
-                    : directSkillText;
-                result = {
-                    didRespond: true,
-                    responseContent: { text: finalText },
-                    responseMessages: [],
-                };
-                responseText = finalText;
-                forcedWalletExecutionText =
-                    isClientVisibleNoResponse(directSkillText);
-                return;
-            }
-            // Direct dispatch for explicit task creation intent from UI
-            const contentMetadata = message.content.metadata;
-            if (contentMetadata?.intent === "create_task") {
-                const coordinator = runtime.getService("SWARM_COORDINATOR");
-                if (coordinator) {
-                    const createTaskAction = runtime.actions.find((a) => a?.name?.toUpperCase() === "START_CODING_TASK") ??
-                        runtime.actions.find((a) => a?.name?.toUpperCase() === "CREATE_TASK");
-                    if (createTaskAction) {
-                        runtime.logger?.info({
-                            src: "eliza-api",
-                            agentType: contentMetadata.agentType,
-                            intent: "create_task",
-                        }, "[eliza-api] Direct dispatch START_CODING_TASK from UI intent");
-                        let actionResponseText = "";
-                        await createTaskAction.handler(runtime, message, undefined, {}, async (content) => {
-                            if (generationTimedOut || opts?.isAborted?.()) {
-                                throw createChatGenerationTimeoutError(generationTimeoutMs);
-                            }
-                            const chunk = extractCompatTextContent(content);
-                            if (chunk) {
-                                applyCallbackTextUpdate(content, chunk);
-                                actionResponseText = responseText;
-                            }
-                            return [];
-                        });
-                        const finalText = actionResponseText || responseText || "Task created.";
-                        result = {
-                            didRespond: true,
-                            responseContent: { text: finalText },
-                            responseMessages: [],
-                        };
-                        responseText = finalText;
-                        return;
-                    }
-                }
-                // Fall through to normal LLM-based routing if coordinator not available
-            }
-            const localInferenceIntent = detectLocalInferenceCommandIntent(originalUserText, {
-                localInferenceContext: hasLocalInferenceMetadata(message),
-            });
-            if (localInferenceIntent) {
-                const localResult = await handleLocalInferenceChatCommand(localInferenceIntent, originalUserText);
-                emitSnapshot(localResult.text);
-                result = {
-                    didRespond: true,
-                    responseContent: {
-                        text: localResult.text,
-                        source: "client_chat",
-                        actions: ["REPLY"],
-                        localInference: localResult.localInference,
-                        failureKind: localResult.localInference.status === "failed" ||
-                            localResult.localInference.status === "no_space"
-                            ? "local_inference"
-                            : undefined,
-                    },
-                    responseMessages: [],
-                };
-                responseText = localResult.text;
-                return;
-            }
-            if (isMobileLocalSimpleChat(message)) {
-                const simpleResult = await generateMobileLocalSimpleReply(runtime, message, agentName, opts);
-                if (simpleResult) {
-                    result = {
-                        didRespond: true,
-                        responseContent: simpleResult.responseContent,
-                        responseMessages: simpleResult.responseMessages ?? [],
-                    };
-                    responseText = simpleResult.text;
-                    return;
-                }
-            }
-            const languageAugmentedMessage = maybeAugmentChatMessageWithLanguage(message, opts?.preferredLanguage);
-            const walletAugmentedMessage = maybeAugmentChatMessageWithWalletContext(runtime, languageAugmentedMessage);
-            const generationMessage = await maybeAugmentChatMessageWithDocuments(runtime, walletAugmentedMessage);
-            result = await runtime.messageService?.handleMessage(runtime, generationMessage, async (content) => {
-                if (generationTimedOut || opts?.isAborted?.()) {
-                    throw createChatGenerationTimeoutError(generationTimeoutMs);
-                }
-                const chunk = extractCompatTextContent(content);
-                recordActionCallback(extractCallbackActionTag(content), Boolean(chunk));
-                if (!chunk)
-                    return [];
-                if (!claimStreamSource("callback"))
-                    return [];
-                applyCallbackTextUpdate(content, chunk);
-                return [];
-            }, {
-                timeoutDuration: generationTimeoutMs,
-                keepExistingResponses: true,
-                onStreamChunk: opts?.onChunk
-                    ? async (chunk) => {
-                        if (generationTimedOut || opts?.isAborted?.()) {
-                            throw createChatGenerationTimeoutError(generationTimeoutMs);
-                        }
-                        if (!chunk)
-                            return;
-                        if (!claimStreamSource("onStreamChunk"))
-                            return;
-                        appendIncomingText(chunk);
-                    }
-                    : undefined,
-            });
-            // Ensure MESSAGE_SENT hooks run for API chat flows.
-            try {
-                const responseMessages = Array.isArray(result?.responseMessages)
-                    ? result.responseMessages
-                    : [];
-                const fallbackResponseContent = result?.responseContent &&
-                    typeof result.responseContent === "object"
-                    ? result.responseContent
-                    : responseText
-                        ? { text: responseText }
-                        : null;
-                const messagesToEmit = responseMessages.length > 0
-                    ? responseMessages
-                    : fallbackResponseContent
-                        ? [
-                            {
-                                id: crypto.randomUUID(),
-                                content: fallbackResponseContent,
-                            },
-                        ]
-                        : [];
-                if (messagesToEmit.length > 0 &&
-                    typeof runtime.emitEvent === "function") {
-                    for (const responseMessage of messagesToEmit) {
-                        const memoryLike = createMessageMemory({
-                            id: responseMessage.id ??
-                                crypto.randomUUID(),
-                            roomId: message.roomId,
-                            entityId: runtime.agentId,
-                            content: ensureMessageMemoryContent(responseMessage.content ?? { text: "" }),
-                        });
-                        memoryLike.metadata = message.metadata;
-                        await runtime.emitEvent("MESSAGE_SENT", {
-                            message: memoryLike,
-                            source: messageSource,
-                        });
-                    }
-                }
-            }
-            catch (err) {
-                runtime.logger?.warn({
-                    err,
-                    src: "eliza-api",
-                    messageId: message.id,
-                    roomId: message.roomId,
-                }, "Failed to emit MESSAGE_SENT event");
-            }
-            // Post-process fallback actions
-            if (result) {
-                const rc = result.responseContent;
-                const resultRecord = asRecord(result);
-                runtime.logger?.info({
-                    src: "eliza-api",
-                    mode: resultRecord?.mode,
-                    actions: rc?.actions,
-                    simple: rc?.simple,
-                    hasText: Boolean(rc?.text),
-                }, "[eliza-api] Chat response metadata");
-                const rawActionsPayload = rc?.actions ?? resultRecord?.actions;
-                const modelText = String(extractCompatTextContent(result.responseContent) ?? "");
-                const parsedFallbackActions = parseFallbackActionBlocks(rawActionsPayload, modelText);
-                const actionNameLookup = buildRuntimeActionNameLookup(runtime);
-                const executedRuntimeActions = listExecutedRuntimeActions(runtime, typeof message.id === "string" ? message.id : undefined);
-                // Only run fallback execution when the core did NOT dispatch actions itself.
-                const coreHandledActions = resultRecord?.mode === "actions";
-                const executableFallbackActions = parsedFallbackActions.filter((action) => {
-                    if (!isExecutableFallbackAction(action)) {
-                        return false;
-                    }
-                    const canonicalName = actionNameLookup.get(normalizeActionName(action.name)) ??
-                        normalizeActionName(action.name);
-                    return !executedRuntimeActions.has(canonicalName);
-                });
-                if (actionCallbacksSeen === 0 &&
-                    !coreHandledActions &&
-                    executableFallbackActions.length > 0) {
-                    const selfControlFallbackActions = executableFallbackActions.filter((action) => {
-                        const canonicalName = actionNameLookup.get(normalizeActionName(action.name)) ??
-                            normalizeActionName(action.name);
-                        return canonicalName === "WEBSITE_BLOCK";
-                    });
-                    const callbacksBeforeFallback = actionCallbacksSeen;
-                    if (selfControlFallbackActions.length > 0) {
-                        await executeFallbackParsedActions(runtime, message, selfControlFallbackActions, appendIncomingText, recordActionCallback, {
-                            getCurrentText: () => responseText || modelText,
-                        });
-                    }
-                    const selfControlFallbackExecuted = actionCallbacksSeen > callbacksBeforeFallback;
-                    const remainingExecutableFallbackActions = executableFallbackActions.filter((action) => {
-                        const canonicalName = actionNameLookup.get(normalizeActionName(action.name)) ??
-                            normalizeActionName(action.name);
-                        if (canonicalName === "WEBSITE_BLOCK") {
-                            return !selfControlFallbackExecuted;
-                        }
-                        return true;
-                    });
-                    if (remainingExecutableFallbackActions.length > 0) {
-                        runtime.logger?.error({
-                            src: "eliza-api",
-                            parsedActions: remainingExecutableFallbackActions.map((a) => a.name),
-                        }, "[eliza-api] Unexecuted action payload detected; failing closed");
-                        const failureText = buildUnexecutedActionPayloadReply(remainingExecutableFallbackActions.map((action) => action.name));
-                        if (opts?.onSnapshot) {
-                            emitSnapshot(failureText);
-                        }
-                        else {
-                            responseText = failureText;
-                        }
-                    }
-                    if (remainingExecutableFallbackActions.some((action) => normalizeActionName(action.name) === "CHECK_BALANCE")) {
-                        forcedWalletExecutionText = true;
-                    }
-                }
-            }
-        })), generationTimeoutMs, () => createChatGenerationTimeoutError(generationTimeoutMs), () => {
-            generationTimedOut = true;
-        }));
-        capturedUsage = generationCapture.usage;
-        const responseMessageText = getLatestVisibleResponseMessageText(result?.responseMessages);
-        const resultText = responseMessageText ||
-            extractCompatTextContent(result?.responseContent) ||
-            "";
-        // Fallback: if callbacks weren't used for text, stream + return final text.
-        if (!responseText && resultText) {
-            if (opts?.onSnapshot) {
-                emitSnapshot(resultText);
-            }
-            else {
-                emitChunk(resultText);
-            }
-        }
-        else if (actionCallbacksSeen === 0 &&
-            resultText &&
-            resultText !== responseText &&
-            resultText.startsWith(responseText)) {
-            emitChunk(resultText.slice(responseText.length));
-        }
-        else if (actionCallbacksSeen === 0 &&
-            resultText &&
-            resultText !== responseText &&
-            !forcedWalletExecutionText) {
-            if (opts?.onSnapshot) {
-                emitSnapshot(resultText);
-            }
-            else {
-                responseText = resultText;
-            }
-        }
-        if (actionCallbacksSeen === 0 &&
-            isWalletActionRequiredIntent(originalUserText)) {
-            const failureText = buildWalletActionNotExecutedReply(runtime, originalUserText.trim());
-            if (opts?.onSnapshot) {
-                emitSnapshot(failureText);
-            }
-            else {
-                responseText = failureText;
-            }
-        }
-        const noResponseFallback = opts?.resolveNoResponseText?.();
-        const exactDocumentValue = await resolveExactDocumentValueForChat(runtime, message);
-        const normalizedResponseText = trimWalletProgressPrefix(exactDocumentValue || responseText || resultText || "");
-        const intentionalNoResponse = isIntentionalNoResponseResult(result, normalizedResponseText);
-        const finalText = intentionalNoResponse
-            ? ""
-            : isClientVisibleNoResponse(normalizedResponseText)
-                ? (noResponseFallback ??
-                    (normalizedResponseText || responseText || "(no response)"))
-                : normalizedResponseText;
-        const responseMessages = Array.isArray(result?.responseMessages)
-            ? result.responseMessages.map((entry) => ({
-                ...(entry?.id ? { id: entry.id } : {}),
-                ...(entry?.content ? { content: entry.content } : {}),
-            }))
-            : [];
-        const responseContent = result?.responseContent && typeof result.responseContent === "object"
-            ? {
-                ...result.responseContent,
-                text: finalText,
-            }
-            : finalText
-                ? { text: finalText }
-                : null;
-        const responseRecord = responseContent;
-        const localInference = responseRecord?.localInference &&
-            typeof responseRecord.localInference === "object"
-            ? responseRecord.localInference
-            : undefined;
-        const failureKind = responseRecord?.failureKind === "local_inference"
-            ? "local_inference"
-            : undefined;
-        return {
-            text: finalText,
-            agentName,
-            ...(intentionalNoResponse
-                ? { noResponseReason: "ignored" }
-                : {}),
-            ...(failureKind ? { failureKind } : {}),
-            ...(localInference ? { localInference } : {}),
-            ...(actionCallbacksSeen > 0 ? { usedActionCallbacks: true } : {}),
-            ...(actionCallbackHistory.length > 0
-                ? { actionCallbackHistory: [...actionCallbackHistory] }
-                : {}),
-            ...(responseContent ? { responseContent } : {}),
-            ...(responseMessages.length > 0 ? { responseMessages } : {}),
-            usage: buildChatUsage(runtime, message, finalText, capturedUsage),
-        };
-    }
-    finally {
-        try {
-            await persistMessageTrajectoryGrouping(runtime, message);
-        }
-        catch (err) {
-            runtime.logger?.warn({
-                err,
-                src: "eliza-api",
-                messageId: message.id,
-                roomId: message.roomId,
-            }, "Failed to persist trajectory grouping metadata");
-        }
-    }
-}
-// ---------------------------------------------------------------------------
-// generateConversationTitle
-// ---------------------------------------------------------------------------
-export async function generateConversationTitle(runtime, userMessage, agentName) {
-    const modelClass = ModelType.TEXT_SMALL;
-    const prompt = `Based on the user's first message in a new chat, generate a very short, concise title (max 4-5 words) for the conversation.
-The agent's name is "${agentName}". The title should reflect the topic or intent of the user.
-Ideally, the title should fit the persona/vibe of the agent if possible, but clarity is more important.
-Do not use quotes. Do not include "Title:" prefix.
-
-User message: "${userMessage}"
-
-Title:`;
-    try {
-        const title = await runtime.useModel(modelClass, {
-            prompt,
-            maxTokens: 20,
-            temperature: 0.7,
-        });
-        if (!title)
-            return null;
-        let cleanTitle = title.trim();
-        if ((cleanTitle.startsWith('"') && cleanTitle.endsWith('"')) ||
-            (cleanTitle.startsWith("'") && cleanTitle.endsWith("'"))) {
-            cleanTitle = cleanTitle.slice(1, -1);
-        }
-        if (!cleanTitle || cleanTitle.length > 50)
-            return null;
-        return cleanTitle;
-    }
-    catch (err) {
-        logger.warn(`[eliza] Failed to generate conversation title: ${err instanceof Error ? err.message : String(err)}`);
-        return null;
-    }
-}
-export function resolveChatAdminEntityId(state) {
-    return resolveClientChatAdminEntityId(state);
-}
-async function ensureCompatChatConnection(state, runtime, agentName, channelIdPrefix, roomKey) {
-    const userId = ensureAdminEntityIdForChat(state);
-    const roomId = stringToUuid(`${agentName}-${channelIdPrefix}-room-${roomKey}`);
-    const worldId = stringToUuid(`${agentName}-web-chat-world`);
-    const messageServerId = stringToUuid(`${agentName}-web-server`);
-    await runtime.ensureConnection({
-        entityId: userId,
-        roomId,
-        worldId,
-        userName: resolveAppUserName(state.config),
-        source: "client_chat",
-        channelId: `${channelIdPrefix}-${roomKey}`,
-        type: ChannelType.DM,
-        messageServerId,
-        metadata: { ownership: { ownerId: userId } },
-    });
-    // Ensure world ownership
-    const world = await runtime.getWorld(worldId);
-    if (world) {
-        let needsUpdate = false;
-        if (!world.metadata) {
-            world.metadata = {};
-            needsUpdate = true;
-        }
-        if (!world.metadata.ownership ||
-            typeof world.metadata.ownership !== "object" ||
-            world.metadata.ownership.ownerId !== userId) {
-            world.metadata.ownership = { ownerId: userId };
-            needsUpdate = true;
-        }
-        const metadataWithRoles = world.metadata;
-        const roles = metadataWithRoles.roles ?? {};
-        if (roles[userId] !== "OWNER") {
-            roles[userId] = "OWNER";
-            metadataWithRoles.roles = roles;
-            needsUpdate = true;
-        }
-        if (needsUpdate) {
-            await runtime.updateWorld(world);
-        }
-    }
-    return { userId, roomId, worldId };
-}
-function ensureAdminEntityIdForChat(state) {
-    return resolveChatAdminEntityId(state);
-}
-function syncRuntimeCharacterToChatStateConfig(state) {
-    if (!state.runtime || !state.config) {
-        return;
-    }
-    syncCharacterIntoConfig(state.config, state.runtime.character);
-}
-// ---------------------------------------------------------------------------
-// Main route handler
-// ---------------------------------------------------------------------------
-export async function handleChatRoutes(ctx) {
-    const { req, res, method, pathname, readJsonBody, json, state } = ctx;
-    // ── GET /v1/models (OpenAI compatible) ─────────────────────────────────
-    if (method === "GET" && pathname === "/v1/models") {
-        const created = Math.floor(Date.now() / 1000);
-        const ids = new Set();
-        ids.add("eliza");
-        if (state.agentName?.trim())
-            ids.add(state.agentName.trim());
-        if (state.runtime?.character.name?.trim())
-            ids.add(state.runtime.character.name.trim());
-        json(res, {
-            object: "list",
-            data: Array.from(ids).map((id) => ({
-                id,
-                object: "model",
-                created,
-                owned_by: "eliza",
-            })),
-        });
-        return true;
-    }
-    // ── GET /v1/models/:id (OpenAI compatible) ─────────────────────────────
-    if (method === "GET" && /^\/v1\/models\/[^/]+$/.test(pathname)) {
-        const created = Math.floor(Date.now() / 1000);
-        const raw = pathname.split("/")[3] ?? "";
-        const decoded = decodePathComponent(raw, res, "model id");
-        if (!decoded)
-            return true;
-        const id = decoded.trim();
-        if (!id) {
-            json(res, {
-                error: {
-                    message: "Model id is required",
-                    type: "invalid_request_error",
-                },
-            }, 400);
-            return true;
-        }
-        json(res, { id, object: "model", created, owned_by: "eliza" });
-        return true;
-    }
-    // ── POST /v1/chat/completions (OpenAI compatible) ──────────────────────
-    if (method === "POST" && pathname === "/v1/chat/completions") {
-        const body = await readJsonBody(req, res);
-        if (!body)
-            return true;
-        if (hasBlockedObjectKeyDeep(body)) {
-            json(res, {
-                error: {
-                    message: "Request body contains a blocked object key",
-                    type: "invalid_request_error",
-                },
-            }, 400);
-            return true;
-        }
-        const safeBody = cloneWithoutBlockedObjectKeys(body);
-        const extracted = extractOpenAiSystemAndLastUser(safeBody.messages);
-        if (!extracted) {
-            json(res, {
-                error: {
-                    message: "messages must be an array containing at least one user message",
-                    type: "invalid_request_error",
-                },
-            }, 400);
-            return true;
-        }
-        const roomKey = resolveCompatRoomKey(safeBody).slice(0, 120);
-        const wantsStream = safeBody.stream === true ||
-            (req.headers.accept ?? "").includes("text/event-stream");
-        const requestedModel = typeof safeBody.model === "string" && safeBody.model.trim()
-            ? safeBody.model.trim()
-            : null;
-        const prompt = extracted.system
-            ? `${extracted.system}\n\n${extracted.user}`.trim()
-            : extracted.user;
-        const created = Math.floor(Date.now() / 1000);
-        const id = `chatcmpl-${crypto.randomUUID()}`;
-        const model = requestedModel ?? state.agentName ?? "eliza";
-        if (wantsStream) {
-            initSse(res);
-            let aborted = false;
-            req.on("close", () => {
-                aborted = true;
-            });
-            const sendChunk = (delta, finishReason) => {
-                writeSseData(res, JSON.stringify({
-                    id,
-                    object: "chat.completion.chunk",
-                    created,
-                    model,
-                    choices: [
-                        {
-                            index: 0,
-                            delta,
-                            finish_reason: finishReason,
-                        },
-                    ],
-                }));
-            };
-            try {
-                if (!state.runtime) {
-                    writeSseData(res, JSON.stringify({
-                        error: {
-                            message: "Agent is not running",
-                            type: "service_unavailable",
-                        },
-                    }));
-                    writeSseData(res, "[DONE]");
-                    return true;
-                }
-                sendChunk({ role: "assistant" }, null);
-                let fullText = "";
-                {
-                    const runtime = state.runtime;
-                    if (!runtime)
-                        throw new Error("Agent is not running");
-                    const agentName = runtime.character.name ?? "Eliza";
-                    const { userId, roomId } = await ensureCompatChatConnection(state, runtime, agentName, "openai-compat", roomKey);
-                    const message = createMessageMemory({
-                        id: crypto.randomUUID(),
-                        entityId: userId,
-                        agentId: runtime.agentId,
-                        roomId,
-                        content: {
-                            text: prompt,
-                            source: "compat_openai",
-                            channelType: ChannelType.API,
-                        },
-                    });
-                    const result = await generateChatResponse(runtime, message, state.agentName, {
-                        isAborted: () => aborted,
-                        onChunk: (chunk) => {
-                            fullText += chunk;
-                            if (chunk)
-                                sendChunk({ content: chunk }, null);
-                        },
-                        resolveNoResponseText: () => resolveNoResponseFallback(state.logBuffer, runtime),
-                    });
-                    if (result.localInference && !fullText) {
-                        fullText = result.text;
-                        sendChunk({ content: result.text }, null);
-                    }
-                    syncRuntimeCharacterToChatStateConfig(state);
-                }
-                const resolved = normalizeChatResponseText(fullText, state.logBuffer, state.runtime);
-                if ((fullText.trim().length === 0 || isNoResponsePlaceholder(fullText)) &&
-                    resolved.trim()) {
-                    sendChunk({ content: resolved }, null);
-                }
-                sendChunk({}, "stop");
-                writeSseData(res, "[DONE]");
-            }
-            catch (err) {
-                if (!aborted) {
-                    if (isLocalInferenceError(err)) {
-                        const localFailure = await getLocalInferenceChatStatus("status", err);
-                        writeSseData(res, JSON.stringify({
-                            error: {
-                                message: localFailure.text,
-                                type: "local_inference",
-                                localInference: localFailure.localInference,
-                            },
-                        }));
-                    }
-                    else if (isNoProviderError(err)) {
-                        writeSseData(res, JSON.stringify({
-                            error: {
-                                message: NO_PROVIDER_CHAT_MESSAGE,
-                                type: "no_provider",
-                                code: "NO_PROVIDER_REGISTERED",
-                            },
-                        }));
-                    }
-                    else {
-                        writeSseData(res, JSON.stringify({
-                            error: {
-                                message: getErrorMessage(err),
-                                type: "server_error",
-                            },
-                        }));
-                    }
-                    writeSseData(res, "[DONE]");
-                }
-            }
-            finally {
-                res.end();
-            }
-            return true;
-        }
-        // Non-streaming
-        try {
-            let responseText;
-            let localInference;
-            let failureKind;
-            {
-                if (!state.runtime) {
-                    json(res, {
-                        error: {
-                            message: "Agent is not running",
-                            type: "service_unavailable",
-                        },
-                    }, 503);
-                    return true;
-                }
-                const runtime = state.runtime;
-                const agentName = runtime.character.name ?? "Eliza";
-                const { userId, roomId } = await ensureCompatChatConnection(state, runtime, agentName, "openai-compat", roomKey);
-                const message = createMessageMemory({
-                    id: crypto.randomUUID(),
-                    entityId: userId,
-                    roomId,
-                    content: {
-                        text: prompt,
-                        source: "compat_openai",
-                        channelType: ChannelType.API,
-                    },
-                });
-                const result = await generateChatResponse(runtime, message, state.agentName, {
-                    resolveNoResponseText: () => resolveNoResponseFallback(state.logBuffer, runtime),
-                });
-                syncRuntimeCharacterToChatStateConfig(state);
-                responseText = result.text;
-                localInference = result.localInference;
-                failureKind = result.failureKind;
-            }
-            const resolvedText = normalizeChatResponseText(responseText, state.logBuffer, state.runtime);
-            json(res, {
-                id,
-                object: "chat.completion",
-                created,
-                model,
-                choices: [
-                    {
-                        index: 0,
-                        message: { role: "assistant", content: resolvedText },
-                        finish_reason: "stop",
-                    },
-                ],
-                ...(failureKind ? { failureKind } : {}),
-                ...(localInference ? { localInference } : {}),
-            });
-        }
-        catch (err) {
-            if (isLocalInferenceError(err)) {
-                const localFailure = await getLocalInferenceChatStatus("status", err);
-                json(res, {
-                    error: {
-                        message: localFailure.text,
-                        type: "local_inference",
-                        localInference: localFailure.localInference,
-                    },
-                }, 503);
-            }
-            else if (isNoProviderError(err)) {
-                json(res, {
-                    error: {
-                        message: NO_PROVIDER_CHAT_MESSAGE,
-                        type: "no_provider",
-                        code: "NO_PROVIDER_REGISTERED",
-                    },
-                }, 503);
-            }
-            else {
-                json(res, { error: { message: getErrorMessage(err), type: "server_error" } }, 500);
-            }
-        }
-        return true;
-    }
-    // ── POST /v1/messages (Anthropic compatible) ───────────────────────────
-    if (method === "POST" && pathname === "/v1/messages") {
-        const body = await readJsonBody(req, res);
-        if (!body)
-            return true;
-        if (hasBlockedObjectKeyDeep(body)) {
-            json(res, {
-                error: {
-                    type: "invalid_request_error",
-                    message: "Request body contains a blocked object key",
-                },
-            }, 400);
-            return true;
-        }
-        const safeBody = cloneWithoutBlockedObjectKeys(body);
-        const extracted = extractAnthropicSystemAndLastUser({
-            system: safeBody.system,
-            messages: safeBody.messages,
-        });
-        if (!extracted) {
-            json(res, {
-                error: {
-                    type: "invalid_request_error",
-                    message: "messages must be an array containing at least one user message",
-                },
-            }, 400);
-            return true;
-        }
-        const roomKey = resolveCompatRoomKey(safeBody).slice(0, 120);
-        const wantsStream = safeBody.stream === true ||
-            (req.headers.accept ?? "").includes("text/event-stream");
-        const requestedModel = typeof safeBody.model === "string" && safeBody.model.trim()
-            ? safeBody.model.trim()
-            : null;
-        const prompt = extracted.system
-            ? `${extracted.system}\n\n${extracted.user}`.trim()
-            : extracted.user;
-        const id = `msg_${crypto.randomUUID().replace(/-/g, "")}`;
-        const model = requestedModel ?? state.agentName ?? "eliza";
-        if (wantsStream) {
-            initSse(res);
-            let aborted = false;
-            req.on("close", () => {
-                aborted = true;
-            });
-            try {
-                if (!state.runtime) {
-                    writeSseJson(res, {
-                        type: "error",
-                        error: {
-                            type: "service_unavailable",
-                            message: "Agent is not running",
-                        },
-                    }, "error");
-                    return true;
-                }
-                writeSseJson(res, {
-                    type: "message_start",
-                    message: {
-                        id,
-                        type: "message",
-                        role: "assistant",
-                        model,
-                        content: [],
-                        stop_reason: null,
-                        stop_sequence: null,
-                        usage: { input_tokens: 0, output_tokens: 0 },
-                    },
-                }, "message_start");
-                writeSseJson(res, {
-                    type: "content_block_start",
-                    index: 0,
-                    content_block: { type: "text", text: "" },
-                }, "content_block_start");
-                let fullText = "";
-                const onDelta = (chunk) => {
-                    if (!chunk)
-                        return;
-                    fullText += chunk;
-                    writeSseJson(res, {
-                        type: "content_block_delta",
-                        index: 0,
-                        delta: { type: "text_delta", text: chunk },
-                    }, "content_block_delta");
-                };
-                {
-                    const runtime = state.runtime;
-                    if (!runtime)
-                        throw new Error("Agent is not running");
-                    const agentName = runtime.character.name ?? "Eliza";
-                    const { userId, roomId } = await ensureCompatChatConnection(state, runtime, agentName, "anthropic-compat", roomKey);
-                    const message = createMessageMemory({
-                        id: crypto.randomUUID(),
-                        entityId: userId,
-                        roomId,
-                        content: {
-                            text: prompt,
-                            source: "compat_anthropic",
-                            channelType: ChannelType.API,
-                        },
-                    });
-                    await generateChatResponse(runtime, message, state.agentName, {
-                        isAborted: () => aborted,
-                        onChunk: onDelta,
-                        resolveNoResponseText: () => resolveNoResponseFallback(state.logBuffer, runtime),
-                    });
-                    syncRuntimeCharacterToChatStateConfig(state);
-                }
-                const resolved = normalizeChatResponseText(fullText, state.logBuffer, state.runtime);
-                if ((fullText.trim().length === 0 || isNoResponsePlaceholder(fullText)) &&
-                    resolved.trim()) {
-                    onDelta(resolved);
-                }
-                writeSseJson(res, { type: "content_block_stop", index: 0 }, "content_block_stop");
-                writeSseJson(res, {
-                    type: "message_delta",
-                    delta: { stop_reason: "end_turn", stop_sequence: null },
-                    usage: { output_tokens: 0 },
-                }, "message_delta");
-                writeSseJson(res, { type: "message_stop" }, "message_stop");
-            }
-            catch (err) {
-                if (!aborted) {
-                    if (isNoProviderError(err)) {
-                        writeSseJson(res, {
-                            type: "error",
-                            error: {
-                                type: "no_provider",
-                                code: "NO_PROVIDER_REGISTERED",
-                                message: NO_PROVIDER_CHAT_MESSAGE,
-                            },
-                        }, "error");
-                    }
-                    else {
-                        writeSseJson(res, {
-                            type: "error",
-                            error: { type: "server_error", message: getErrorMessage(err) },
-                        }, "error");
-                    }
-                }
-            }
-            finally {
-                res.end();
-            }
-            return true;
-        }
-        // Non-streaming
-        try {
-            let responseText;
-            {
-                if (!state.runtime) {
-                    json(res, {
-                        error: {
-                            type: "service_unavailable",
-                            message: "Agent is not running",
-                        },
-                    }, 503);
-                    return true;
-                }
-                const runtime = state.runtime;
-                const agentName = runtime.character.name ?? "Eliza";
-                const { userId, roomId } = await ensureCompatChatConnection(state, runtime, agentName, "anthropic-compat", roomKey);
-                const message = createMessageMemory({
-                    id: crypto.randomUUID(),
-                    entityId: userId,
-                    roomId,
-                    content: {
-                        text: prompt,
-                        source: "compat_anthropic",
-                        channelType: ChannelType.API,
-                    },
-                });
-                const result = await generateChatResponse(runtime, message, state.agentName, {
-                    resolveNoResponseText: () => resolveNoResponseFallback(state.logBuffer, runtime),
-                });
-                syncRuntimeCharacterToChatStateConfig(state);
-                responseText = result.text;
-            }
-            const resolvedText = normalizeChatResponseText(responseText, state.logBuffer, state.runtime);
-            json(res, {
-                id,
-                type: "message",
-                role: "assistant",
-                model,
-                content: [{ type: "text", text: resolvedText }],
-                stop_reason: "end_turn",
-                stop_sequence: null,
-                usage: { input_tokens: 0, output_tokens: 0 },
-            });
-        }
-        catch (err) {
-            if (isNoProviderError(err)) {
-                json(res, {
-                    error: {
-                        type: "no_provider",
-                        code: "NO_PROVIDER_REGISTERED",
-                        message: NO_PROVIDER_CHAT_MESSAGE,
-                    },
-                }, 503);
-            }
-            else {
-                json(res, { error: { type: "server_error", message: getErrorMessage(err) } }, 500);
-            }
-        }
-        return true;
-    }
-    return false;
-}