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.

27.0 KB
Raw Blame
import { subscriptionProviderMutation } from "./subscription-auth/providerMutation.ts";
import { ProviderInstanceRegistryMutator } from "./provider/Services/ProviderInstanceRegistryMutator.ts";
import { computerRegistry } from "./provider/computerRegistry.ts";
import * as Cause from "effect/Cause";
import * as Crypto from "effect/Crypto";
import * as Effect from "effect/Effect";
import * as Option from "effect/Option";
import * as Ref from "effect/Ref";
import * as Schema from "effect/Schema";
import * as Stream from "effect/Stream";
import {
  AuthAccessWriteScope,
  AuthAccessStreamError,
  type ChannelBinding,
  type AuthEnvironmentScope,
  CommandId,
  type EditorId,
  type OrchestrationClientOrigin,
  OrchestrationDispatchCommandError,
  OrchestrationGetSnapshotError,
  ProviderInstanceId,
  type SubscriptionProviderId,
  RpcClientId,
  ComputerError,
  EnvironmentAuthorizationError,
  ImageGenerationError,
  SubscriptionAuthError,
} from "@akeru/contracts";
import { SubscriptionAuthService } from "./subscription-auth/service.ts";
import { apiKeySessionReset } from "./subscription-auth/sessionReset.ts";
import { subscriptionProviderSettingsPatch } from "./subscription-auth/runtime.ts";
import { imageProviderStatuses } from "./image-generation/service.ts";
import { deriveProviderInstanceConfigMap } from "./provider/Layers/ProviderInstanceRegistryHydration.ts";
import {
  buildProviderAccessCapabilities,
  subscriptionDependentBots,
} from "./subscription-auth/snapshot.ts";
import { BotInboxService } from "./bot-inbox/service.ts";
import { syncAccessIncidents, syncConnectorIncidents } from "./bot-inbox/connectorIncidents.ts";
import * as ChannelRuntime from "./channels/ChannelRuntime.ts";
import * as CheckpointDiffQuery from "./checkpointing/CheckpointDiffQuery.ts";
import * as ServerConfig from "./config.ts";
import * as Keybindings from "./keybindings.ts";
import * as ExternalLauncher from "./process/externalLauncher.ts";
import * as OrchestrationEngine from "./orchestration/Services/OrchestrationEngine.ts";
import * as ProjectionSnapshotQuery from "./orchestration/Services/ProjectionSnapshotQuery.ts";
import { ThreadDeletionReactor } from "./orchestration/Services/ThreadDeletionReactor.ts";
import { OrchestrationCommandReceiptRepository } from "./persistence/Services/OrchestrationCommandReceipts.ts";
import * as ProjectionBots from "./persistence/Services/ProjectionBots.ts";
import * as ProjectionGroups from "./persistence/Services/ProjectionGroups.ts";
import { BotMemoryStore } from "./memory/BotMemory.ts";
import { EntityMemoryRepository } from "./memory/Services/EntityMemoryRepository.ts";
import { MemoryApprovals } from "./memory/MemoryApprovals.ts";
import {
  observeRpcEffect as instrumentRpcEffect,
  observeRpcStream as instrumentRpcStream,
  observeRpcStreamEffect as instrumentRpcStreamEffect,
} from "./observability/RpcInstrumentation.ts";
import * as AgentController from "./provider/Services/AgentController.ts";
import * as ProviderRegistry from "./provider/Services/ProviderRegistry.ts";
import * as ProviderMaintenanceRunner from "./provider/providerMaintenanceRunner.ts";
import * as ServerSelfUpdate from "./cloud/selfUpdate.ts";
import * as ServiceLauncherClient from "./cloud/serviceLauncherClient.ts";
import { isRemoteInstall } from "./remote/remoteMode.ts";
import * as ServerLifecycleEvents from "./serverLifecycleEvents.ts";
import * as ServerRuntimeStartup from "./serverRuntimeStartup.ts";
import * as ServerSettings from "./serverSettings.ts";
import { RoutineRepository } from "./routines/Repository.ts";
import { RoutineRuntime } from "./routines/Runtime.ts";
import * as PreviewAutomationBroker from "./mcp/PreviewAutomationBroker.ts";
import * as PreviewManager from "./preview/Manager.ts";
import * as PortScanner from "./preview/PortScanner.ts";
import * as WorkspaceEntries from "./workspace/WorkspaceEntries.ts";
import * as WorkspaceFileSystem from "./workspace/WorkspaceFileSystem.ts";
import * as GitWorkflowService from "./git/GitWorkflowService.ts";
import * as ServerEnvironment from "./environment/ServerEnvironment.ts";
import * as RemoteOpenTargets from "./environment/RemoteOpenTargets.ts";
import * as BackgroundPolicy from "./background/BackgroundPolicy.ts";
import * as EnvironmentAuth from "./auth/EnvironmentAuth.ts";
import * as ServerSecretStore from "./auth/ServerSecretStore.ts";
import * as Composio from "./composio/ComposioService.ts";
import { requiredScopeForRpcMethod } from "./auth/RpcAuthorization.ts";
import * as ProcessDiagnostics from "./diagnostics/ProcessDiagnostics.ts";
import * as ProcessResourceMonitor from "./diagnostics/ProcessResourceMonitor.ts";
import * as ResourceTelemetry from "./resourceTelemetry/ResourceTelemetry.ts";
import { BotUsageLedger } from "./usage/BotUsageLedger.ts";
import * as UsageService from "./usage/UsageService.ts";
import * as VoiceCallManager from "./voiceCall/VoiceCallManager.ts";
import * as PairingGrantStore from "./auth/PairingGrantStore.ts";
import * as SessionStore from "./auth/SessionStore.ts";
import {
  isOrchestrationDispatchCommandError,
  subscriptionDriverByProvider,
  subscriptionProviderForDriver,
  resolveAvailableEditorsForConfig,
  resolveFileManagerRevealKindForConfig,
  type ProviderSubscribeRefreshes,
  ORCHESTRATION_REPLAY_PAYLOAD_BUDGET_BYTES,
} from "./wsSupport.ts";

