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.

31.2 KB
Raw Blame
import * as Predicate from "effect/Predicate";
import * as NodeFS from "node:fs";
import * as NodeOS from "node:os";
import * as NodePath from "node:path";
import * as NodeServices from "@effect/platform-node/NodeServices";
import type { AgentControllerEvent } from "@mastra/core/agent-controller";
import {
  ApprovalRequestId,
  ProviderDriverKind,
  ThreadId,
  type ProviderRuntimeEvent,
} from "@akeru/contracts";
import { it } from "@effect/vitest";
import * as Context from "effect/Context";
import * as Effect from "effect/Effect";
import * as Exit from "effect/Exit";
import * as Fiber from "effect/Fiber";
import * as Layer from "effect/Layer";
import * as Scope from "effect/Scope";
import * as Stream from "effect/Stream";
import { assert, describe, expect, vi } from "vite-plus/test";
import { ServerConfig } from "../../config.ts";
import { layerTest as serverSettingsLayerTest } from "../../serverSettings.ts";
import { EntityMemoryRepository } from "../../memory/Services/EntityMemoryRepository.ts";
import { AgentController } from "../Services/AgentController.ts";
import { makeAkeruMastraHarness } from "../AkeruMastraHarness.ts";
import { LegacyProviderBridge } from "../Services/LegacyProviderBridge.ts";
import type { ProviderServiceShape } from "../Services/ProviderService.ts";
import { agentControllerLayerWith, type AgentControllerLiveOptions } from "./AgentController.ts";
import { BotUsageLedger } from "../../usage/BotUsageLedger.ts";
import {
  claudeThreadId,
  kimiThreadId,
  claudeInstanceId,
  openCodeInstanceId,
  kimiInstanceId,
  codexSelection,
} from "./test-support/agentControllerFixtures.ts";
import {
  makeBridge,
  makeLayer,
  provideController,
  kimiModel,
  kimiStartInput,
  resolveKimi,
  mastraWireCases,
} from "./test-support/agentControllerLayers.ts";
import { usageLedgerFixture } from "./test-support/agentControllerMemory.ts";
import { mastraHarnessFixture } from "./test-support/agentControllerHarness.ts";

describe("AgentControllerLive", () => {
  describe("Kimi Mastra normalization", () => {
    it.effect("resumes a Kimi thread through a fresh controller after a server restart", () => {
      // Restart means the controller scope closes and a new layer is built
      // against the same persisted state directory. A fresh Mastra harness
      // (fresh createSession spies) proves nothing in-memory leaks across
      // the boundary, and the bridge never sees a session call.
      const bridge = makeBridge();
      const mastraBefore = mastraHarnessFixture();
      const mastraAfter = mastraHarnessFixture();
      const baseDir = NodeFS.mkdtempSync(NodePath.join(NodeOS.tmpdir(), "akeru-kimi-restart-"));

      const layer = (factory: NonNullable<AgentControllerLiveOptions["makeMastraHarness"]>) =>
        makeLayer(bridge.service, factory, undefined, baseDir);

      return Effect.gen(function* () {
        const firstScope = yield* Scope.make("sequential");
        const firstContext = yield* Layer.buildWithScope(layer(mastraBefore.factory), firstScope);
        const first = Context.get(firstContext, AgentController);
        yield* first.resolveEngine({
          threadId: kimiThreadId,
          engine: { provider: String(kimiInstanceId), model: "k3-256k" },
          fallback: codexSelection,
          mode: "default",
          botConversation: true,
        });
        yield* first.startSession(kimiThreadId, kimiStartInput("k3-256k"));
        yield* first.sendTurn({ threadId: kimiThreadId, input: "Before restart." });
        yield* Effect.yieldNow;
        mastraBefore.emit({ type: "agent_end", reason: "complete" } as AgentControllerEvent);
        mastraBefore.finishSend();
        yield* Effect.yieldNow;
        yield* Scope.close(firstScope, Exit.void);
        expect(mastraBefore.session.abort).toHaveBeenCalled();

        const secondScope = yield* Scope.make("sequential");
        const secondContext = yield* Layer.buildWithScope(layer(mastraAfter.factory), secondScope);
        const second = Context.get(secondContext, AgentController);
        // The saved model is re-resolved from the thread's engine selection —
        // not carried over in memory — and the new scope builds a fresh
        // Mastra session for the same thread.
        yield* second.resolveEngine({
          threadId: kimiThreadId,
          engine: { provider: String(kimiInstanceId), model: "k3-256k" },
          fallback: codexSelection,
          mode: "default",
          botConversation: true,
        });
        yield* second.startSession(kimiThreadId, kimiStartInput("k3-256k"));

        const completed = yield* second.streamEvents.pipe(
          Stream.filter((event) => event.type === "turn.completed"),
          Stream.runHead,
          Effect.forkChild({ startImmediately: true }),
        );

        yield* Effect.yieldNow;
        yield* second.sendTurn({ threadId: kimiThreadId, input: "After restart." });
        yield* Effect.yieldNow;
        mastraAfter.emit({ type: "agent_end", reason: "complete" } as AgentControllerEvent);
        mastraAfter.finishSend();
        assert.equal((yield* Fiber.join(completed))._tag, "Some");

        expect(mastraAfter.createSession).toHaveBeenCalledOnce();
        expect(mastraAfter.session.model.switch).toHaveBeenCalledWith({
          modelId: "kimi-for-coding/k3-256k",
        });
        expect(mastraAfter.sendMessage).toHaveBeenCalledWith({ content: "After restart." });
        yield* Scope.close(secondScope, Exit.void);
        expect(bridge.startSession).not.toHaveBeenCalled();
        expect(bridge.sendTurn).not.toHaveBeenCalled();
        expect(bridge.stopSession).not.toHaveBeenCalled();
      }).pipe(
        Effect.ensuring(
          Effect.sync(() => NodeFS.rmSync(baseDir, { recursive: true, force: true })),
        ),
        Effect.orDie,
      );
    });
  });
});

