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.

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

import { ProviderDriverKind } from "@akeru/contracts";
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("creates a fresh assistant message when Claude reuses a text block index", () => {
    const harness = makeHarness();

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

      const runtimeEventsFiber = yield* Stream.take(adapter.streamEvents, 9).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: "hello",
        attachments: [],
      });

      harness.query.emit(
        claudeMessage({
          type: "stream_event",
          session_id: "sdk-session-reused-text-index",
          uuid: "stream-reused-start-1",
          parent_tool_use_id: null,
          event: {
            type: "content_block_start",
            index: 0,
            content_block: {
              type: "text",
              text: "",
            },
          },
        }),
      );

      harness.query.emit(
        claudeMessage({
          type: "stream_event",
          session_id: "sdk-session-reused-text-index",
          uuid: "stream-reused-delta-1",
          parent_tool_use_id: null,
          event: {
            type: "content_block_delta",
            index: 0,
            delta: {
              type: "text_delta",
              text: "First",
            },
          },
        }),
      );

      harness.query.emit(
        claudeMessage({
          type: "stream_event",
          session_id: "sdk-session-reused-text-index",
          uuid: "stream-reused-stop-1",
          parent_tool_use_id: null,
          event: {
            type: "content_block_stop",
            index: 0,
          },
        }),
      );

      harness.query.emit(
        claudeMessage({
          type: "stream_event",
          session_id: "sdk-session-reused-text-index",
          uuid: "stream-reused-start-2",
          parent_tool_use_id: null,
          event: {
            type: "content_block_start",
            index: 0,
            content_block: {
              type: "text",
              text: "",
            },
          },
        }),
      );

      harness.query.emit(
        claudeMessage({
          type: "stream_event",
          session_id: "sdk-session-reused-text-index",
          uuid: "stream-reused-delta-2",
          parent_tool_use_id: null,
          event: {
            type: "content_block_delta",
            index: 0,
            delta: {
              type: "text_delta",
              text: "Second",
            },
          },
        }),
      );

      harness.query.emit(
        claudeMessage({
          type: "stream_event",
          session_id: "sdk-session-reused-text-index",
          uuid: "stream-reused-stop-2",
          parent_tool_use_id: null,
          event: {
            type: "content_block_stop",
            index: 0,
          },
        }),
      );

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

      const runtimeEvents = Array.from(yield* Fiber.join(runtimeEventsFiber));
      assert.deepEqual(
        runtimeEvents.map((event) => event.type),
        [
          "session.started",
          "session.configured",
          "session.state.changed",
          "turn.started",
          "thread.started",
          "content.delta",
          "item.completed",
          "content.delta",
          "item.completed",
        ],
      );

      const assistantDeltas = runtimeEvents.filter(
        (event) => event.type === "content.delta" && event.payload.streamKind === "assistant_text",
      );

      assert.equal(assistantDeltas.length, 2);

      if (assistantDeltas.length !== 2) {
        return;
      }

      const [firstAssistantDelta, secondAssistantDelta] = assistantDeltas;
      assert.equal(firstAssistantDelta?.type, "content.delta");
      assert.equal(secondAssistantDelta?.type, "content.delta");

      if (
        firstAssistantDelta?.type !== "content.delta" ||
        secondAssistantDelta?.type !== "content.delta"
      ) {
        return;
      }

      assert.equal(firstAssistantDelta.payload.delta, "First");
      assert.equal(secondAssistantDelta.payload.delta, "Second");
      assert.notEqual(firstAssistantDelta.itemId, secondAssistantDelta.itemId);

      const assistantCompletions = runtimeEvents.filter(
        (event) =>
          event.type === "item.completed" && event.payload.itemType === "assistant_message",
      );

      assert.equal(assistantCompletions.length, 2);
      assert.equal(String(assistantCompletions[0]?.itemId), String(firstAssistantDelta.itemId));
      assert.equal(String(assistantCompletions[1]?.itemId), String(secondAssistantDelta.itemId));
      assert.notEqual(
        String(assistantCompletions[0]?.itemId),
        String(assistantCompletions[1]?.itemId),
      );
    }).pipe(
      Effect.provideService(Random.Random, makeDeterministicRandomService()),
      Effect.provide(harness.layer),
    );
  });
});

