Skip to content

Open-source Grok Bot alternative for named AI teammates. Local-first desktop, web, and mobile clients with per-bot tools, instructions, and memory. Independent fork of T3 Code.

19.4 KB
Raw Blame
import { claudeMessage } from "./test-support/claudeMessages.ts";

import { ProviderDriverKind, ProviderInstanceId } from "@akeru/contracts";
import { createModelSelection } from "@akeru/shared/model";
import { assert, describe, it } from "@effect/vitest";
import * as Effect from "effect/Effect";
import * as Fiber from "effect/Fiber";
import * as Random from "effect/Random";
import * as Stream from "effect/Stream";
import {
  ClaudeAdapter,
  makeHarness,
  makeDeterministicRandomService,
  THREAD_ID,
} from "./test-support/claudeAdapterHarness.ts";

describe("ClaudeAdapterLive", () => {
  it.effect("classifies Claude Task tool invocations as collaboration agent work", () => {
    const harness = makeHarness();

    return Effect.gen(function* () {
      const adapter = yield* ClaudeAdapter;

      const runtimeEventsFiber = yield* Stream.take(adapter.streamEvents, 8).pipe(
        Stream.runCollect,
        Effect.forkChild,
      );

      const session = yield* adapter.startSession({
        threadId: THREAD_ID,
        provider: ProviderDriverKind.make("claudeAgent"),
        runtimeMode: "full-access",
      });

      yield* adapter.sendTurn({
        threadId: session.threadId,
        input: "delegate this",
        attachments: [],
      });

      harness.query.emit(
        claudeMessage({
          type: "stream_event",
          session_id: "sdk-session-task",
          uuid: "stream-task-1",
          parent_tool_use_id: null,
          event: {
            type: "content_block_start",
            index: 0,
            content_block: {
              type: "tool_use",
              id: "tool-task-1",
              name: "Task",
              input: {
                description: "Review the database layer",
                prompt: "Audit the SQL changes",
                subagent_type: "code-reviewer",
              },
            },
          },
        }),
      );

      harness.query.emit(
        claudeMessage({
          type: "assistant",
          session_id: "sdk-session-task",
          uuid: "assistant-task-1",
          parent_tool_use_id: null,
          message: {
            id: "assistant-message-task-1",
            content: [{ type: "text", text: "Delegated" }],
          },
        }),
      );

      harness.query.emit(
        claudeMessage({
          type: "result",
          subtype: "success",
          is_error: false,
          errors: [],
          session_id: "sdk-session-task",
          uuid: "result-task-1",
        }),
      );

      const runtimeEvents = Array.from(yield* Fiber.join(runtimeEventsFiber));
      const toolStarted = runtimeEvents.find((event) => event.type === "item.started");
      assert.equal(toolStarted?.type, "item.started");

      if (toolStarted?.type === "item.started") {
        assert.equal(toolStarted.payload.itemType, "collab_agent_tool_call");
        assert.equal(toolStarted.payload.title, "Subagent task");
      }
    }).pipe(
      Effect.provideService(Random.Random, makeDeterministicRandomService()),
      Effect.provide(harness.layer),
    );
  });
});

describe("ClaudeAdapterLive", () => {
  it.effect("interruptTurn settles live tasks and closes the provider session", () => {
    const harness = makeHarness();

    return Effect.gen(function* () {
      const adapter = yield* ClaudeAdapter;

      // Wait for the three task.* runtime events to prove the lifecycle
      // handlers processed the emissions (no wall-clock sleeps under the
      // test clock).
      const taskEventsFiber = yield* adapter.streamEvents.pipe(
        Stream.filter((event) => event.type.startsWith("task.")),
        Stream.take(3),
        Stream.runCollect,
        Effect.forkChild,
      );

      const session = yield* adapter.startSession({
        threadId: THREAD_ID,
        provider: ProviderDriverKind.make("claudeAgent"),
        runtimeMode: "full-access",
      });

      yield* adapter.sendTurn({
        threadId: session.threadId,
        input: "spawn agents",
        attachments: [],
      });

      harness.query.emit(
        claudeMessage({
          type: "system",
          subtype: "task_started",
          task_id: "task-live",
          description: "Agent A",
          task_type: "local_agent",
          uuid: "task-live-uuid",
          session_id: "sdk-session",
        }),
      );
      harness.query.emit(
        claudeMessage({
          type: "system",
          subtype: "task_started",
          task_id: "task-settled",
          description: "Agent B",
          task_type: "local_agent",
          uuid: "task-settled-uuid",
          session_id: "sdk-session",
        }),
      );
      harness.query.emit(
        claudeMessage({
          type: "system",
          subtype: "task_notification",
          task_id: "task-settled",
          status: "completed",
          output_file: "/tmp/task-settled.jsonl",
          summary: "done",
          uuid: "task-settled-done-uuid",
          session_id: "sdk-session",
        }),
      );

      yield* Fiber.join(taskEventsFiber);

      const stoppedTaskEventFiber = yield* adapter.streamEvents.pipe(
        Stream.filter((event) => event.type === "task.completed"),
        Stream.take(1),
        Stream.runCollect,
        Effect.forkChild,
      );

      yield* adapter.interruptTurn(session.threadId);

      // Closing the session is the hard stop because SDK interrupt can leave
      // resumed background work alive.
      assert.equal(harness.query.closeCalls, 1);

      const sessions = yield* adapter.listSessions();
      assert.equal(sessions.length, 0);

      const stoppedTaskEvents = Array.from(yield* Fiber.join(stoppedTaskEventFiber));
      assert.equal(stoppedTaskEvents.length, 1);
      const stoppedTaskEvent = stoppedTaskEvents[0];
      assert.equal(stoppedTaskEvent?.type, "task.completed");

      if (stoppedTaskEvent?.type === "task.completed") {
        assert.equal(String(stoppedTaskEvent.payload.taskId), "task-live");
        assert.equal(stoppedTaskEvent.payload.status, "stopped");
        assert.equal(stoppedTaskEvent.payload.taskType, "local_agent");
        assert.equal(stoppedTaskEvent.payload.title, "Agent A");
      }
    }).pipe(
      Effect.provideService(Random.Random, makeDeterministicRandomService()),
      Effect.provide(harness.layer),
    );
  });
});

