@tradejs/app 3.0.1 → 3.1.1

package/README.md

@@ -42,3 +42,5 @@ before starting or building the app with:
 ```bash
 NEXT_PUBLIC_TRADEJS_TELEMETRY_DISABLED=1
 ```
+
+Keywords: ai, claude, codex.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tradejs/app",
-  "version": "3.0.1",
+  "version": "3.1.1",
   "description": "Installable Next.js UI for the TradeJS TypeScript framework: dashboards, backtests, charts, and runtime data.",
   "keywords": [
     "tradejs",
@@ -9,7 +9,10 @@
     "app",
     "dashboard",
     "nextjs",
-    "signals"
+    "signals",
+    "ai",
+    "claude",
+    "codex"
   ],
   "files": [
     "README.md",
@@ -49,15 +52,11 @@
     "@chakra-ui/charts": "3.36.1",
     "@chakra-ui/react": "3.36.1",
     "@emotion/react": "^11.14.0",
-    "@langchain/core": "^1.2.3",
-    "@langchain/openai": "^1.5.5",
-    "@tradejs/connectors": "^3.0.1",
-    "@tradejs/core": "^3.0.1",
-    "@tradejs/indicators": "^3.0.1",
-    "@tradejs/infra": "^3.0.1",
-    "@tradejs/node": "^3.0.1",
-    "@tradejs/strategies": "^3.0.1",
-    "@tradejs/types": "^3.0.1",
+    "@tradejs/core": "^3.1.1",
+    "@tradejs/indicators": "^3.1.1",
+    "@tradejs/infra": "^3.1.1",
+    "@tradejs/node": "^3.1.1",
+    "@tradejs/types": "^3.1.1",
     "@types/bcryptjs": "2.4.6",
     "@types/lodash": "4.17.24",
     "@types/node": "24.13.3",

package/src/app/actions/strategies.ts

@@ -1,6 +1,8 @@
 import { API } from '@tradejs/core/api';
-import type { StrategyChartsSnapshotResponse } from '@tradejs/types';
-import type { RuntimeStrategiesResponse } from '#app/lib/runtimeStrategyContracts';
+import type {
+  RuntimeStrategiesResponse,
+  StrategyChartsSnapshotResponse,
+} from '@tradejs/types';
 
 const API_PATH = '/api/strategies/runtime';
 const REPLAY_API_PATH = '/api/strategies/replay';

package/src/app/api/ai/route.ts

@@ -1,19 +1,11 @@
 import { NextRequest, NextResponse } from 'next/server';
-import { ChatOpenAI } from '@langchain/openai';
-import {
-  BaseMessage,
-  HumanMessage,
-  SystemMessage,
-} from '@langchain/core/messages';
 import { TTL_1M } from '@tradejs/core/constants';
 import { toJson } from '@tradejs/core/data';
 import {
   getAiResponseLanguagePromptName,
   normalizeAiResponseLanguage,
 } from '@tradejs/core/aiLanguages';
-import { normalizeAiEndpoint } from '@tradejs/core/aiEndpoints';
-import { normalizeAiModel } from '@tradejs/core/aiModels';
-import { DEFAULT_AI_MODEL, getOpenRouterModelKwargs } from '@tradejs/node/ai';
+import { invokeAiChat, type AiChatMessage } from '@tradejs/node/ai';
 import {
   AIChatHistory,
   AIChatMessage,
@@ -74,56 +66,31 @@ const buildMessages = (
   historyData: unknown,
   responseLanguage: string,
 ) => {
-  const messages = new Array<BaseMessage>();
-
-  messages.push(
-    new SystemMessage(
-      `You are a crypto trader assistant. Reply in ${getAiResponseLanguagePromptName(
-        responseLanguage,
-      )}.`,
-    ),
-  );
-
-  messages.push(
-    new SystemMessage(
-      `Here is the market data for ${filters.symbol}: ${toJson(historyData)}`,
-    ),
-  );
+  const messages: AiChatMessage[] = [];
+
+  messages.push({
+    role: 'system',
+    content: `You are a crypto trader assistant. Reply in ${getAiResponseLanguagePromptName(
+      responseLanguage,
+    )}.`,
+  });
+
+  messages.push({
+    role: 'system',
+    content: `Here is the market data for ${filters.symbol}: ${toJson(historyData)}`,
+  });
 
   if (historyEntry.command === '/line') {
-    messages.push(new HumanMessage(historyEntry.text));
+    messages.push({ role: 'user', content: historyEntry.text });
   }
 
   if (historyEntry.command === 'prompt') {
-    messages.push(new HumanMessage(historyEntry.text));
+    messages.push({ role: 'user', content: historyEntry.text });
   }
 
   return messages;
 };
 
-const invokeChatModel = async (messages: BaseMessage[], userName: string) => {
-  const settings = await getUserSettings(userName);
-  const endpoint = normalizeAiEndpoint(settings.AI_API_ENDPOINT);
-  if (!settings.AI_API_KEY || !endpoint) {
-    throw new Error(`AI settings are incomplete for user ${userName}`);
-  }
-
-  const modelKwargs = getOpenRouterModelKwargs(endpoint);
-
-  const model = new ChatOpenAI({
-    temperature: 0.7,
-    modelName:
-      normalizeAiModel(settings.AI_MODEL, endpoint) || DEFAULT_AI_MODEL,
-    apiKey: settings.AI_API_KEY,
-    ...(Object.keys(modelKwargs).length ? { modelKwargs } : {}),
-    configuration: {
-      baseURL: endpoint,
-    },
-  });
-
-  return model.invoke(messages);
-};
-
 export const GET = async (request: NextRequest) => {
   try {
     const userName = await getCurrentUserName();
@@ -210,7 +177,11 @@ export const POST = async (request: NextRequest) => {
       normalizeAiResponseLanguage(settings.AI_RESPONSE_LANGUAGE),
     );
 
-    const response = await invokeChatModel(chatMessages, userName);
+    const response = await invokeAiChat({
+      messages: chatMessages,
+      userName,
+      temperature: 0.7,
+    });
 
     const responseMessage: AIChatMessage = {
       from: 'ai',

package/src/app/api/strategies/runtime/route.ts

@@ -1,7 +1,7 @@
 import { NextRequest, NextResponse } from 'next/server';
 import { logger } from '@tradejs/infra/logger';
+import { loadRuntimeDashboard } from '@tradejs/node/runtimeDashboard';
 import { getCurrentUserName } from '#app/lib/currentUser';
-import { loadRuntimeDashboard } from '#app/lib/runtimeDashboard';
 
 export const dynamic = 'force-dynamic';
 

package/src/app/api/user/runtime-deployments/[deploymentId]/strategies/[strategyName]/control/route.ts

@@ -0,0 +1,73 @@
+import { NextRequest, NextResponse } from 'next/server';
+import {
+  getRuntimeDeployment,
+  saveRuntimeDeployment,
+} from '@tradejs/infra/runtimeDeployments';
+import { recordRuntimeStrategyControlEvent } from '@tradejs/infra/runtimeStrategyReleases';
+import type { RuntimeStrategyControlState } from '@tradejs/types';
+import { getCurrentUserName } from '#app/lib/currentUser';
+
+export const PATCH = async (
+  request: NextRequest,
+  {
+    params,
+  }: {
+    params: Promise<{ deploymentId: string; strategyName: string }>;
+  },
+) => {
+  const userName = await getCurrentUserName();
+  if (!userName) {
+    return NextResponse.json({ error: 'Unauthorized' }, { status: 401 });
+  }
+  const { deploymentId, strategyName: encodedStrategyName } = await params;
+  const strategyName = decodeURIComponent(encodedStrategyName);
+  const deployment = await getRuntimeDeployment(userName, deploymentId);
+  if (!deployment) {
+    return NextResponse.json(
+      { error: 'Deployment not found' },
+      { status: 404 },
+    );
+  }
+  const body = (await request.json()) as { controlState?: unknown };
+  if (
+    body.controlState !== 'active' &&
+    body.controlState !== 'entries_paused'
+  ) {
+    return NextResponse.json(
+      { error: 'controlState must be active or entries_paused' },
+      { status: 400 },
+    );
+  }
+  const controlState: RuntimeStrategyControlState = body.controlState;
+  const reference = deployment.strategies.find(
+    (strategy) => strategy.strategyName === strategyName,
+  );
+  if (!reference?.releaseVersion) {
+    return NextResponse.json(
+      { error: 'Pause/resume requires a versioned strategy release' },
+      { status: 400 },
+    );
+  }
+  const previousState = reference.controlState ?? 'active';
+  if (previousState === controlState) {
+    return NextResponse.json({ deployment, controlState });
+  }
+  const updated = await saveRuntimeDeployment(userName, {
+    ...deployment,
+    strategies: deployment.strategies.map((strategy) =>
+      strategy.strategyName === strategyName
+        ? { ...strategy, controlState }
+        : strategy,
+    ),
+  });
+  const event = await recordRuntimeStrategyControlEvent({
+    userName,
+    deploymentId: deployment.id,
+    strategyName,
+    releaseVersion: reference.releaseVersion,
+    previousState,
+    nextState: controlState,
+    createdBy: userName,
+  });
+  return NextResponse.json({ deployment: updated, controlState, event });
+};

package/src/app/api/user/runtime-deployments/route.ts

@@ -5,6 +5,7 @@ import {
   saveRuntimeDeployment,
 } from '@tradejs/infra/runtimeDeployments';
 import { getTradingAccount } from '@tradejs/infra/tradingAccounts';
+import { getRuntimeStrategyRelease } from '@tradejs/infra/runtimeStrategyReleases';
 import { isMarketUniverse, type RuntimeDeployment } from '@tradejs/types';
 import { getCurrentUserName } from '#app/lib/currentUser';
 
@@ -32,21 +33,59 @@ export const POST = async (request: NextRequest) => {
   }
   try {
     const body = (await request.json()) as Partial<RuntimeDeployment>;
-    const universe = body.universe;
+    const hasVersionedStrategies = Boolean(
+      body.strategies?.some((strategy) => strategy.releaseVersion != null),
+    );
+    if (
+      hasVersionedStrategies &&
+      body.strategies?.some((strategy) => strategy.releaseVersion == null)
+    ) {
+      return NextResponse.json(
+        { error: 'A deployment cannot mix legacy configs and releases' },
+        { status: 400 },
+      );
+    }
+    const releases = hasVersionedStrategies
+      ? await Promise.all(
+          (body.strategies ?? []).map(async (strategy) => {
+            if (
+              !Number.isSafeInteger(strategy.releaseVersion) ||
+              !strategy.releaseVersion ||
+              (strategy.config && Object.keys(strategy.config).length)
+            ) {
+              throw new Error('Invalid versioned strategy reference');
+            }
+            const release = await getRuntimeStrategyRelease(
+              userName,
+              strategy.strategyName,
+              strategy.releaseVersion,
+            );
+            if (!release) {
+              throw new Error(
+                `Release not found: ${strategy.strategyName} v${strategy.releaseVersion}`,
+              );
+            }
+            return release;
+          }),
+        )
+      : [];
+    const universe = releases[0]?.config.UNIVERSE ?? body.universe;
+    const interval = releases[0]?.config.INTERVAL ?? body.interval;
     if (
       !body.id ||
       !body.label ||
       !body.connectorName ||
       !body.provider ||
       !body.accountId ||
-      !body.interval ||
+      !interval ||
       !isMarketUniverse(universe) ||
       !Array.isArray(body.strategies) ||
       !body.strategies.length ||
-      body.strategies.some(
-        (strategy) =>
-          !String(strategy.strategyName ?? '').trim() ||
-          !String(strategy.policyProfileId ?? '').trim(),
+      body.strategies.some((strategy) =>
+        hasVersionedStrategies
+          ? !String(strategy.strategyName ?? '').trim()
+          : !String(strategy.strategyName ?? '').trim() ||
+            !String(strategy.policyProfileId ?? '').trim(),
       )
     ) {
       return NextResponse.json(
@@ -78,9 +117,17 @@ export const POST = async (request: NextRequest) => {
       provider: body.provider,
       accountId: body.accountId,
       universe,
-      interval: String(body.interval),
+      interval: String(interval),
       enabled: body.enabled !== false,
-      strategies: body.strategies,
+      strategies: body.strategies.map((strategy) =>
+        hasVersionedStrategies
+          ? {
+              strategyName: strategy.strategyName,
+              releaseVersion: strategy.releaseVersion,
+              controlState: strategy.controlState ?? 'active',
+            }
+          : strategy,
+      ),
       assetClasses: body.assetClasses,
       tickers: body.tickers,
     });

package/src/app/api/user/runtime-strategy-releases/route.ts

@@ -0,0 +1,60 @@
+import { NextRequest, NextResponse } from 'next/server';
+import {
+  getRuntimeStrategyReleaseOptions,
+  publishRuntimeStrategyReleaseForUser,
+  saveRuntimeStrategyReleaseDraftForUser,
+} from '#app/lib/runtimeStrategyReleaseService';
+import { getCurrentUserName } from '#app/lib/currentUser';
+
+export const dynamic = 'force-dynamic';
+
+const projectRoot =
+  String(process.env.PROJECT_CWD || process.cwd()).trim() || process.cwd();
+
+export const GET = async () => {
+  const userName = await getCurrentUserName();
+  if (!userName)
+    return NextResponse.json({ error: 'Unauthorized' }, { status: 401 });
+  return NextResponse.json(
+    await getRuntimeStrategyReleaseOptions({ userName, projectRoot }),
+  );
+};
+
+export const PATCH = async (request: NextRequest) => {
+  const userName = await getCurrentUserName();
+  if (!userName)
+    return NextResponse.json({ error: 'Unauthorized' }, { status: 401 });
+  try {
+    const draft = await saveRuntimeStrategyReleaseDraftForUser({
+      userName,
+      projectRoot,
+      input: (await request.json()) as Record<string, unknown>,
+    });
+    return NextResponse.json({ draft });
+  } catch (error) {
+    return NextResponse.json(
+      { error: error instanceof Error ? error.message : String(error) },
+      { status: 400 },
+    );
+  }
+};
+
+export const POST = async (request: NextRequest) => {
+  const userName = await getCurrentUserName();
+  if (!userName)
+    return NextResponse.json({ error: 'Unauthorized' }, { status: 401 });
+  try {
+    const body = (await request.json()) as { strategyName?: unknown };
+    const release = await publishRuntimeStrategyReleaseForUser({
+      userName,
+      projectRoot,
+      strategyName: String(body.strategyName ?? '').trim(),
+    });
+    return NextResponse.json({ release });
+  } catch (error) {
+    return NextResponse.json(
+      { error: error instanceof Error ? error.message : String(error) },
+      { status: 400 },
+    );
+  }
+};

package/src/app/components/Strategies/RuntimeStrategyCard.presenter.ts

@@ -3,7 +3,11 @@ import {
   getFormatted,
   type AdvancedTradeInput,
 } from '@tradejs/core/backtest';
-import type { TestThresholdsKey, ThresholdLevel } from '@tradejs/types';
+import type {
+  RuntimeStrategyView,
+  TestThresholdsKey,
+  ThresholdLevel,
+} from '@tradejs/types';
 import {
   formatCompactNumber,
   formatFee,
@@ -16,7 +20,6 @@ import {
   type OrdersDrawerOrder,
   type OrdersDrawerSummaryItem,
 } from '#components/Shared/OrdersDrawer';
-import type { RuntimeStrategyView } from '#app/lib/runtimeStrategyContracts';
 import {
   buildStrategyPerformanceViewModel,
   calculateMaxLossStreak,

package/src/app/components/Strategies/RuntimeStrategyCard.tsx

@@ -13,12 +13,11 @@ import {
   Text,
 } from '@chakra-ui/react';
 import { getFormatted } from '@tradejs/core/backtest';
-import type { TestThresholdsKey } from '@tradejs/types';
+import type { RuntimeStrategyView, TestThresholdsKey } from '@tradejs/types';
 import {
   formatDateTime,
   OrdersDrawerPanel,
 } from '#components/Shared/OrdersDrawer';
-import type { RuntimeStrategyView } from '#app/lib/runtimeStrategyContracts';
 import { RuntimeStrategyChart } from './RuntimeStrategyChart';
 import { RuntimeStrategyConfigDrawer } from './RuntimeStrategyConfigDrawer';
 import { RuntimeStrategyStatsDrawer } from './RuntimeStrategyStatsDrawer';
@@ -27,6 +26,7 @@ import {
   getColorByLevel,
   RUNTIME_ORDER_ROW_HEIGHT,
 } from './RuntimeStrategyCard.presenter';
+import { toaster } from '#ui';
 
 const StatItem = ({
   stat,
@@ -65,11 +65,42 @@ export const RuntimeStrategyCard = ({
   const [configOpen, setConfigOpen] = useState(false);
   const [ordersOpen, setOrdersOpen] = useState(false);
   const [statsOpen, setStatsOpen] = useState(false);
+  const [controlSaving, setControlSaving] = useState(false);
   const viewModel = useMemo(
     () => buildRuntimeStrategyCardViewModel(strategy),
     [strategy],
   );
   const { lastTrade, runtimeOrders } = viewModel;
+  const setControlState = async (controlState: 'active' | 'entries_paused') => {
+    if (!strategy.deploymentId || !strategy.releaseVersion) return;
+    setControlSaving(true);
+    try {
+      const response = await fetch(
+        `/api/user/runtime-deployments/${encodeURIComponent(strategy.deploymentId)}/strategies/${encodeURIComponent(strategy.strategyName)}/control`,
+        {
+          method: 'PATCH',
+          headers: { 'content-type': 'application/json' },
+          body: JSON.stringify({ controlState }),
+        },
+      );
+      const payload = (await response.json()) as { error?: string };
+      if (!response.ok) throw new Error(payload.error || 'Update failed');
+      toaster.success({
+        title:
+          controlState === 'entries_paused'
+            ? 'New entries paused'
+            : 'Strategy resumed',
+      });
+      await onUpdated();
+    } catch (error) {
+      toaster.error({
+        title: 'Could not update strategy state',
+        description: error instanceof Error ? error.message : String(error),
+      });
+    } finally {
+      setControlSaving(false);
+    }
+  };
 
   return (
     <Box
@@ -92,7 +123,11 @@ export const RuntimeStrategyCard = ({
           fontFamily="mono"
           letterSpacing="0"
         >
-          {strategy.enabled ? 'enabled' : 'disabled'}
+          {strategy.controlState === 'entries_paused'
+            ? 'entries paused'
+            : strategy.enabled
+              ? 'enabled'
+              : 'disabled'}
         </Badge>
         <Badge colorPalette="blue" variant="outline">
           {strategy.universe}
@@ -100,9 +135,15 @@ export const RuntimeStrategyCard = ({
         <Badge colorPalette="cyan" variant="outline">
           TF: {strategy.interval}m
         </Badge>
-        <Badge colorPalette="gray" variant="outline">
-          config: {strategy.configId}
-        </Badge>
+        {strategy.releaseVersion ? (
+          <Badge colorPalette="gray" variant="outline">
+            release: v{strategy.releaseVersion}
+          </Badge>
+        ) : (
+          <Badge colorPalette="gray" variant="outline">
+            legacy config: {strategy.configId}
+          </Badge>
+        )}
         {strategy.accountId ? (
           <Badge colorPalette="purple" variant="outline">
             account: {strategy.accountLabel ?? strategy.accountId}
@@ -172,7 +213,24 @@ export const RuntimeStrategyCard = ({
                 <Menu.Content minW="160px">
                   {strategy.connected ? (
                     <Menu.Item value="edit" onClick={() => setConfigOpen(true)}>
-                      Edit
+                      {strategy.releaseVersion ? 'View config' : 'Edit'}
+                    </Menu.Item>
+                  ) : null}
+                  {strategy.releaseVersion && strategy.deploymentId ? (
+                    <Menu.Item
+                      value="control"
+                      disabled={controlSaving}
+                      onClick={() =>
+                        void setControlState(
+                          strategy.controlState === 'entries_paused'
+                            ? 'active'
+                            : 'entries_paused',
+                        )
+                      }
+                    >
+                      {strategy.controlState === 'entries_paused'
+                        ? 'Resume entries'
+                        : 'Pause new entries'}
                     </Menu.Item>
                   ) : null}
                   <Menu.Item value="orders" onClick={() => setOrdersOpen(true)}>

package/src/app/components/Strategies/RuntimeStrategyConfigDrawer.tsx

@@ -21,8 +21,7 @@ import {
   Text,
   Textarea,
 } from '@chakra-ui/react';
-import type { MarketUniverse } from '@tradejs/types';
-import type { RuntimeStrategyView } from '#app/lib/runtimeStrategyContracts';
+import type { MarketUniverse, RuntimeStrategyView } from '@tradejs/types';
 import {
   DEFAULT_RUNTIME_STRATEGY_MANAGED_PARAMETERS,
   mergeRuntimeStrategyManagedParameters,
@@ -161,7 +160,7 @@ export const RuntimeStrategyConfigDrawer = ({
       setMlThreshold(String(managed.mlThreshold));
       setParameters('{}');
     }
-    void loadOptions();
+    if (!strategy?.releaseVersion) void loadOptions();
   }, [loadOptions, open, strategy]);
 
   const compatibleAccounts = useMemo(
@@ -252,6 +251,50 @@ export const RuntimeStrategyConfigDrawer = ({
     }
   };
 
+  if (strategy?.releaseVersion) {
+    return (
+      <Drawer.Root
+        size="lg"
+        open={open}
+        onOpenChange={(event) => onOpenChange(event.open)}
+      >
+        <Portal>
+          <Drawer.Backdrop />
+          <Drawer.Positioner>
+            <Drawer.Content bg="gray.950">
+              <Drawer.Header>
+                <Drawer.Title>
+                  {strategy.strategyName} release v{strategy.releaseVersion}
+                </Drawer.Title>
+                <Drawer.CloseTrigger asChild>
+                  <CloseButton size="sm" />
+                </Drawer.CloseTrigger>
+              </Drawer.Header>
+              <Drawer.Body display="flex" flexDirection="column" gap={4}>
+                <Text color="gray.400">
+                  Published releases are immutable. Create and publish a new
+                  release to change this configuration.
+                </Text>
+                <Textarea
+                  value={JSON.stringify(strategy.config ?? {}, null, 2)}
+                  readOnly
+                  minH="70vh"
+                  fontFamily="mono"
+                  fontSize="sm"
+                />
+              </Drawer.Body>
+              <Drawer.Footer>
+                <Button variant="outline" onClick={() => onOpenChange(false)}>
+                  Close
+                </Button>
+              </Drawer.Footer>
+            </Drawer.Content>
+          </Drawer.Positioner>
+        </Portal>
+      </Drawer.Root>
+    );
+  }
+
   return (
     <Drawer.Root
       size="lg"

package/src/app/components/Strategies/RuntimeStrategyStatsDrawer.tsx

@@ -10,7 +10,7 @@ import {
   SimpleGrid,
   Text,
 } from '@chakra-ui/react';
-import type { ThresholdLevel } from '@tradejs/types';
+import type { RuntimeStrategyView, ThresholdLevel } from '@tradejs/types';
 import {
   formatInteger,
   formatPercent,
@@ -18,7 +18,6 @@ import {
   getPnlColor,
   type OrdersDrawerSummaryItem,
 } from '#components/Shared/OrdersDrawer';
-import type { RuntimeStrategyView } from '#app/lib/runtimeStrategyContracts';
 import { buildQuarterlyMonthlyStats } from '#app/lib/strategyPerformance';
 import { AdvancedMetricsPanel } from './AdvancedMetricsPanel';
 import {

package/src/app/components/Strategies/StrategyEvidencePopover.tsx

@@ -137,7 +137,9 @@ export const StrategyEvidencePopover = ({
                           )}.`
                       : timeline.status === 'invalid'
                         ? 'Evidence failed checksum, identity, or structure verification. No markers are rendered.'
-                        : 'No checksum-verified evidence artifact is available. No mutable fallback is used.'}
+                        : timeline.status === 'not_attached'
+                          ? 'The runtime release is published, but no checksum-verified research artifact is attached yet.'
+                          : 'No checksum-verified evidence artifact is available. No mutable fallback is used.'}
                   </Text>
                 </Box>
 

package/src/app/lib/connectorCreator.ts

@@ -1,4 +1,3 @@
-import { getConnectorCreatorByProvider as getBuiltinConnectorCreatorByProvider } from '@tradejs/connectors';
 import { resolveTradingAccount } from '@tradejs/infra/tradingAccounts';
 import { getConnectorCreatorByProvider as getRegisteredConnectorCreatorByProvider } from '@tradejs/node/connectors';
 import { ConnectorCreator, MarketUniverse } from '@tradejs/types';
@@ -35,13 +34,5 @@ export const resolveConnectorCreatorByProvider = async (
       projectRoot,
     ));
 
-  if (registeredConnector) {
-    return registeredConnector as ConnectorCreator;
-  }
-
-  return (
-    getBuiltinConnectorCreatorByProvider(provider) ||
-    getBuiltinConnectorCreatorByProvider(fallbackProvider) ||
-    null
-  );
+  return (registeredConnector as ConnectorCreator | null) ?? null;
 };