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.

15.2 KB
Raw Blame
import * as Predicate from "effect/Predicate";
import * as NodeAssert from "node:assert/strict";
import * as NodeServices from "@effect/platform-node/NodeServices";
import { it } from "@effect/vitest";
import * as Effect from "effect/Effect";
import * as Fiber from "effect/Fiber";
import * as Layer from "effect/Layer";
import * as Option from "effect/Option";
import * as Stream from "effect/Stream";
import { beforeEach } from "vite-plus/test";
import { ProviderDriverKind, ProviderInstanceId } from "@akeru/contracts";
import { createModelSelection } from "@akeru/shared/model";
import { ServerConfig } from "../../config.ts";
import { ServerSettingsService } from "../../serverSettings.ts";
import { OpenCodeRuntime } from "../opencodeRuntime.ts";
import {
  appendOpenCodeAssistantTextDelta,
  makeOpenCodeAdapter,
  mergeOpenCodeAssistantText,
} from "./OpenCodeAdapter.ts";
import {
  OpenCodeAdapter,
  asThreadId,
  providerSessionDirectoryTestLayer,
  openCodeAdapterTestSettings,
  makeOpenCodeAdapterHarness,
} from "./test-support/openCodeAdapterHarness.ts";

const { runtimeMock, OpenCodeRuntimeTestDouble, OpenCodeAdapterTestLayer } =
  makeOpenCodeAdapterHarness();

beforeEach(() => {
  runtimeMock.reset();
});

it.layer(OpenCodeAdapterTestLayer)("OpenCodeAdapterLive", (it) => {
  it.effect(
    "forks the resumed session into the requested directory instead of losing context",
    () =>
      Effect.gen(function* () {
        const adapter = yield* OpenCodeAdapter;
        const threadId = asThreadId("thread-opencode-cwd");
        // The persisted session still exists but was created in another working dir
        // (e.g. the thread moved from the project root into a git worktree).
        runtimeMock.state.sessionDirectoryById.set("ses_otherdir", "/some/other/worktree");

        const session = yield* adapter.startSession({
          provider: ProviderDriverKind.make("opencode"),
          threadId,
          runtimeMode: "full-access",
          resumeCursor: { schemaVersion: 1, sessionId: "ses_otherdir" },
        });

        // A cwd change must not mint an empty session: the adapter forks the
        // persisted session into the requested cwd, carrying history forward.
        NodeAssert.deepEqual(runtimeMock.state.sessionGetIds, ["ses_otherdir"]);
        NodeAssert.deepEqual(runtimeMock.state.sessionCreateUrls, []);
        NodeAssert.equal(runtimeMock.state.forkCalls.length, 1);
        NodeAssert.equal(runtimeMock.state.forkCalls[0]?.sessionID, "ses_otherdir");
        NodeAssert.ok(Predicate.isString(runtimeMock.state.forkCalls[0]?.directory));
        // Permission ruleset re-asserted on the fork for the current runtimeMode.
        NodeAssert.equal(runtimeMock.state.sessionUpdateCalls.length, 1);
        NodeAssert.equal(runtimeMock.state.sessionUpdateCalls[0]?.sessionID, "ses_otherdir_fork");
        // Durable cursor now points at the history-complete fork in the new directory.
        NodeAssert.deepEqual(session.resumeCursor, {
          schemaVersion: 1,
          sessionId: "ses_otherdir_fork",
        });

        yield* adapter.stopSession(threadId);
      }),
  );
});

it.layer(OpenCodeAdapterTestLayer)("OpenCodeAdapterLive", (it) => {
  it.effect("keeps private memory context out of user-authored prompt parts", () => {
    const instanceId = ProviderInstanceId.make("opencode_zen");

    const adapterLayer = Layer.effect(
      OpenCodeAdapter,
      makeOpenCodeAdapter(openCodeAdapterTestSettings, { instanceId }),
    ).pipe(
      Layer.provideMerge(Layer.succeed(OpenCodeRuntime, OpenCodeRuntimeTestDouble)),
      Layer.provideMerge(ServerConfig.layerTest(process.cwd(), process.cwd())),
      Layer.provideMerge(ServerSettingsService.layerTest()),
      Layer.provideMerge(providerSessionDirectoryTestLayer),
      Layer.provideMerge(NodeServices.layer),
    );

    return Effect.gen(function* () {
      const adapter = yield* OpenCodeAdapter;
      const threadId = asThreadId("thread-private-memory-context");
      yield* adapter.startSession({
        provider: ProviderDriverKind.make("opencode"),
        threadId,
        runtimeMode: "full-access",
      });

      yield* adapter.sendTurn({
        threadId,
        input: "  visible user text  ",
        persistentMemoryContext: "private memory context",
        modelSelection: createModelSelection(
          ProviderInstanceId.make("opencode_zen"),
          "anthropic/claude-sonnet-4-5",
        ),
      });

      NodeAssert.deepEqual(runtimeMock.state.promptCalls.at(-1), {
        sessionID: "http://127.0.0.1:9999/session",
        model: {
          providerID: "anthropic",
          modelID: "claude-sonnet-4-5",
        },
        system: "private memory context",
        parts: [{ type: "text", text: "  visible user text  " }],
      });
    }).pipe(Effect.provide(adapterLayer));
  });
});

