@openfinclaw/findoo-alpha-plugin 2026.3.12

package/test/a2a-live.test.ts

@@ -0,0 +1,198 @@
+/**
+ * L2 — Findoo A2A Live Integration Test
+ *
+ * Tests real A2A communication with the remote strategy-agent (43.128.100.43:5085).
+ * Requires network access to PRD server.
+ *
+ * Run: LIVE=1 npx vitest run extensions/findoo-alpha-plugin/test/a2a-live.test.ts
+ */
+import { describe, expect, it } from "vitest";
+import { A2AClient } from "../src/a2a-client.js";
+
+const SKIP = !process.env.LIVE;
+const STRATEGY_AGENT_URL = process.env.STRATEGY_AGENT_URL ?? "http://43.128.100.43:5085";
+const ASSISTANT_ID = process.env.STRATEGY_ASSISTANT_ID ?? "d2310a07-b552-453c-a8bb-7b9b86de6b23";
+
+describe.skipIf(SKIP)("L2 — Findoo A2A Live", { timeout: 180_000 }, () => {
+  const client = new A2AClient(STRATEGY_AGENT_URL, ASSISTANT_ID);
+
+  it("1. strategy-agent /ok endpoint is reachable", async () => {
+    const resp = await fetch(`${STRATEGY_AGENT_URL}/ok`, {
+      signal: AbortSignal.timeout(10_000),
+    });
+    expect(resp.ok).toBe(true);
+    const body = await resp.json();
+    expect(body).toHaveProperty("ok", true);
+  });
+
+  it("2. /assistants/search returns assistants", async () => {
+    const resp = await fetch(`${STRATEGY_AGENT_URL}/assistants/search`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({}),
+      signal: AbortSignal.timeout(10_000),
+    });
+    expect(resp.ok).toBe(true);
+    const assistants = await resp.json();
+    expect(Array.isArray(assistants)).toBe(true);
+    expect(assistants.length).toBeGreaterThan(0);
+    expect(assistants[0]).toHaveProperty("assistant_id");
+    expect(assistants[0]).toHaveProperty("graph_id", "strategy");
+  });
+
+  it("3. A2A message/send returns valid JSON-RPC response", async () => {
+    const resp = await client.sendMessage("你好，请简要介绍你的能力", {
+      timeoutMs: 120_000,
+    });
+
+    expect(resp.jsonrpc).toBe("2.0");
+    expect(resp.id).toBeDefined();
+    // Should have result (success) or error
+    expect(resp.result !== undefined || resp.error !== undefined).toBe(true);
+
+    if (resp.result) {
+      console.log("[A2A] Result keys:", Object.keys(resp.result));
+    }
+    if (resp.error) {
+      console.log("[A2A] Error:", resp.error);
+    }
+  });
+
+  it("4. A2A message/send with data part (structured context)", async () => {
+    const resp = await client.sendMessage("查看这只股票的基本情况", {
+      data: { symbol: "600519.SS", market: "cn" },
+      timeoutMs: 120_000,
+    });
+
+    expect(resp.jsonrpc).toBe("2.0");
+    if (resp.result) {
+      console.log("[A2A with data] Result preview:", JSON.stringify(resp.result).slice(0, 300));
+    }
+    if (resp.error) {
+      console.log("[A2A with data] Error:", resp.error);
+    }
+  });
+
+  it("5. A2A message/stream returns SSE events and final result", async () => {
+    const events: Array<{ kind: string; state?: string; final: boolean }> = [];
+
+    for await (const event of client.sendMessageStream("你好，请简要介绍你的能力", {
+      timeoutMs: 120_000,
+    })) {
+      events.push({
+        kind: event.kind,
+        state: event.status?.state,
+        final: event.final,
+      });
+      console.log("[SSE]", event.kind, event.status?.state, event.final ? "(final)" : "");
+    }
+
+    // Should have at least one event
+    expect(events.length).toBeGreaterThan(0);
+    // Last event should be final
+    const last = events[events.length - 1];
+    expect(last.final).toBe(true);
+  });
+
+  it("6. collectStreamResult returns A2AResponse from stream", async () => {
+    const resp = await client.collectStreamResult("BTC当前价格趋势简要分析", {
+      timeoutMs: 120_000,
+    });
+
+    expect(resp.jsonrpc).toBe("2.0");
+    expect(resp.result !== undefined || resp.error !== undefined).toBe(true);
+
+    if (resp.result) {
+      console.log("[collectStream] Result preview:", JSON.stringify(resp.result).slice(0, 300));
+    }
+    if (resp.error) {
+      console.log("[collectStream] Error:", resp.error);
+    }
+  });
+
+  it("7. A2A stream → grab taskId fast → background stream completes", async () => {
+    // The real async pattern: open stream, grab taskId from first event (~1-2s),
+    // then let the stream run in background until final event.
+    // Note: tasks/get doesn't work after stream ends (LangGraph cleans up),
+    // so the stream itself is the only reliable completion channel.
+    const start = Date.now();
+    let taskId: string | undefined;
+
+    const stream = client.sendMessageStream("简要分析A股大盘趋势", {
+      timeoutMs: 300_000,
+    });
+
+    // Step 1: Read first event → get taskId (must be fast)
+    const first = await stream.next();
+    expect(first.done).toBe(false);
+    const firstRaw = first.value.raw as Record<string, unknown>;
+    taskId = (firstRaw.id ?? firstRaw.taskId) as string | undefined;
+
+    const submitMs = Date.now() - start;
+    console.log(`[Async] Got taskId in ${submitMs}ms:`, taskId);
+    expect(taskId).toBeDefined();
+    expect(submitMs).toBeLessThan(10_000); // taskId must arrive within 10s
+
+    // Step 2: Continue consuming stream until final event
+    let lastMessage: Record<string, unknown> | undefined;
+    let finalState: string | undefined;
+
+    for await (const event of stream) {
+      const msg = event.status?.message;
+      if (msg && typeof msg === "object") {
+        lastMessage = msg as Record<string, unknown>;
+      }
+      if (event.final) {
+        finalState = event.status?.state;
+        break;
+      }
+    }
+
+    const totalMs = Date.now() - start;
+    console.log(`[Async] Stream completed in ${totalMs}ms, state=${finalState}`);
+
+    expect(finalState).toBe("completed");
+
+    // Verify we got actual content from the stream
+    if (lastMessage) {
+      const parts = lastMessage.parts as Array<Record<string, unknown>> | undefined;
+      if (Array.isArray(parts)) {
+        const text = parts
+          .filter((p: Record<string, unknown>) => typeof p.text === "string")
+          .map((p: Record<string, unknown>) => String(p.text))
+          .join("");
+        console.log(`[Async] Got ${text.length} chars of content`);
+        expect(text.length).toBeGreaterThan(0);
+      }
+    }
+  });
+
+  it("8. A2A supports threaded conversation", async () => {
+    // First message — establish context
+    const resp1 = await client.sendMessage("记住这个：我关注茅台", {
+      timeoutMs: 120_000,
+    });
+    expect(resp1.jsonrpc).toBe("2.0");
+
+    // Extract threadId if available in result
+    const result1 = resp1.result as Record<string, unknown> | undefined;
+    const threadId = (result1?.thread_id ?? result1?.threadId ?? result1?.taskId) as
+      | string
+      | undefined;
+
+    if (threadId) {
+      // Second message — should have context
+      const resp2 = await client.sendMessage("我刚才说关注什么？", {
+        threadId,
+        timeoutMs: 120_000,
+      });
+      expect(resp2.jsonrpc).toBe("2.0");
+      console.log(
+        "[Thread] Follow-up result:",
+        JSON.stringify(resp2.result ?? resp2.error).slice(0, 300),
+      );
+    } else {
+      console.log("[Thread] No threadId in first response, skipping follow-up");
+    }
+  });
+});