describe("AgentControllerLive", () => {
  describe("Kimi Mastra normalization", () => {
    it.effect("normalizes a Kimi model switch in-session between turns", () => {
      const bridge = makeBridge();
      const mastra = mastraHarnessFixture();

      return provideController(
        Effect.gen(function* () {
          const controller = yield* AgentController;
          yield* resolveKimi(controller, "kimi-for-coding");
          yield* controller.startSession(kimiThreadId, kimiStartInput("kimi-for-coding"));
          yield* controller.sendTurn({ threadId: kimiThreadId, input: "First turn." });
          yield* Effect.yieldNow;
          mastra.emit({ type: "agent_end", reason: "complete" } as AgentControllerEvent);
          mastra.finishSend();
          yield* Effect.yieldNow;
          expect(mastra.session.model.switch).toHaveBeenCalledWith({
            modelId: "kimi-for-coding/kimi-for-coding",
          });

          // The user picks a different advertised model; the existing Mastra
          // session absorbs the switch instead of being rebuilt.
          yield* resolveKimi(controller, "kimi-for-coding-highspeed");
          expect(mastra.session.model.switch).toHaveBeenCalledWith({
            modelId: "kimi-for-coding/kimi-for-coding-highspeed",
          });
          expect(mastra.createSession).toHaveBeenCalledOnce();

          const completed = yield* controller.streamEvents.pipe(
            Stream.filter((event) => event.type === "turn.completed"),
            Stream.runHead,
            Effect.forkChild({ startImmediately: true }),
          );

          yield* controller.sendTurn({
            threadId: kimiThreadId,
            input: "Second turn.",
            modelSelection: kimiModel("kimi-for-coding-highspeed"),
          });
          yield* Effect.yieldNow;
          mastra.emit({ type: "agent_end", reason: "complete" } as AgentControllerEvent);
          mastra.finishSend();
          assert.equal((yield* Fiber.join(completed))._tag, "Some");

          const [session] = yield* controller.listSessions();
          assert.equal(session?.model, "kimi-for-coding-highspeed");
          expect(mastra.sendMessage).toHaveBeenNthCalledWith(2, { content: "Second turn." });
          expect(bridge.sendTurn).not.toHaveBeenCalled();
        }),
        bridge.service,
        mastra.factory,
      );
    });
  });
});