describe("ClaudeAdapterLive", () => {
  it.effect("segments Claude assistant text blocks around tool calls", () => {
    const harness = makeHarness();

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

      const runtimeEventsFiber = yield* Stream.take(adapter.streamEvents, 13).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: "hello",
        attachments: [],
      });

      harness.query.emit(
        claudeMessage({
          type: "stream_event",
          session_id: "sdk-session-interleaved",
          uuid: "stream-text-1-start",
          parent_tool_use_id: null,
          event: {
            type: "content_block_start",
            index: 0,
            content_block: {
              type: "text",
              text: "",
            },
          },
        }),
      );

      harness.query.emit(
        claudeMessage({
          type: "stream_event",
          session_id: "sdk-session-interleaved",
          uuid: "stream-text-1-delta",
          parent_tool_use_id: null,
          event: {
            type: "content_block_delta",
            index: 0,
            delta: {
              type: "text_delta",
              text: "First message.",
            },
          },
        }),
      );

      harness.query.emit(
        claudeMessage({
          type: "stream_event",
          session_id: "sdk-session-interleaved",
          uuid: "stream-text-1-stop",
          parent_tool_use_id: null,
          event: {
            type: "content_block_stop",
            index: 0,
          },
        }),
      );

      harness.query.emit(
        claudeMessage({
          type: "stream_event",
          session_id: "sdk-session-interleaved",
          uuid: "stream-tool-start",
          parent_tool_use_id: null,
          event: {
            type: "content_block_start",
            index: 1,
            content_block: {
              type: "tool_use",
              id: "tool-interleaved-1",
              name: "Grep",
              input: {
                pattern: "assistant",
                path: "src",
              },
            },
          },
        }),
      );

      harness.query.emit(
        claudeMessage({
          type: "stream_event",
          session_id: "sdk-session-interleaved",
          uuid: "stream-tool-stop",
          parent_tool_use_id: null,
          event: {
            type: "content_block_stop",
            index: 1,
          },
        }),
      );

      harness.query.emit(
        claudeMessage({
          type: "user",
          session_id: "sdk-session-interleaved",
          uuid: "user-tool-result-interleaved",
          parent_tool_use_id: null,
          message: {
            role: "user",
            content: [
              {
                type: "tool_result",
                tool_use_id: "tool-interleaved-1",
                content: "src/example.ts:1:assistant",
              },
            ],
          },
        }),
      );

      harness.query.emit(
        claudeMessage({
          type: "stream_event",
          session_id: "sdk-session-interleaved",
          uuid: "stream-text-2-start",
          parent_tool_use_id: null,
          event: {
            type: "content_block_start",
            index: 2,
            content_block: {
              type: "text",
              text: "",
            },
          },
        }),
      );

      harness.query.emit(
        claudeMessage({
          type: "stream_event",
          session_id: "sdk-session-interleaved",
          uuid: "stream-text-2-delta",
          parent_tool_use_id: null,
          event: {
            type: "content_block_delta",
            index: 2,
            delta: {
              type: "text_delta",
              text: "Second message.",
            },
          },
        }),
      );

      harness.query.emit(
        claudeMessage({
          type: "stream_event",
          session_id: "sdk-session-interleaved",
          uuid: "stream-text-2-stop",
          parent_tool_use_id: null,
          event: {
            type: "content_block_stop",
            index: 2,
          },
        }),
      );

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

      const runtimeEvents = Array.from(yield* Fiber.join(runtimeEventsFiber));
      assert.deepEqual(
        runtimeEvents.map((event) => event.type),
        [
          "session.started",
          "session.configured",
          "session.state.changed",
          "turn.started",
          "thread.started",
          "content.delta",
          "item.completed",
          "item.started",
          "item.updated",
          "item.completed",
          "content.delta",
          "item.completed",
          "turn.completed",
        ],
      );

      const assistantTextDeltas = runtimeEvents.filter(
        (event) => event.type === "content.delta" && event.payload.streamKind === "assistant_text",
      );

      assert.equal(assistantTextDeltas.length, 2);

      if (assistantTextDeltas.length !== 2) {
        return;
      }

      const [firstAssistantDelta, secondAssistantDelta] = assistantTextDeltas;

      if (!firstAssistantDelta || !secondAssistantDelta) {
        return;
      }

      assert.notEqual(String(firstAssistantDelta.itemId), String(secondAssistantDelta.itemId));

      const firstAssistantCompletedIndex = runtimeEvents.findIndex(
        (event) =>
          event.type === "item.completed" &&
          event.payload.itemType === "assistant_message" &&
          String(event.itemId) === String(firstAssistantDelta.itemId),
      );

      const toolStartedIndex = runtimeEvents.findIndex((event) => event.type === "item.started");

      const secondAssistantDeltaIndex = runtimeEvents.findIndex(
        (event) =>
          event.type === "content.delta" &&
          event.payload.streamKind === "assistant_text" &&
          String(event.itemId) === String(secondAssistantDelta.itemId),
      );

      assert.equal(
        firstAssistantCompletedIndex >= 0 &&
          toolStartedIndex >= 0 &&
          secondAssistantDeltaIndex >= 0 &&
          firstAssistantCompletedIndex < toolStartedIndex &&
          toolStartedIndex < secondAssistantDeltaIndex,
        true,
      );
    }).pipe(
      Effect.provideService(Random.Random, makeDeterministicRandomService()),
      Effect.provide(harness.layer),
    );
  });
});