describe("ClaudeAdapterLive", () => {
  it.effect("workflow member coalescing: identical snapshots suppress, changes emit", () => {
    const harness = makeHarness();

    return Effect.gen(function* () {
      const adapter = yield* ClaudeAdapter;

      // Collect task.progress until member-0's tick-3 emission lands, then
      // evaluate member emissions.
      const progressFiber = yield* adapter.streamEvents.pipe(
        Stream.filter((event) => event.type === "task.progress"),
        Stream.takeUntil(
          // Sentinel: member-0's tick-3 emission (tokens 20) — members are
          // emitted after the coordinator row within a tick.
          (event) =>
            (event.payload as { taskId?: string }).taskId === "wf-coalesce:wf:0" &&
            (event.payload as { typedUsage?: { totalTokens?: number } }).typedUsage?.totalTokens ===
              20,
        ),
        Stream.runCollect,
        Effect.forkChild,
      );

      const session = yield* adapter.startSession({
        threadId: THREAD_ID,
        provider: ProviderDriverKind.make("claudeAgent"),
        runtimeMode: "full-access",
      });

      yield* adapter.sendTurn({
        threadId: session.threadId,
        input: "run workflow",
        attachments: [],
      });

      const memberSnapshot = (tokens: number) => [
        { type: "workflow_phase", index: 0, title: "Work" },
        {
          type: "workflow_agent",
          index: 0,
          state: "running",
          label: "member-0",
          phaseIndex: 0,
          tokens,
        },
        {
          type: "workflow_agent",
          index: 1,
          state: "running",
          label: "member-1",
          phaseIndex: 0,
          tokens: 50,
        },
      ];

      const tick = (usageTotal: number, snapshot: ReturnType<typeof memberSnapshot>) =>
        harness.query.emit(
          claudeMessage({
            type: "system",
            subtype: "task_progress",
            task_id: "wf-coalesce",
            description: "Coalescing workflow",
            usage: { total_tokens: usageTotal, tool_uses: 1, duration_ms: 10 },
            workflow_progress: snapshot,
            uuid: `wf-tick-${usageTotal}`,
            session_id: "sdk-session",
          }),
        );

      // Tick 1: both members are new -> 2 member events.
      tick(100, memberSnapshot(10));
      // Tick 2: IDENTICAL member snapshot -> 0 member events (coordinator
      // usage changed, but members did not).
      tick(200, memberSnapshot(10));
      // Tick 3: member-0's tokens advanced -> exactly 1 member event.
      tick(300, memberSnapshot(20));

      const progressEvents = Array.from(yield* Fiber.join(progressFiber));
      const byMember = new Map<string, number>();

      for (const event of progressEvents) {
        const taskId = (event.payload as { taskId: string }).taskId;

        if (!taskId.includes(":wf:")) continue;
        byMember.set(taskId, (byMember.get(taskId) ?? 0) + 1);
      }

      // member-0: tick 1 + tick 3. member-1: tick 1 only (tick 2 identical,
      // tick 3 unchanged).
      assert.equal(byMember.get("wf-coalesce:wf:0"), 2);
      assert.equal(byMember.get("wf-coalesce:wf:1"), 1);
    }).pipe(
      Effect.provideService(Random.Random, makeDeterministicRandomService()),
      Effect.provide(harness.layer),
    );
  });
});