package/test/pending-task-tracker.test.ts

@@ -0,0 +1,287 @@
+/**
+ * L1 — PendingTaskTracker unit tests
+ *
+ * Tests stream-based tracking: trackStream consumes background SSE stream,
+ * fires onCompleted/onFailed callbacks on completion/error/timeout.
+ */
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+import type { A2AStreamEvent } from "../src/a2a-client.js";
+import { extractSummary, PendingTaskTracker } from "../src/pending-task-tracker.js";
+
+/** Helper: create an async generator from an array of events */
+async function* mockStream(events: A2AStreamEvent[]): AsyncGenerator<A2AStreamEvent> {
+  for (const e of events) {
+    yield e;
+  }
+}
+
+/** Helper: create a stream that yields events with delays */
+async function* delayedStream(
+  events: Array<{ event: A2AStreamEvent; delayMs: number }>,
+): AsyncGenerator<A2AStreamEvent> {
+  for (const { event, delayMs } of events) {
+    await new Promise((r) => setTimeout(r, delayMs));
+    yield event;
+  }
+}
+
+function createMockA2A() {
+  return {} as unknown as import("../src/a2a-client.js").A2AClient;
+}
+
+function makeEvent(
+  kind: string,
+  state: string,
+  final: boolean,
+  extra?: Record<string, unknown>,
+): A2AStreamEvent {
+  return {
+    kind: kind as A2AStreamEvent["kind"],
+    status: { state },
+    final,
+    raw: { kind, status: { state }, final, ...extra },
+  };
+}
+
+describe("PendingTaskTracker", () => {
+  beforeEach(() => {
+    vi.useFakeTimers();
+  });
+  afterEach(() => {
+    vi.useRealTimers();
+  });
+
+  it("submit() adds a task to pending list", () => {
+    const tracker = new PendingTaskTracker({
+      a2aClient: createMockA2A(),
+      onTaskCompleted: vi.fn(),
+      onTaskFailed: vi.fn(),
+    });
+
+    const task = tracker.submit("task-1", "分析茅台", {});
+    expect(task.taskId).toBe("task-1");
+    expect(task.query).toBe("分析茅台");
+    expect(task.status).toBe("submitted");
+    expect(tracker.getPending()).toHaveLength(1);
+  });
+
+  it("trackStream() fires onCompleted when stream has final event", async () => {
+    vi.useRealTimers();
+    const onCompleted = vi.fn();
+    const tracker = new PendingTaskTracker({
+      a2aClient: createMockA2A(),
+      onTaskCompleted: onCompleted,
+      onTaskFailed: vi.fn(),
+    });
+
+    const stream = mockStream([
+      makeEvent("status-update", "working", false),
+      makeEvent("status-update", "working", false),
+      makeEvent("status-update", "completed", true, { result: "done" }),
+    ]);
+
+    tracker.trackStream("task-1", "分析茅台", stream);
+
+    // Wait for stream to be consumed
+    await new Promise((r) => setTimeout(r, 50));
+
+    expect(onCompleted).toHaveBeenCalledOnce();
+    expect(onCompleted.mock.calls[0][0].taskId).toBe("task-1");
+    expect(onCompleted.mock.calls[0][0].status).toBe("completed");
+    expect(tracker.getPending()).toHaveLength(0);
+  });
+
+  it("trackStream() fires onFailed on error event", async () => {
+    vi.useRealTimers();
+    const onFailed = vi.fn();
+    const tracker = new PendingTaskTracker({
+      a2aClient: createMockA2A(),
+      onTaskCompleted: vi.fn(),
+      onTaskFailed: onFailed,
+    });
+
+    const stream = mockStream([
+      { kind: "error", final: true, raw: { error: "Agent crashed" } } as A2AStreamEvent,
+    ]);
+
+    tracker.trackStream("task-2", "BTC分析", stream);
+    await new Promise((r) => setTimeout(r, 50));
+
+    expect(onFailed).toHaveBeenCalledOnce();
+    expect(onFailed.mock.calls[0][0].status).toBe("failed");
+    expect(tracker.getPending()).toHaveLength(0);
+  });
+
+  it("trackStream() updates task status to working", async () => {
+    vi.useRealTimers();
+    const onCompleted = vi.fn();
+    const tracker = new PendingTaskTracker({
+      a2aClient: createMockA2A(),
+      onTaskCompleted: onCompleted,
+      onTaskFailed: vi.fn(),
+    });
+
+    // Use delayed stream so we can check intermediate state
+    const stream = delayedStream([
+      { event: makeEvent("status-update", "working", false), delayMs: 10 },
+      { event: makeEvent("status-update", "completed", true), delayMs: 50 },
+    ]);
+
+    tracker.trackStream("task-3", "宏观分析", stream);
+
+    // Check after first event
+    await new Promise((r) => setTimeout(r, 30));
+    const pending = tracker.getPending();
+    if (pending.length > 0) {
+      expect(pending[0].status).toBe("working");
+    }
+
+    // Wait for completion
+    await new Promise((r) => setTimeout(r, 100));
+    expect(onCompleted).toHaveBeenCalledOnce();
+  });
+
+  it("trackStream() handles stream ending without final flag", async () => {
+    vi.useRealTimers();
+    const onCompleted = vi.fn();
+    const tracker = new PendingTaskTracker({
+      a2aClient: createMockA2A(),
+      onTaskCompleted: onCompleted,
+      onTaskFailed: vi.fn(),
+    });
+
+    const stream = mockStream([
+      makeEvent("status-update", "working", false),
+      makeEvent("status-update", "working", false),
+    ]);
+
+    tracker.trackStream("task-4", "ETF分析", stream);
+    await new Promise((r) => setTimeout(r, 50));
+
+    // Should still complete (stream ended naturally)
+    expect(onCompleted).toHaveBeenCalledOnce();
+  });
+
+  it("trackStream() fires onFailed on empty stream", async () => {
+    vi.useRealTimers();
+    const onFailed = vi.fn();
+    const tracker = new PendingTaskTracker({
+      a2aClient: createMockA2A(),
+      onTaskCompleted: vi.fn(),
+      onTaskFailed: onFailed,
+    });
+
+    const stream = mockStream([]);
+    tracker.trackStream("task-5", "空流", stream);
+    await new Promise((r) => setTimeout(r, 50));
+
+    expect(onFailed).toHaveBeenCalledOnce();
+    expect(onFailed.mock.calls[0][1]).toContain("Stream ended without events");
+  });
+
+  it("trackStream() fires onFailed on stream exception", async () => {
+    vi.useRealTimers();
+    const onFailed = vi.fn();
+    const tracker = new PendingTaskTracker({
+      a2aClient: createMockA2A(),
+      onTaskCompleted: vi.fn(),
+      onTaskFailed: onFailed,
+    });
+
+    async function* errorStream(): AsyncGenerator<A2AStreamEvent> {
+      yield makeEvent("status-update", "working", false);
+      throw new Error("network failure");
+    }
+
+    tracker.trackStream("task-6", "网络错误", errorStream());
+    await new Promise((r) => setTimeout(r, 50));
+
+    expect(onFailed).toHaveBeenCalledOnce();
+    expect(onFailed.mock.calls[0][1]).toContain("network failure");
+  });
+
+  it("trackStream() times out long-running streams", async () => {
+    vi.useRealTimers();
+    const onFailed = vi.fn();
+    const tracker = new PendingTaskTracker({
+      a2aClient: createMockA2A(),
+      onTaskCompleted: vi.fn(),
+      onTaskFailed: onFailed,
+      timeoutMs: 100, // very short for testing
+    });
+
+    // Stream that takes too long
+    async function* slowStream(): AsyncGenerator<A2AStreamEvent> {
+      yield makeEvent("status-update", "working", false);
+      await new Promise((r) => setTimeout(r, 500));
+      yield makeEvent("status-update", "completed", true);
+    }
+
+    tracker.trackStream("task-7", "超时测试", slowStream());
+
+    // Wait for timeout to trigger
+    await new Promise((r) => setTimeout(r, 200));
+
+    expect(onFailed).toHaveBeenCalledOnce();
+    expect(onFailed.mock.calls[0][0].status).toBe("timeout");
+    expect(onFailed.mock.calls[0][1]).toContain("timed out");
+  });
+
+  it("stop() clears all pending tasks", () => {
+    const tracker = new PendingTaskTracker({
+      a2aClient: createMockA2A(),
+      onTaskCompleted: vi.fn(),
+      onTaskFailed: vi.fn(),
+    });
+
+    tracker.submit("task-a", "测试A");
+    tracker.submit("task-b", "测试B");
+    expect(tracker.getPending()).toHaveLength(2);
+
+    tracker.stop();
+    expect(tracker.getPending()).toHaveLength(0);
+  });
+
+  it("tracks contextId in tasks", () => {
+    const tracker = new PendingTaskTracker({
+      a2aClient: createMockA2A(),
+      onTaskCompleted: vi.fn(),
+      onTaskFailed: vi.fn(),
+    });
+
+    const task = tracker.submit("task-ctx", "上下文测试", { contextId: "ctx-123" });
+    expect(task.contextId).toBe("ctx-123");
+  });
+});
+
+describe("extractSummary", () => {
+  it("extracts text from artifacts", () => {
+    const result = {
+      artifacts: [{ parts: [{ kind: "text", text: "茅台分析结果：估值偏高" }] }],
+    };
+    expect(extractSummary(result)).toBe("茅台分析结果：估值偏高");
+  });
+
+  it("extracts text from status.message.parts", () => {
+    const result = {
+      status: {
+        state: "completed",
+        message: { parts: [{ kind: "text", text: "BTC 处于牛市周期" }] },
+      },
+    };
+    expect(extractSummary(result)).toBe("BTC 处于牛市周期");
+  });
+
+  it("falls back to JSON.stringify", () => {
+    const result = { foo: "bar" };
+    expect(extractSummary(result)).toBe('{"foo":"bar"}');
+  });
+
+  it("truncates long results", () => {
+    const longText = "x".repeat(3000);
+    const result = { artifacts: [{ parts: [{ kind: "text", text: longText }] }] };
+    const summary = extractSummary(result, 100);
+    expect(summary.length).toBe(101); // 100 + "…"
+    expect(summary.endsWith("…")).toBe(true);
+  });
+});

