@elizaos/autonomous 2.0.0-alpha.13 → 2.0.0-alpha.14

package/src/runtime/eliza.ts

@@ -41,6 +41,8 @@ import {
   ChannelType,
   type Character,
   type Component,
+  type MessageExampleGroup,
+  type ServiceTypeName,
   createMessageMemory,
   type Entity,
   type LogEntry,
@@ -54,13 +56,6 @@ import {
   type UUID,
 } from "@elizaos/core";
 import * as pluginAgentOrchestrator from "@elizaos/plugin-agent-orchestrator";
-import * as pluginAgentSkills from "@elizaos/plugin-agent-skills";
-import * as pluginAnthropic from "@elizaos/plugin-anthropic";
-import * as pluginCron from "@elizaos/plugin-cron";
-import * as pluginElizacloud from "@elizaos/plugin-elizacloud";
-import * as pluginExperience from "@elizaos/plugin-experience";
-import * as pluginForm from "@elizaos/plugin-form";
-import * as pluginKnowledge from "@elizaos/plugin-knowledge";
 import * as pluginLocalEmbedding from "@elizaos/plugin-local-embedding";
 import * as pluginOllama from "@elizaos/plugin-ollama";
 import * as pluginOpenai from "@elizaos/plugin-openai";
@@ -125,24 +120,17 @@ const STATIC_ELIZA_PLUGINS: Record<string, unknown> = {
   "@elizaos/plugin-sql": pluginSql,
   "@elizaos/plugin-local-embedding": pluginLocalEmbedding,
   "@elizaos/plugin-secrets-manager": pluginSecretsManager,
-  "@elizaos/plugin-form": pluginForm,
-  "@elizaos/plugin-knowledge": pluginKnowledge,
   "@elizaos/plugin-rolodex": pluginRolodex,
   "@elizaos/plugin-trajectory-logger": pluginTrajectoryLogger,
   "@elizaos/plugin-agent-orchestrator": pluginAgentOrchestrator,
-  "@elizaos/plugin-cron": pluginCron,
   "@elizaos/plugin-shell": pluginShell,
   "@elizaos/plugin-plugin-manager": pluginPluginManager,
-  "@elizaos/plugin-agent-skills": pluginAgentSkills,
   "@elizaos/plugin-pdf": pluginPdf,
   "@elizaos/plugin-openai": pluginOpenai,
-  "@elizaos/plugin-anthropic": pluginAnthropic,
   "@elizaos/plugin-ollama": pluginOllama,
-  "@elizaos/plugin-elizacloud": pluginElizacloud,
   "@elizaos/plugin-trust": pluginTrust,
   "@elizaos/plugin-todo": pluginTodo,
   "@elizaos/plugin-personality": pluginPersonality,
-  "@elizaos/plugin-experience": pluginExperience,
 };
 
 // NODE_PATH so dynamic plugin imports (e.g. @elizaos/plugin-agent-orchestrator) resolve.
@@ -2340,10 +2328,14 @@ async function initializeDatabaseAdapter(
   runtime: AgentRuntime,
   config: MiladyConfig,
 ): Promise<void> {
-  if (!runtime.adapter || (await runtime.adapter.isReady())) return;
+  const adapterWithInit = runtime.adapter as unknown as {
+    isReady(): Promise<boolean>;
+    init(): Promise<void>;
+  };
+  if (!runtime.adapter || (await adapterWithInit.isReady())) return;
 
   try {
-    await runtime.adapter.init();
+    await adapterWithInit.init();
     logger.info(
       "[milady] Database adapter initialized early (before plugin inits)",
     );
@@ -2373,7 +2365,7 @@ async function initializeDatabaseAdapter(
       process.env.PGLITE_DATA_DIR = pgliteDataDir;
     }
 
-    await runtime.adapter.init();
+    await adapterWithInit.init();
     logger.info(
       recoveryAction === "retry-without-reset"
         ? "[milady] Database adapter recovered after clearing a stale PGLite lock"
@@ -2666,7 +2658,7 @@ export function installRuntimeMethodBindings(runtime: AgentRuntime): void {
   // to create the same entity in rapid succession; plugin-sql's batch insert is
   // non-idempotent and can fail entire writes on duplicate/conflicting rows.
   if (!runtimeWithBindings.__miladyEntityWriteDiagnosticsInstalled) {
-    type CreateEntitiesFn = (entities: Entity[]) => Promise<boolean>;
+    type CreateEntitiesFn = (entities: Entity[]) => Promise<string[]>;
     type GetEntitiesByIdsFn = (entityIds: UUID[]) => Promise<Entity[]>;
     type EnsureEntityExistsFn = (entity: Entity) => Promise<boolean>;
     const runtimeWithEntityWrites = runtime as AgentRuntime & {
@@ -2680,14 +2672,14 @@ export function installRuntimeMethodBindings(runtime: AgentRuntime): void {
         runtimeWithEntityWrites.createEntities.bind(runtime);
       runtimeWithEntityWrites.createEntities = async (
         entities: Entity[],
-      ): Promise<boolean> => {
+      ): Promise<string[]> => {
         return withEntityCreateMutex(runtimeWithBindings, async () => {
           const uniqueById = new Map<UUID, Entity>();
           for (const entity of entities) {
             if (entity?.id) uniqueById.set(entity.id as UUID, entity);
           }
           const deduped = Array.from(uniqueById.values());
-          if (deduped.length === 0) return true;
+          if (deduped.length === 0) return [];
 
           let missing = deduped;
           if (typeof runtimeWithEntityWrites.getEntitiesByIds === "function") {
@@ -2709,10 +2701,10 @@ export function installRuntimeMethodBindings(runtime: AgentRuntime): void {
               );
             }
           }
-          if (missing.length === 0) return true;
+          if (missing.length === 0) return deduped.map((e) => e.id as string);
 
-          const ok = await originalCreateEntities(missing);
-          if (ok) return true;
+          const createdIds = await originalCreateEntities(missing);
+          if (createdIds.length > 0) return createdIds;
 
           if (
             typeof runtimeWithEntityWrites.ensureEntityExists === "function"
@@ -2730,13 +2722,13 @@ export function installRuntimeMethodBindings(runtime: AgentRuntime): void {
                 );
               }
             }
-            if (allRecovered) return true;
+            if (allRecovered) return missing.map((e) => e.id as string);
           }
 
           logger.warn(
             `[milady] createEntities unresolved after guarded retries (requested=${entities.length}, deduped=${deduped.length}, missing=${missing.length})`,
           );
-          return false;
+          return [];
         });
       };
     }
@@ -2998,7 +2990,7 @@ export function buildCharacterFromConfig(config: MiladyConfig): Character {
     ...(style ? { style } : {}),
     ...(adjectives ? { adjectives } : {}),
     ...(postExamples ? { postExamples } : {}),
-    ...(mappedExamples ? { messageExamples: mappedExamples } : {}),
+    ...(mappedExamples ? { messageExamples: mappedExamples as MessageExampleGroup[] } : {}),
     secrets,
   });
 }
@@ -4080,7 +4072,7 @@ export async function startEliza(
   let runtime = new AgentRuntime({
     character,
     // advancedCapabilities: true,
-    actionPlanning: true,
+    // actionPlanning: true, // Not supported in this version of AgentRuntime
     // advancedMemory: true, // Not supported in this version of AgentRuntime
     plugins: [miladyPlugin, ...pluginsForRuntime],
     ...(runtimeLogLevel ? { logLevel: runtimeLogLevel } : {}),
@@ -4219,7 +4211,7 @@ export async function startEliza(
     // so API + agent come online immediately.
     try {
       const skillServicePromise = runtime.getServiceLoadPromise(
-        "AGENT_SKILLS_SERVICE",
+        "AGENT_SKILLS_SERVICE" as ServiceTypeName,
       );
       const timeout = new Promise<never>((_resolve, reject) => {
         setTimeout(() => {

package/src/runtime/milady-plugin.ts

@@ -123,10 +123,7 @@ export function createMiladyPlugin(config?: MiladyPluginConfig): Plugin {
       const lines = customActions.map((a) => {
         const params =
           a.parameters
-            ?.map(
-              (p) =>
-                `${p.name}${(p as { required?: boolean }).required ? " (required)" : ""}`,
-            )
+            ?.map((p) => `${p.name}${p.required ? " (required)" : ""}`)
             .join(", ") || "none";
         return `- **${a.name}**: ${a.description} [params: ${params}]`;
       });

package/src/server/index.ts

@@ -1,6 +1,2 @@
-export {
-  startApiServer,
-} from "../api/server";
-export type {
-  captureEarlyLogs,
-} from "../api/server";
+export type { captureEarlyLogs } from "../api/server";
+export { startApiServer } from "../api/server";

package/src/services/agent-export.ts

@@ -352,7 +352,8 @@ async function extractAgentData(
   logger.info(`[agent-export] Extracting data for agent ${agentId}`);
 
   // 1. Agent record
-  const agent = await db.getAgent(agentId);
+  const agents = await db.getAgentsByIds([agentId]);
+  const agent = agents[0];
   if (!agent) {
     throw new AgentExportError(`Agent ${agentId} not found in database.`);
   }
@@ -367,14 +368,14 @@ async function extractAgentData(
 
   for (const world of agentWorlds) {
     if (!world.id) continue;
-    const worldRooms = await db.getRoomsByWorld(world.id);
+    const worldRooms = await db.getRoomsByWorlds([world.id]);
     for (const room of worldRooms) {
       if (room.id) roomMap.set(room.id, room);
     }
   }
 
   // Also get rooms the agent participates in directly
-  const participantRoomIds = await db.getRoomsForParticipant(agentId);
+  const participantRoomIds = await db.getRoomsForParticipants([agentId]);
   if (participantRoomIds.length > 0) {
     const participantRooms = await db.getRoomsByIds(participantRoomIds);
     if (participantRooms) {
@@ -398,14 +399,19 @@ async function extractAgentData(
   for (const room of rooms) {
     if (!room.id) continue;
 
-    const roomEntities = await db.getEntitiesForRoom(room.id, true);
+    const entitiesResult = await db.getEntitiesForRooms([room.id], true);
+    const roomEntities = entitiesResult[0]?.entities ?? [];
     for (const entity of roomEntities) {
       if (entity.id) entityMap.set(entity.id, entity);
     }
 
-    const participantIds = await db.getParticipantsForRoom(room.id);
+    const participantsResult = await db.getParticipantsForRooms([room.id]);
+    const participantIds = participantsResult[0]?.entityIds ?? [];
     for (const entityId of participantIds) {
-      const userState = await db.getParticipantUserState(room.id, entityId);
+      const userStates = await db.getParticipantUserStates([
+        { roomId: room.id, entityId },
+      ]);
+      const userState = userStates[0] ?? null;
       participantRecords.push({
         entityId,
         roomId: room.id,
@@ -430,10 +436,11 @@ async function extractAgentData(
   };
   for (const entity of entities) {
     if (!entity.id) continue;
-    for (const c of await db.getComponents(entity.id)) addComponent(c);
+    for (const c of await db.getComponentsForEntities([entity.id]))
+      addComponent(c);
     for (const world of agentWorlds) {
       if (!world.id) continue;
-      for (const c of await db.getComponents(entity.id, world.id))
+      for (const c of await db.getComponentsForEntities([entity.id], world.id))
         addComponent(c);
     }
   }
@@ -463,7 +470,7 @@ async function extractAgentData(
     if (!world.id) continue;
     for (const tableName of MEMORY_TABLES) {
       const worldMemories = await db.getMemoriesByWorldId({
-        worldId: world.id,
+        worldIds: [world.id],
         count: Number.MAX_SAFE_INTEGER,
         tableName,
       });
@@ -479,13 +486,13 @@ async function extractAgentData(
   logger.info(`[agent-export] Found ${allMemories.length} memories`);
 
   // 7. Relationships
-  const relationships = await db.getRelationships({ entityId: agentId });
+  const relationships = await db.getRelationships({ entityIds: [agentId] });
   logger.info(`[agent-export] Found ${relationships.length} relationships`);
 
   // 8. Tasks
   // The Task proto type does not declare agentId, but the DB schema stores
   // agent_id. Filter using a dynamic property access to handle both shapes.
-  const allTasks = await db.getTasks({});
+  const allTasks = await db.getTasks({ agentIds: [agentId] });
   const agentTasks = allTasks.filter((t) => taskAgentId(t) === agentId);
   logger.info(`[agent-export] Found ${agentTasks.length} tasks`);
 
@@ -502,11 +509,11 @@ async function extractAgentData(
   let characterConfig: Record<string, unknown> | undefined;
   if (runtime.character) {
     // Clone and strip secrets/sensitive fields
-    const { secrets, ...safeChar } = runtime.character as Record<
+    const { secrets, ...safeChar } = runtime.character;
+    characterConfig = Object.fromEntries(Object.entries(safeChar)) as Record<
       string,
       unknown
     >;
-    characterConfig = safeChar;
     logger.info(
       `[agent-export] Captured runtime character config (${Object.keys(safeChar).length} fields)`,
     );
@@ -581,8 +588,8 @@ async function restoreAgentData(
   agentData.createdAt = Date.now();
   agentData.updatedAt = Date.now();
 
-  const agentCreated = await db.createAgent(agentData);
-  if (!agentCreated) {
+  const agentCreatedIds = await db.createAgents([agentData]);
+  if (!agentCreatedIds || agentCreatedIds.length === 0) {
     throw new AgentExportError("Failed to create agent in database.");
   }
   logger.info(
@@ -597,7 +604,7 @@ async function restoreAgentData(
       id: remap(world.id ?? "") as UUID,
       agentId: newAgentId as UUID,
     };
-    await db.createWorld(newWorld);
+    await db.createWorlds([newWorld]);
     worldsImported++;
   }
   logger.info(`[agent-import] Imported ${worldsImported} worlds`);
@@ -644,9 +651,11 @@ async function restoreAgentData(
   for (const p of payload.participants) {
     const newEntityId = remap(p.entityId) as UUID;
     const newRoomId = remap(p.roomId) as UUID;
-    await db.addParticipantsRoom([newEntityId], newRoomId);
+    await db.createRoomParticipants([newEntityId], newRoomId);
     if (p.userState === "FOLLOWED" || p.userState === "MUTED") {
-      await db.setParticipantUserState(newRoomId, newEntityId, p.userState);
+      await db.updateParticipantUserStates([
+        { roomId: newRoomId, entityId: newEntityId, state: p.userState },
+      ]);
     }
     participantsImported++;
   }
@@ -666,7 +675,7 @@ async function restoreAgentData(
         ? { sourceEntityId: remap(comp.sourceEntityId) as UUID }
         : {}),
     };
-    await db.createComponent(newComp);
+    await db.createComponents([newComp]);
     componentsImported++;
   }
   logger.info(`[agent-import] Imported ${componentsImported} components`);
@@ -685,7 +694,7 @@ async function restoreAgentData(
       // Embeddings are excluded — they will be regenerated
       embedding: undefined,
     };
-    await db.createMemory(newMem, tableName);
+    await db.createMemories([{ memory: newMem, tableName }]);
     memoriesImported++;
   }
   logger.info(`[agent-import] Imported ${memoriesImported} memories`);
@@ -693,12 +702,12 @@ async function restoreAgentData(
   // 8. Create relationships
   let relationshipsImported = 0;
   for (const rel of payload.relationships) {
-    await db.createRelationship({
+    await db.createRelationships([{
       sourceEntityId: remap(rel.sourceEntityId ?? "") as UUID,
       targetEntityId: remap(rel.targetEntityId ?? "") as UUID,
       tags: rel.tags,
       metadata: rel.metadata,
-    });
+    }]);
     relationshipsImported++;
   }
   logger.info(`[agent-import] Imported ${relationshipsImported} relationships`);
@@ -717,7 +726,7 @@ async function restoreAgentData(
       worldId: task.worldId ? (remap(task.worldId) as UUID) : undefined,
       entityId: task.entityId ? (remap(task.entityId) as UUID) : undefined,
     } as Task;
-    await db.createTask(newTask);
+    await db.createTasks([newTask]);
     tasksImported++;
   }
   logger.info(`[agent-import] Imported ${tasksImported} tasks`);
@@ -725,16 +734,16 @@ async function restoreAgentData(
   // 10. Create logs
   let logsImported = 0;
   for (const logEntry of payload.logs) {
-    await db.log({
+    await db.createLogs([{
       body: logEntry.body,
-      entityId: logEntry.entityId
+      entityId: (logEntry.entityId
         ? (remap(logEntry.entityId) as UUID)
-        : logEntry.entityId,
+        : logEntry.entityId) as UUID,
       roomId: logEntry.roomId
         ? (remap(logEntry.roomId) as UUID)
         : (newAgentId as UUID),
       type: logEntry.type ?? "action",
-    });
+    }]);
     logsImported++;
   }
   logger.info(`[agent-import] Imported ${logsImported} logs`);
@@ -944,16 +953,18 @@ export async function estimateExportSize(
   const allWorlds = await db.getAllWorlds();
   const agentWorlds = allWorlds.filter((w) => w.agentId === agentId);
 
-  const roomIds = await db.getRoomsForParticipant(agentId);
+  const roomIds = await db.getRoomsForParticipants([agentId]);
   const entityIdSet = new Set<string>();
-  for (const roomId of roomIds) {
-    const roomEntities = await db.getEntitiesForRoom(roomId);
-    for (const e of roomEntities) {
-      if (e.id) entityIdSet.add(e.id);
+  if (roomIds.length > 0) {
+    const entitiesResult = await db.getEntitiesForRooms(roomIds as UUID[], true);
+    for (const result of entitiesResult) {
+      for (const e of result.entities) {
+        if (e.id) entityIdSet.add(e.id);
+      }
     }
   }
 
-  const tasks = await db.getTasks({});
+  const tasks = await db.getTasks({ agentIds: [agentId] });
   const agentTasks = tasks.filter((t) => taskAgentId(t) === agentId);
 
   // Rough estimate: ~500 bytes per memory, ~200 bytes per entity, ~300 per room

package/src/services/index.ts

@@ -2,16 +2,16 @@ export * from "./agent-export";
 export * from "./app-manager";
 export * from "./browser-capture";
 export * from "./fallback-training-service";
-export * from "./remote-signing-service";
+export * from "./privy-wallets";
 export * from "./registry-client";
+export * from "./remote-signing-service";
 export * from "./sandbox-engine";
 export * from "./sandbox-manager";
-export * from "./skill-catalog-client";
-export * from "./skill-marketplace";
 export * from "./self-updater";
 export * from "./signing-policy";
+export * from "./skill-catalog-client";
+export * from "./skill-marketplace";
 export * from "./stream-manager";
 export * from "./tts-stream-bridge";
 export * from "./update-checker";
-export * from "./privy-wallets";
 export * from "./version-compat";

package/src/services/whatsapp-pairing.ts

@@ -67,8 +67,11 @@ export class WhatsAppPairingSession {
 
     const baileys = await import("@whiskeysockets/baileys");
     const makeWASocket = baileys.default;
-    const { useMultiFileAuthState, fetchLatestBaileysVersion, DisconnectReason } =
-      baileys;
+    const {
+      useMultiFileAuthState,
+      fetchLatestBaileysVersion,
+      DisconnectReason,
+    } = baileys;
     const QRCode = (await import("qrcode")).default;
     const { Boom } = await import("@hapi/boom");
 

package/src/triggers/runtime.ts

@@ -1,5 +1,5 @@
 import crypto from "node:crypto";
-import type { IAgentRuntime, Task, UUID } from "@elizaos/core";
+import type { IAgentRuntime, Service, Task, UUID } from "@elizaos/core";
 import { stringToUuid } from "@elizaos/core";
 import {
   buildTriggerMetadata,
@@ -128,10 +128,22 @@ export function getTriggerLimit(runtime?: IAgentRuntime): number {
   return DEFAULT_MAX_ACTIVE_TRIGGERS;
 }
 
+type AutonomyServiceLike = {
+  injectAutonomousInstruction?: (payload: {
+    instructions: string;
+    source: string;
+    wakeMode: TriggerConfig["wakeMode"];
+    triggerId: UUID;
+    triggerTaskId: UUID;
+    taskId?: UUID;
+    roomId?: UUID;
+  }) => Promise<void> | void;
+};
+
 function isAutonomyServiceAvailable(runtime: IAgentRuntime): boolean {
   const svc =
-    (runtime.getService("autonomy") as Record<string, unknown> | null) ??
-    (runtime.getService("AUTONOMY") as Record<string, unknown> | null);
+    runtime.getService<Service & AutonomyServiceLike>("autonomy") ??
+    runtime.getService<Service & AutonomyServiceLike>("AUTONOMY");
   return typeof svc?.injectAutonomousInstruction === "function";
 }
 
@@ -348,6 +360,7 @@ export function registerTriggerTaskWorker(runtime: IAgentRuntime): void {
         source: options.source === "manual" ? "manual" : "scheduler",
         force: options.force === true,
       });
+      return {};
     },
   });
 }
@@ -358,6 +371,7 @@ export async function listTriggerTasks(
   if (!triggersFeatureEnabled(runtime)) return [];
   return runtime.getTasks({
     tags: [...TRIGGER_TASK_TAGS],
+    agentIds: [runtime.agentId],
   });
 }
 

package/test/api/agent-admin-routes.test.ts

@@ -1,16 +1,19 @@
-import { describe, test, expect, vi } from "vitest";
+import { describe, expect, test, vi } from "vitest";
+import type { AgentAdminRouteContext } from "../../src/api/agent-admin-routes";
+import { handleAgentAdminRoutes } from "../../src/api/agent-admin-routes";
 import {
-  createMockIncomingMessage,
   createMockHttpResponse,
+  createMockIncomingMessage,
 } from "../../src/test-support/test-helpers";
-import { handleAgentAdminRoutes } from "../../src/api/agent-admin-routes";
-import type { AgentAdminRouteContext } from "../../src/api/agent-admin-routes";
 
 function buildCtx(
   method: string,
   pathname: string,
   overrides?: Partial<AgentAdminRouteContext>,
-): AgentAdminRouteContext & { getStatus: () => number; getJson: () => unknown } {
+): AgentAdminRouteContext & {
+  getStatus: () => number;
+  getJson: () => unknown;
+} {
   const { res, getStatus, getJson } = createMockHttpResponse();
   const req = createMockIncomingMessage({ method, url: pathname });
   const ctx = {
@@ -48,13 +51,13 @@ function buildCtx(
     stateDirExists: () => false,
     removeStateDir: vi.fn(),
     logWarn: vi.fn(),
+    getStatus,
+    getJson,
     ...overrides,
   } as AgentAdminRouteContext & {
     getStatus: () => number;
     getJson: () => unknown;
   };
-  (ctx as any).getStatus = getStatus;
-  (ctx as any).getJson = getJson;
   return ctx;
 }
 
@@ -96,11 +99,14 @@ describe("agent-admin-routes", () => {
     });
 
     test("returns success when onRestart returns a new runtime", async () => {
-      const mockRuntime = {
+      const mockRuntime: Pick<
+        import("@elizaos/core").AgentRuntime,
+        "character" | "getSetting" | "modelProvider"
+      > = {
         character: { name: "NewAgent" },
         getSetting: () => undefined,
         modelProvider: "openai",
-      } as any;
+      };
       const onRestart = vi.fn(async () => mockRuntime);
       const onRuntimeSwapped = vi.fn();
       const ctx = buildCtx("POST", "/api/agent/restart", {

package/test/api/agent-lifecycle-routes.test.ts

@@ -1,13 +1,13 @@
-import { describe, test, expect, vi } from "vitest";
-import {
-  createMockIncomingMessage,
-  createMockHttpResponse,
-} from "../../src/test-support/test-helpers";
-import { handleAgentLifecycleRoutes } from "../../src/api/agent-lifecycle-routes";
+import { describe, expect, test, vi } from "vitest";
 import type {
   AgentLifecycleRouteContext,
   AgentLifecycleRouteState,
 } from "../../src/api/agent-lifecycle-routes";
+import { handleAgentLifecycleRoutes } from "../../src/api/agent-lifecycle-routes";
+import {
+  createMockHttpResponse,
+  createMockIncomingMessage,
+} from "../../src/test-support/test-helpers";
 
 function buildState(
   overrides?: Partial<AgentLifecycleRouteState>,
@@ -115,7 +115,9 @@ describe("agent-lifecycle-routes", () => {
 
     test("returns enabled true when runtime has autonomy", async () => {
       const state = buildState({
-        runtime: { enableAutonomy: true } as any,
+        runtime: {
+          enableAutonomy: true,
+        } as Pick<import("@elizaos/core").AgentRuntime, "enableAutonomy">,
       });
       const ctx = buildCtx("GET", "/api/agent/autonomy", state);
       await handleAgentLifecycleRoutes(ctx);
@@ -126,7 +128,9 @@ describe("agent-lifecycle-routes", () => {
 
   describe("POST /api/agent/autonomy", () => {
     test("sets autonomy on runtime", async () => {
-      const runtime = { enableAutonomy: false } as any;
+      const runtime = {
+        enableAutonomy: false,
+      } as Pick<import("@elizaos/core").AgentRuntime, "enableAutonomy">;
       const state = buildState({ runtime });
       const ctx = buildCtx("POST", "/api/agent/autonomy", state, {
         readJsonBody: vi.fn(async () => ({ enabled: true })),
@@ -136,7 +140,12 @@ describe("agent-lifecycle-routes", () => {
     });
 
     test("rejects non-boolean enabled", async () => {
-      const state = buildState({ runtime: {} as any });
+      const state = buildState({
+        runtime: {} as Pick<
+          import("@elizaos/core").AgentRuntime,
+          "enableAutonomy"
+        >,
+      });
       const ctx = buildCtx("POST", "/api/agent/autonomy", state, {
         readJsonBody: vi.fn(async () => ({ enabled: "yes" })),
       });

package/test/api/agent-transfer-routes.test.ts

@@ -1,10 +1,10 @@
-import { describe, test, expect, vi } from "vitest";
+import { describe, expect, test, vi } from "vitest";
+import type { AgentTransferRouteContext } from "../../src/api/agent-transfer-routes";
+import { handleAgentTransferRoutes } from "../../src/api/agent-transfer-routes";
 import {
-  createMockIncomingMessage,
   createMockHttpResponse,
+  createMockIncomingMessage,
 } from "../../src/test-support/test-helpers";
-import { handleAgentTransferRoutes } from "../../src/api/agent-transfer-routes";
-import type { AgentTransferRouteContext } from "../../src/api/agent-transfer-routes";
 
 function buildCtx(
   method: string,
@@ -38,12 +38,12 @@ function buildCtx(
     importAgent: vi.fn(async () => ({ ok: true })),
     isAgentExportError: () => false,
     ...overrides,
+    getStatus,
+    getJson,
   } as AgentTransferRouteContext & {
     getStatus: () => number;
     getJson: () => unknown;
   };
-  (ctx as any).getStatus = getStatus;
-  (ctx as any).getJson = getJson;
   return ctx;
 }
 
@@ -60,7 +60,10 @@ describe("agent-transfer-routes", () => {
     });
 
     test("returns 400 when password is missing", async () => {
-      const mockRuntime = { character: { name: "Agent" } } as any;
+      const mockRuntime: Pick<
+        import("@elizaos/core").AgentRuntime,
+        "character"
+      > = { character: { name: "Agent" } };
       const ctx = buildCtx("POST", "/api/agent/export", {
         state: { runtime: mockRuntime },
         readJsonBody: vi.fn(async () => ({})),
@@ -73,7 +76,10 @@ describe("agent-transfer-routes", () => {
     });
 
     test("exports successfully with valid password", async () => {
-      const mockRuntime = { character: { name: "Agent" } } as any;
+      const mockRuntime: Pick<
+        import("@elizaos/core").AgentRuntime,
+        "character"
+      > = { character: { name: "Agent" } };
       const ctx = buildCtx("POST", "/api/agent/export", {
         state: { runtime: mockRuntime },
         readJsonBody: vi.fn(async () => ({
@@ -99,7 +105,10 @@ describe("agent-transfer-routes", () => {
     });
 
     test("returns estimate when runtime is available", async () => {
-      const mockRuntime = { character: { name: "Agent" } } as any;
+      const mockRuntime: Pick<
+        import("@elizaos/core").AgentRuntime,
+        "character"
+      > = { character: { name: "Agent" } };
       const ctx = buildCtx("GET", "/api/agent/export/estimate", {
         state: { runtime: mockRuntime },
       });