@elizaos/app-core 2.0.0-beta.3 → 2.0.3-beta.3

package/runtime/mode/remote-forwarder.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"remote-forwarder.d.ts","sourceRoot":"","sources":["../../../../../../src/runtime/mode/remote-forwarder.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAEH,OAAO,KAAK,IAAI,MAAM,WAAW,CAAC;AAelC,wBAAgB,2BAA2B,CACzC,QAAQ,EAAE,MAAM,EAChB,MAAM,EAAE,MAAM,GACb,OAAO,CAKT;AAgBD;;;;;;;;GAQG;AACH,wBAAgB,mBAAmB,CACjC,QAAQ,EAAE,IAAI,CAAC,mBAAmB,EAClC,UAAU,EAAE,MAAM,EAClB,iBAAiB,EAAE,MAAM,GAAG,IAAI,GAC/B,OAAO,CAkBT;AAUD;;;;;GAKG;AACH,wBAAsB,0BAA0B,CAC9C,GAAG,EAAE,IAAI,CAAC,eAAe,EACzB,GAAG,EAAE,IAAI,CAAC,cAAc,GACvB,OAAO,CAAC,OAAO,CAAC,CAkDlB"}
+{"version":3,"file":"remote-forwarder.d.ts","sourceRoot":"","sources":["../../../../../../src/runtime/mode/remote-forwarder.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAEH,OAAO,KAAK,IAAI,MAAM,WAAW,CAAC;AAelC,wBAAgB,2BAA2B,CACzC,QAAQ,EAAE,MAAM,EAChB,MAAM,EAAE,MAAM,GACb,OAAO,CAKT;AAgBD;;;;;;;;GAQG;AACH,wBAAgB,mBAAmB,CACjC,QAAQ,EAAE,IAAI,CAAC,mBAAmB,EAClC,UAAU,EAAE,MAAM,EAClB,iBAAiB,EAAE,MAAM,GAAG,IAAI,GAC/B,OAAO,CAkBT;AAUD;;;;;GAKG;AACH,wBAAsB,0BAA0B,CAC9C,GAAG,EAAE,IAAI,CAAC,eAAe,EACzB,GAAG,EAAE,IAAI,CAAC,cAAc,GACvB,OAAO,CAAC,OAAO,CAAC,CAiDlB"}

package/runtime/mode/remote-forwarder.js

@@ -14,8 +14,8 @@
  * 502 surface to the caller, not a silent log-and-continue.
  */
 import { fetchWithTimeoutGuard } from "@elizaos/agent";
-import { sendJsonError } from "../../api/response";
-import { getRuntimeModeSnapshot } from "./runtime-mode";
+import { sendJsonError } from "../../api/response.js";
+import { getRuntimeModeSnapshot } from "./runtime-mode.js";
 /** Pathnames whose mutations belong to the target in remote mode. */
 const REMOTE_FORWARDED_MUTATION_PREFIXES = [
     "/api/cloud/login",

package/runtime/mode/route-mode-guard.d.ts

@@ -6,11 +6,10 @@
  * want cloud mode to be probeable for local-inference state) and returns
  * `true` so the dispatcher stops walking handlers.
  *
- * No defensive try/catch: a config-load failure is the runtime's problem,
- * not the gate's.
+ * Config-load failures propagate to the runtime error handler.
  */
 import type http from "node:http";
-import { type RuntimeMode } from "./runtime-mode";
+import { type RuntimeMode } from "./runtime-mode.js";
 export interface ModeGateOutcome {
     /** True when the dispatcher should stop — guard wrote a 404. */
     handled: boolean;

package/runtime/mode/route-mode-guard.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"route-mode-guard.d.ts","sourceRoot":"","sources":["../../../../../../src/runtime/mode/route-mode-guard.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,OAAO,KAAK,IAAI,MAAM,WAAW,CAAC;AAElC,OAAO,EAA0B,KAAK,WAAW,EAAE,MAAM,gBAAgB,CAAC;AAG1E,MAAM,WAAW,eAAe;IAC9B,gEAAgE;IAChE,OAAO,EAAE,OAAO,CAAC;IACjB,4CAA4C;IAC5C,IAAI,EAAE,WAAW,CAAC;CACnB;AAED,wBAAgB,mBAAmB,CACjC,GAAG,EAAE,IAAI,CAAC,eAAe,EACzB,GAAG,EAAE,IAAI,CAAC,cAAc,GACvB,eAAe,CAkBjB"}
+{"version":3,"file":"route-mode-guard.d.ts","sourceRoot":"","sources":["../../../../../../src/runtime/mode/route-mode-guard.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH,OAAO,KAAK,IAAI,MAAM,WAAW,CAAC;AAGlC,OAAO,EAA0B,KAAK,WAAW,EAAE,MAAM,gBAAgB,CAAC;AAE1E,MAAM,WAAW,eAAe;IAC9B,gEAAgE;IAChE,OAAO,EAAE,OAAO,CAAC;IACjB,4CAA4C;IAC5C,IAAI,EAAE,WAAW,CAAC;CACnB;AAED,wBAAgB,mBAAmB,CACjC,GAAG,EAAE,IAAI,CAAC,eAAe,EACzB,GAAG,EAAE,IAAI,CAAC,cAAc,GACvB,eAAe,CAkBjB"}

package/runtime/mode/route-mode-guard.js

@@ -6,12 +6,11 @@
  * want cloud mode to be probeable for local-inference state) and returns
  * `true` so the dispatcher stops walking handlers.
  *
- * No defensive try/catch: a config-load failure is the runtime's problem,
- * not the gate's.
+ * Config-load failures propagate to the runtime error handler.
  */
-import { sendJsonError } from "../../api/response";
-import { getRuntimeModeSnapshot } from "./runtime-mode";
-import { findRouteModeRule } from "./route-mode-matrix";
+import { sendJsonError } from "../../api/response.js";
+import { findRouteModeRule } from "./route-mode-matrix.js";
+import { getRuntimeModeSnapshot } from "./runtime-mode.js";
 export function applyRouteModeGuard(req, res) {
     const url = new URL(req.url ?? "/", "http://localhost");
     const method = (req.method ?? "GET").toUpperCase();

package/runtime/mode/route-mode-matrix.d.ts

@@ -24,7 +24,7 @@
  *     to the target. Local-inference and cloud are NOT exposed by the
  *     controller; the controller proxies to the target instead.
  */
-import type { RuntimeMode } from "./runtime-mode";
+import type { RuntimeMode } from "./runtime-mode.js";
 export type HttpMethod = "GET" | "POST" | "PUT" | "PATCH" | "DELETE" | "HEAD" | "*";
 export interface RouteModeRule {
     /**

package/runtime/mode/route-mode-matrix.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"route-mode-matrix.d.ts","sourceRoot":"","sources":["../../../../../../src/runtime/mode/route-mode-matrix.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AAEH,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,gBAAgB,CAAC;AAElD,MAAM,MAAM,UAAU,GAClB,KAAK,GACL,MAAM,GACN,KAAK,GACL,OAAO,GACP,QAAQ,GACR,MAAM,GACN,GAAG,CAAC;AAER,MAAM,WAAW,aAAa;IAC5B;;;OAGG;IACH,IAAI,EAAE,MAAM,CAAC;IACb,mCAAmC;IACnC,MAAM,EAAE,UAAU,CAAC;IACnB,qEAAqE;IACrE,KAAK,EAAE,aAAa,CAAC,WAAW,CAAC,CAAC;IAClC,kEAAkE;IAClE,MAAM,EAAE,MAAM,CAAC;CAChB;AAED;;;GAGG;AACH,eAAO,MAAM,iBAAiB,EAAE,aAAa,CAAC,aAAa,CA8DjD,CAAC;AAcX;;;;GAIG;AACH,wBAAgB,iBAAiB,CAC/B,QAAQ,EAAE,MAAM,EAChB,MAAM,EAAE,MAAM,GACb,aAAa,GAAG,IAAI,CAOtB;AAED;;;;;GAKG;AACH,wBAAgB,cAAc,CAAC,IAAI,EAAE;IACnC,QAAQ,EAAE,MAAM,CAAC;IACjB,MAAM,EAAE,MAAM,CAAC;IACf,IAAI,EAAE,WAAW,CAAC;CACnB,GAAG,OAAO,CAIV"}
+{"version":3,"file":"route-mode-matrix.d.ts","sourceRoot":"","sources":["../../../../../../src/runtime/mode/route-mode-matrix.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AAEH,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,gBAAgB,CAAC;AAElD,MAAM,MAAM,UAAU,GAClB,KAAK,GACL,MAAM,GACN,KAAK,GACL,OAAO,GACP,QAAQ,GACR,MAAM,GACN,GAAG,CAAC;AAER,MAAM,WAAW,aAAa;IAC5B;;;OAGG;IACH,IAAI,EAAE,MAAM,CAAC;IACb,mCAAmC;IACnC,MAAM,EAAE,UAAU,CAAC;IACnB,qEAAqE;IACrE,KAAK,EAAE,aAAa,CAAC,WAAW,CAAC,CAAC;IAClC,kEAAkE;IAClE,MAAM,EAAE,MAAM,CAAC;CAChB;AAED;;;GAGG;AACH,eAAO,MAAM,iBAAiB,EAAE,aAAa,CAAC,aAAa,CA0EjD,CAAC;AAcX;;;;GAIG;AACH,wBAAgB,iBAAiB,CAC/B,QAAQ,EAAE,MAAM,EAChB,MAAM,EAAE,MAAM,GACb,aAAa,GAAG,IAAI,CAUtB;AAED;;;;;GAKG;AACH,wBAAgB,cAAc,CAAC,IAAI,EAAE;IACnC,QAAQ,EAAE,MAAM,CAAC;IACjB,MAAM,EAAE,MAAM,CAAC;IACf,IAAI,EAAE,WAAW,CAAC;CACnB,GAAG,OAAO,CAIV"}

package/runtime/mode/route-mode-matrix.js

@@ -76,6 +76,18 @@ export const ROUTE_MODE_MATRIX = [
         modes: ["local", "cloud", "remote"],
         reason: "cloud TTS preview — hidden in local-only",
     },
+    {
+        path: "/api/tts/local-inference",
+        method: "POST",
+        modes: ["local", "local-only"],
+        reason: "local TTS preview — hidden in cloud + remote",
+    },
+    {
+        path: "/api/asr/local-inference",
+        method: "POST",
+        modes: ["local", "local-only"],
+        reason: "local ASR transcription — hidden in cloud + remote",
+    },
     // ── /api/dev/* — dev observability (always-on for local dev) ──────────
     // Cloud-provisioned containers can disable separately via env, but the
     // matrix entry is "all modes" so the dispatcher does not synthesise a
@@ -105,7 +117,8 @@ function matchesMethod(ruleMethod, requestMethod) {
  */
 export function findRouteModeRule(pathname, method) {
     for (const rule of ROUTE_MODE_MATRIX) {
-        if (matchesPath(rule.path, pathname) && matchesMethod(rule.method, method)) {
+        if (matchesPath(rule.path, pathname) &&
+            matchesMethod(rule.method, method)) {
             return rule;
         }
     }

package/runtime/mode/runtime-mode.d.ts

@@ -7,7 +7,7 @@
  * the local-inference service, and the UI bridge all read from.
  *
  * Resolution order (highest precedence first):
- *   1. `config.deploymentTarget.runtime` — the persisted onboarding choice.
+ *   1. `config.deploymentTarget.runtime` — the persisted first-run choice.
  *   2. (local only) `config.cloud.enabled === false` collapses `local` to
  *      `local-only`.
  *

package/runtime/mode/runtime-mode.js

@@ -7,7 +7,7 @@
  * the local-inference service, and the UI bridge all read from.
  *
  * Resolution order (highest precedence first):
- *   1. `config.deploymentTarget.runtime` — the persisted onboarding choice.
+ *   1. `config.deploymentTarget.runtime` — the persisted first-run choice.
  *   2. (local only) `config.cloud.enabled === false` collapses `local` to
  *      `local-only`.
  *

package/runtime/runtime-bootstrap-policy.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"runtime-bootstrap-policy.d.ts","sourceRoot":"","sources":["../../../../../src/runtime/runtime-bootstrap-policy.ts"],"names":[],"mappings":"AAQA,eAAO,MAAM,oCAAoC,IAAI,CAAC;AACtD,eAAO,MAAM,8BAA8B,QAAa,CAAC;AAEzD,wBAAgB,2BAA2B,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,CAGnE;AAED,wBAAgB,8BAA8B,CAAC,MAAM,EAAE;IACrD,OAAO,EAAE,MAAM,CAAC;IAChB,GAAG,EAAE,OAAO,CAAC;IACb,cAAc,EAAE,MAAM,CAAC;IACvB,GAAG,EAAE,MAAM,CAAC;CACb,GAAG;IACF,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,SAAS,EAAE,MAAM,CAAC;IAClB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,KAAK,EAAE,eAAe,GAAG,eAAe,CAAC;IACzC,WAAW,EAAE,OAAO,CAAC;IACrB,KAAK,EAAE,OAAO,GAAG,UAAU,CAAC;CAC7B,CA6BA"}
+{"version":3,"file":"runtime-bootstrap-policy.d.ts","sourceRoot":"","sources":["../../../../../src/runtime/runtime-bootstrap-policy.ts"],"names":[],"mappings":"AAMA,eAAO,MAAM,oCAAoC,IAAI,CAAC;AACtD,eAAO,MAAM,8BAA8B,QAAa,CAAC;AAEzD,wBAAgB,2BAA2B,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,CAGnE;AAgBD,wBAAgB,8BAA8B,CAAC,MAAM,EAAE;IACrD,OAAO,EAAE,MAAM,CAAC;IAChB,GAAG,EAAE,OAAO,CAAC;IACb,cAAc,EAAE,MAAM,CAAC;IACvB,GAAG,EAAE,MAAM,CAAC;CACb,GAAG;IACF,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,SAAS,EAAE,MAAM,CAAC;IAClB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,KAAK,EAAE,eAAe,GAAG,eAAe,CAAC;IACzC,WAAW,EAAE,OAAO,CAAC;IACrB,KAAK,EAAE,OAAO,GAAG,UAAU,CAAC;CAC7B,CA6BA"}

package/runtime/runtime-bootstrap-policy.js

@@ -1,4 +1,3 @@
-import { getErrorMessage } from "./embedding-manager-support.js";
 const FATAL_PGLITE_CODES = new Set([
     "ELIZA_PGLITE_DATA_DIR_IN_USE",
     "ELIZA_PGLITE_CORRUPT_DATA",
@@ -10,8 +9,21 @@ export function nextRuntimeBootRetryDelayMs(attempt) {
     const raw = 1000 * 2 ** Math.max(0, Math.min(attempt - 1, 5));
     return Math.min(30_000, raw);
 }
+function getRuntimeBootErrorMessage(error) {
+    if (error instanceof Error)
+        return error.message;
+    if (typeof error === "string")
+        return error;
+    if (error !== null &&
+        typeof error === "object" &&
+        "message" in error &&
+        typeof error.message === "string") {
+        return error.message;
+    }
+    return String(error);
+}
 export function resolveRuntimeBootstrapFailure(params) {
-    const lastError = getErrorMessage(params.err);
+    const lastError = getRuntimeBootErrorMessage(params.err);
     if (typeof params.err === "object" &&
         params.err !== null &&
         "code" in params.err &&

package/runtime/telegram-standalone-handler.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"telegram-standalone-handler.d.ts","sourceRoot":"","sources":["../../../../../src/runtime/telegram-standalone-handler.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,YAAY,EAQlB,MAAM,eAAe,CAAC;AAEvB,KAAK,sBAAsB,GAAG;IAC5B,EAAE,CAAC,EAAE,MAAM,GAAG,MAAM,CAAC;IACrB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,MAAM,CAAC,EAAE,OAAO,CAAC;CAClB,CAAC;AAEF,KAAK,sBAAsB,GAAG;IAC5B,EAAE,EAAE,MAAM,GAAG,MAAM,CAAC;IACpB,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,UAAU,CAAC,EAAE,MAAM,CAAC;CACrB,CAAC;AAEF,KAAK,yBAAyB,GAAG;IAC/B,UAAU,CAAC,EAAE,MAAM,GAAG,MAAM,CAAC;IAC7B,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,IAAI,CAAC,EAAE,sBAAsB,CAAC;IAC9B,IAAI,CAAC,EAAE,sBAAsB,CAAC;IAC9B,iBAAiB,CAAC,EAAE,MAAM,GAAG,MAAM,CAAC;IACpC,gBAAgB,CAAC,EAAE;QAAE,UAAU,CAAC,EAAE,MAAM,GAAG,MAAM,CAAA;KAAE,CAAC;CACrD,CAAC;AAEF,MAAM,MAAM,yBAAyB,GAAG;IACtC,OAAO,CAAC,EAAE,yBAAyB,CAAC;IACpC,IAAI,CAAC,EAAE,sBAAsB,CAAC;IAC9B,IAAI,CAAC,EAAE,sBAAsB,CAAC;IAC9B,KAAK,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,OAAO,CAAC,OAAO,CAAC,CAAC;CAC3C,CAAC;AAgEF,wBAAsB,+BAA+B,CACnD,OAAO,EAAE,YAAY,EACrB,GAAG,EAAE,yBAAyB,GAC7B,OAAO,CAAC,IAAI,CAAC,CAuMf"}
+{"version":3,"file":"telegram-standalone-handler.d.ts","sourceRoot":"","sources":["../../../../../src/runtime/telegram-standalone-handler.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,YAAY,EAQlB,MAAM,eAAe,CAAC;AAGvB,KAAK,sBAAsB,GAAG;IAC5B,EAAE,CAAC,EAAE,MAAM,GAAG,MAAM,CAAC;IACrB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,MAAM,CAAC,EAAE,OAAO,CAAC;CAClB,CAAC;AAEF,KAAK,sBAAsB,GAAG;IAC5B,EAAE,EAAE,MAAM,GAAG,MAAM,CAAC;IACpB,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,UAAU,CAAC,EAAE,MAAM,CAAC;CACrB,CAAC;AAEF,KAAK,yBAAyB,GAAG;IAC/B,UAAU,CAAC,EAAE,MAAM,GAAG,MAAM,CAAC;IAC7B,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,IAAI,CAAC,EAAE,sBAAsB,CAAC;IAC9B,IAAI,CAAC,EAAE,sBAAsB,CAAC;IAC9B,iBAAiB,CAAC,EAAE,MAAM,GAAG,MAAM,CAAC;IACpC,gBAAgB,CAAC,EAAE;QAAE,UAAU,CAAC,EAAE,MAAM,GAAG,MAAM,CAAA;KAAE,CAAC;CACrD,CAAC;AAEF,MAAM,MAAM,yBAAyB,GAAG;IACtC,OAAO,CAAC,EAAE,yBAAyB,CAAC;IACpC,IAAI,CAAC,EAAE,sBAAsB,CAAC;IAC9B,IAAI,CAAC,EAAE,sBAAsB,CAAC;IAC9B,KAAK,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,OAAO,CAAC,OAAO,CAAC,CAAC;CAC3C,CAAC;AAgEF,wBAAsB,+BAA+B,CACnD,OAAO,EAAE,YAAY,EACrB,GAAG,EAAE,yBAAyB,GAC7B,OAAO,CAAC,IAAI,CAAC,CAmMf"}

package/runtime/telegram-standalone-handler.js

@@ -1,4 +1,5 @@
 import { ChannelType, createUniqueUuid, logger, } from "@elizaos/core";
+import { formatError } from "@elizaos/shared";
 function parseAllowedTelegramChats(raw) {
     if (Array.isArray(raw)) {
         const entries = raw.map(String).filter(Boolean);
@@ -54,14 +55,14 @@ export async function handleTelegramStandaloneMessage(runtime, ctx) {
         const text = message?.text;
         if (!text)
             return;
-        const chat = ctx.chat ?? message?.chat;
+        const chat = ctx.chat ?? message.chat;
         if (!chat)
             return;
         const chatId = String(chat.id);
-        const from = ctx.from ?? message?.from;
+        const from = ctx.from ?? message.from;
         const telegramUserId = String(from?.id ?? `chat-${chatId}`);
         const username = from?.username ?? from?.first_name ?? `telegram-${telegramUserId}`;
-        const threadId = message?.message_thread_id !== undefined
+        const threadId = message.message_thread_id !== undefined
             ? String(message.message_thread_id)
             : undefined;
         const telegramRoomId = threadId ? `${chatId}-${threadId}` : chatId;
@@ -80,9 +81,9 @@ export async function handleTelegramStandaloneMessage(runtime, ctx) {
         const entityId = createUniqueUuid(runtime, `telegram-user:${telegramUserId}`);
         const roomId = createUniqueUuid(runtime, `telegram-room:${telegramRoomId}`);
         const worldId = createUniqueUuid(runtime, `telegram-world:${chatId}`);
-        const messageId = createUniqueUuid(runtime, `telegram-message:${message?.message_id ?? `${chatId}:${Date.now()}`}`);
+        const messageId = createUniqueUuid(runtime, `telegram-message:${message.message_id ?? `${chatId}:${Date.now()}`}`);
         const channelType = getTelegramChannelType(chat.type);
-        const createdAt = typeof message?.date === "number" ? message.date * 1000 : Date.now();
+        const createdAt = typeof message.date === "number" ? message.date * 1000 : Date.now();
         await runtime.ensureConnection({
             entityId,
             roomId,
@@ -105,7 +106,7 @@ export async function handleTelegramStandaloneMessage(runtime, ctx) {
                 text,
                 source: "telegram",
                 channelType,
-                inReplyTo: message?.reply_to_message?.message_id !== undefined
+                inReplyTo: message.reply_to_message?.message_id !== undefined
                     ? createUniqueUuid(runtime, `telegram-message:${message.reply_to_message.message_id}`)
                     : undefined,
             },
@@ -120,7 +121,7 @@ export async function handleTelegramStandaloneMessage(runtime, ctx) {
                 fromId: telegramUserId,
                 sourceId: entityId,
                 chatType: chat.type,
-                messageIdFull: String(message?.message_id ?? ""),
+                messageIdFull: String(message.message_id ?? ""),
                 sender: {
                     id: telegramUserId,
                     name: from?.first_name,
@@ -128,7 +129,7 @@ export async function handleTelegramStandaloneMessage(runtime, ctx) {
                 },
                 telegram: {
                     chatId,
-                    messageId: String(message?.message_id ?? ""),
+                    messageId: String(message.message_id ?? ""),
                     threadId,
                 },
                 telegramUserId,
@@ -187,7 +188,7 @@ export async function handleTelegramStandaloneMessage(runtime, ctx) {
         await runtimeWithMessages.messageService.handleMessage(runtime, memory, callback, { continueAfterActions: true });
     }
     catch (outerErr) {
-        logger.warn(`[eliza] Telegram handler error: ${outerErr instanceof Error ? outerErr.message : String(outerErr)}`);
+        logger.warn(`[eliza] Telegram handler error: ${formatError(outerErr)}`);
         await ctx
             .reply("Sorry, I encountered an error processing your message.")
             .catch(() => { });

package/runtime/tts-cache-wiring.d.ts

@@ -0,0 +1,29 @@
+/**
+ * TTS-handler ↔ first-line-cache wiring for the app-core runtime.
+ *
+ * The first-line cache lives in `@elizaos/plugin-local-inference/services`
+ * because it needs `node:sqlite` + the local state-dir. We do a dynamic
+ * import here so this module stays browser-safe and so cores that don't
+ * ship the local-inference plugin still load.
+ *
+ * Each TTS provider has a different shape for `voiceId`, `voiceRevision`,
+ * and voice-settings fingerprint — and they get bundled lazily, so we
+ * resolve the context inside the handler closure rather than at registration
+ * time.
+ */
+import type { AgentRuntime } from "@elizaos/core";
+/**
+ * Loose handler shape that matches both the runtime's generic registerModel
+ * signature and `@elizaos/plugin-edge-tts`'s TTS handler. The wrapper passes
+ * the input through unchanged, so structural compatibility is what matters.
+ */
+export type EdgeTtsHandler = (runtime: AgentRuntime, input: unknown) => Promise<unknown>;
+/**
+ * Wrap an `@elizaos/plugin-edge-tts` `ModelType.TEXT_TO_SPEECH` handler with
+ * the local first-line cache.
+ *
+ * Returns `null` if the cache plugin isn't available (e.g. browser bundle,
+ * missing node:sqlite); callers should fall back to the unwrapped handler.
+ */
+export declare function wrapEdgeTtsHandlerWithFirstLineCache(inner: EdgeTtsHandler): Promise<EdgeTtsHandler | null>;
+//# sourceMappingURL=tts-cache-wiring.d.ts.map

package/runtime/tts-cache-wiring.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tts-cache-wiring.d.ts","sourceRoot":"","sources":["../../../../../src/runtime/tts-cache-wiring.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAGH,OAAO,KAAK,EAAE,YAAY,EAAiB,MAAM,eAAe,CAAC;AAIjE;;;;GAIG;AACH,MAAM,MAAM,cAAc,GAAG,CAC3B,OAAO,EAAE,YAAY,EACrB,KAAK,EAAE,OAAO,KACX,OAAO,CAAC,OAAO,CAAC,CAAC;AAuBtB;;;;;;GAMG;AACH,wBAAsB,oCAAoC,CACxD,KAAK,EAAE,cAAc,GACpB,OAAO,CAAC,cAAc,GAAG,IAAI,CAAC,CAgHhC"}

package/runtime/tts-cache-wiring.js

@@ -0,0 +1,114 @@
+/**
+ * TTS-handler ↔ first-line-cache wiring for the app-core runtime.
+ *
+ * The first-line cache lives in `@elizaos/plugin-local-inference/services`
+ * because it needs `node:sqlite` + the local state-dir. We do a dynamic
+ * import here so this module stays browser-safe and so cores that don't
+ * ship the local-inference plugin still load.
+ *
+ * Each TTS provider has a different shape for `voiceId`, `voiceRevision`,
+ * and voice-settings fingerprint — and they get bundled lazily, so we
+ * resolve the context inside the handler closure rather than at registration
+ * time.
+ */
+import process from "node:process";
+import { logger } from "@elizaos/core";
+import { FIRST_SENTENCE_SNIP_VERSION, formatError } from "@elizaos/shared";
+const EDGE_TTS_DEFAULT_VOICE = "en-US-MichelleNeural";
+function readEdgeTtsSetting(runtime, key, fallback) {
+    const envValue = process.env ? process.env[key] : undefined;
+    const getSetting = typeof runtime.getSetting ===
+        "function"
+        ? runtime.getSetting.bind(runtime)
+        : undefined;
+    const settingValue = getSetting
+        ? getSetting(key)
+        : undefined;
+    return settingValue ?? envValue ?? fallback;
+}
+/**
+ * Wrap an `@elizaos/plugin-edge-tts` `ModelType.TEXT_TO_SPEECH` handler with
+ * the local first-line cache.
+ *
+ * Returns `null` if the cache plugin isn't available (e.g. browser bundle,
+ * missing node:sqlite); callers should fall back to the unwrapped handler.
+ */
+export async function wrapEdgeTtsHandlerWithFirstLineCache(inner) {
+    let wrapModule;
+    try {
+        wrapModule = (await import("@elizaos/plugin-local-inference/services"));
+    }
+    catch (err) {
+        logger.debug(`[tts-cache-wiring] @elizaos/plugin-local-inference/services unavailable; cache disabled: ${formatError(err)}`);
+        return null;
+    }
+    if (typeof wrapModule.wrapWithFirstLineCache !== "function" ||
+        typeof wrapModule.fingerprintVoiceSettings !== "function") {
+        return null;
+    }
+    const { wrapWithFirstLineCache, fingerprintVoiceSettings } = wrapModule;
+    // EdgeTtsHandler uses `input: unknown` (loose public shape) while TtsHandler
+    // requires `input: TtsHandlerInput` (concrete union). They are structurally
+    // compatible at runtime — the cast bridges the static mismatch.
+    const wrapped = wrapWithFirstLineCache(inner, {
+        resolveContext: (runtime, input) => {
+            const requestedVoice = typeof input === "object" && input
+                ? input.voice
+                : undefined;
+            const settingVoice = readEdgeTtsSetting(runtime, "EDGE_TTS_VOICE", EDGE_TTS_DEFAULT_VOICE);
+            const voiceId = requestedVoice || settingVoice || EDGE_TTS_DEFAULT_VOICE;
+            const outputFormat = readEdgeTtsSetting(runtime, "EDGE_TTS_OUTPUT_FORMAT", "audio-24khz-48kbitrate-mono-mp3") ?? "audio-24khz-48kbitrate-mono-mp3";
+            // Edge TTS doesn't expose a stable voice revision token. Synthesize
+            // one bound to the SDK package id + selected output format so backend
+            // sample-rate or codec changes invalidate cached bytes. The
+            // `node-edge-tts` package version isn't easily resolvable at runtime;
+            // we conservatively pin `edge-tts:v1`.
+            const voiceRevision = `edge-tts:v1:${outputFormat}`;
+            const rate = readEdgeTtsSetting(runtime, "EDGE_TTS_RATE");
+            const pitch = readEdgeTtsSetting(runtime, "EDGE_TTS_PITCH");
+            const volume = readEdgeTtsSetting(runtime, "EDGE_TTS_VOLUME");
+            const lang = readEdgeTtsSetting(runtime, "EDGE_TTS_LANG", "en-US");
+            const voiceSettingsFingerprint = fingerprintVoiceSettings({
+                rate: rate ?? null,
+                pitch: pitch ?? null,
+                volume: volume ?? null,
+                lang: lang ?? null,
+                outputFormat,
+            });
+            const codec = /(opus)/i.test(outputFormat)
+                ? "opus"
+                : /(ogg|webm)/i.test(outputFormat)
+                    ? "ogg"
+                    : /(wav|riff|pcm)/i.test(outputFormat)
+                        ? "wav"
+                        : "mp3";
+            const contentType = codec === "mp3"
+                ? "audio/mpeg"
+                : codec === "opus"
+                    ? "audio/opus"
+                    : codec === "ogg"
+                        ? "audio/ogg"
+                        : "audio/wav";
+            // Sample rate inferred from the Edge output format. Most defaults
+            // expose 24 kHz; the `audio-48khz-*` variants exist but are rare.
+            const sampleRate = /(48khz)/i.test(outputFormat)
+                ? 48000
+                : /(16khz)/i.test(outputFormat)
+                    ? 16000
+                    : 24000;
+            return {
+                provider: "edge-tts",
+                voiceId,
+                voiceRevision,
+                codec,
+                contentType,
+                sampleRate,
+                voiceSettingsFingerprint,
+            };
+        },
+    });
+    logger.debug(`[tts-cache-wiring] edge-tts wrapped with first-line cache (algo ${FIRST_SENTENCE_SNIP_VERSION})`);
+    // TtsHandler (stricter input) → EdgeTtsHandler (looser input: unknown).
+    // Structurally compatible at runtime; cast bridges the static mismatch.
+    return wrapped;
+}

package/runtime/voice-warmup.d.ts

@@ -0,0 +1,66 @@
+/**
+ * voice-warmup — background "warm like embedding" for voice models.
+ *
+ * Unlike embedding (which has a runtime-free `ensureModel` facade), the voice
+ * models (local Whisper STT / Kokoro TTS, or cloud ElevenLabs) only load
+ * through the live agent runtime's `useModel(TRANSCRIPTION | TEXT_TO_SPEECH, …)`
+ * path — the Kokoro bridge auto-starts on the first TEXT_TO_SPEECH call, and
+ * the cloud handler validates its connection. So we warm them AFTER the runtime
+ * is ready by firing one tiny request at each, fire-and-forget. That actually
+ * loads (not just downloads) the models, so the first real voice interaction is
+ * instant — the embedding warmup's spirit, via the path voice already uses.
+ * Nothing in the voice engine is touched.
+ *
+ * Warmup fires for both local and cloud setups; for cloud providers this means
+ * two tiny billable API calls per desktop boot (a ~100 ms silent WAV for STT
+ * and an empty-string TTS), non-blocking and non-fatal. Suppress it entirely
+ * with ELIZA_SKIP_LOCAL_VOICE_WARMUP=1.
+ */
+/** Minimal runtime surface we need — avoids importing the heavy AgentRuntime. */
+export interface VoiceWarmupRuntime {
+    useModel(modelType: unknown, params: unknown): Promise<unknown>;
+}
+export interface VoiceWarmupGate {
+    /** Running on a mobile platform (no local voice models shipped). */
+    mobile: boolean;
+    /** ELIZA_SKIP_LOCAL_VOICE_WARMUP is set. */
+    skipEnv: boolean;
+    /**
+     * Dev hot-reload respawn (not a cold boot). Each hot-reload spawns a fresh
+     * API child that re-runs the whole boot tail; warming voice every bounce
+     * re-fires a billable cloud TTS call and fully reloads the native whisper
+     * model (~80 lines of GPU init), flooding the dev log on every edit. Warmup
+     * is a first-use-latency optimization, so we skip it on reloads — voice still
+     * loads on first real use. Cold boot still warms.
+     */
+    hotReload?: boolean;
+}
+/** Pure policy: should we warm voice models in the background? */
+export declare function shouldWarmupVoice(gate: VoiceWarmupGate): boolean;
+/**
+ * A tiny valid silent WAV (16 kHz mono 16-bit, ~100 ms) used as transcription
+ * warmup input. Enough to make the runtime load the ASR model; the (empty)
+ * result is discarded.
+ */
+export declare function buildSilentWarmupWav(): Buffer;
+export interface VoiceWarmupModelTypes {
+    /** ModelType.TEXT_TO_SPEECH value (injected to keep this module decoupled). */
+    ttsType: unknown;
+    /** ModelType.TRANSCRIPTION value. */
+    transcriptionType: unknown;
+}
+type LogSink = {
+    info: (msg: string) => void;
+    warn: (msg: string) => void;
+};
+/**
+ * Load both voice models by firing one warm request at each. Each call is
+ * independently guarded: a failure (e.g. missing native lib) is logged and
+ * skipped — the model simply loads on first real use instead. Never rejects.
+ *
+ * Transient cloud errors (429 / 503) are retried up to 2 times with backoff
+ * before being treated as non-fatal.
+ */
+export declare function warmVoiceModels(runtime: VoiceWarmupRuntime, types: VoiceWarmupModelTypes, log?: LogSink): Promise<void>;
+export {};
+//# sourceMappingURL=voice-warmup.d.ts.map

package/runtime/voice-warmup.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"voice-warmup.d.ts","sourceRoot":"","sources":["../../../../../src/runtime/voice-warmup.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AAEH,iFAAiF;AACjF,MAAM,WAAW,kBAAkB;IACjC,QAAQ,CAAC,SAAS,EAAE,OAAO,EAAE,MAAM,EAAE,OAAO,GAAG,OAAO,CAAC,OAAO,CAAC,CAAC;CACjE;AAED,MAAM,WAAW,eAAe;IAC9B,oEAAoE;IACpE,MAAM,EAAE,OAAO,CAAC;IAChB,4CAA4C;IAC5C,OAAO,EAAE,OAAO,CAAC;IACjB;;;;;;;OAOG;IACH,SAAS,CAAC,EAAE,OAAO,CAAC;CACrB;AAED,kEAAkE;AAClE,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,eAAe,GAAG,OAAO,CAKhE;AAED;;;;GAIG;AACH,wBAAgB,oBAAoB,IAAI,MAAM,CAmB7C;AAED,MAAM,WAAW,qBAAqB;IACpC,+EAA+E;IAC/E,OAAO,EAAE,OAAO,CAAC;IACjB,qCAAqC;IACrC,iBAAiB,EAAE,OAAO,CAAC;CAC5B;AAED,KAAK,OAAO,GAAG;IACb,IAAI,EAAE,CAAC,GAAG,EAAE,MAAM,KAAK,IAAI,CAAC;IAC5B,IAAI,EAAE,CAAC,GAAG,EAAE,MAAM,KAAK,IAAI,CAAC;CAC7B,CAAC;AA8BF;;;;;;;GAOG;AACH,wBAAsB,eAAe,CACnC,OAAO,EAAE,kBAAkB,EAC3B,KAAK,EAAE,qBAAqB,EAC5B,GAAG,GAAE,OAAiB,GACrB,OAAO,CAAC,IAAI,CAAC,CA+Bf"}

package/runtime/voice-warmup.js

@@ -0,0 +1,101 @@
+/**
+ * voice-warmup — background "warm like embedding" for voice models.
+ *
+ * Unlike embedding (which has a runtime-free `ensureModel` facade), the voice
+ * models (local Whisper STT / Kokoro TTS, or cloud ElevenLabs) only load
+ * through the live agent runtime's `useModel(TRANSCRIPTION | TEXT_TO_SPEECH, …)`
+ * path — the Kokoro bridge auto-starts on the first TEXT_TO_SPEECH call, and
+ * the cloud handler validates its connection. So we warm them AFTER the runtime
+ * is ready by firing one tiny request at each, fire-and-forget. That actually
+ * loads (not just downloads) the models, so the first real voice interaction is
+ * instant — the embedding warmup's spirit, via the path voice already uses.
+ * Nothing in the voice engine is touched.
+ *
+ * Warmup fires for both local and cloud setups; for cloud providers this means
+ * two tiny billable API calls per desktop boot (a ~100 ms silent WAV for STT
+ * and an empty-string TTS), non-blocking and non-fatal. Suppress it entirely
+ * with ELIZA_SKIP_LOCAL_VOICE_WARMUP=1.
+ */
+/** Pure policy: should we warm voice models in the background? */
+export function shouldWarmupVoice(gate) {
+    if (gate.mobile)
+        return false;
+    if (gate.skipEnv)
+        return false;
+    if (gate.hotReload)
+        return false;
+    return true;
+}
+/**
+ * A tiny valid silent WAV (16 kHz mono 16-bit, ~100 ms) used as transcription
+ * warmup input. Enough to make the runtime load the ASR model; the (empty)
+ * result is discarded.
+ */
+export function buildSilentWarmupWav() {
+    const sampleRate = 16_000;
+    const numSamples = Math.round(sampleRate * 0.1); // ~100 ms
+    const dataBytes = numSamples * 2; // 16-bit mono
+    const buf = Buffer.alloc(44 + dataBytes); // header + silence (already zeroed)
+    buf.write("RIFF", 0, "ascii");
+    buf.writeUInt32LE(36 + dataBytes, 4); // file size - 8
+    buf.write("WAVE", 8, "ascii");
+    buf.write("fmt ", 12, "ascii");
+    buf.writeUInt32LE(16, 16); // PCM fmt chunk size
+    buf.writeUInt16LE(1, 20); // PCM
+    buf.writeUInt16LE(1, 22); // mono
+    buf.writeUInt32LE(sampleRate, 24);
+    buf.writeUInt32LE(sampleRate * 2, 28); // byte rate (mono 16-bit)
+    buf.writeUInt16LE(2, 32); // block align
+    buf.writeUInt16LE(16, 34); // bits per sample
+    buf.write("data", 36, "ascii");
+    buf.writeUInt32LE(dataBytes, 40);
+    return buf;
+}
+const noopLog = { info: () => { }, warn: () => { } };
+/**
+ * Retry a warmup call up to `maxRetries` times when the error message
+ * indicates a transient HTTP issue (429 / 503). Waits `delayMs` between
+ * retries (doubles each attempt). Non-transient errors are re-thrown
+ * immediately so the caller's catch handler logs them.
+ */
+async function withRetry(fn, maxRetries = 2, delayMs = 3_000) {
+    let attempt = 0;
+    while (true) {
+        try {
+            await fn();
+            return;
+        }
+        catch (err) {
+            const msg = err instanceof Error ? err.message : String(err);
+            const isTransient = /\b(429|503)\b/.test(msg);
+            if (!isTransient || attempt >= maxRetries)
+                throw err;
+            attempt++;
+            await new Promise((r) => setTimeout(r, delayMs * attempt));
+        }
+    }
+}
+/**
+ * Load both voice models by firing one warm request at each. Each call is
+ * independently guarded: a failure (e.g. missing native lib) is logged and
+ * skipped — the model simply loads on first real use instead. Never rejects.
+ *
+ * Transient cloud errors (429 / 503) are retried up to 2 times with backoff
+ * before being treated as non-fatal.
+ */
+export async function warmVoiceModels(runtime, types, log = noopLog) {
+    try {
+        await withRetry(() => runtime.useModel(types.ttsType, "Warming up voice."));
+        log.info("[eliza] Voice TTS model: ready");
+    }
+    catch (err) {
+        log.warn(`[eliza] Voice TTS warmup failed (will load on first use): ${err instanceof Error ? err.message : String(err)}`);
+    }
+    try {
+        await withRetry(() => runtime.useModel(types.transcriptionType, buildSilentWarmupWav()));
+        log.info("[eliza] Voice STT model: ready");
+    }
+    catch (err) {
+        log.warn(`[eliza] Voice STT warmup failed (will load on first use): ${err instanceof Error ? err.message : String(err)}`);
+    }
+}