@polderlabs/bizar-plugin 0.5.4

package/tests/tools/bg-status.test.ts

@@ -0,0 +1,216 @@
+/**
+ * bizar_status tool tests.
+ *
+ * Tests: list all, single instance, filter, no instances,
+ * returns documented shape per §7.1. Read-only — any agent can call.
+ */
+
+import { describe, it, expect } from "bun:test";
+
+// ---------------------------------------------------------------------------
+// Fake BackgroundState for testing
+// ---------------------------------------------------------------------------
+
+interface BackgroundState {
+  instanceId: string;
+  agent: string;
+  status: "pending" | "running" | "done" | "failed" | "killed" | "timed_out";
+  startedAt: number;
+  toolCallCount: number;
+  promptPreview: string;
+  resultPreview?: string;
+  error?: string;
+  parentAgent: string;
+  parentInstanceId?: string;
+  durationMs?: number;
+}
+
+function makeBgState(overrides: Partial<BackgroundState> = {}): BackgroundState {
+  return {
+    instanceId: "bgr_test_01",
+    agent: "mimir",
+    status: "running",
+    startedAt: Date.now() - 60_000,
+    toolCallCount: 12,
+    promptPreview: "Do the research on X",
+    resultPreview: undefined,
+    error: undefined,
+    parentAgent: "odin",
+    parentInstanceId: undefined,
+    durationMs: 60_000,
+    ...overrides,
+  };
+}
+
+// ---------------------------------------------------------------------------
+// Fake bizar_status implementation (read-only — any agent can call)
+// ---------------------------------------------------------------------------
+
+function bizar_status(
+  args: { instanceId?: string } | undefined,
+  _ctx: { agent: string },
+  instances: Map<string, BackgroundState>,
+): BackgroundState[] | BackgroundState | { error: string } {
+  if (!args || args.instanceId === undefined) {
+    // Return all
+    return [...instances.values()];
+  }
+
+  const inst = instances.get(args.instanceId);
+  if (!inst) {
+    return { error: `Instance ${args.instanceId} not found` };
+  }
+  return inst;
+}
+
+// ---------------------------------------------------------------------------
+// In-memory instance store for tests
+// ---------------------------------------------------------------------------
+
+const instances = new Map<string, BackgroundState>();
+instances.set("bgr_01", makeBgState({ instanceId: "bgr_01", agent: "mimir", status: "running" }));
+instances.set("bgr_02", makeBgState({ instanceId: "bgr_02", agent: "thor", status: "done", resultPreview: "Done!", completedAt: Date.now() }));
+instances.set("bgr_03", makeBgState({ instanceId: "bgr_03", agent: "tyr", status: "failed", error: "Loop protection: 12 identical calls to read" }));
+
+function makeCompletedState(overrides: Partial<BackgroundState> = {}): BackgroundState {
+  return {
+    instanceId: "bgr_completed",
+    agent: "mimir",
+    status: "done",
+    startedAt: Date.now() - 120_000,
+    toolCallCount: 5,
+    promptPreview: "Quick task",
+    resultPreview: "All done!",
+    error: undefined,
+    parentAgent: "odin",
+    parentInstanceId: undefined,
+    durationMs: 120_000,
+    ...overrides,
+  };
+}
+
+// ---------------------------------------------------------------------------
+// bizarre_status — list all
+// ---------------------------------------------------------------------------
+
+describe("bizar_status — list all", () => {
+  it("returns all instances when called with no args", () => {
+    const result = bizar_status(undefined, { agent: "odin" }, instances);
+    expect(Array.isArray(result)).toBe(true);
+    expect((result as BackgroundState[]).length).toBe(3);
+  });
+
+  it("includes all documented fields per instance (§7.1)", () => {
+    const all = bizar_status(undefined, { agent: "odin" }, instances) as BackgroundState[];
+    const first = all[0];
+    expect(first).toHaveProperty("instanceId");
+    expect(first).toHaveProperty("agent");
+    expect(first).toHaveProperty("status");
+    expect(first).toHaveProperty("startedAt");
+    expect(first).toHaveProperty("toolCallCount");
+    expect(first).toHaveProperty("promptPreview");
+    expect(first).toHaveProperty("resultPreview");
+    expect(first).toHaveProperty("error");
+    expect(first).toHaveProperty("parentAgent");
+  });
+
+  it("returns instances in any order (stable map iteration)", () => {
+    const all = bizar_status(undefined, { agent: "odin" }, instances) as BackgroundState[];
+    const ids = all.map((i) => i.instanceId);
+    expect(ids).toContain("bgr_01");
+    expect(ids).toContain("bgr_02");
+    expect(ids).toContain("bgr_03");
+  });
+
+  it("any agent can call bizar_status (read-only)", () => {
+    for (const agent of ["odin", "vor", "frigg", "mimir", "thor", "tyr", "heimdall"]) {
+      const result = bizar_status(undefined, { agent }, instances);
+      expect(Array.isArray(result)).toBe(true);
+    }
+  });
+});
+
+// ---------------------------------------------------------------------------
+// bizar_status — single instance
+// ---------------------------------------------------------------------------
+
+describe("bizar_status — single instance", () => {
+  it("returns the requested instance", () => {
+    const result = bizar_status({ instanceId: "bgr_02" }, { agent: "odin" }, instances);
+    expect((result as BackgroundState).instanceId).toBe("bgr_02");
+    expect((result as BackgroundState).agent).toBe("thor");
+    expect((result as BackgroundState).status).toBe("done");
+  });
+
+  it("returns error for unknown instanceId", () => {
+    const result = bizar_status({ instanceId: "bgr_unknown" }, { agent: "odin" }, instances);
+    expect(result).toHaveProperty("error");
+    expect((result as { error: string }).error).toContain("not found");
+  });
+});
+
+// ---------------------------------------------------------------------------
+// Status values
+// ---------------------------------------------------------------------------
+
+describe("bizar_status — status values", () => {
+  it("running instance shows running status", () => {
+    const result = bizar_status({ instanceId: "bgr_01" }, { agent: "odin" }, instances) as BackgroundState;
+    expect(result.status).toBe("running");
+    expect(result.resultPreview).toBeUndefined();
+  });
+
+  it("done instance shows resultPreview", () => {
+    const result = bizar_status({ instanceId: "bgr_02" }, { agent: "odin" }, instances) as BackgroundState;
+    expect(result.status).toBe("done");
+    expect(result.resultPreview).toBe("Done!");
+  });
+
+  it("failed instance shows error", () => {
+    const result = bizar_status({ instanceId: "bgr_03" }, { agent: "odin" }, instances) as BackgroundState;
+    expect(result.status).toBe("failed");
+    expect(result.error).toContain("Loop protection");
+  });
+});
+
+// ---------------------------------------------------------------------------
+// No instances
+// ---------------------------------------------------------------------------
+
+describe("bizar_status — no instances", () => {
+  it("returns empty array when no instances exist", () => {
+    const emptyMap = new Map<string, BackgroundState>();
+    const result = bizar_status(undefined, { agent: "odin" }, emptyMap);
+    expect(Array.isArray(result)).toBe(true);
+    expect((result as BackgroundState[]).length).toBe(0);
+  });
+
+  it("returns error for unknown instanceId when map is empty", () => {
+    const emptyMap = new Map<string, BackgroundState>();
+    const result = bizar_status({ instanceId: "bgr_anything" }, { agent: "odin" }, emptyMap);
+    expect(result).toHaveProperty("error");
+  });
+});
+
+// ---------------------------------------------------------------------------
+// Duration calculation
+// ---------------------------------------------------------------------------
+
+describe("bizar_status — durationMs", () => {
+  it("durationMs is derived from startedAt and now (or completedAt)", () => {
+    // Test the concept: durationMs is computed from startedAt vs now/completedAt
+    // In a real instance, running.durationMs would be Date.now() - startedAt
+    // Here we just verify the field exists and is a number
+    const running = makeBgState({ startedAt: Date.now() - 30_000, status: "running" });
+    expect(typeof running.durationMs).toBe("number");
+    expect(running.durationMs).toBeGreaterThan(0);
+  });
+
+  it("durationMs uses completedAt when instance is done", () => {
+    // completedAt - startedAt gives the actual duration
+    const startedAt = Date.now() - 60_000;
+    const completedAt = Date.now() - 30_000;
+    const expectedDuration = completedAt - startedAt;
+    expect(expectedDuration).toBe(30_000);
+  });
+});