it.layer(OpenCodeAdapterTestLayer)("OpenCodeAdapterLive", (it) => {
  it.effect("reverts the first removed assistant message and returns only retained turns", () =>
    Effect.gen(function* () {
      const adapter = yield* OpenCodeAdapter;
      const threadId = asThreadId("thread-rollback-all");
      yield* adapter.startSession({
        provider: ProviderDriverKind.make("opencode"),
        threadId,
        runtimeMode: "full-access",
      });

      runtimeMock.state.messages = [
        { info: { id: "user-1", role: "user" }, parts: [] },
        {
          info: { id: "assistant-1", role: "assistant" },
          parts: [{ id: "part-1", type: "text", text: "first answer" }],
        },
        { info: { id: "user-2", role: "user" }, parts: [] },
        {
          info: { id: "assistant-2", role: "assistant" },
          parts: [{ id: "part-2", type: "text", text: "second answer" }],
        },
      ];

      for (const numTurns of [0, 1, 2, 3]) {
        runtimeMock.state.revertMessageID = undefined;
        runtimeMock.state.revertCalls.length = 0;
        const snapshot = yield* adapter.rollbackThread(threadId, numTurns);
        NodeAssert.deepEqual(
          runtimeMock.state.revertCalls,
          numTurns === 0
            ? []
            : [
                {
                  sessionID: "http://127.0.0.1:9999/session",
                  messageID: numTurns === 1 ? "assistant-2" : "assistant-1",
                },
              ],
        );
        NodeAssert.deepEqual(
          snapshot.turns.map((turn) => turn.id),
          ["assistant-1", "assistant-2"].slice(0, Math.max(0, 2 - numTurns)),
        );
      }

      runtimeMock.state.revertMessageID = undefined;

      for (const remaining of [1, 0]) {
        const snapshot = yield* adapter.rollbackThread(threadId, 1);
        NodeAssert.equal(snapshot.turns.length, remaining);
        NodeAssert.deepEqual((yield* adapter.readThread(threadId)).turns, snapshot.turns);
      }

      NodeAssert.deepEqual(
        runtimeMock.state.revertCalls.slice(-2).map((call) => call.messageID),
        ["assistant-2", "assistant-1"],
      );
      runtimeMock.state.revertMessageID = undefined;
      runtimeMock.state.messages = runtimeMock.state.messages.filter(
        (entry) => entry.info.id !== "user-2",
      );
      const sharedUserSnapshot = yield* adapter.rollbackThread(threadId, 1);
      NodeAssert.equal(runtimeMock.state.revertMessageID, "user-1");
      NodeAssert.deepEqual(sharedUserSnapshot.turns, []);
      NodeAssert.deepEqual((yield* adapter.readThread(threadId)).turns, []);

      runtimeMock.state.messages = [];
      runtimeMock.state.revertCalls.length = 0;
      const emptySnapshot = yield* adapter.rollbackThread(threadId, 1);
      NodeAssert.deepEqual(runtimeMock.state.revertCalls, []);
      NodeAssert.deepEqual(emptySnapshot.turns, []);
    }),
  );
});

it.layer(OpenCodeAdapterTestLayer)("OpenCodeAdapterLive", (it) => {
  it.effect("appends raw assistant text deltas and reconciles part update snapshots", () =>
    Effect.sync(() => {
      const firstUpdate = mergeOpenCodeAssistantText(undefined, "Hello");
      const overlapDelta = appendOpenCodeAssistantTextDelta(firstUpdate.latestText, "lo world");
      const secondUpdate = mergeOpenCodeAssistantText(overlapDelta.nextText, "Hellolo world");

      NodeAssert.deepEqual(
        [firstUpdate.deltaToEmit, overlapDelta.deltaToEmit, secondUpdate.deltaToEmit],
        ["Hello", "lo world", ""],
      );
      NodeAssert.equal(secondUpdate.latestText, "Hellolo world");
    }),
  );
});

