@elizaos/agent 0.25.8 → 2.0.0-alpha.144

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

@@ -0,0 +1,1485 @@
+/**
+ * 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, createMessageMemory, logger, ModelType, runWithTrajectoryContext, stringToUuid, } from "@elizaos/core";
+// Dynamic import: app-lifeops self-control helpers (optional in minimal builds)
+let hasWebsiteBlockDeferralIntent;
+let hasWebsiteBlockIntent;
+try {
+    const mod = await import("@elizaos/app-lifeops/selfcontrol/selfcontrol");
+    hasWebsiteBlockDeferralIntent = mod.hasWebsiteBlockDeferralIntent;
+    hasWebsiteBlockIntent = mod.hasWebsiteBlockIntent;
+}
+catch {
+    // Self-control module not available — website blocker features disabled
+}
+import { normalizeCharacterLanguage } from "../onboarding-presets.js";
+import { asRecord, 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 { extractAnthropicSystemAndLastUser, extractCompatTextContent, extractOpenAiSystemAndLastUser, resolveCompatRoomKey, } from "./compat-utils.js";
+import { isInsufficientCreditsError, isInsufficientCreditsMessage, } from "./credit-detection.js";
+import { buildWalletActionNotExecutedReply, cloneWithoutBlockedObjectKeys, decodePathComponent, getErrorMessage, hasBlockedObjectKeyDeep, isUuidLike, isWalletActionRequiredIntent, maybeAugmentChatMessageWithKnowledge, maybeAugmentChatMessageWithLanguage, maybeAugmentChatMessageWithWalletContext, normalizeIncomingChatPrompt, resolveAppUserName, trimWalletProgressPrefix, validateChatImages, } from "./server-helpers.js";
+import { resolveStreamingUpdate } from "./streaming-text.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();
+}
+// ---------------------------------------------------------------------------
+// Chat failure / no-response helpers
+// ---------------------------------------------------------------------------
+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.";
+const GENERIC_NO_RESPONSE_CHAT_REPLY = PROVIDER_ISSUE_CHAT_REPLY;
+const DEFAULT_CHAT_GENERATION_TIMEOUT_MS = 90_000;
+const WEBSITE_BLOCK_SUBJECT_RE = /\b(websites?|sites?|domains?|x\.com|twitter\.com)\b/i;
+const WEBSITE_BLOCK_FOLLOW_UP_RE = /\b(do it|do that|block it|block them|go ahead|use self ?control|self ?control now|block the websites?|please do|now)\b/i;
+const WEBSITE_BLOCK_PERMISSION_RE = /\b(permission|permissions|approval|approve|access|admin|administrator|root|sudo|allow|grant|enable)\b/i;
+const WEBSITE_BLOCK_PERMISSION_MODEL_RE = /\b(permission|approval|approve|access|admin|administrator|root|sudo)\b/i;
+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 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 hasWebsiteBlockingPermissionIntent(text) {
+    return (WEBSITE_BLOCK_PERMISSION_RE.test(text) &&
+        /\b(block(?:ing)?|self ?control|hosts? file|websites?)\b/i.test(text));
+}
+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 GENERIC_NO_RESPONSE_CHAT_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() ||
+        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();
+    }
+    return getProviderIssueChatReply();
+}
+export function normalizeChatResponseText(text, logBuffer, runtime) {
+    if (text.trim() === PROVIDER_ISSUE_CHAT_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 inferWebsiteBlockFallback(userText, modelText) {
+    if (hasWebsiteBlockDeferralIntent?.(userText)) {
+        return null;
+    }
+    const userHasBlockIntent = hasWebsiteBlockIntent?.(userText) ?? false;
+    const modelLooksLikeBlockConfirmation = /\b(blocking|block|self ?control)\b/i.test(modelText);
+    const userHasPermissionIntent = hasWebsiteBlockingPermissionIntent(userText);
+    if (userHasPermissionIntent) {
+        return null;
+    }
+    const userLooksLikeBlockIntent = userHasBlockIntent &&
+        (WEBSITE_BLOCK_SUBJECT_RE.test(userText) ||
+            /\b(it|them)\b/i.test(userText));
+    if (userLooksLikeBlockIntent) {
+        return { name: "BLOCK_WEBSITES" };
+    }
+    if (modelLooksLikeBlockConfirmation &&
+        WEBSITE_BLOCK_FOLLOW_UP_RE.test(userText)) {
+        return { name: "BLOCK_WEBSITES" };
+    }
+    return null;
+}
+function inferWebsiteBlockingPermissionFallback(userText, modelText) {
+    const userHasPermissionIntent = hasWebsiteBlockingPermissionIntent(userText);
+    if (userHasPermissionIntent) {
+        return { name: "REQUEST_WEBSITE_BLOCKING_PERMISSION" };
+    }
+    const modelLooksLikePermissionConfirmation = WEBSITE_BLOCK_PERMISSION_MODEL_RE.test(modelText) &&
+        /\b(ask|request|grant|enable|allow|approve|get)\b/i.test(modelText);
+    if (modelLooksLikePermissionConfirmation &&
+        WEBSITE_BLOCK_FOLLOW_UP_RE.test(userText)) {
+        return { name: "REQUEST_WEBSITE_BLOCKING_PERMISSION" };
+    }
+    return null;
+}
+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");
+}
+function buildWebsiteBlockingActionNotExecutedReply(userPrompt) {
+    return [
+        `I could not complete "${userPrompt}" because no website-blocking action actually ran.`,
+        "No websites were blocked and no permissions were changed.",
+    ].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;
+    }
+    // Fire-and-forget: update relationship strength for co-participants
+    // based on conversation proximity (last N messages in the same room).
+    void import("../services/conversation-proximity.js").then(({ updateProximityRelationships }) => updateProximityRelationships(runtime, memory).catch(() => {
+        /* non-critical — don't fail the chat flow */
+    }));
+}
+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 } : {}),
+        },
+    });
+}
+// ---------------------------------------------------------------------------
+// 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 actionCallbacksSeen = 0;
+        const seenActionTags = new Set();
+        const recordActionCallback = (actionTag, hasText) => {
+            actionCallbacksSeen += 1;
+            seenActionTags.add(actionTag.toUpperCase());
+            runtime.logger?.info({
+                src: "eliza-api",
+                action: actionTag,
+                hasText,
+            }, `[eliza-api] Action callback fired: ${actionTag}`);
+        };
+        await 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() === "CREATE_TASK");
+                    if (createTaskAction) {
+                        runtime.logger?.info({
+                            src: "eliza-api",
+                            agentType: contentMetadata.agentType,
+                            intent: "create_task",
+                        }, "[eliza-api] Direct dispatch CREATE_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 languageAugmentedMessage = maybeAugmentChatMessageWithLanguage(message, opts?.preferredLanguage);
+            const walletAugmentedMessage = maybeAugmentChatMessageWithWalletContext(runtime, languageAugmentedMessage);
+            const generationMessage = await maybeAugmentChatMessageWithKnowledge(runtime, walletAugmentedMessage);
+            result = await runtime.messageService?.handleMessage(runtime, generationMessage, async (content) => {
+                if (generationTimedOut || opts?.isAborted?.()) {
+                    throw createChatGenerationTimeoutError(generationTimeoutMs);
+                }
+                const actionTag = content?.action;
+                if (typeof actionTag === "string" && actionTag.length > 0) {
+                    recordActionCallback(actionTag, Boolean(extractCompatTextContent(content)));
+                }
+                const chunk = extractCompatTextContent(content);
+                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 = {
+                            id: responseMessage.id ?? crypto.randomUUID(),
+                            roomId: message.roomId,
+                            entityId: runtime.agentId,
+                            content: responseMessage.content ?? { text: "" },
+                            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 = 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 === "BLOCK_WEBSITES" ||
+                            canonicalName === "REQUEST_WEBSITE_BLOCKING_PERMISSION");
+                    });
+                    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 === "BLOCK_WEBSITES" ||
+                            canonicalName === "REQUEST_WEBSITE_BLOCKING_PERMISSION") {
+                            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;
+        });
+        const resultText = 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;
+            }
+        }
+        if (actionCallbacksSeen === 0 && !seenActionTags.has("BLOCK_WEBSITES")) {
+            const websiteBlockAttempt = inferWebsiteBlockFallback(originalUserText, responseText || resultText || "");
+            const websitePermissionAttempt = inferWebsiteBlockingPermissionFallback(originalUserText, responseText || resultText || "");
+            if (websiteBlockAttempt || websitePermissionAttempt) {
+                const callbacksBeforeFallback = actionCallbacksSeen;
+                await executeFallbackParsedActions(runtime, message, [
+                    ...(websiteBlockAttempt ? [websiteBlockAttempt] : []),
+                    ...(websitePermissionAttempt ? [websitePermissionAttempt] : []),
+                ], appendIncomingText, recordActionCallback, {
+                    getCurrentText: () => responseText || resultText || "",
+                });
+                if (actionCallbacksSeen === callbacksBeforeFallback) {
+                    const failureText = buildWebsiteBlockingActionNotExecutedReply(originalUserText.trim());
+                    if (opts?.onSnapshot) {
+                        emitSnapshot(failureText);
+                    }
+                    else {
+                        responseText = failureText;
+                    }
+                }
+            }
+        }
+        const noResponseFallback = opts?.resolveNoResponseText?.();
+        const normalizedResponseText = trimWalletProgressPrefix(responseText || resultText || "");
+        const intentionalNoResponse = isIntentionalNoResponseResult(result, normalizedResponseText);
+        const finalText = intentionalNoResponse
+            ? ""
+            : isClientVisibleNoResponse(normalizedResponseText)
+                ? (noResponseFallback ??
+                    (normalizedResponseText || responseText || "(no response)"))
+                : normalizedResponseText;
+        // Estimate token usage from text lengths (~4 chars per token)
+        const promptText = extractCompatTextContent(message.content) ?? "";
+        const estPromptTokens = Math.ceil(promptText.length / 4);
+        const estCompletionTokens = Math.ceil(finalText.length / 4);
+        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;
+        return {
+            text: finalText,
+            agentName,
+            ...(intentionalNoResponse
+                ? { noResponseReason: "ignored" }
+                : {}),
+            ...(actionCallbacksSeen > 0 ? { usedActionCallbacks: true } : {}),
+            ...(actionCallbackHistory.length > 0
+                ? { actionCallbackHistory: [...actionCallbackHistory] }
+                : {}),
+            ...(responseContent ? { responseContent } : {}),
+            ...(responseMessages.length > 0 ? { responseMessages } : {}),
+            usage: {
+                promptTokens: estPromptTokens,
+                completionTokens: estCompletionTokens,
+                totalTokens: estPromptTokens + estCompletionTokens,
+                model: detectRuntimeModel(runtime, undefined) ?? undefined,
+            },
+        };
+    }
+    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;
+    }
+}
+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) {
+    if (state.adminEntityId) {
+        return state.adminEntityId;
+    }
+    const configured = state.config.agents?.defaults?.adminEntityId?.trim();
+    const nextAdminEntityId = configured && isUuidLike(configured)
+        ? configured
+        : stringToUuid(`${state.agentName}-admin-entity`);
+    if (configured && !isUuidLike(configured)) {
+        logger.warn(`[eliza-api] Invalid agents.defaults.adminEntityId "${configured}", using deterministic fallback`);
+    }
+    state.adminEntityId = nextAdminEntityId;
+    state.chatUserId = state.adminEntityId;
+    return nextAdminEntityId;
+}
+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,
+                        },
+                    });
+                    await generateChatResponse(runtime, message, state.agentName, {
+                        isAborted: () => aborted,
+                        onChunk: (chunk) => {
+                            fullText += chunk;
+                            if (chunk)
+                                sendChunk({ content: chunk }, null);
+                        },
+                        resolveNoResponseText: () => resolveNoResponseFallback(state.logBuffer, runtime),
+                    });
+                    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) {
+                    writeSseData(res, JSON.stringify({
+                        error: {
+                            message: getErrorMessage(err),
+                            type: "server_error",
+                        },
+                    }));
+                    writeSseData(res, "[DONE]");
+                }
+            }
+            finally {
+                res.end();
+            }
+            return true;
+        }
+        // Non-streaming
+        try {
+            let responseText;
+            {
+                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;
+            }
+            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",
+                    },
+                ],
+            });
+        }
+        catch (err) {
+            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) {
+                    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) {
+            json(res, { error: { type: "server_error", message: getErrorMessage(err) } }, 500);
+        }
+        return true;
+    }
+    return false;
+}