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.

5.9 KB
Raw Blame
/**
 * ProviderAdapterRegistryLive — facade over `ProviderInstanceRegistry`.
 *
 * `ProviderAdapterRegistry` historically mapped one `ProviderDriverKind` to one
 * adapter via the four `<X>AdapterLive` singleton Layers. The per-instance
 * refactor moved adapter construction inside each `ProviderDriver.create()`:
 * adapters are now bundled on the `ProviderInstance` that the
 * `ProviderInstanceRegistry` owns.
 *
 * This facade fulfills the `ProviderAdapterRegistryShape` contract by doing
 * dynamic look-ups against `ProviderInstanceRegistry` on every call. That
 * means settings-driven hot-reload shows up here automatically — adding a
 * new instance via settings makes `getByInstance` resolve immediately
 * without rebuilding the facade.
 *
 * @module ProviderAdapterRegistryLive
 */
import {
  defaultInstanceIdForDriver,
  ProviderInstanceId,
  type ProviderDriverKind,
} from "@akeru/contracts";
import * as Effect from "effect/Effect";
import * as Layer from "effect/Layer";

import { ProviderUnsupportedError } from "../Errors.ts";
import { ProviderInstanceRegistry } from "../Services/ProviderInstanceRegistry.ts";
import {
  ProviderAdapterRegistry,
  type ProviderAdapterRegistryShape,
  type ProviderInstanceRoutingInfo,
} from "../Services/ProviderAdapterRegistry.ts";

const makeProviderAdapterRegistry = Effect.fn("makeProviderAdapterRegistry")(function* () {
  const registry = yield* ProviderInstanceRegistry;

  const getByInstance: ProviderAdapterRegistryShape["getByInstance"] = (instanceId) =>
    registry.getInstance(instanceId).pipe(
      Effect.flatMap((instance) =>
        instance?.adapter === undefined
          ? Effect.fail(
              new ProviderUnsupportedError({
                provider: instanceId,
              }),
            )
          : Effect.succeed(instance.adapter),
      ),
    );

  const getInstanceInfo: ProviderAdapterRegistryShape["getInstanceInfo"] = (instanceId) =>
    registry.getInstance(instanceId).pipe(
      Effect.flatMap((instance) =>
        instance === undefined
          ? Effect.fail(
              new ProviderUnsupportedError({
                provider: instanceId,
              }),
            )
          : instance.snapshot.getSnapshot.pipe(
              Effect.map(
                (snapshot): ProviderInstanceRoutingInfo => ({
                  instanceId: instance.instanceId,
                  driverKind: instance.driverKind,
                  displayName: instance.displayName,
                  accentColor: instance.accentColor,
                  enabled: instance.enabled,
                  continuationIdentity: instance.continuationIdentity,
                  instanceSnapshot: snapshot,
                  ...(instance.mastraConnection
                    ? { mastraConnection: instance.mastraConnection }
                    : {}),
                }),
              ),
              // A snapshot read that fails must not block routing entirely;
              // advertise the instance without a snapshot so callers treat the
              // catalog as unknown rather than fabricating a failure.
              Effect.catchCause((cause) =>
                Effect.logWarning("provider instance snapshot unavailable during routing", {
                  instanceId,
                  cause,
                }).pipe(
                  Effect.as({
                    instanceId: instance.instanceId,
                    driverKind: instance.driverKind,
                    displayName: instance.displayName,
                    accentColor: instance.accentColor,
                    enabled: instance.enabled,
                    continuationIdentity: instance.continuationIdentity,
                    ...(instance.mastraConnection
                      ? { mastraConnection: instance.mastraConnection }
                      : {}),
                  } satisfies ProviderInstanceRoutingInfo),
                ),
              ),
            ),
      ),
    );

  const dispatchIfEnabled: ProviderAdapterRegistryShape["dispatchIfEnabled"] = (
    instanceId,
    dispatch,
  ) => registry.dispatchIfEnabled(instanceId, dispatch);

  const listInstances: ProviderAdapterRegistryShape["listInstances"] = () =>
    registry.listInstances.pipe(
      Effect.map((instances) => instances.map((instance) => instance.instanceId)),
    );

  const listProviders: ProviderAdapterRegistryShape["listProviders"] = () =>
    registry.listInstances.pipe(
      Effect.map((instances) => {
        const kinds = new Set<ProviderDriverKind>();

        for (const instance of instances) {
          const defaultId = defaultInstanceIdForDriver(instance.driverKind);

          if (instance.instanceId === defaultId) {
            // Only the default-instance rows show up through the legacy
            // shim — custom instances like `codex_personal` have no
            // `ProviderDriverKind` equivalent.
            kinds.add(instance.driverKind);
          }
        }

        return Array.from(kinds);
      }),
    );

  return {
    getByInstance,
    getInstanceInfo,
    dispatchIfEnabled,
    listInstances,
    listProviders,
    // Proxy directly — the facade has no state of its own; the instance
    // registry already coalesces adds/removes/rebuilds into one emission.
    streamChanges: registry.streamChanges,
    subscribeChanges: registry.subscribeChanges,
  } satisfies ProviderAdapterRegistryShape;
});

export const ProviderAdapterRegistryLive = Layer.effect(
  ProviderAdapterRegistry,
  makeProviderAdapterRegistry(),
);

// Exposed for tests that want to build a facade over a pre-assembled
// `ProviderInstanceRegistry` without pulling in the whole boot graph.
export { makeProviderAdapterRegistry };

// Re-export for consumers that need the accessor shape. The service tag
// itself lives in `Services/ProviderAdapterRegistry.ts`.
export { ProviderAdapterRegistry } from "../Services/ProviderAdapterRegistry.ts";

// Re-export for consumers (including tests) that construct a
// `ProviderInstanceId` before calling `getByInstance`.
export { ProviderInstanceId };