package/test/plugin-register.test.ts

@@ -0,0 +1,101 @@
+import type { OpenClawPluginApi } from "openclaw/plugin-sdk";
+import { describe, expect, it, vi } from "vitest";
+import findooPlugin from "../index.js";
+
+describe("findoo-alpha-plugin registration", () => {
+  function createMockApi(): OpenClawPluginApi & {
+    tools: Map<string, unknown>;
+    services: Map<string, unknown>;
+    logs: Array<{ level: string; msg: string }>;
+  } {
+    const tools = new Map<string, unknown>();
+    const services = new Map<string, unknown>();
+    const logs: Array<{ level: string; msg: string }> = [];
+
+    return {
+      tools,
+      services,
+      logs,
+      pluginConfig: { apiKey: "test-license-key" },
+      resolvePath: (p: string) => `/tmp/test/${p}`,
+      logger: {
+        info: (msg: string) => logs.push({ level: "info", msg }),
+        warn: (msg: string) => logs.push({ level: "warn", msg }),
+        error: (msg: string) => logs.push({ level: "error", msg }),
+        debug: (msg: string) => logs.push({ level: "debug", msg }),
+      },
+      registerTool: (tool: { name: string }) => {
+        tools.set(tool.name, tool);
+      },
+      runtime: { services },
+    } as unknown as OpenClawPluginApi & {
+      tools: Map<string, unknown>;
+      services: Map<string, unknown>;
+      logs: Array<{ level: string; msg: string }>;
+    };
+  }
+
+  it("has correct metadata", () => {
+    expect(findooPlugin.id).toBe("findoo-alpha-plugin");
+    expect(findooPlugin.name).toBe("Findoo Alpha");
+    expect(findooPlugin.kind).toBe("financial");
+  });
+
+  it("registers 1 tool (async submit + heartbeat push mode)", () => {
+    // Mock fetch for startup health check
+    vi.spyOn(globalThis, "fetch").mockResolvedValue(
+      new Response(JSON.stringify({ ok: true }), { status: 200 }),
+    );
+
+    const api = createMockApi();
+    findooPlugin.register(api);
+
+    expect(api.tools.size).toBe(1);
+    expect(api.tools.has("fin_analyze")).toBe(true);
+    // fin_analyze_skills removed — no longer needed
+    expect(api.tools.has("fin_analyze_skills")).toBe(false);
+
+    vi.restoreAllMocks();
+  });
+
+  it("registers fin-strategy-agent service", () => {
+    vi.spyOn(globalThis, "fetch").mockResolvedValue(
+      new Response(JSON.stringify({ ok: true }), { status: 200 }),
+    );
+
+    const api = createMockApi();
+    findooPlugin.register(api);
+
+    expect(api.services.has("fin-strategy-agent")).toBe(true);
+    const svc = api.services.get("fin-strategy-agent") as { getConfig: () => unknown };
+    const cfg = svc.getConfig() as { url: string; assistantId: string };
+    expect(cfg.url).toBe("http://43.128.100.43:5085");
+    expect(cfg.assistantId).toBe("d2310a07-b552-453c-a8bb-7b9b86de6b23");
+
+    vi.restoreAllMocks();
+  });
+
+  it("skips registration without license key", () => {
+    const api = createMockApi();
+    (api as unknown as { pluginConfig: Record<string, unknown> }).pluginConfig = {};
+    findooPlugin.register(api);
+
+    expect(api.tools.size).toBe(0);
+    expect(api.services.size).toBe(0);
+    expect(api.logs.some((l) => l.msg.includes("license key not configured"))).toBe(true);
+  });
+
+  it("logs startup info", () => {
+    vi.spyOn(globalThis, "fetch").mockResolvedValue(
+      new Response(JSON.stringify({ ok: true }), { status: 200 }),
+    );
+
+    const api = createMockApi();
+    findooPlugin.register(api);
+
+    expect(api.logs.some((l) => l.msg.includes("43.128.100.43:5085"))).toBe(true);
+    expect(api.logs.some((l) => l.msg.includes("d2310a07"))).toBe(true);
+
+    vi.restoreAllMocks();
+  });
+});