@elizaos/autonomous 2.0.0-alpha.73 → 2.0.0-alpha.74

package/test/trajectory-restart-carryover.e2e.test.ts

@@ -1,306 +0,0 @@
-import http from "node:http";
-import type { AgentRuntime } from "@elizaos/core";
-import { afterAll, beforeAll, describe, expect, it } from "vitest";
-import { startApiServer } from "../src/api/server";
-
-type JsonValue =
-  | string
-  | number
-  | boolean
-  | null
-  | JsonValue[]
-  | {
-      [key: string]: JsonValue;
-    };
-
-type JsonObject = Record<string, JsonValue>;
-
-type RawSqlQuery = {
-  queryChunks?: Array<{
-    value?: string[];
-  }>;
-};
-
-function sqlText(query: RawSqlQuery): string {
-  const chunks = query.queryChunks ?? [];
-  return chunks
-    .map((chunk) => (Array.isArray(chunk.value) ? chunk.value.join("") : ""))
-    .join("")
-    .trim();
-}
-
-function splitSqlTuple(valueList: string): string[] {
-  const values: string[] = [];
-  let current = "";
-  let inString = false;
-  for (let i = 0; i < valueList.length; i += 1) {
-    const char = valueList[i];
-    if (char === "'") {
-      current += char;
-      if (inString && valueList[i + 1] === "'") {
-        current += "'";
-        i += 1;
-        continue;
-      }
-      inString = !inString;
-      continue;
-    }
-    if (char === "," && !inString) {
-      values.push(current.trim());
-      current = "";
-      continue;
-    }
-    current += char;
-  }
-  if (current.trim().length > 0) values.push(current.trim());
-  return values;
-}
-
-function parseSqlScalar(token: string): string | number | null {
-  if (token.toUpperCase() === "NULL") return null;
-  if (token.startsWith("'") && token.endsWith("'")) {
-    return token.slice(1, -1).replace(/''/g, "'");
-  }
-  const asNumber = Number(token);
-  return Number.isFinite(asNumber) ? asNumber : token;
-}
-
-class InMemoryTrajectoryDb {
-  private rows = new Map<string, Record<string, unknown>>();
-
-  async execute(query: RawSqlQuery): Promise<{ rows: unknown[] }> {
-    const sql = sqlText(query);
-    const normalized = sql.toLowerCase().replace(/\s+/g, " ").trim();
-
-    if (normalized.startsWith("create table if not exists trajectories")) {
-      return { rows: [] };
-    }
-
-    if (normalized.startsWith("insert into trajectories")) {
-      const match =
-        /insert into trajectories\s*\(([\s\S]+?)\)\s*values\s*\(([\s\S]+?)\)\s*on conflict/i.exec(
-          sql,
-        );
-      if (!match) return { rows: [] };
-      const columns = splitSqlTuple(match[1]).map((col) => col.trim());
-      const values = splitSqlTuple(match[2]).map(parseSqlScalar);
-      const row: Record<string, unknown> = {};
-      for (let i = 0; i < columns.length; i += 1) {
-        row[columns[i]] = values[i] ?? null;
-      }
-      const id = String(row.id ?? "");
-      if (id) {
-        const existing = this.rows.get(id) ?? {};
-        this.rows.set(id, { ...existing, ...row });
-      }
-      return { rows: [] };
-    }
-
-    if (normalized.startsWith("select * from trajectories where id =")) {
-      const match = /where id = '([^']*(?:''[^']*)*)'/i.exec(sql);
-      const id = match ? match[1].replace(/''/g, "'") : "";
-      const row = id ? this.rows.get(id) : null;
-      return { rows: row ? [row] : [] };
-    }
-
-    if (normalized.startsWith("select * from trajectories")) {
-      const limitMatch = /limit\s+(\d+)/i.exec(sql);
-      const limit = limitMatch ? Number(limitMatch[1]) : 5000;
-      const rows = Array.from(this.rows.values()).sort((a, b) =>
-        String(b.created_at ?? "").localeCompare(String(a.created_at ?? "")),
-      );
-      return { rows: rows.slice(0, limit) };
-    }
-
-    return { rows: [] };
-  }
-}
-
-function req(
-  port: number,
-  method: string,
-  p: string,
-): Promise<{ status: number; data: JsonObject }> {
-  return new Promise((resolve, reject) => {
-    const request = http.request(
-      {
-        hostname: "127.0.0.1",
-        port,
-        path: p,
-        method,
-      },
-      (res) => {
-        const chunks: Buffer[] = [];
-        res.on("data", (chunk: Buffer) => chunks.push(chunk));
-        res.on("end", () => {
-          const raw = Buffer.concat(chunks).toString("utf-8");
-          let data: JsonObject = {};
-          try {
-            data = JSON.parse(raw) as JsonObject;
-          } catch {
-            data = { _raw: raw };
-          }
-          resolve({ status: res.statusCode ?? 0, data });
-        });
-      },
-    );
-    request.on("error", reject);
-    request.end();
-  });
-}
-
-type InMemoryTrajectoryLogger = {
-  isEnabled: () => boolean;
-  getLlmCallLogs: () => ReadonlyArray<Record<string, unknown>>;
-  getProviderAccessLogs: () => ReadonlyArray<Record<string, unknown>>;
-  logLlmCall?: (params: Record<string, unknown>) => void;
-  llmCalls: Array<Record<string, unknown>>;
-  providerAccess: Array<Record<string, unknown>>;
-};
-
-function createRuntimeWithCoreLogger(
-  agentId: string,
-  name: string,
-  logger: InMemoryTrajectoryLogger,
-  db: InMemoryTrajectoryDb,
-): AgentRuntime {
-  const noop = () => {};
-  return {
-    agentId,
-    character: { name },
-    adapter: { db } as unknown as AgentRuntime["adapter"],
-    plugins: [],
-    actions: [],
-    providers: [],
-    evaluators: [],
-    services: new Map(),
-    getService: (serviceType: string) =>
-      serviceType === "trajectory_logger" ? logger : null,
-    getServicesByType: (serviceType: string) =>
-      serviceType === "trajectory_logger" ? [logger] : [],
-    messageService: null,
-    logger: {
-      trace: noop,
-      debug: noop,
-      info: noop,
-      warn: noop,
-      error: noop,
-      fatal: noop,
-      success: noop,
-      progress: noop,
-      clear: noop,
-      child: () =>
-        ({
-          trace: noop,
-          debug: noop,
-          info: noop,
-          warn: noop,
-          error: noop,
-          fatal: noop,
-          success: noop,
-          progress: noop,
-          clear: noop,
-          child: () => ({}),
-        }) as AgentRuntime["logger"],
-    } as AgentRuntime["logger"],
-  } as unknown as AgentRuntime;
-}
-
-describe("trajectory logs survive updateRuntime hot-swap", () => {
-  let port = 0;
-  let closeServer: (() => Promise<void>) | null = null;
-  let updateRuntime: ((rt: AgentRuntime) => void) | null = null;
-  const db = new InMemoryTrajectoryDb();
-  let loggerA: InMemoryTrajectoryLogger | null = null;
-
-  beforeAll(async () => {
-    loggerA = {
-      isEnabled: () => true,
-      llmCalls: [],
-      providerAccess: [],
-      getLlmCallLogs() {
-        return this.llmCalls;
-      },
-      getProviderAccessLogs() {
-        return this.providerAccess;
-      },
-    };
-
-    const runtimeA = createRuntimeWithCoreLogger(
-      "00000000-0000-0000-0000-000000000001",
-      "CarryoverA",
-      loggerA,
-      db,
-    );
-
-    const server = await startApiServer({ port: 0, runtime: runtimeA });
-    port = server.port;
-    closeServer = server.close;
-    updateRuntime = server.updateRuntime;
-
-    loggerA.logLlmCall?.({
-      stepId: "step-a",
-      model: "unit-test-model",
-      systemPrompt: "sys",
-      userPrompt: "hello",
-      response: "world",
-      temperature: 0,
-      maxTokens: 64,
-      purpose: "action",
-      actionType: "runtime.useModel",
-      latencyMs: 12,
-      timestamp: Date.now(),
-    });
-    await new Promise((resolve) => setTimeout(resolve, 50));
-  }, 30_000);
-
-  afterAll(async () => {
-    if (closeServer) {
-      await closeServer();
-    }
-  });
-
-  it("retains existing trajectories after runtime swap", async () => {
-    const before = await req(port, "GET", "/api/trajectories");
-    if (before.status === 503) {
-      expect(typeof before.data.error).toBe("string");
-      return;
-    }
-    expect(before.status).toBe(200);
-    const beforeRows = (before.data.trajectories ?? []) as Array<JsonObject>;
-    expect(beforeRows.length).toBeGreaterThan(0);
-
-    const loggerB: InMemoryTrajectoryLogger = {
-      isEnabled: () => true,
-      llmCalls: [],
-      providerAccess: [],
-      getLlmCallLogs() {
-        return this.llmCalls;
-      },
-      getProviderAccessLogs() {
-        return this.providerAccess;
-      },
-    };
-    const runtimeB = createRuntimeWithCoreLogger(
-      "00000000-0000-0000-0000-000000000002",
-      "CarryoverB",
-      loggerB,
-      db,
-    );
-
-    if (!updateRuntime) {
-      throw new Error("updateRuntime not available");
-    }
-    updateRuntime(runtimeB);
-
-    const after = await req(port, "GET", "/api/trajectories");
-    if (after.status === 503) {
-      expect(typeof after.data.error).toBe("string");
-      return;
-    }
-    expect(after.status).toBe(200);
-    const afterRows = (after.data.trajectories ?? []) as Array<JsonObject>;
-    expect(afterRows.length).toBeGreaterThanOrEqual(beforeRows.length);
-    expect(afterRows.some((row) => row.id === beforeRows[0]?.id)).toBe(true);
-  });
-});

package/test/trigger-execution-flow.e2e.test.ts

@@ -1,132 +0,0 @@
-/**
- * Trigger Execution Flow — E2E Tests
- *
- * Tests trigger CRUD and validation via the API server:
- * - Create trigger with validation
- * - List triggers
- * - Manual trigger execution
- * - Trigger deletion
- * - Duplicate detection (dedupeKey)
- */
-
-import http from "node:http";
-import { afterAll, beforeAll, describe, expect, it, vi } from "vitest";
-import { startApiServer } from "../src/api/server";
-
-vi.mock("../src/services/mcp-marketplace", () => ({
-  searchMcpMarketplace: vi.fn().mockResolvedValue({ results: [] }),
-  getMcpServerDetails: vi.fn().mockResolvedValue(null),
-}));
-
-// ---------------------------------------------------------------------------
-// HTTP helper
-// ---------------------------------------------------------------------------
-
-function req(
-  port: number,
-  method: string,
-  p: string,
-  body?: Record<string, unknown>,
-): Promise<{
-  status: number;
-  headers: http.IncomingHttpHeaders;
-  data: Record<string, unknown>;
-}> {
-  return new Promise((resolve, reject) => {
-    const b = body ? JSON.stringify(body) : undefined;
-    const r = http.request(
-      {
-        hostname: "127.0.0.1",
-        port,
-        path: p,
-        method,
-        headers: {
-          "Content-Type": "application/json",
-          ...(b ? { "Content-Length": Buffer.byteLength(b) } : {}),
-        },
-      },
-      (res) => {
-        const ch: Buffer[] = [];
-        res.on("data", (c: Buffer) => ch.push(c));
-        res.on("end", () => {
-          const raw = Buffer.concat(ch).toString("utf-8");
-          let data: Record<string, unknown> = {};
-          try {
-            data = JSON.parse(raw) as Record<string, unknown>;
-          } catch {
-            data = { _raw: raw };
-          }
-          resolve({ status: res.statusCode ?? 0, headers: res.headers, data });
-        });
-      },
-    );
-    r.on("error", reject);
-    if (b) r.write(b);
-    r.end();
-  });
-}
-
-// ---------------------------------------------------------------------------
-// Server lifecycle
-// ---------------------------------------------------------------------------
-
-let port: number;
-let server: Awaited<ReturnType<typeof startApiServer>>;
-
-beforeAll(async () => {
-  server = await startApiServer({
-    port: 0,
-    initialAgentState: "not_started",
-  });
-  port = server.port;
-}, 30_000);
-
-afterAll(async () => {
-  if (server) {
-    await server.close();
-  }
-}, 15_000);
-
-// ============================================================================
-//  1. Trigger API availability
-// ============================================================================
-
-describe("trigger API endpoints", () => {
-  it("GET /api/triggers returns list (may be empty)", async () => {
-    const { status } = await req(port, "GET", "/api/triggers");
-    // Without runtime/tasks, may return 200 with empty or 500
-    expect([200, 500, 503]).toContain(status);
-  });
-
-  it("POST /api/triggers validates required fields", async () => {
-    const { status } = await req(port, "POST", "/api/triggers", {});
-    // Missing required trigger fields should be rejected
-    expect([400, 500, 503]).toContain(status);
-  });
-
-  it("POST /api/triggers rejects invalid trigger type", async () => {
-    const { status } = await req(port, "POST", "/api/triggers", {
-      name: "Test Trigger",
-      type: "invalid_type",
-      instruction: "do something",
-    });
-    expect([400, 500, 503]).toContain(status);
-  });
-});
-
-// ============================================================================
-//  2. Manual trigger execution
-// ============================================================================
-
-describe("manual trigger execution", () => {
-  it("POST /api/triggers/:id/execute rejects non-existent trigger", async () => {
-    const { status } = await req(
-      port,
-      "POST",
-      "/api/triggers/nonexistent-id/execute",
-      {},
-    );
-    // Should return 404 or 500 for non-existent trigger
-    expect([404, 500, 503]).toContain(status);
-  });
-});

package/test/trigger-runtime.e2e.test.ts

@@ -1,247 +0,0 @@
-import crypto from "node:crypto";
-import http from "node:http";
-import {
-  type AgentRuntime,
-  stringToUuid,
-  type Task,
-  type UUID,
-} from "@elizaos/core";
-import { afterAll, beforeAll, describe, expect, it, vi } from "vitest";
-import { startApiServer } from "../src/api/server";
-
-type JsonPrimitive = string | number | boolean | null;
-type JsonValue = JsonPrimitive | JsonObject | JsonArray;
-type JsonArray = JsonValue[];
-interface JsonObject {
-  [key: string]: JsonValue;
-}
-
-interface ApiResponse {
-  status: number;
-  data: JsonValue;
-}
-
-interface TriggerRuntimeHarness {
-  runtime: AgentRuntime;
-  injectAutonomousInstruction: ReturnType<typeof vi.fn>;
-}
-
-function parseJson(raw: string): JsonValue {
-  try {
-    return JSON.parse(raw) as JsonValue;
-  } catch {
-    return { raw };
-  }
-}
-
-function asObject(value: JsonValue): JsonObject {
-  if (!value || typeof value !== "object" || Array.isArray(value)) return {};
-  return value;
-}
-
-function asArray(value: JsonValue): JsonArray {
-  if (!Array.isArray(value)) return [];
-  return value;
-}
-
-function requestApi(
-  port: number,
-  method: string,
-  path: string,
-  body?: JsonObject,
-): Promise<ApiResponse> {
-  return new Promise((resolve, reject) => {
-    const payload = body ? JSON.stringify(body) : undefined;
-    const request = http.request(
-      {
-        hostname: "127.0.0.1",
-        port,
-        path,
-        method,
-        headers: payload
-          ? {
-              "Content-Type": "application/json",
-              "Content-Length": Buffer.byteLength(payload),
-            }
-          : undefined,
-      },
-      (response) => {
-        const chunks: Buffer[] = [];
-        response.on("data", (chunk: Buffer) => chunks.push(chunk));
-        response.on("end", () => {
-          const raw = Buffer.concat(chunks).toString("utf-8");
-          resolve({
-            status: response.statusCode ?? 0,
-            data: parseJson(raw),
-          });
-        });
-      },
-    );
-    request.on("error", reject);
-    if (payload) request.write(payload);
-    request.end();
-  });
-}
-
-function createTriggerRuntimeHarness(): TriggerRuntimeHarness {
-  let tasks: Task[] = [];
-  const injectAutonomousInstruction = vi.fn(
-    async (_params: {
-      instructions: string;
-      source: string;
-      wakeMode: "inject_now" | "next_autonomy_cycle";
-      triggerId: UUID;
-      triggerTaskId: UUID;
-    }) => undefined,
-  );
-
-  const runtimePartial: Partial<AgentRuntime> = {
-    agentId: "00000000-0000-0000-0000-000000000001" as UUID,
-    character: { name: "TriggerRuntimeE2E" } as AgentRuntime["character"],
-    getSetting: (_key: string) => undefined,
-    getService: (serviceType: string) => {
-      if (serviceType !== "AUTONOMY") return null;
-      return {
-        getAutonomousRoomId: () =>
-          "00000000-0000-0000-0000-000000000201" as UUID,
-        injectAutonomousInstruction,
-      } as {
-        getAutonomousRoomId: () => UUID;
-        injectAutonomousInstruction: (params: {
-          instructions: string;
-          source: string;
-          wakeMode: "inject_now" | "next_autonomy_cycle";
-          triggerId: UUID;
-          triggerTaskId: UUID;
-        }) => Promise<void>;
-      };
-    },
-    getTasks: async (query?: { tags?: string[] }) => {
-      if (!query?.tags || query.tags.length === 0) return tasks;
-      return tasks.filter((task) =>
-        query.tags?.every((tag) => task.tags?.includes(tag)),
-      );
-    },
-    getTask: async (taskId: UUID) =>
-      tasks.find((task) => task.id === taskId) ?? null,
-    getRoomsByWorld: async () => [],
-    createTask: async (task: Task) => {
-      const id = stringToUuid(crypto.randomUUID());
-      const created: Task = {
-        ...task,
-        id,
-      };
-      tasks.push(created);
-      return id;
-    },
-    updateTask: async (taskId: UUID, update: Partial<Task>) => {
-      tasks = tasks.map((task) =>
-        task.id === taskId
-          ? {
-              ...task,
-              ...update,
-              metadata: {
-                ...(task.metadata ?? {}),
-                ...(update.metadata ?? {}),
-              },
-            }
-          : task,
-      );
-    },
-    deleteTask: async (taskId: UUID) => {
-      tasks = tasks.filter((task) => task.id !== taskId);
-    },
-    createMemory: vi.fn(async () => undefined),
-    getTaskWorker: vi.fn(),
-    registerTaskWorker: vi.fn(),
-    logger: {
-      debug: vi.fn(),
-      info: vi.fn(),
-      warn: vi.fn(),
-      error: vi.fn(),
-    } as AgentRuntime["logger"],
-  };
-
-  return {
-    runtime: runtimePartial as AgentRuntime,
-    injectAutonomousInstruction,
-  };
-}
-
-describe("Trigger runtime E2E", () => {
-  let server: { port: number; close: () => Promise<void> } | null = null;
-  let harness: TriggerRuntimeHarness;
-
-  beforeAll(async () => {
-    harness = createTriggerRuntimeHarness();
-    server = await startApiServer({
-      port: 0,
-      runtime: harness.runtime,
-    });
-  });
-
-  afterAll(async () => {
-    if (server) {
-      await server.close();
-    }
-  });
-
-  it("creates a trigger, executes it, records run history, and dispatches autonomy", async () => {
-    if (!server) {
-      throw new Error("Server was not initialized");
-    }
-
-    const createResponse = await requestApi(
-      server.port,
-      "POST",
-      "/api/triggers",
-      {
-        displayName: "Heartbeat runtime e2e",
-        instructions: "Send a runtime heartbeat update",
-        triggerType: "interval",
-        intervalMs: 60_000,
-        wakeMode: "inject_now",
-      },
-    );
-
-    expect(createResponse.status).toBe(201);
-    const createBody = asObject(createResponse.data);
-    const trigger = asObject(createBody.trigger ?? null);
-    const triggerId = String(trigger.id ?? "");
-    expect(triggerId.length).toBeGreaterThan(0);
-
-    const executeResponse = await requestApi(
-      server.port,
-      "POST",
-      `/api/triggers/${encodeURIComponent(triggerId)}/execute`,
-    );
-    expect(executeResponse.status).toBe(200);
-    const executeBody = asObject(executeResponse.data);
-    const executeResult = asObject(executeBody.result ?? null);
-    expect(executeResult.status).toBe("success");
-    expect(harness.injectAutonomousInstruction).toHaveBeenCalledTimes(1);
-
-    const runsResponse = await requestApi(
-      server.port,
-      "GET",
-      `/api/triggers/${encodeURIComponent(triggerId)}/runs`,
-    );
-    expect(runsResponse.status).toBe(200);
-    const runsBody = asObject(runsResponse.data);
-    const runs = asArray(runsBody.runs ?? []);
-    expect(runs.length).toBe(1);
-    const run = asObject(runs[0] ?? null);
-    expect(run.status).toBe("success");
-    expect(run.source).toBe("manual");
-
-    const healthResponse = await requestApi(
-      server.port,
-      "GET",
-      "/api/triggers/health",
-    );
-    expect(healthResponse.status).toBe(200);
-    const health = asObject(healthResponse.data);
-    expect(Number(health.totalExecutions ?? 0)).toBeGreaterThanOrEqual(1);
-    expect(Number(health.totalFailures ?? 0)).toBe(0);
-  });
-});