describe("AgentControllerLive", () => {
  it.effect(
    "runs a real Mastra turn for Kimi through AkeruKimiProvider and a fake transport",
    () => {
      // This is the causal-flow proof the mocked-harness tests cannot give:
      // `sendTurn` drives the real Mastra Session, the resolved model is the
      // real `akeruKimiProvider` Anthropic transport, the scripted SSE reply
      // produces a `tool_approval_required`, the controller response resumes
      // the run, and `turn.completed` lands through the real event pipeline.
      const bridge = makeBridge();

      const kimiRequests: Array<{
        readonly url: string;
        readonly body: string;
        readonly headers: Record<string, string>;
      }> = [];

      // Scripted Kimi replies: the first request emits a Shell tool_use, and
      // the post-approval resume ends the turn with a text reply. The SSE
      // parser only emits a tool_call when the `content_block_start` carries
      // the full `input` object — streaming `input_json_delta` args alone
      // leaves the call without a parsed tool_use payload.
      const toolCallSse =
        [
          "event: message_start",
          'data: {"type":"message_start","message":{"id":"msg_1","type":"message","role":"assistant","model":"kimi-for-coding","content":[],"stop_reason":null,"usage":{"input_tokens":10,"output_tokens":0}}}',
          "event: content_block_start",
          'data: {"type":"content_block_start","index":0,"content_block":{"type":"tool_use","id":"toolu_shell","name":"Shell","input":{"command":"pwd"}}}',
          "event: content_block_stop",
          'data: {"type":"content_block_stop","index":0}',
          "event: message_delta",
          'data: {"type":"message_delta","delta":{"stop_reason":"tool_use"},"usage":{"output_tokens":12}}',
          "event: message_stop",
          'data: {"type":"message_stop"}',
        ].join("\n\n") + "\n\n";

      const endTurnSse =
        [
          "event: message_start",
          'data: {"type":"message_start","message":{"id":"msg_2","type":"message","role":"assistant","model":"kimi-for-coding","content":[],"stop_reason":null,"usage":{"input_tokens":20,"output_tokens":0}}}',
          "event: content_block_start",
          'data: {"type":"content_block_start","index":0,"content_block":{"type":"text","text":"pwd printed the working directory."}}',
          "event: content_block_stop",
          'data: {"type":"content_block_stop","index":0}',
          "event: message_delta",
          'data: {"type":"message_delta","delta":{"stop_reason":"end_turn"},"usage":{"output_tokens":9}}',
          "event: message_stop",
          'data: {"type":"message_stop"}',
        ].join("\n\n") + "\n\n";

      const fakeKimi = vi.fn(async (input: string | URL | Request, init?: RequestInit) => {
        const url = Predicate.isString(input)
          ? input
          : input instanceof URL
            ? input.href
            : input.url;

        const body = Predicate.isString(init?.body) ? init.body : "";

        const headers = Object.fromEntries(
          new Headers(input instanceof Request ? input.headers : (init?.headers ?? {})),
        );

        kimiRequests.push({ url, body, headers });

        return new Response(kimiRequests.length === 1 ? toolCallSse : endTurnSse, {
          status: 200,
          headers: { "content-type": "text/event-stream" },
        });
      });

      const baseDir = NodeFS.mkdtempSync(NodePath.join(NodeOS.tmpdir(), "akeru-kimi-e2e-"));
      NodeFS.mkdirSync(NodePath.join(baseDir, "userdata", "secrets"), { recursive: true });
      NodeFS.writeFileSync(
        NodePath.join(baseDir, "userdata", "secrets", "subscription-auth.json"),
        JSON.stringify({
          "kimi-for-coding": {
            type: "oauth",
            access: "kimi-e2e-token",
            refresh: "kimi-e2e-refresh",
            expires: 4_102_444_800_000,
            deviceId: "0123456789abcdef0123456789abcdef",
          },
        }),
      );

      const originalFetch = globalThis.fetch;

      const fetchPatched = vi.spyOn(globalThis, "fetch").mockImplementation((input, init) => {
        const url = Predicate.isString(input)
          ? input
          : input instanceof URL
            ? input.href
            : input.url;

        return url.startsWith("https://api.kimi.com/coding/v1/messages")
          ? fakeKimi(input as string | URL | Request, init as RequestInit | undefined)
          : originalFetch(input, init);
      });

      const layer = agentControllerLayerWith({
        makeMastraHarness: makeAkeruMastraHarness,
        makeBotBrowser: () => ({
          tools: {},
          attachment: async () => undefined,
          reconnect: async () => undefined,
          close: async () => undefined,
        }),
      }).pipe(
        Layer.provideMerge(
          Layer.mergeAll(
            Layer.succeed(LegacyProviderBridge, bridge.service),
            Layer.succeed(BotUsageLedger, usageLedgerFixture().service),
            Layer.mock(EntityMemoryRepository)({}),
            serverSettingsLayerTest({}),
            ServerConfig.layerTest(process.cwd(), baseDir).pipe(Layer.provide(NodeServices.layer)),
            NodeServices.layer,
          ),
        ),
      );

      return Effect.gen(function* () {
        const unrelated = yield* Effect.promise(() =>
          fetch("data:text/plain,unrelated").then((response) => response.text()),
        );

        assert.equal(unrelated, "unrelated");
        assert.equal(kimiRequests.length, 0);
        const scope = yield* Scope.make("sequential");
        const context = yield* Layer.buildWithScope(layer, scope);
        const controller = Context.get(context, AgentController);

        yield* controller.resolveEngine({
          threadId: kimiThreadId,
          engine: { provider: String(kimiInstanceId), model: "kimi-for-coding" },
          fallback: codexSelection,
          mode: "default",
          botConversation: true,
        });
        // No cwd and sandbox: "none" would keep the model's tool list empty;
        // the harness is verified with the real Akeru tool surface, so use a
        // local workspace rooted at the repo checkout.
        yield* controller.startSession(kimiThreadId, {
          threadId: kimiThreadId,
          provider: ProviderDriverKind.make("kimi"),
          providerInstanceId: kimiInstanceId,
          cwd: process.cwd(),
          modelSelection: { instanceId: kimiInstanceId, model: "kimi-for-coding" },
          runtimeMode: "approval-required",
          botSandbox: "local",
        });

        const events: ProviderRuntimeEvent[] = [];

        const collector = yield* controller.streamEvents.pipe(
          Stream.runForEach((event) => Effect.sync(() => events.push(event))),
          Effect.forkChild({ startImmediately: true }),
        );

        const opened = yield* controller.streamEvents.pipe(
          Stream.filter(
            (event) => event.type === "request.opened" && event.threadId === kimiThreadId,
          ),
          Stream.runHead,
          Effect.forkChild({ startImmediately: true }),
        );

        yield* Effect.yieldNow;

        yield* controller.sendTurn({ threadId: kimiThreadId, input: "Run pwd." });
        // The model request is the deterministic fake transport — the turn is
        // now parked on the interactive tool-approval gate the harness raised.
        assert.equal((yield* Fiber.join(opened))._tag, "Some");
        assert.equal(kimiRequests.length, 1);
        expect(kimiRequests[0]!.url).toContain("api.kimi.com/coding/v1/messages");
        expect(kimiRequests[0]!.headers["authorization"]).toBe("Bearer kimi-e2e-token");
        expect(kimiRequests[0]!.headers["x-msh-device-id"]).toBeDefined();

        const completed = yield* controller.streamEvents.pipe(
          Stream.filter((event) => event.type === "turn.completed"),
          Stream.runHead,
          Effect.forkChild({ startImmediately: true }),
        );

        yield* Effect.yieldNow;
        yield* controller.respondToRequest({
          threadId: kimiThreadId,
          requestId: ApprovalRequestId.make("toolu_shell"),
          decision: "accept",
        });

        // Approving resumes the provider turn; the scripted second model reply
        // completes it. The completion receipt is the proof the whole chain ran.
        yield* Fiber.join(completed).pipe(Effect.timeout(10_000), Effect.orDie);

        // The controller emitted the approval request, the resolved approval,
        // the tool item, and the completed turn — in that causal order.
        const types = events.map((event) => event.type);

        const causalOrder = [
          types.indexOf("turn.started"),
          types.indexOf("request.opened"),
          types.indexOf("request.resolved"),
          types.indexOf("item.completed"),
          types.indexOf("turn.completed"),
        ];

        assert.notInclude(causalOrder, -1);
        assert.deepEqual(
          [...causalOrder].sort((a, b) => a - b),
          causalOrder,
        );
        const resolved = events.find((event) => event.type === "request.resolved");
        expect(resolved).toMatchObject({ payload: { outcome: "approved" } });
        const itemCompleted = events.find((event) => event.type === "item.completed");
        expect(itemCompleted).toMatchObject({ payload: { status: "completed" } });
        const finished = events.find((event) => event.type === "turn.completed");
        expect(finished).toMatchObject({ payload: { state: "completed" } });
        // The resume ran the approved tool call through the runtime and asked
        // the model for its follow-up, so the transport saw a second request
        // carrying the tool result back to Kimi.
        assert.equal(kimiRequests.length, 2);
        expect(kimiRequests[1]!.body).toContain('"tool_result"');
        expect(bridge.sendTurn).not.toHaveBeenCalled();
        expect(bridge.startSession).not.toHaveBeenCalled();

        yield* Fiber.interrupt(collector);
        yield* Scope.close(scope, Exit.void);
      }).pipe(
        Effect.ensuring(
          Effect.sync(() => {
            fetchPatched.mockRestore();
            NodeFS.rmSync(baseDir, { recursive: true, force: true });
          }),
        ),
        Effect.orDie,
      );
    },
  );
});