it.layer(OpenCodeAdapterTestLayer)("OpenCodeAdapterLive", (it) => {
  it.effect("does not strip coincidental prefix overlap from OpenCode part deltas", () =>
    Effect.gen(function* () {
      const adapter = yield* OpenCodeAdapter;
      const threadId = asThreadId("thread-opencode-raw-delta");

      const part = {
        id: "part-raw-delta",
        sessionID: "http://127.0.0.1:9999/session",
        messageID: "msg-raw-delta",
        type: "text",
        text: "A B",
        time: { start: 1 },
      };

      runtimeMock.state.subscribedEvents = [
        {
          type: "message.updated",
          properties: {
            sessionID: "http://127.0.0.1:9999/session",
            info: {
              id: "msg-raw-delta",
              role: "assistant",
            },
          },
        },
        {
          type: "message.part.updated",
          properties: {
            sessionID: "http://127.0.0.1:9999/session",
            part,
            time: 1,
          },
        },
        {
          type: "message.part.delta",
          properties: {
            sessionID: "http://127.0.0.1:9999/session",
            messageID: "msg-raw-delta",
            partID: "part-raw-delta",
            field: "text",
            delta: "Bonus",
          },
        },
        {
          type: "message.part.updated",
          properties: {
            sessionID: "http://127.0.0.1:9999/session",
            part: {
              ...part,
              text: "A BBonus",
              time: { start: 1, end: 2 },
            },
            time: 2,
          },
        },
      ];

      const eventsFiber = yield* adapter.streamEvents.pipe(
        Stream.filter((event) => event.threadId === threadId),
        Stream.take(5),
        Stream.runCollect,
        Effect.forkChild,
      );

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

      const events = Array.from(yield* Fiber.join(eventsFiber).pipe(Effect.timeout("1 second")));
      const deltas = events.filter((event) => event.type === "content.delta");
      NodeAssert.deepEqual(
        deltas.map((event) => (event.type === "content.delta" ? event.payload.delta : "")),
        ["A B", "Bonus"],
      );
      NodeAssert.equal(events.at(-1)?.type, "item.completed");
      const completed = events.at(-1);

      if (completed?.type === "item.completed") {
        NodeAssert.equal(completed.payload.detail, "A BBonus");
      }
    }),
  );
});

it.layer(OpenCodeAdapterTestLayer)("OpenCodeAdapterLive", (it) => {
  it.effect("applies late assistant metadata without scanning historical tool parts", () =>
    Effect.gen(function* () {
      const adapter = yield* OpenCodeAdapter;
      const threadId = asThreadId("thread-opencode-text-index");
      const sessionID = "http://127.0.0.1:9999/session";

      const toolEvents = Array.from({ length: 24 }, (_, index) => ({
        type: "message.part.updated",
        properties: {
          sessionID,
          part: {
            id: `tool-${index}`,
            messageID: "msg-tools",
            type: "tool",
            tool: "bash",
            callID: `call-${index}`,
            state: {
              status: "completed",
              output: "x".repeat(1024),
              time: { start: 1, end: 2 },
            },
          },
        },
      }));

      runtimeMock.state.subscribedEvents = [
        ...toolEvents,
        {
          type: "message.part.updated",
          properties: {
            sessionID,
            part: {
              id: "text-1",
              messageID: "msg-assistant",
              type: "text",
              text: "Hello",
              time: { start: 1 },
            },
          },
        },
        {
          type: "message.updated",
          properties: {
            sessionID,
            info: { id: "msg-assistant", role: "assistant" },
          },
        },
      ];

      const eventsFiber = yield* adapter.streamEvents.pipe(
        Stream.filter((event) => event.threadId === threadId && event.type === "content.delta"),
        Stream.runHead,
        Effect.forkChild,
      );

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

      const delta = Option.getOrThrow(
        yield* Fiber.join(eventsFiber).pipe(Effect.timeout("1 second")),
      );

      NodeAssert.equal(delta.type, "content.delta");

      if (delta.type === "content.delta") {
        NodeAssert.equal(delta.payload.delta, "Hello");
      }

      yield* adapter.stopSession(threadId);
    }),
  );
});

it.layer(OpenCodeAdapterTestLayer)("OpenCodeAdapterLive", (it) => {
  it.effect("does not re-emit an individually removed text part", () =>
    Effect.gen(function* () {
      const adapter = yield* OpenCodeAdapter;
      const threadId = asThreadId("thread-opencode-removed-text-part");
      const sessionID = "http://127.0.0.1:9999/session";
      runtimeMock.state.subscribedEvents = [
        {
          type: "message.updated",
          properties: {
            sessionID,
            info: { id: "msg-assistant", role: "assistant" },
          },
        },
        {
          type: "message.part.updated",
          properties: {
            sessionID,
            part: {
              id: "removed-text-part",
              messageID: "msg-assistant",
              type: "text",
              text: "stale text that was removed",
              time: { start: 1 },
            },
          },
        },
        {
          type: "message.part.removed",
          properties: {
            sessionID,
            messageID: "msg-assistant",
            partID: "removed-text-part",
          },
        },
        {
          type: "message.updated",
          properties: {
            sessionID,
            info: { id: "msg-assistant", role: "assistant" },
          },
        },
        {
          type: "message.part.updated",
          properties: {
            sessionID,
            part: {
              id: "retained-text-part",
              messageID: "msg-assistant",
              type: "text",
              text: "replacement text",
              time: { start: 2 },
            },
          },
        },
      ];

      const eventsFiber = yield* adapter.streamEvents.pipe(
        Stream.filter((event) => event.threadId === threadId && event.type === "content.delta"),
        Stream.take(2),
        Stream.runCollect,
        Effect.forkChild,
      );

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

      const deltas = Array.from(
        yield* Fiber.join(eventsFiber).pipe(Effect.timeout("1 second")),
      ).map((event) => (event.type === "content.delta" ? event.payload.delta : undefined));

      NodeAssert.deepEqual(deltas, ["stale text that was removed", "replacement text"]);
      yield* adapter.stopSession(threadId);
    }),
  );
});