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.

7.9 KB
Raw Blame
import { invalidReasoningSelection, type AkeruModelOptions } from "../../ReasoningOptions.ts";
import { resolveClaudeApiModelId } from "../ClaudeProvider.ts";
import { ProviderDriverKind } from "@akeru/contracts";
import { ProviderInstanceId } from "@akeru/contracts";

import * as Effect from "effect/Effect";

import * as Semaphore from "effect/Semaphore";

import { SubscriptionAuthService } from "../../../subscription-auth/service.ts";
import { mastraModelId } from "../../AkeruMastraHarness.ts";

import {
  AgentControllerRuntimeError,
  AgentControllerUnsupportedEngineError,
  ProviderValidationError,
} from "../../Errors.ts";
import { type AgentControllerShape } from "../../Services/AgentController.ts";
import { LegacyProviderBridge } from "../../Services/LegacyProviderBridge.ts";

import { type ResolvedEngine, type ActiveSession } from "./State.ts";
import { subscriptionProviderForDriver, mastraConnectionIssue } from "./ProviderAccess.ts";

export function createEngineRouting(deps: {
  readonly legacyProviderBridge: LegacyProviderBridge["Service"];
  readonly usesMastraCode: (provider: ProviderDriverKind) => boolean;
  readonly disabledProviderError: (
    operation: string,
    providerInstanceId: ProviderInstanceId,
  ) => ProviderValidationError;
  readonly modelConnections: Map<
    string,
    {
      readonly environment: NodeJS.ProcessEnv;
      readonly instanceEnvironment: NodeJS.ProcessEnv;
      readonly useSavedCredential: boolean;
    }
  >;
  readonly subscriptionAuth: SubscriptionAuthService;
  readonly mutationLock: Semaphore.Semaphore;
  readonly resolvedByThread: Map<string, ResolvedEngine>;
  readonly sessions: Map<string, ActiveSession>;
  readonly mastraModelOptions: (resolved: ResolvedEngine) => AkeruModelOptions | undefined;
  readonly runMastra: <A>(
    operation: string,
    run: (signal: AbortSignal) => Promise<A>,
  ) => Effect.Effect<A, AgentControllerRuntimeError, never>;
}) {
  const inspectEngine: AgentControllerShape["inspectEngine"] = Effect.fn(
    "AgentController.inspectEngine",
  )(function* (modelSelection) {
    const provider = String(modelSelection.instanceId);
    const model = modelSelection.model;

    const unavailable = (cause: unknown) =>
      new AgentControllerUnsupportedEngineError({
        provider,
        model,
        detail: `Provider instance '${provider}' is not set up.`,
        cause,
      });

    const routing = yield* deps.legacyProviderBridge
      .getInstanceInfo(modelSelection.instanceId)
      .pipe(Effect.mapError(unavailable));

    if (deps.usesMastraCode(routing.driverKind) && !routing.enabled) {
      return yield* deps.disabledProviderError(
        "AgentController.inspectEngine",
        modelSelection.instanceId,
      );
    }

    // Fail closed on a model the instance's snapshot does not advertise.
    // The bot engine is applied after ws-level preflight ran against the
    // command's own selection, so this check is the only validation a
    // bot-owned thread ever sees. An empty snapshot is not evidence the
    // model is unknown — the first probe may still be running.
    // Only a settled probe is authoritative: pending snapshots still carry
    // the built-in catalog, and probe fallbacks do too, so neither proves the
    // saved model is gone.
    if (
      deps.usesMastraCode(routing.driverKind) &&
      routing.instanceSnapshot !== undefined &&
      routing.instanceSnapshot.status === "ready"
    ) {
      const advertised = routing.instanceSnapshot.models;

      const advertisedModel = advertised.find((entry) => entry.slug === model);

      const invalidOption = invalidReasoningSelection(
        modelSelection,
        advertisedModel?.capabilities,
      );

      if (invalidOption) {
        return yield* new ProviderValidationError({
          operation: "AgentController.inspectEngine",
          issue: invalidOption,
        });
      }

      if (advertised.length > 0 && !advertisedModel) {
        const name = routing.instanceSnapshot.displayName ?? routing.driverKind;

        return yield* new AgentControllerUnsupportedEngineError({
          provider,
          model,
          detail: `Model '${model}' is not available for ${name}.`,
          unavailability: "unsupported-model",
        });
      }
    }

    if (routing.mastraConnection) {
      deps.modelConnections.set(String(modelSelection.instanceId), routing.mastraConnection);
    } else {
      deps.modelConnections.delete(String(modelSelection.instanceId));
    }

    if (deps.usesMastraCode(routing.driverKind)) {
      const subscriptionProvider = subscriptionProviderForDriver(routing.driverKind);

      const issue = mastraConnectionIssue(
        routing.driverKind,
        routing.mastraConnection,
        subscriptionProvider
          ? deps.subscriptionAuth.isConnected(subscriptionProvider, modelSelection.instanceId)
          : false,
      );

      if (issue) {
        return yield* new AgentControllerUnsupportedEngineError({
          provider,
          model,
          detail: issue,
          // Signing in only fixes an instance that uses a saved account. A
          // custom-credential instance, or a driver with no account such as
          // Custom API, keeps its own message.
          ...(subscriptionProvider && routing.mastraConnection?.useSavedCredential
            ? { unavailability: "missing-login" as const }
            : {}),
        });
      }
    }

    const capabilities = deps.usesMastraCode(routing.driverKind)
      ? { sessionModelSwitch: "in-session" as const }
      : yield* deps.legacyProviderBridge
          .getCapabilities(modelSelection.instanceId)
          .pipe(Effect.mapError(unavailable));

    return { modelSelection, routing, capabilities };
  });

  const resolveEngine: AgentControllerShape["resolveEngine"] = (input) =>
    deps.mutationLock.withPermits(1)(
      Effect.gen(function* () {
        const modelSelection =
          input.engine === null
            ? input.fallback
            : {
                instanceId: ProviderInstanceId.make(input.engine.provider),
                model: input.engine.model,
                ...(input.engine.options ? { options: input.engine.options } : {}),
              };

        const inspected = yield* inspectEngine(modelSelection);
        const previous = deps.resolvedByThread.get(String(input.threadId));

        const resolved: ResolvedEngine = {
          modelSelection,
          provider: inspected.routing.driverKind,
          providerInstanceId: modelSelection.instanceId,
          mastraModelId: mastraModelId(
            inspected.routing.driverKind,
            inspected.routing.driverKind === "claudeAgent"
              ? resolveClaudeApiModelId(modelSelection)
              : modelSelection.model,
          ),
          botConversation: input.botConversation,
          ...(previous?.botName ? { botName: previous.botName } : {}),
          ...(previous?.personalityTone !== undefined
            ? { personalityTone: previous.personalityTone }
            : {}),
        };

        deps.resolvedByThread.set(String(input.threadId), resolved);
        const active = deps.sessions.get(String(input.threadId));

        if (active && deps.usesMastraCode(resolved.provider)) {
          const { modelOptions: _priorModelOptions, ...activeState } = active.session.state.get();
          const nextModelOptions = deps.mastraModelOptions(resolved);
          yield* deps.runMastra("state.set", () =>
            active.session.state.set({
              ...activeState,
              providerInstanceId: String(resolved.providerInstanceId),
              modelOptions: nextModelOptions ?? {},
            }),
          );
          yield* deps.runMastra("model.switch", () =>
            active.session.model.switch({ modelId: resolved.mastraModelId }),
          );
          active.model = modelSelection.model;
        }

        return { ...inspected, mode: "default" };
      }),
    );

  return { inspectEngine, resolveEngine };
}