describe("AgentControllerLive", () => {
  it.effect("does not fall back to the legacy Kimi loop when its Mastra session is absent", () => {
    const bridge = makeBridge();
    const mastra = mastraHarnessFixture();

    return provideController(
      Effect.gen(function* () {
        const controller = yield* AgentController;
        yield* controller.resolveEngine({
          threadId: kimiThreadId,
          engine: { provider: String(kimiInstanceId), model: "k3-256k" },
          fallback: codexSelection,
          mode: "default",
          botConversation: true,
        });

        const error = yield* controller
          .sendTurn({ threadId: kimiThreadId, input: "No legacy fallback." })
          .pipe(Effect.flip);

        assert.equal(error._tag, "AgentControllerRuntimeError");
        expect(bridge.sendTurn).not.toHaveBeenCalled();
      }),
      bridge.service,
      mastra.factory,
    );
  });
});

describe("AgentControllerLive", () => {
  describe("per-driver wire-format model routing", () => {
    for (const testCase of mastraWireCases) {
      it.effect(`sends the saved ${testCase.provider} model to the Mastra wire`, () => {
        const bridge = makeBridge();
        const mastra = mastraHarnessFixture();

        const modelSelection = {
          instanceId: testCase.instanceId,
          model: testCase.model,
          ...(testCase.options ? { options: [...testCase.options] } : {}),
        };

        return provideController(
          Effect.gen(function* () {
            const controller = yield* AgentController;
            yield* controller.resolveEngine({
              threadId: testCase.threadId,
              engine: {
                provider: String(testCase.instanceId),
                model: testCase.model,
                ...(testCase.options ? { options: [...testCase.options] } : {}),
              },
              fallback: codexSelection,
              mode: "default",
              botConversation: true,
            });

            const session = yield* controller.startSession(testCase.threadId, {
              threadId: testCase.threadId,
              provider: testCase.provider,
              providerInstanceId: testCase.instanceId,
              cwd: process.cwd(),
              modelSelection,
              runtimeMode: "approval-required",
            });

            assert.equal(session.provider, testCase.provider);
            assert.equal(session.model, testCase.model);

            yield* controller.sendTurn({ threadId: testCase.threadId, input: "Route me." });
            yield* Effect.promise(() => mastra.waitForSendMessageCount(1));
            mastra.finishSend();
            yield* Effect.yieldNow;

            expect(mastra.session.model.switch).toHaveBeenCalledWith({
              modelId: testCase.wireModelId,
            });

            if (testCase.modelOptions !== undefined) {
              expect(mastra.session.state.set).toHaveBeenLastCalledWith(
                expect.objectContaining({ modelOptions: testCase.modelOptions }),
              );
            }

            expect(mastra.sendMessage).toHaveBeenCalledWith({ content: "Route me." });
            expect(bridge.startSession).not.toHaveBeenCalled();
            expect(bridge.sendTurn).not.toHaveBeenCalled();
          }),
          bridge.service,
          mastra.factory,
        );
      });
    }
  });
});

