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

package/scripts/link-docker-local-app-packages.mjs

@@ -14,23 +14,46 @@ const { workspaceDirs } = collectWorkspaceMaps(
   rootPkg.workspaces ?? [],
 );
 const localPackages = [
-  "eliza/plugins/app-companion",
-  "eliza/plugins/app-elizamaker",
-  "eliza/plugins/app-documents",
-  "eliza/plugins/app-lifeops",
-  "eliza/plugins/app-steward",
-  "eliza/plugins/app-task-coordinator",
-  "eliza/plugins/app-training",
-  "eliza/plugins/app-shopify",
-  "eliza/plugins/app-vincent",
-  "eliza/packages/app-core",
-  "eliza/cloud/packages/sdk",
+  // Foundational workspace packages. These build to ./dist/ but keep their
+  // package.json at the package root (no dist/package.json), so they are
+  // linked package-root -> package-root here rather than via
+  // relink-workspace-packages-to-dist.mjs (which targets <pkg>/dist and
+  // requires a dist/package.json). @elizaos/shared declares @elizaos/core as
+  // a runtime dep and shared/dist/api/http-helpers.js imports it eagerly, so
+  // node_modules/@elizaos/core MUST exist or boot crashes with
+  // "Cannot find package '@elizaos/core'". Listed first so they link before
+  // any per-package side effects (e.g. the app-core argon2/jose linking).
+  "eliza/packages/core",
+  "eliza/packages/contracts",
   "eliza/packages/cloud-routing",
+  // @elizaos/app-core's registry/index.ts eagerly re-exports
+  // `@elizaos/registry/first-party` (#9190 moved the curated app/plugin/connector
+  // registry out of app-core into this package). It must be linked or the agent
+  // boot crashes with "Cannot find package '@elizaos/registry' imported from
+  // .../app-core/dist/registry/index.js". Foundational, so listed up here.
+  "eliza/packages/registry",
+  // @elizaos/agent's remote-plugin-bridge imports the `./error` subpath of
+  // plugin-worker-runtime eagerly at boot. Without linking it here its
+  // node_modules entry is never established, so boot crashes with
+  // "Cannot find module .../@elizaos/plugin-worker-runtime/dist/error.js".
+  "eliza/packages/plugin-worker-runtime",
+  "eliza/plugins/plugin-companion",
+  "eliza/plugins/plugin-elizamaker",
+  "eliza/plugins/plugin-documents",
+  "eliza/plugins/plugin-personal-assistant",
+  "eliza/plugins/plugin-steward-app",
+  "eliza/plugins/plugin-task-coordinator",
+  "eliza/plugins/plugin-training",
+  "eliza/plugins/plugin-shopify-ui",
+  "eliza/plugins/plugin-vincent",
+  "eliza/packages/app-core",
+  "eliza/packages/cloud-sdk",
   "eliza/packages/shared",
   "eliza/packages/skills",
   "eliza/packages/ui",
   "eliza/packages/vault",
   "eliza/plugins/plugin-agent-skills",
+  "eliza/plugins/plugin-app-manager",
   "eliza/plugins/plugin-browser",
   "eliza/plugins/plugin-capacitor-bridge",
   "eliza/plugins/plugin-coding-tools",
@@ -38,16 +61,16 @@ const localPackages = [
   "eliza/plugins/plugin-discord",
   "eliza/plugins/plugin-elizacloud",
   "eliza/plugins/plugin-imessage",
-  "eliza/plugins/plugin-local-embedding",
   "eliza/plugins/plugin-local-inference",
   "eliza/plugins/plugin-mcp",
   "eliza/plugins/plugin-pdf",
   "eliza/plugins/plugin-signal",
   "eliza/plugins/plugin-streaming",
-  "eliza/packages/native-plugins/activity-tracker",
+  "eliza/plugins/plugin-native-activity-tracker",
   "eliza/plugins/plugin-sql",
   "eliza/plugins/plugin-telegram",
   "eliza/plugins/plugin-video",
+  "eliza/plugins/plugin-wallet",
   "eliza/plugins/plugin-whatsapp",
   "eliza/plugins/plugin-workflow",
   "eliza/plugins/plugin-x402",
@@ -148,6 +171,20 @@ function linkPackageTarget({ packageDir, pkg, rewroteExports, target }) {
     return;
   }
 
+  // rewroteExports === true means this package had no built dist, so its
+  // exports were rewritten from ./dist/*.js to ./src/*.ts (rewriteDistExportsToSource).
+  // The production image now starts the agent under plain `node` (no tsx loader,
+  // #8837), so importing a .ts entry at runtime throws ERR_UNKNOWN_FILE_EXTENSION
+  // on the core boot path or silently fails an app-route plugin (post-ready,
+  // swallowed → that plugin registers zero routes). Surface it loudly so a
+  // missing-dist build is visible instead of shipping a half-broken image.
+  console.warn(
+    `[link-docker] WARNING: ${pkg.name ?? "(unknown package)"} has no built dist; ` +
+      "its exports were rewritten to .ts source. The production agent starts under " +
+      "plain node (tsx removed in #8837), so this package will fail to import at " +
+      "runtime — build its dist before imaging.",
+  );
+
   fs.mkdirSync(target, { recursive: true });
   fs.writeFileSync(
     path.join(target, "package.json"),
@@ -181,39 +218,68 @@ function removePath(filePath) {
   }
 }
 
-function resolveRootPackageDir(packageName) {
-  const packageDir = path.join(
-    repoRoot,
-    "node_modules",
-    ...packageName.split("/"),
-  );
-  if (fs.existsSync(path.join(packageDir, "package.json"))) {
-    return packageDir;
+function resolveDependencyPackageDir(packageName, baseDirs = [repoRoot]) {
+  const packageSegments = packageName.split("/");
+  // Return the realpath so `linkDependencyPackage`'s `packageDir === target`
+  // check works when a previous loop iteration already symlinked the dep
+  // (avoids circular symlinks like jose → app-core/jose → root jose).
+  const realIfExists = (dir) => {
+    if (!fs.existsSync(path.join(dir, "package.json"))) return null;
+    try {
+      return fs.realpathSync(dir);
+    } catch {
+      return null;
+    }
+  };
+  for (const baseDir of baseDirs) {
+    const real = realIfExists(
+      path.join(baseDir, "node_modules", ...packageSegments),
+    );
+    if (real) return real;
   }
 
-  const bunStoreDir = path.join(repoRoot, "node_modules", ".bun");
-  if (pathExists(bunStoreDir)) {
-    const packageSegments = packageName.split("/");
-    for (const entry of fs.readdirSync(bunStoreDir).sort().reverse()) {
-      const candidate = path.join(
-        bunStoreDir,
-        entry,
-        "node_modules",
-        ...packageSegments,
-      );
-      if (fs.existsSync(path.join(candidate, "package.json"))) {
-        return candidate;
+  for (const baseDir of baseDirs) {
+    const bunStoreDir = path.join(baseDir, "node_modules", ".bun");
+    if (pathExists(bunStoreDir)) {
+      for (const entry of fs.readdirSync(bunStoreDir).sort().reverse()) {
+        const real = realIfExists(
+          path.join(bunStoreDir, entry, "node_modules", ...packageSegments),
+        );
+        if (real) return real;
       }
     }
   }
 
   throw new Error(
-    `Missing root package manifest: node_modules/${packageName}/package.json`,
+    `Missing package manifest: ${baseDirs
+      .map((baseDir) =>
+        path.relative(
+          repoRoot,
+          path.join(
+            baseDir,
+            "node_modules",
+            ...packageSegments,
+            "package.json",
+          ),
+        ),
+      )
+      .join(" or ")}`,
   );
 }
 
+function resolveRootPackageDir(packageName) {
+  return resolveDependencyPackageDir(packageName);
+}
+
 function linkRootDependency({ packageName, target }) {
   const packageDir = resolveRootPackageDir(packageName);
+  linkDependencyPackage({ packageDir, target });
+}
+
+function linkDependencyPackage({ packageDir, target }) {
+  if (path.resolve(packageDir) === path.resolve(target)) {
+    return;
+  }
   fs.mkdirSync(path.dirname(target), { recursive: true });
   removePath(target);
   fs.symlinkSync(
@@ -223,6 +289,11 @@ function linkRootDependency({ packageName, target }) {
   );
 }
 
+function linkDependency({ packageName, target, baseDirs = [repoRoot] }) {
+  const packageDir = resolveDependencyPackageDir(packageName, baseDirs);
+  linkDependencyPackage({ packageDir, target });
+}
+
 function resolveLocalPackageDir(packagePath) {
   const candidates = [packagePath];
   if (packagePath.startsWith("eliza/")) {
@@ -326,15 +397,17 @@ for (const packagePath of localPackages) {
 
   if (pkg.name === "@elizaos/app-core") {
     for (const rootDep of ["@node-rs/argon2", "jose"]) {
-      linkRootDependency({
+      linkDependency({
         packageName: rootDep,
         target: path.join(packageDir, "node_modules", rootDep),
+        baseDirs: [packageDir, repoRoot],
       });
       // Also ensure root-level node_modules has it so ESM resolution always
       // finds the package regardless of which symlink depth Node traverses.
-      linkRootDependency({
+      linkDependency({
         packageName: rootDep,
         target: path.join(repoRoot, "node_modules", rootDep),
+        baseDirs: [packageDir, repoRoot],
       });
     }
   }

package/scripts/local-stt-bench.ts

@@ -0,0 +1,192 @@
+#!/usr/bin/env bun
+/**
+ * Local STT (speech-to-text) microbenchmark.
+ *
+ * Drives `AgentRuntime.useModel(ModelType.TRANSCRIPTION, ...)` against a
+ * mocked handler so we can measure the per-turn cost of the runtime's
+ * model-dispatch path — independent of any real ASR backend. The mock
+ * handler sleeps `BENCH_DECODE_MS` to simulate decode time and returns a
+ * canned transcript. The script reports min/p50/p90/p99/max/mean over
+ * `BENCH_TURNS` turns.
+ *
+ * Run:
+ *   BUN_TEST_COVERAGE=0 bun packages/app-core/scripts/local-stt-bench.ts
+ *
+ * Output: a human-readable table on stderr + a single JSON block on stdout.
+ * Exit code is 0 unless the runtime itself fails — this is a measurement
+ * tool, not a CI checker.
+ */
+
+import { performance } from "node:perf_hooks";
+import { InMemoryDatabaseAdapter } from "../../core/src/database/inMemoryAdapter";
+import { AgentRuntime } from "../../core/src/runtime";
+import { ModelType } from "../../core/src/types";
+
+// ---------------------------------------------------------------------------
+// Knobs (override via env)
+// ---------------------------------------------------------------------------
+
+const TURN_COUNT = Number(process.env.BENCH_TURNS ?? "5");
+const DECODE_MS = Number(process.env.BENCH_DECODE_MS ?? "80");
+const PCM_SAMPLES = Number(process.env.BENCH_PCM_SAMPLES ?? "480");
+const TRANSCRIPT = process.env.BENCH_TRANSCRIPT ?? "hello world";
+
+// ---------------------------------------------------------------------------
+// Helpers (mirror streaming-pipeline-bench.ts)
+// ---------------------------------------------------------------------------
+
+async function sleep(ms: number): Promise<void> {
+  if (ms <= 0) return;
+  await new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+function pct(samples: number[], p: number): number | null {
+  if (samples.length === 0) return null;
+  const sorted = [...samples].sort((a, b) => a - b);
+  const idx = Math.min(
+    sorted.length - 1,
+    Math.max(0, Math.ceil((p / 100) * sorted.length) - 1),
+  );
+  return sorted[idx]!;
+}
+
+interface SampleSummary {
+  count: number;
+  min: number | null;
+  p50: number | null;
+  p90: number | null;
+  p99: number | null;
+  max: number | null;
+  mean: number | null;
+}
+
+function summarize(samples: number[]): SampleSummary {
+  if (samples.length === 0) {
+    return {
+      count: 0,
+      min: null,
+      p50: null,
+      p90: null,
+      p99: null,
+      max: null,
+      mean: null,
+    };
+  }
+  const sum = samples.reduce((a, b) => a + b, 0);
+  return {
+    count: samples.length,
+    min: Math.min(...samples),
+    p50: pct(samples, 50),
+    p90: pct(samples, 90),
+    p99: pct(samples, 99),
+    max: Math.max(...samples),
+    mean: sum / samples.length,
+  };
+}
+
+function fmt(n: number | null, suffix = "ms"): string {
+  if (n === null) return "—";
+  return `${n.toFixed(2)}${suffix}`;
+}
+
+// ---------------------------------------------------------------------------
+// Driver
+// ---------------------------------------------------------------------------
+
+interface TranscriptionParams {
+  pcm: Float32Array;
+  sampleRateHz: number;
+}
+
+async function buildRuntime(): Promise<AgentRuntime> {
+  const runtime = new AgentRuntime({
+    character: {
+      name: "LocalSttBench",
+      bio: "bench",
+      settings: {},
+    } as never,
+    adapter: new InMemoryDatabaseAdapter(),
+    logLevel: "fatal",
+  });
+
+  const handler = async (
+    _runtime: unknown,
+    _params: unknown,
+  ): Promise<string> => {
+    await sleep(DECODE_MS);
+    return TRANSCRIPT;
+  };
+  runtime.registerModel(
+    ModelType.TRANSCRIPTION,
+    handler,
+    "eliza-local-inference",
+  );
+
+  return runtime;
+}
+
+async function runTurn(runtime: AgentRuntime): Promise<number> {
+  const params: TranscriptionParams = {
+    pcm: new Float32Array(PCM_SAMPLES),
+    sampleRateHz: 16_000,
+  };
+  const t0 = performance.now();
+  const out = await runtime.useModel(ModelType.TRANSCRIPTION, params as never);
+  const elapsed = performance.now() - t0;
+  if (typeof out !== "string" || out.length === 0) {
+    throw new Error(
+      `local-stt-bench: handler returned unexpected value: ${JSON.stringify(out)}`,
+    );
+  }
+  return elapsed;
+}
+
+async function main(): Promise<void> {
+  process.stderr.write(
+    `local-stt-bench: turns=${TURN_COUNT}, decode=${DECODE_MS}ms, pcm-samples=${PCM_SAMPLES}\n`,
+  );
+
+  const runtime = await buildRuntime();
+
+  // One warmup turn so the JIT + lazy state-store init don't bias the first sample.
+  await runTurn(runtime);
+
+  const samples: number[] = [];
+  for (let i = 0; i < TURN_COUNT; i++) {
+    samples.push(await runTurn(runtime));
+  }
+
+  const stats = summarize(samples);
+
+  // Human-readable table on stderr.
+  process.stderr.write(`\n=== TRANSCRIPTION (useModel → handler) ===\n`);
+  process.stderr.write(
+    `${"metric".padEnd(40)} ${"min".padStart(8)} ${"p50".padStart(8)} ${"p90".padStart(8)} ${"p99".padStart(8)} ${"max".padStart(8)} ${"mean".padStart(8)}\n`,
+  );
+  process.stderr.write(
+    `${"per-turn latency".padEnd(40)} ${fmt(stats.min).padStart(8)} ${fmt(stats.p50).padStart(8)} ${fmt(stats.p90).padStart(8)} ${fmt(stats.p99).padStart(8)} ${fmt(stats.max).padStart(8)} ${fmt(stats.mean).padStart(8)}\n`,
+  );
+
+  // Machine-readable summary on stdout.
+  process.stdout.write(
+    `${JSON.stringify(
+      {
+        config: {
+          turns: TURN_COUNT,
+          decodeMs: DECODE_MS,
+          pcmSamples: PCM_SAMPLES,
+        },
+        perTurnMs: stats,
+      },
+      null,
+      2,
+    )}\n`,
+  );
+}
+
+main().catch((err) => {
+  process.stderr.write(
+    `local-stt-bench failed: ${err instanceof Error ? err.stack : String(err)}\n`,
+  );
+  process.exit(1);
+});

package/scripts/maintain-cloud-api-production-gateway.mjs

@@ -0,0 +1,54 @@
+#!/usr/bin/env node
+/**
+ * Verify production Cloud API gateway contract, repairing only on drift.
+ *
+ * This is safe for repeated operator runs: it verifies first and only deploys
+ * when the live Worker no longer returns +14159611510/bluebubbles/blooio.
+ */
+import { spawnSync } from "node:child_process";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+
+const scriptDir = path.dirname(fileURLToPath(import.meta.url));
+const verifyScript = path.join(scriptDir, "verify-cloud-api-production-deploy.mjs");
+const deployScript = path.join(scriptDir, "deploy-cloud-api-production-gateway.mjs");
+
+function run(command, args, options = {}) {
+  const result = spawnSync(command, args, {
+    cwd: options.cwd ?? process.cwd(),
+    encoding: "utf8",
+    stdio: options.inherit ? "inherit" : ["ignore", "pipe", "pipe"],
+    timeout: options.timeout ?? 300_000,
+  });
+  return {
+    status: result.status ?? (result.error ? 1 : 0),
+    output: `${result.stdout ?? ""}${result.stderr ?? ""}`,
+  };
+}
+
+function main() {
+  console.log("[cloud-api-gateway-maintain] verifying production gateway contract");
+  const first = run("node", [verifyScript], { timeout: 180_000 });
+  if (first.status === 0) {
+    process.stdout.write(first.output);
+    console.log("[cloud-api-gateway-maintain] PASS no repair needed");
+    return;
+  }
+
+  process.stdout.write(first.output);
+  console.log("[cloud-api-gateway-maintain] drift detected; running production repair deploy");
+  const repair = run("node", [deployScript], { inherit: true, timeout: 600_000 });
+  if (repair.status !== 0) {
+    throw new Error(`production repair deploy failed with ${repair.status}`);
+  }
+  console.log("[cloud-api-gateway-maintain] PASS repaired production gateway contract");
+}
+
+try {
+  main();
+} catch (error) {
+  console.error(
+    `[cloud-api-gateway-maintain] ${error instanceof Error ? error.message : String(error)}`,
+  );
+  process.exit(1);
+}