describe("ClaudeAdapterLive", () => {
  it.effect("task.started carries model/effort; subagent snapshots refine the model", () => {
    const harness = makeHarness();

    return Effect.gen(function* () {
      const adapter = yield* ClaudeAdapter;

      const taskEventsFiber = yield* adapter.streamEvents.pipe(
        Stream.filter((event) => event.type.startsWith("task.")),
        Stream.take(2),
        Stream.runCollect,
        Effect.forkChild,
      );

      const session = yield* adapter.startSession({
        threadId: THREAD_ID,
        provider: ProviderDriverKind.make("claudeAgent"),
        modelSelection: createModelSelection(
          ProviderInstanceId.make("claudeAgent"),
          "claude-opus-4-6",
          [{ id: "effort", value: "max" }],
        ),
        runtimeMode: "full-access",
      });

      yield* adapter.sendTurn({
        threadId: session.threadId,
        input: "spawn an agent",
        attachments: [],
      });

      // No explicit model/effort on the launch input: the task inherits the
      // session's selection.
      harness.query.emit(
        claudeMessage({
          type: "system",
          subtype: "task_started",
          task_id: "task-model",
          description: "Agent M",
          task_type: "local_agent",
          tool_use_id: "toolu_agent_m",
          uuid: "task-model-uuid",
          session_id: "sdk-session",
        }),
      );
      // The subagent's assistant snapshot carries the authoritative API
      // model id, which refines the linkage on later rows.
      harness.query.emit(
        claudeMessage({
          type: "assistant",
          parent_tool_use_id: "toolu_agent_m",
          message: {
            model: "claude-sonnet-5[1m]",
            content: [],
          },
          uuid: "subagent-snapshot-uuid",
          session_id: "sdk-session",
        }),
      );
      harness.query.emit(
        claudeMessage({
          type: "system",
          subtype: "task_progress",
          task_id: "task-model",
          description: "Agent M",
          usage: { total_tokens: 100, tool_uses: 1, duration_ms: 10 },
          uuid: "task-model-progress-uuid",
          session_id: "sdk-session",
        }),
      );

      const taskEvents = Array.from(yield* Fiber.join(taskEventsFiber));
      const started = taskEvents[0];
      assert.equal(started?.type, "task.started");

      if (started?.type === "task.started") {
        assert.equal(started.payload.model, "claude-opus-4-6");
        assert.equal(started.payload.effort, "max");
      }

      const progress = taskEvents[1];
      assert.equal(progress?.type, "task.progress");

      if (progress?.type === "task.progress") {
        assert.equal(progress.payload.model, "claude-sonnet-5[1m]");
        assert.equal(progress.payload.effort, "max");
      }
    }).pipe(
      Effect.provideService(Random.Random, makeDeterministicRandomService()),
      Effect.provide(harness.layer),
    );
  });
});

describe("ClaudeAdapterLive", () => {
  it.effect("a subagent snapshot that beats task_started still wins over the seed", () => {
    const harness = makeHarness();

    return Effect.gen(function* () {
      const adapter = yield* ClaudeAdapter;

      const taskEventsFiber = yield* adapter.streamEvents.pipe(
        Stream.filter((event) => event.type.startsWith("task.")),
        Stream.take(2),
        Stream.runCollect,
        Effect.forkChild,
      );

      const session = yield* adapter.startSession({
        threadId: THREAD_ID,
        provider: ProviderDriverKind.make("claudeAgent"),
        modelSelection: createModelSelection(
          ProviderInstanceId.make("claudeAgent"),
          "claude-opus-4-6",
          [{ id: "effort", value: "max" }],
        ),
        runtimeMode: "full-access",
      });

      yield* adapter.sendTurn({
        threadId: session.threadId,
        input: "spawn an agent",
        attachments: [],
      });

      // The subagent streams its first assistant snapshot before the task is
      // registered, so there is no agent to refine yet.
      harness.query.emit(
        claudeMessage({
          type: "assistant",
          parent_tool_use_id: "toolu_agent_early",
          message: {
            model: "claude-sonnet-5[1m]",
            content: [],
          },
          uuid: "early-snapshot-uuid",
          session_id: "sdk-session",
        }),
      );
      harness.query.emit(
        claudeMessage({
          type: "system",
          subtype: "task_started",
          task_id: "task-early",
          description: "Agent E",
          task_type: "local_agent",
          tool_use_id: "toolu_agent_early",
          uuid: "task-early-uuid",
          session_id: "sdk-session",
        }),
      );
      harness.query.emit(
        claudeMessage({
          type: "system",
          subtype: "task_progress",
          task_id: "task-early",
          description: "Agent E",
          usage: { total_tokens: 100, tool_uses: 1, duration_ms: 10 },
          uuid: "task-early-progress-uuid",
          session_id: "sdk-session",
        }),
      );

      const taskEvents = Array.from(yield* Fiber.join(taskEventsFiber));
      const started = taskEvents[0];
      assert.equal(started?.type, "task.started");

      if (started?.type === "task.started") {
        assert.equal(started.payload.model, "claude-sonnet-5[1m]");
        assert.equal(started.payload.effort, "max");
      }

      const progress = taskEvents[1];
      assert.equal(progress?.type, "task.progress");

      if (progress?.type === "task.progress") {
        assert.equal(progress.payload.model, "claude-sonnet-5[1m]");
      }
    }).pipe(
      Effect.provideService(Random.Random, makeDeterministicRandomService()),
      Effect.provide(harness.layer),
    );
  });
});