describe("AgentControllerLive", () => {
  describe("per-driver wire-format model routing", () => {
    it.effect("sends the saved OpenCode model to the legacy bridge", () => {
      const bridge = makeBridge();
      const mastra = mastraHarnessFixture();

      const modelSelection = {
        instanceId: openCodeInstanceId,
        model: "anthropic/claude-sonnet-4-5",
        options: [
          { id: "agent", value: "build" },
          { id: "variant", value: "high" },
        ],
      };

      return provideController(
        Effect.gen(function* () {
          const controller = yield* AgentController;
          yield* controller.resolveEngine({
            threadId: claudeThreadId,
            engine: {
              provider: String(openCodeInstanceId),
              model: "anthropic/claude-sonnet-4-5",
              options: [
                { id: "agent", value: "build" },
                { id: "variant", value: "high" },
              ],
            },
            fallback: codexSelection,
            mode: "default",
            botConversation: true,
          });

          const session = yield* controller.startSession(claudeThreadId, {
            threadId: claudeThreadId,
            provider: ProviderDriverKind.make("opencode"),
            providerInstanceId: openCodeInstanceId,
            cwd: process.cwd(),
            modelSelection,
            runtimeMode: "approval-required",
          });

          assert.equal(session.provider, "opencode");

          yield* controller.sendTurn({
            threadId: claudeThreadId,
            input: "Route me.",
            modelSelection,
          });

          expect(bridge.startSession).toHaveBeenCalledOnce();
          expect(bridge.startSession.mock.calls[0]?.[1]).toMatchObject({ modelSelection });
          const sentInput = bridge.sendTurn.mock.calls[0]?.[0];
          expect(sentInput?.threadId).toBe(claudeThreadId);
          expect(sentInput?.modelSelection).toEqual(modelSelection);
          expect(mastra.sendMessage).not.toHaveBeenCalled();
        }),
        bridge.service,
        mastra.factory,
      );
    });
  });
});