import { createWsMemoryAccess } from "./wsMemoryAccess.ts";

export const createWsServices = (
  currentSession: EnvironmentAuth.AuthenticatedSession,
  clientOrigin: OrchestrationClientOrigin,
  previewAutomationBroker: PreviewAutomationBroker.PreviewAutomationBroker["Service"],
  voiceCalls: VoiceCallManager.VoiceCallManager["Service"],
  providerRefreshes: ProviderSubscribeRefreshes,
) =>
  Effect.gen(function* () {
    const currentSessionId = currentSession.sessionId;

    const crypto = yield* Crypto.Crypto;

    const voiceCallOwnerId = yield* crypto.randomUUIDv4.pipe(Effect.orDie);

    const computerClients = new Set<string>();

    const computerClient = (id: number) => {
      const key = `${voiceCallOwnerId}:${id}`;
      computerClients.add(key);

      return key;
    };

    yield* Effect.addFinalizer(() =>
      Effect.sync(() => {
        for (const client of computerClients) computerRegistry.disconnect(client);
      }),
    );

    const isComputerError = Schema.is(ComputerError);

    const computerOperation = <A>(client: string, operation: () => Promise<A>) =>
      Effect.tryPromise({
        try: operation,
        catch: (cause) =>
          isComputerError(cause)
            ? cause
            : new ComputerError({ code: "adapter", message: "Computer operation failed." }),
      }).pipe(Effect.onInterrupt(() => Effect.sync(() => computerRegistry.disconnect(client))));

    const projectionSnapshotQuery = yield* ProjectionSnapshotQuery.ProjectionSnapshotQuery;

    const projectionBots = yield* ProjectionBots.ProjectionBotRepository;

    const botUsageLedger = yield* BotUsageLedger;

    const projectionGroups = yield* ProjectionGroups.ProjectionGroupRepository;

    const routineRepository = yield* RoutineRepository;

    const routineRuntime = yield* RoutineRuntime;

    const orchestrationEngine = yield* OrchestrationEngine.OrchestrationEngineService;

    const canReplayPersistedRange = Effect.fnUntraced(function* (
      afterSequence: number,
      headSequence: number,
      maxGap: number,
    ) {
      const replayGap = headSequence - afterSequence;

      if (replayGap < 0 || replayGap > maxGap) {
        return false;
      }

      const stats = yield* projectionSnapshotQuery
        .getEventReplayStats({
          fromSequenceExclusive: afterSequence,
          toSequenceInclusive: headSequence,
        })
        .pipe(
          Effect.mapError(
            (cause) =>
              new OrchestrationGetSnapshotError({
                message: "Failed to measure orchestration replay range",
                cause,
              }),
          ),
        );

      if (stats.payloadBytes > ORCHESTRATION_REPLAY_PAYLOAD_BUDGET_BYTES) {
        yield* Effect.logDebug("orchestration replay replaced by snapshot", {
          afterSequence,
          headSequence,
          replayGap,
          eventCount: stats.eventCount,
          payloadBytes: stats.payloadBytes,
          payloadBudgetBytes: ORCHESTRATION_REPLAY_PAYLOAD_BUDGET_BYTES,
        });

        return false;
      }

      return true;
    });

    const threadDeletionReactor = yield* ThreadDeletionReactor;

    // Every command dispatched on this connection carries the connecting
    // client's origin, including server-generated bootstrap sub-commands:
    // the client's request caused them.
    const hasClientOrigin =
      clientOrigin.surface !== undefined || clientOrigin.appVersion !== undefined;

    const dispatchActor = {
      personId: currentSessionId,
      canManageGroups: currentSession.scopes.includes(AuthAccessWriteScope),
    };

    const dispatchFromClient: OrchestrationEngine.OrchestrationEngineShape["dispatch"] = (
      command,
    ) =>
      orchestrationEngine.dispatch(command, {
        actor: dispatchActor,
        ...(hasClientOrigin ? { origin: clientOrigin } : {}),
      });

    const checkpointDiffQuery = yield* CheckpointDiffQuery.CheckpointDiffQuery;

    const keybindings = yield* Keybindings.Keybindings;

    const externalLauncher = yield* ExternalLauncher.ExternalLauncher;

    const remoteOpenTargets = yield* RemoteOpenTargets.RemoteOpenTargets;

    const gitWorkflow = yield* GitWorkflowService.GitWorkflowService;

    const previewManager = yield* PreviewManager.PreviewManager;

    const portDiscovery = yield* PortScanner.PortDiscovery;

    const agentController = yield* AgentController.AgentController;

    const entityMemoryRepositoryOption = yield* Effect.serviceOption(EntityMemoryRepository);

    const entityMemoryRepository = Option.getOrNull(entityMemoryRepositoryOption);

    const memoryApprovals = Option.getOrNull(yield* Effect.serviceOption(MemoryApprovals));

    const providerRegistry = yield* ProviderRegistry.ProviderRegistry;

    const providerMaintenanceRunner = yield* ProviderMaintenanceRunner.ProviderMaintenanceRunner;

    const serverSelfUpdate = yield* ServerSelfUpdate.ServerSelfUpdate;

    const config = yield* ServerConfig.ServerConfig;

    const remoteDoctorTarget = {
      baseDir: config.baseDir,
      remote: isRemoteInstall({
        launcherManaged: Option.match(
          yield* Effect.serviceOption(ServiceLauncherClient.ServiceLauncherClient),
          { onNone: () => false, onSome: (launcher) => launcher.managed },
        ),
        env: process.env,
      }),
    };

    const botMemoryStore = new BotMemoryStore(config.stateDir);

    const subscriptionAuth = yield* SubscriptionAuthService.forSecretsDir(config.secretsDir, {
      checkHealthOnConnect: true,
    });

    const botInbox = BotInboxService.forSecretsDir(config.secretsDir);

    const lifecycleEvents = yield* ServerLifecycleEvents.ServerLifecycleEvents;

    const serverSettings = yield* ServerSettings.ServerSettingsService;

    const refreshChangedSubscriptionProviders = subscriptionProviderMutation(
      subscriptionAuth,
      serverSettings,
      yield* ProviderInstanceRegistryMutator,
      providerRegistry,
    );

    const syncSubscriptionProviderSettings = Effect.gen(function* () {
      const settings = yield* serverSettings.getSettings;
      const patch = subscriptionProviderSettingsPatch(settings, subscriptionAuth.statuses());

      if (patch) yield* serverSettings.updateSettings(patch);
    }).pipe(
      Effect.catch((cause) =>
        Effect.logWarning("Failed to align provider settings with subscription connections", {
          detail: cause.message,
        }),
      ),
    );

    yield* syncSubscriptionProviderSettings;

    const resetChangedApiKeySessions = apiKeySessionReset(
      subscriptionAuth,
      agentController,
      serverSettings.getSettings.pipe(
        Effect.map(deriveProviderInstanceConfigMap),
        Effect.orElseSucceed(() => ({})),
      ),
    );

    const validateAccountInstance = Effect.fn("validateAccountInstance")(function* (
      provider: SubscriptionProviderId,
      instanceId: ProviderInstanceId | undefined,
    ) {
      if (!instanceId) return;

      const settings = yield* serverSettings.getSettings.pipe(
        Effect.mapError((cause) => new SubscriptionAuthError({ reason: cause.message })),
      );

      const instance = deriveProviderInstanceConfigMap(settings)[instanceId];
      const driver = subscriptionDriverByProvider[provider];

      if (instance?.driver !== driver) {
        return yield* new SubscriptionAuthError({
          reason: `Provider instance '${instanceId}' does not belong to ${provider}.`,
        });
      }
    });

    const startup = yield* ServerRuntimeStartup.ServerRuntimeStartup;

    const workspaceEntries = yield* WorkspaceEntries.WorkspaceEntries;

    const workspaceFileSystem = yield* WorkspaceFileSystem.WorkspaceFileSystem;

    const serverEnvironment = yield* ServerEnvironment.ServerEnvironment;

    const backgroundPolicy = yield* BackgroundPolicy.BackgroundPolicy;

    const rpcClientIds = yield* Ref.make(new Set<RpcClientId>());

    yield* Effect.addFinalizer(() =>
      Effect.all(
        [
          Ref.get(rpcClientIds).pipe(
            Effect.flatMap((clientIds) =>
              Effect.forEach(
                clientIds,
                (clientId) => backgroundPolicy.removeRpcClient(currentSessionId, clientId),
                { discard: true },
              ),
            ),
            Effect.ignore,
          ),
          voiceCalls.hangupOwner(voiceCallOwnerId),
        ],
        { discard: true },
      ),
    );

    const serverAuth = yield* EnvironmentAuth.EnvironmentAuth;

    const secretStore = yield* ServerSecretStore.ServerSecretStore;

    const composioService = yield* Effect.serviceOption(Composio.ComposioService);

    const composio = Option.getOrElse(composioService, () => Composio.make(secretStore));

    const commandReceipts = yield* Effect.serviceOption(OrchestrationCommandReceiptRepository);

    const channelRuntime = yield* Effect.serviceOption(ChannelRuntime.ChannelRuntime);

    const channelBindingsForRuntime = (bindings: ReadonlyArray<ChannelBinding>) =>
      Option.match(channelRuntime, {
        onNone: () => ChannelRuntime.channelBindingsForRuntime(bindings, () => false),
        onSome: (runtime) => runtime.channelBindingsForRuntime(bindings),
      });

    const bootstrapCredentials = yield* PairingGrantStore.PairingGrantStore;

    const sessions = yield* SessionStore.SessionStore;

    const processDiagnostics = yield* ProcessDiagnostics.ProcessDiagnostics;

    const processResourceMonitor = yield* ProcessResourceMonitor.ProcessResourceMonitor;

    const resourceTelemetry = yield* ResourceTelemetry.ResourceTelemetry;

    const usage = yield* UsageService.UsageService;

    const { resolveMemoryAccess, resolveBotMemoryAccess, readArchiveConversations } =
      createWsMemoryAccess(projectionSnapshotQuery, projectionGroups, agentController);

    const authorizationError = (requiredScope: AuthEnvironmentScope) =>
      new EnvironmentAuthorizationError({
        message: `The authenticated token is missing required scope: ${requiredScope}.`,
        requiredScope,
      });

    const getAccessHealthSnapshot = Effect.fn("getAccessHealthSnapshot")(function* () {
      yield* subscriptionAuth.reload();
      botInbox.reload();
      yield* syncSubscriptionProviderSettings;

      const [providers, bots, snapshot, settings] = yield* Effect.all([
        providerRegistry.getProviders,
        projectionBots
          .listAll()
          .pipe(Effect.mapError((cause) => new SubscriptionAuthError({ reason: cause.message }))),
        projectionSnapshotQuery
          .getShellSnapshot()
          .pipe(Effect.mapError((cause) => new SubscriptionAuthError({ reason: cause.message }))),
        serverSettings.getSettings.pipe(
          Effect.mapError((cause) => new SubscriptionAuthError({ reason: cause.message })),
        ),
      ]);

      const dependentBots = subscriptionDependentBots(
        bots.map((bot) => ({ id: bot.botId, name: bot.name, engine: bot.engine })),
        providers,
      );

      const subscriptionStatuses = subscriptionAuth.statuses(dependentBots);

      const access = buildProviderAccessCapabilities(
        subscriptionStatuses,
        providers,
        (instanceId) => subscriptionAuth.providerInstanceRequestHealth(instanceId),
        snapshot.mcpServers ?? [],
        bots.map((bot) => ({
          id: bot.botId,
          name: bot.name,
          engine: bot.engine,
          disabledMcpServerIds: bot.disabledMcpServerIds,
        })),
        (serverId) => subscriptionAuth.mcpRequestHealth(serverId),
      );

      syncConnectorIncidents(botInbox, subscriptionStatuses);
      syncAccessIncidents(botInbox, access);

      return {
        providers: subscriptionStatuses.map((status) => ({
          ...status,
          dependentBots: status.dependentBots.filter((dependent) =>
            bots.some(
              (bot) =>
                bot.botId === dependent.id &&
                bot.engine?.provider === subscriptionDriverByProvider[status.provider],
            ),
          ),
        })),
        accounts: Object.entries(deriveProviderInstanceConfigMap(settings)).flatMap(
          ([instanceId, instance]) => {
            const provider = subscriptionProviderForDriver(instance.driver);

            return provider && instanceId !== subscriptionDriverByProvider[provider]
              ? [
                  subscriptionAuth.accountStatus(
                    provider,
                    ProviderInstanceId.make(instanceId),
                    bots
                      .filter((bot) => bot.engine?.provider === instanceId)
                      .map((bot) => ({
                        id: bot.botId,
                        name: bot.name,
                        provider,
                      })),
                  ),
                ]
              : [];
          },
        ),
        access,
        linkedAccounts: subscriptionAuth.linkedAccountStatuses(),
        inbox: botInbox.list(),
      };
    });

    const getImageProviderSnapshot = Effect.fn("getImageProviderSnapshot")(function* () {
      yield* subscriptionAuth.reload();

      const settings = yield* serverSettings.getSettings.pipe(
        Effect.mapError((cause) => new ImageGenerationError({ reason: cause.message })),
      );

      return {
        providers: imageProviderStatuses({
          settings: settings.imageGeneration,
          subscriptionStatuses: subscriptionAuth.statuses(),
          chatgptAccountConnected: subscriptionAuth.hasOpenAICodexAccount(),
          requestHealth: (provider) => subscriptionAuth.imageRequestHealth(provider),
          lastGenerationAt: (provider) => subscriptionAuth.imageLastGenerationAt(provider),
        }),
      };
    });

    const authorizeEffect = <A, E, R>(
      requiredScope: AuthEnvironmentScope,
      effect: Effect.Effect<A, E, R>,
    ): Effect.Effect<A, E | EnvironmentAuthorizationError, R> =>
      currentSession.scopes.includes(requiredScope)
        ? effect
        : Effect.fail(authorizationError(requiredScope));

    const authorizeStream = <A, E, R>(
      requiredScope: AuthEnvironmentScope,
      stream: Stream.Stream<A, E, R>,
    ): Stream.Stream<A, E | EnvironmentAuthorizationError, R> =>
      currentSession.scopes.includes(requiredScope)
        ? stream
        : Stream.fail(authorizationError(requiredScope));

    const observeRpcEffect = <A, E, R>(
      method: string,
      effect: Effect.Effect<A, E, R>,
      traceAttributes?: Parameters<typeof instrumentRpcEffect>[2],
    ) =>
      instrumentRpcEffect(
        method,
        authorizeEffect(requiredScopeForRpcMethod(method), effect),
        traceAttributes,
      );

    const observeRpcStream = <A, E, R>(
      method: string,
      stream: Stream.Stream<A, E, R>,
      traceAttributes?: Parameters<typeof instrumentRpcEffect>[2],
    ) =>
      instrumentRpcStream(
        method,
        authorizeStream(requiredScopeForRpcMethod(method), stream),
        traceAttributes,
      );

    const observeRpcStreamEffect = <A, StreamError, StreamContext, EffectError, EffectContext>(
      method: string,
      effect: Effect.Effect<
        Stream.Stream<A, StreamError, StreamContext>,
        EffectError,
        EffectContext
      >,
      traceAttributes?: Parameters<typeof instrumentRpcEffect>[2],
    ) =>
      instrumentRpcStreamEffect(
        method,
        authorizeEffect(requiredScopeForRpcMethod(method), effect),
        traceAttributes,
      );

    const toDispatchCommandError = (cause: unknown, fallbackMessage: string) =>
      isOrchestrationDispatchCommandError(cause)
        ? cause
        : new OrchestrationDispatchCommandError({
            message: cause instanceof Error ? cause.message : fallbackMessage,
            cause,
          });

    const randomUUID = crypto.randomUUIDv4.pipe(
      Effect.mapError((cause) =>
        toDispatchCommandError(cause, "Failed to generate orchestration command identifier."),
      ),
    );

    const serverCommandId = (tag: string) =>
      randomUUID.pipe(Effect.map((uuid) => CommandId.make(`server:${tag}:${uuid}`)));

    const loadEnvironmentPeople = () =>
      serverAuth.listClientSessions(currentSessionId).pipe(
        Effect.map((clientSessions) => {
          const currentClient = clientSessions.find(
            (session) => session.sessionId === currentSessionId,
          );

          const hostClient = clientSessions.find((session) =>
            session.scopes.includes(AuthAccessWriteScope),
          );

          return {
            current: {
              personId: currentSessionId,
              displayName:
                currentClient?.client.label ??
                (currentSession.scopes.includes(AuthAccessWriteScope) ? "Host" : "Paired person"),
            },
            host:
              hostClient === undefined
                ? undefined
                : {
                    personId: hostClient.sessionId,
                    displayName: hostClient.client.label ?? "Host",
                  },
          };
        }),
      );

    const loadAuthAccessSnapshot = () =>
      Effect.all({
        pairingLinks: serverAuth.listPairingLinks(),
        clientSessions: serverAuth.listClientSessions(currentSessionId),
      }).pipe(
        Effect.mapError(
          (error) =>
            new AuthAccessStreamError({
              message: error.message,
            }),
        ),
      );

    const toBootstrapDispatchCommandCauseError = (cause: Cause.Cause<unknown>) => {
      const error = Cause.squash(cause);

      return isOrchestrationDispatchCommandError(error)
        ? error
        : new OrchestrationDispatchCommandError({
            message: error instanceof Error ? error.message : "Failed to start the chat.",
            cause,
          });
    };

    const loadServerConfig = Effect.gen(function* () {
      const keybindingsConfig = yield* keybindings.loadConfigState;
      const providers = yield* providerRegistry.getProviders;

      const settings = ServerSettings.redactServerSettingsForClient(
        yield* serverSettings.getSettings,
      );

      const environment = yield* serverEnvironment.getDescriptor;
      const auth = yield* serverAuth.getDescriptor();

      const availableEditors: ReadonlyArray<EditorId> = yield* resolveAvailableEditorsForConfig(
        externalLauncher.resolveAvailableEditors(),
      );

      const fileManagerRevealKind = availableEditors.includes("file-manager")
        ? yield* resolveFileManagerRevealKindForConfig(
            externalLauncher.resolveFileManagerRevealKind(),
          )
        : undefined;

      return {
        environment,
        auth,
        cwd: config.cwd,
        keybindingsConfigPath: config.keybindingsConfigPath,
        keybindings: keybindingsConfig.keybindings,
        issues: keybindingsConfig.issues,
        providers,
        availableEditors,
        // Same discovery-with-timeout treatment as editors: a slow probe
        // must not stall server.getConfig, so it degrades to no targets.
        remoteOpenTargets: yield* resolveAvailableEditorsForConfig(
          remoteOpenTargets.resolveTargets(),
        ),
        observability: {
          logsDirectoryPath: config.logsDir,
          localTracingEnabled: true,
          ...(config.otlpTracesUrl !== undefined ? { otlpTracesUrl: config.otlpTracesUrl } : {}),
          otlpTracesEnabled: config.otlpTracesUrl !== undefined,
          ...(config.otlpMetricsUrl !== undefined ? { otlpMetricsUrl: config.otlpMetricsUrl } : {}),
          otlpMetricsEnabled: config.otlpMetricsUrl !== undefined,
        },
        settings,
        shellResumeCompletionMarker: true,
        ...(fileManagerRevealKind === undefined
          ? {}
          : {
              shellRevealInFileManager: true,
              shellRevealInFileManagerKind: fileManagerRevealKind,
            }),
        threadResumeCompletionMarker: true,
        threadSnapshotPagination: true,
      };
    });

    return {
      currentSession,
      clientOrigin,
      previewAutomationBroker,
      voiceCalls,
      providerRefreshes,
      currentSessionId,
      crypto,
      voiceCallOwnerId,
      computerClients,
      computerClient,
      isComputerError,
      computerOperation,
      projectionSnapshotQuery,
      projectionBots,
      botUsageLedger,
      projectionGroups,
      routineRepository,
      routineRuntime,
      orchestrationEngine,
      canReplayPersistedRange,
      threadDeletionReactor,
      hasClientOrigin,
      dispatchActor,
      dispatchFromClient,
      checkpointDiffQuery,
      keybindings,
      externalLauncher,
      remoteOpenTargets,
      gitWorkflow,
      previewManager,
      portDiscovery,
      agentController,
      entityMemoryRepositoryOption,
      entityMemoryRepository,
      memoryApprovals,
      providerRegistry,
      providerMaintenanceRunner,
      serverSelfUpdate,
      config,
      remoteDoctorTarget,
      botMemoryStore,
      subscriptionAuth,
      botInbox,
      lifecycleEvents,
      serverSettings,
      syncSubscriptionProviderSettings,
      refreshChangedSubscriptionProviders,
      resetChangedApiKeySessions,
      validateAccountInstance,
      startup,
      workspaceEntries,
      workspaceFileSystem,
      serverEnvironment,
      backgroundPolicy,
      rpcClientIds,
      serverAuth,
      secretStore,
      composioService,
      composio,
      commandReceipts,
      channelRuntime,
      channelBindingsForRuntime,
      bootstrapCredentials,
      sessions,
      processDiagnostics,
      processResourceMonitor,
      resourceTelemetry,
      usage,
      resolveMemoryAccess,
      resolveBotMemoryAccess,
      readArchiveConversations,
      authorizationError,
      getAccessHealthSnapshot,
      getImageProviderSnapshot,
      authorizeEffect,
      authorizeStream,
      observeRpcEffect,
      observeRpcStream,
      observeRpcStreamEffect,
      toDispatchCommandError,
      randomUUID,
      serverCommandId,
      loadEnvironmentPeople,
      loadAuthAccessSnapshot,
      toBootstrapDispatchCommandCauseError,
      loadServerConfig,
    };
  });

export type WsServices = Effect.Success<ReturnType<typeof createWsServices>>;