describe("ClaudeAdapterLive", () => {
  it.effect("forwards Claude task progress summaries for subagent updates", () => {
    const harness = makeHarness();

    return Effect.gen(function* () {
      const adapter = yield* ClaudeAdapter;

      const runtimeEventsFiber = yield* Stream.take(adapter.streamEvents, 6).pipe(
        Stream.runCollect,
        Effect.forkChild,
      );

      yield* adapter.startSession({
        threadId: THREAD_ID,
        provider: ProviderDriverKind.make("claudeAgent"),
        runtimeMode: "full-access",
      });

      harness.query.emit(
        claudeMessage({
          type: "system",
          subtype: "task_progress",
          task_id: "task-subagent-1",
          description: "Running background teammate",
          summary: "Code reviewer checked the migration edge cases.",
          usage: {
            total_tokens: 123,
            tool_uses: 4,
            duration_ms: 987,
          },
          session_id: "sdk-session-task-summary",
          uuid: "task-progress-1",
        }),
      );

      const runtimeEvents = Array.from(yield* Fiber.join(runtimeEventsFiber));
      const progressEvent = runtimeEvents.find((event) => event.type === "task.progress");
      assert.equal(progressEvent?.type, "task.progress");

      if (progressEvent?.type === "task.progress") {
        assert.equal(
          progressEvent.payload.summary,
          "Code reviewer checked the migration edge cases.",
        );
        assert.equal(progressEvent.payload.description, "Running background teammate");
      }
    }).pipe(
      Effect.provideService(Random.Random, makeDeterministicRandomService()),
      Effect.provide(harness.layer),
    );
  });
});

describe("ClaudeAdapterLive", () => {
  it.effect(
    "preserves oversized Claude result totals after task progress snapshots are recorded",
    () => {
      const harness = makeHarness();

      return Effect.gen(function* () {
        const adapter = yield* ClaudeAdapter;

        const runtimeEventsFiber = yield* Stream.take(adapter.streamEvents, 9).pipe(
          Stream.runCollect,
          Effect.forkChild,
        );

        yield* adapter.startSession({
          threadId: THREAD_ID,
          provider: ProviderDriverKind.make("claudeAgent"),
          runtimeMode: "full-access",
        });

        yield* adapter.sendTurn({
          threadId: THREAD_ID,
          input: "hello",
          attachments: [],
        });

        harness.query.emit(
          claudeMessage({
            type: "system",
            subtype: "task_progress",
            task_id: "task-usage-clamped",
            description: "Thinking through the patch",
            usage: {
              total_tokens: 190000,
            },
            session_id: "sdk-session-task-usage-clamped",
            uuid: "task-usage-progress-clamped",
          }),
        );

        harness.query.emit(
          claudeMessage({
            type: "result",
            subtype: "success",
            is_error: false,
            duration_ms: 1234,
            duration_api_ms: 1200,
            num_turns: 1,
            result: "done",
            stop_reason: "end_turn",
            session_id: "sdk-session-result-usage-clamped-after-progress",
            usage: {
              total_tokens: 535000,
            },
            modelUsage: {
              "claude-opus-4-6": {
                contextWindow: 200000,
                maxOutputTokens: 64000,
              },
            },
          }),
        );
        harness.query.finish();

        const runtimeEvents = Array.from(yield* Fiber.join(runtimeEventsFiber));

        const usageEvents = runtimeEvents.filter(
          (event) => event.type === "thread.token-usage.updated",
        );

        const finalUsageEvent = usageEvents.at(-1);
        assert.equal(finalUsageEvent?.type, "thread.token-usage.updated");

        if (finalUsageEvent?.type === "thread.token-usage.updated") {
          assert.deepEqual(finalUsageEvent.payload, {
            usage: {
              usedTokens: 190000,
              lastUsedTokens: 190000,
              totalProcessedTokens: 535000,
              maxTokens: 200000,
            },
          });
        }
      }).pipe(
        Effect.provideService(Random.Random, makeDeterministicRandomService()),
        Effect.provide(harness.layer),
      );
    },
  );
});