describe("AgentControllerLive", () => {
  describe("per-driver wire-format model routing", () => {
    it.effect.each([
      {
        provider: "codex",
        instanceId: "codex-isolated",
        issue: "This Codex instance needs OPENAI_API_KEY",
      },
      {
        provider: "claudeAgent",
        instanceId: "claudeAgent-isolated",
        issue: "This Claude instance needs an API key or auth token",
      },
      {
        provider: "grok",
        instanceId: "grok-isolated",
        issue: "This Grok instance needs XAI_API_KEY",
      },
      {
        provider: "kimi",
        instanceId: "kimi-isolated",
        issue: "Custom Kimi credentials are not supported",
      },
      {
        provider: "opencodeGo",
        instanceId: "opencodeGo-isolated",
        issue: "This OpenCode Go instance needs OPENCODE_API_KEY",
      },
    ] as const)(
      "fails closed for $provider when no credential transport is configured",
      ({ provider, instanceId: _instanceSlug, issue: expectedIssue }) => {
        const bridge = makeBridge();
        const mastra = mastraHarnessFixture();
        const threadId = ThreadId.make(`thread-${provider.toLowerCase()}-isolated`);

        const service: ProviderServiceShape = {
          ...bridge.service,
          getInstanceInfo: (candidate) =>
            Effect.succeed({
              instanceId: candidate,
              driverKind: ProviderDriverKind.make(provider),
              displayName: undefined,
              enabled: true,
              continuationIdentity: {
                driverKind: ProviderDriverKind.make(provider),
                continuationKey: `${provider}:instance:${candidate}`,
              },
              mastraConnection: {
                environment: {},
                instanceEnvironment: {},
                useSavedCredential: false,
              },
            }),
        };

        return provideController(
          Effect.gen(function* () {
            const controller = yield* AgentController;

            const error = yield* controller
              .resolveEngine({
                threadId,
                engine: { provider, model: "removed-model" },
                fallback: codexSelection,
                mode: "default",
                botConversation: true,
              })
              .pipe(Effect.flip);

            assert.equal(error._tag, "AgentControllerUnsupportedEngineError");

            if (Predicate.isTagged(error, "AgentControllerUnsupportedEngineError")) {
              // The chat shows the detail, so it carries the fix, not a generic refusal.
              assert.include(error.detail, expectedIssue);

              // Signing in cannot fix a custom-credential instance.
              assert.isUndefined(error.unavailability);
            }

            expect(bridge.startSession).not.toHaveBeenCalled();
            expect(bridge.sendTurn).not.toHaveBeenCalled();
            expect(mastra.session.model.switch).not.toHaveBeenCalled();
          }),
          service,
          mastra.factory,
        );
      },
    );

    it.effect("asks to sign in when a saved-account provider is not connected", () => {
      const bridge = makeBridge();
      const mastra = mastraHarnessFixture();

      const service: ProviderServiceShape = {
        ...bridge.service,
        getInstanceInfo: (candidate) =>
          Effect.succeed({
            instanceId: candidate,
            driverKind: ProviderDriverKind.make("claudeAgent"),
            displayName: undefined,
            enabled: true,
            continuationIdentity: {
              driverKind: ProviderDriverKind.make("claudeAgent"),
              continuationKey: `claudeAgent:instance:${candidate}`,
            },
            mastraConnection: {
              environment: {},
              instanceEnvironment: {},
              useSavedCredential: true,
            },
          }),
      };

      return provideController(
        Effect.gen(function* () {
          const controller = yield* AgentController;

          const error = yield* controller
            .resolveEngine({
              threadId: ThreadId.make("thread-claude-signed-out"),
              engine: { provider: "claudeAgent", model: "claude-sonnet-4-6" },
              fallback: codexSelection,
              mode: "default",
              botConversation: true,
            })
            .pipe(Effect.flip);

          assert.equal(error._tag, "AgentControllerUnsupportedEngineError");

          if (Predicate.isTagged(error, "AgentControllerUnsupportedEngineError")) {
            assert.include(error.detail, "Connect Claude in Settings.");
            assert.equal(error.unavailability, "missing-login");
          }
        }),
        service,
        mastra.factory,
      );
    });

    it.effect("does not ask to sign in to a provider that has no account", () => {
      const bridge = makeBridge();
      const mastra = mastraHarnessFixture();

      const service: ProviderServiceShape = {
        ...bridge.service,
        getInstanceInfo: (candidate) =>
          Effect.succeed({
            instanceId: candidate,
            driverKind: ProviderDriverKind.make("customOpenai"),
            displayName: undefined,
            enabled: true,
            continuationIdentity: {
              driverKind: ProviderDriverKind.make("customOpenai"),
              continuationKey: `customOpenai:instance:${candidate}`,
            },
            mastraConnection: {
              environment: {},
              instanceEnvironment: {},
              useSavedCredential: true,
            },
          }),
      };

      return provideController(
        Effect.gen(function* () {
          const controller = yield* AgentController;

          const error = yield* controller
            .resolveEngine({
              threadId: ThreadId.make("thread-custom-api-no-url"),
              engine: { provider: "customOpenai", model: "llama-3.3" },
              fallback: codexSelection,
              mode: "default",
              botConversation: true,
            })
            .pipe(Effect.flip);

          assert.equal(error._tag, "AgentControllerUnsupportedEngineError");

          if (Predicate.isTagged(error, "AgentControllerUnsupportedEngineError")) {
            assert.include(error.detail, "This Custom API instance needs a base URL.");

            assert.isUndefined(error.unavailability);
          }
        }),
        service,
        mastra.factory,
      );
    });
  });
});

describe("AgentControllerLive", () => {
  describe("per-driver wire-format model routing", () => {
    it.effect("fails closed for a disabled saved provider instead of rerouting", () => {
      const bridge = makeBridge();
      const mastra = mastraHarnessFixture();

      return provideController(
        Effect.gen(function* () {
          const controller = yield* AgentController;
          bridge.setInstanceEnabled(false);

          const error = yield* controller
            .resolveEngine({
              threadId: claudeThreadId,
              engine: { provider: String(claudeInstanceId), model: "claude-opus-4-6" },
              fallback: codexSelection,
              mode: "default",
              botConversation: true,
            })
            .pipe(Effect.flip);

          assert.equal(error._tag, "ProviderValidationError");

          if (Predicate.isTagged(error, "ProviderValidationError")) {
            assert.include(error.issue, "disabled in Akeru Bot settings");
          }

          expect(bridge.startSession).not.toHaveBeenCalled();
          expect(bridge.sendTurn).not.toHaveBeenCalled();
          expect(mastra.session.model.switch).not.toHaveBeenCalled();
        }),
        bridge.service,
        mastra.factory,
      );
    });
  });
});