@librechat/agents 3.6.15 → 3.6.16

package/src/llm/providerRegistry.ts

@@ -0,0 +1,134 @@
+import type { BaseChatModel } from '@langchain/core/language_models/chat_models';
+import type {
+  ProviderFamily,
+  ProviderRegistrationOptions,
+} from '../provider-registration';
+import type { ProviderModelConstructor, ProviderName } from '@/types';
+
+interface StoredProviderRegistration {
+  model: new (config: never) => BaseChatModel;
+  family: ProviderFamily;
+  manualToolStream: boolean;
+  strictAlternation: boolean;
+  owner: symbol;
+}
+
+interface ProviderRegistryGlobal {
+  [key: symbol]: Map<ProviderName, StoredProviderRegistration> | undefined;
+}
+
+const PROVIDER_REGISTRY_KEY = Symbol.for(
+  '@librechat/agents:providerRegistry:v1'
+);
+const providerRegistryGlobal = globalThis as ProviderRegistryGlobal;
+const registeredProviders =
+  providerRegistryGlobal[PROVIDER_REGISTRY_KEY] ??
+  new Map<ProviderName, StoredProviderRegistration>();
+providerRegistryGlobal[PROVIDER_REGISTRY_KEY] = registeredProviders;
+const builtInProviders = new Map<ProviderName, StoredProviderRegistration>();
+
+function normalizeProvider(provider: ProviderName): ProviderName {
+  if (typeof provider !== 'string' || provider.trim() === '') {
+    throw new TypeError('LLM provider name must be a non-empty string');
+  }
+  if (provider !== provider.trim()) {
+    throw new TypeError(
+      'LLM provider name must not have surrounding whitespace'
+    );
+  }
+  return provider;
+}
+
+function isConstructible<T extends abstract new (...args: never[]) => object>(
+  value: T
+): boolean {
+  try {
+    Reflect.construct(String, [], value);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+function createRegistration<
+  TOptions extends object,
+  TModel extends BaseChatModel,
+>(
+  provider: ProviderName,
+  options: ProviderRegistrationOptions<TOptions, TModel>
+): StoredProviderRegistration {
+  if (typeof options.model !== 'function' || !isConstructible(options.model)) {
+    throw new TypeError(`LLM provider constructor is invalid: ${provider}`);
+  }
+  return {
+    model: options.model,
+    family: options.family ?? 'generic',
+    manualToolStream: options.manualToolStream ?? false,
+    strictAlternation: options.strictAlternation ?? false,
+    owner: Symbol(provider),
+  };
+}
+
+function getRegistration(
+  provider: ProviderName
+): StoredProviderRegistration | undefined {
+  return builtInProviders.get(provider) ?? registeredProviders.get(provider);
+}
+
+/** Registers one host provider until the returned disposer is called. */
+export function registerProvider<
+  TOptions extends object,
+  TModel extends BaseChatModel,
+>(options: ProviderRegistrationOptions<TOptions, TModel>): () => void {
+  const provider = normalizeProvider(options.provider);
+  if (getRegistration(provider) != null) {
+    throw new Error(`LLM provider already registered: ${provider}`);
+  }
+
+  const registration = createRegistration(provider, options);
+  registeredProviders.set(provider, registration);
+
+  return (): void => {
+    if (registeredProviders.get(provider)?.owner === registration.owner) {
+      registeredProviders.delete(provider);
+    }
+  };
+}
+
+/** Initializes one built-in for the current package module graph. */
+export function registerBuiltInProvider<
+  TOptions extends object,
+  TModel extends BaseChatModel,
+>(options: ProviderRegistrationOptions<TOptions, TModel>): void {
+  const provider = normalizeProvider(options.provider);
+  if (builtInProviders.has(provider)) {
+    throw new Error(`LLM provider already registered: ${provider}`);
+  }
+  builtInProviders.set(provider, createRegistration(provider, options));
+}
+
+export function getRegisteredChatModelClass<P extends ProviderName>(
+  provider: P
+): ProviderModelConstructor<P> {
+  const registration = getRegistration(provider);
+  if (!registration) {
+    throw new Error(`Unsupported LLM provider: ${provider}`);
+  }
+  return registration.model as ProviderModelConstructor<P>;
+}
+
+export function getProviderFamily(
+  provider: ProviderName
+): ProviderFamily | undefined {
+  return getRegistration(provider)?.family;
+}
+
+export function providerUsesManualToolStream(provider: ProviderName): boolean {
+  return getRegistration(provider)?.manualToolStream ?? false;
+}
+
+export function providerRequiresStrictAlternation(
+  provider: ProviderName
+): boolean {
+  return getRegistration(provider)?.strictAlternation ?? false;
+}

package/src/llm/providers.ts

@@ -1,10 +1,9 @@
-// src/llm/providers.ts
-import { CustomChatMistralAI } from '@/llm/mistral';
 import type {
   ChatModelConstructorMap,
-  ProviderOptionsMap,
-  ChatModelMap,
+  ProviderModelConstructor,
+  ProviderName,
 } from '@/types';
+import type { ProviderFamily } from '../provider-registration';
 import {
   AzureChatOpenAI,
   ChatDeepSeek,
@@ -12,41 +11,85 @@ import {
   ChatOpenAI,
   ChatXAI,
 } from '@/llm/openai';
+import {
+  getRegisteredChatModelClass,
+  registerBuiltInProvider,
+} from '@/llm/providerRegistry';
 import { CustomChatGoogleGenerativeAI } from '@/llm/google';
 import { CustomChatBedrockConverse } from '@/llm/bedrock';
+import { CustomChatMistralAI } from '@/llm/mistral';
 import { CustomAnthropic } from '@/llm/anthropic';
 import { ChatOpenRouter } from '@/llm/openrouter';
 import { ChatVertexAI } from '@/llm/vertexai';
 import { Providers } from '@/common';
 
-export const llmProviders: Partial<ChatModelConstructorMap> = {
-  [Providers.XAI]: ChatXAI,
-  [Providers.OPENAI]: ChatOpenAI,
-  [Providers.AZURE]: AzureChatOpenAI,
-  [Providers.VERTEXAI]: ChatVertexAI,
-  [Providers.DEEPSEEK]: ChatDeepSeek,
-  [Providers.MISTRALAI]: CustomChatMistralAI,
-  [Providers.MISTRAL]: CustomChatMistralAI,
-  [Providers.ANTHROPIC]: CustomAnthropic,
-  [Providers.OPENROUTER]: ChatOpenRouter,
-  [Providers.BEDROCK]: CustomChatBedrockConverse,
-  // [Providers.ANTHROPIC]: ChatAnthropic,
-  [Providers.GOOGLE]: CustomChatGoogleGenerativeAI,
-  [Providers.MOONSHOT]: ChatMoonshot,
+type BuiltInProviderTraits = {
+  family: ProviderFamily;
+  manualToolStream?: boolean;
+  strictAlternation?: boolean;
 };
 
-export const manualToolStreamProviders = new Set<Providers | string>([
-  Providers.ANTHROPIC,
-  Providers.BEDROCK,
-]);
+function initializeBuiltInProvider<P extends Providers>(
+  provider: P,
+  model: ChatModelConstructorMap[P],
+  traits: BuiltInProviderTraits
+): void {
+  registerBuiltInProvider({
+    provider,
+    model,
+    ...traits,
+  });
+}
 
-export const getChatModelClass = <P extends Providers>(
+initializeBuiltInProvider(Providers.XAI, ChatXAI, { family: 'openai' });
+initializeBuiltInProvider(Providers.OPENAI, ChatOpenAI, { family: 'openai' });
+initializeBuiltInProvider(Providers.AZURE, AzureChatOpenAI, {
+  family: 'openai',
+});
+initializeBuiltInProvider(Providers.VERTEXAI, ChatVertexAI, {
+  family: 'google',
+});
+initializeBuiltInProvider(Providers.DEEPSEEK, ChatDeepSeek, {
+  family: 'openai',
+});
+initializeBuiltInProvider(Providers.MISTRALAI, CustomChatMistralAI, {
+  family: 'mistral',
+  strictAlternation: true,
+});
+initializeBuiltInProvider(Providers.MISTRAL, CustomChatMistralAI, {
+  family: 'mistral',
+  strictAlternation: true,
+});
+initializeBuiltInProvider(Providers.ANTHROPIC, CustomAnthropic, {
+  family: 'anthropic',
+  manualToolStream: true,
+});
+initializeBuiltInProvider(Providers.OPENROUTER, ChatOpenRouter, {
+  family: 'openai',
+});
+initializeBuiltInProvider(Providers.BEDROCK, CustomChatBedrockConverse, {
+  family: 'bedrock',
+  manualToolStream: true,
+  strictAlternation: true,
+});
+initializeBuiltInProvider(Providers.GOOGLE, CustomChatGoogleGenerativeAI, {
+  family: 'google',
+});
+initializeBuiltInProvider(Providers.MOONSHOT, ChatMoonshot, {
+  family: 'generic',
+});
+
+export const getChatModelClass = <P extends ProviderName>(
   provider: P
-): new (config: ProviderOptionsMap[P]) => ChatModelMap[P] => {
-  const ChatModelClass = llmProviders[provider];
-  if (!ChatModelClass) {
-    throw new Error(`Unsupported LLM provider: ${provider}`);
-  }
+): ProviderModelConstructor<P> => getRegisteredChatModelClass(provider);
 
-  return ChatModelClass;
-};
+export {
+  getProviderFamily,
+  providerRequiresStrictAlternation,
+  providerUsesManualToolStream,
+  registerProvider,
+} from '@/llm/providerRegistry';
+export type {
+  ProviderFamily,
+  ProviderRegistrationOptions,
+} from '../provider-registration';

package/src/llm/request.ts

@@ -1,4 +1,5 @@
 import type * as t from '@/types';
+import { getProviderFamily } from '@/llm/providerRegistry';
 import { Providers } from '@/common';
 
 /**
@@ -7,20 +8,21 @@ import { Providers } from '@/common';
  * and OpenAI-compat (modelKwargs.thinking).
  */
 export function isThinkingEnabled(
-  provider: Providers,
+  provider: t.ProviderName,
   clientOptions?: t.ClientOptions
 ): boolean {
   if (!clientOptions) return false;
+  const family = getProviderFamily(provider);
 
   if (
-    provider === Providers.ANTHROPIC &&
+    (provider === Providers.ANTHROPIC || family === 'anthropic') &&
     (clientOptions as t.AnthropicClientOptions).thinking != null
   ) {
     return true;
   }
 
   if (
-    provider === Providers.BEDROCK &&
+    (provider === Providers.BEDROCK || family === 'bedrock') &&
     (clientOptions as t.BedrockAnthropicInput).additionalModelRequestFields?.[
       'thinking'
     ] != null
@@ -29,7 +31,7 @@ export function isThinkingEnabled(
   }
 
   if (
-    provider === Providers.OPENAI &&
+    (provider === Providers.OPENAI || family === 'openai') &&
     (
       (clientOptions as t.OpenAIClientOptions).modelKwargs
         ?.thinking as t.AnthropicClientOptions['thinking']
@@ -47,9 +49,11 @@ export function isThinkingEnabled(
  * use `maxTokens`.
  */
 export function getMaxOutputTokensKey(
-  provider: Providers | string
+  provider: t.ProviderName
 ): 'maxOutputTokens' | 'maxTokens' {
-  return provider === Providers.GOOGLE || provider === Providers.VERTEXAI
+  return provider === Providers.GOOGLE ||
+    provider === Providers.VERTEXAI ||
+    getProviderFamily(provider) === 'google'
     ? 'maxOutputTokens'
     : 'maxTokens';
 }

package/src/llm/truncation.ts

@@ -1,4 +1,6 @@
 import type { AIMessageChunk, BaseMessage } from '@langchain/core/messages';
+import type { ProviderName } from '@/types';
+import { getProviderFamily } from '@/llm/providerRegistry';
 import { Providers } from '@/common';
 
 /**
@@ -7,7 +9,7 @@ import { Providers } from '@/common';
  * `functionCall` whole and seal it on arrival, so a `MAX_TOKENS` finish does
  * NOT imply the arguments were cut off — the truncation guard must skip them.
  */
-const ATOMIC_TOOL_CALL_ARG_PROVIDERS = new Set<Providers>([
+const ATOMIC_TOOL_CALL_ARG_PROVIDERS = new Set<ProviderName>([
   Providers.GOOGLE,
   Providers.VERTEXAI,
 ]);
@@ -162,12 +164,16 @@ function collectToolCallNames(message: AIMessageChunk | BaseMessage): string[] {
  */
 export function assertNotTruncatedToolCall(
   message: AIMessageChunk | BaseMessage | undefined | null,
-  provider?: Providers
+  provider?: ProviderName
 ): void {
   if (message == null) {
     return;
   }
-  if (provider != null && ATOMIC_TOOL_CALL_ARG_PROVIDERS.has(provider)) {
+  if (
+    provider != null &&
+    (ATOMIC_TOOL_CALL_ARG_PROVIDERS.has(provider) ||
+      getProviderFamily(provider) === 'google')
+  ) {
     return;
   }
   const stopReason = getTruncationStopReason(message);

package/src/messages/core.ts

@@ -90,7 +90,7 @@ const modifyContent = ({
   messageType,
   content,
 }: {
-  provider: Providers;
+  provider: t.ProviderName;
   messageType: string;
   content: t.ExtendedMessageContent[];
 }): (t.ExtendedMessageContent | null)[] => {
@@ -243,7 +243,7 @@ function hasReasoningContent(content: BaseMessage['content']): boolean {
 }
 
 export function modifyDeltaProperties(
-  provider: Providers,
+  provider: t.ProviderName,
   obj?: AIMessageChunk
 ): AIMessageChunk | undefined {
   if (!obj || typeof obj !== 'object') return obj;

package/src/messages/format.ts

@@ -27,6 +27,7 @@ import type {
   ToolCallPart,
   TPayload,
   TMessage,
+  ProviderName,
 } from '@/types';
 import type {
   ProviderMessageAttribution,
@@ -366,7 +367,7 @@ export const formatFromLangChain = (
 interface FormatAssistantMessageOptions {
   preserveUnpairedServerToolUses?: boolean;
   preserveReasoningContent?: boolean;
-  provider?: Providers;
+  provider?: ProviderName;
   sourceMessageId?: string;
   sourceContentPartOffset?: number;
   sourceContentPartIndices?: readonly SourceContentPartIndices[];
@@ -376,7 +377,7 @@ interface FormatAssistantMessageOptions {
 type SourceContentPartIndices = number | readonly number[];
 
 interface FormatAgentMessagesOptions {
-  provider?: Providers;
+  provider?: ProviderName;
   /** Reconstruct hidden `reasoning_content` from `THINK` parts onto prior
    *  tool-call messages. Explicit opt-in for OpenAI-compatible endpoints that
    *  replay reasoning across turns; defaults to on for DeepSeek thinking-mode. */
@@ -478,10 +479,7 @@ function collectTrustedToolResultSourceContentPartIndices(
   let trusted: Set<number> | undefined;
   let previousPart: MessageContentComplex | null | undefined;
   for (let index = 0; index < content.length; index++) {
-    const part = content[index] as
-      | MessageContentComplex
-      | null
-      | undefined;
+    const part = content[index] as MessageContentComplex | null | undefined;
     if (part == null) {
       previousPart = part;
       continue;
@@ -509,13 +507,18 @@ function sourceContentPartIndicesAreTrustedToolResult(
   trustedToolSourceContentPartIndices: ReadonlySet<number> | undefined
 ): boolean {
   if (typeof sourceContentPartIndices === 'number') {
-    return trustedToolSourceContentPartIndices?.has(sourceContentPartIndices) === true;
+    return (
+      trustedToolSourceContentPartIndices?.has(sourceContentPartIndices) ===
+      true
+    );
   }
   if (sourceContentPartIndices.length === 0) {
     return false;
   }
   for (const sourceContentPartIndex of sourceContentPartIndices) {
-    if (trustedToolSourceContentPartIndices?.has(sourceContentPartIndex) !== true) {
+    if (
+      trustedToolSourceContentPartIndices?.has(sourceContentPartIndex) !== true
+    ) {
       return false;
     }
   }
@@ -1377,10 +1380,7 @@ function stampSourceMessageIdentity(
       },
     ];
   }
-  setProviderMessageProvenance(
-    message,
-    partsToStamp
-  );
+  setProviderMessageProvenance(message, partsToStamp);
   if (sourceMessageId == null || derivedIndex !== 0) {
     return;
   }
@@ -2759,9 +2759,7 @@ function getSyntheticProviderContextProvenanceParts(
 ): ProviderMessageProvenancePart[] | null {
   /** Fold labels are generated context, while retained source bytes keep their
    * original attribution so downstream policy can still route them exactly. */
-  const parts: ProviderMessageProvenancePart[] = [
-    { attribution: 'synthetic' },
-  ];
+  const parts: ProviderMessageProvenancePart[] = [{ attribution: 'synthetic' }];
   for (const source of sourceMessages) {
     const {
       message: sourceMessage,
@@ -3311,7 +3309,7 @@ function appendToolCalls(
  */
 export function ensureThinkingBlockInMessages(
   messages: BaseMessage[],
-  _provider: Providers,
+  _provider: ProviderName,
   config?: RunnableConfig,
   runStartIndex?: number
 ): BaseMessage[] {

package/src/messages/prune.ts

@@ -13,6 +13,7 @@ import type {
 } from '@/types/stream';
 import type { ContextPruningConfig } from '@/types/graph';
 import type { TokenCounter } from '@/types/run';
+import type { ProviderName } from '@/types';
 import {
   cloneToolMessageWithContent,
   compactToolContent,
@@ -29,6 +30,7 @@ import {
 import { resolveContextPruningSettings } from './contextPruningSettings';
 import { hasUnsafeStructuredSerialization } from '@/utils/tokens';
 import { ContentTypes, Providers, Constants } from '@/common';
+import { getProviderFamily } from '@/llm/providerRegistry';
 import { applyContextPruning } from './contextPruning';
 import { toLangChainContent } from './langchain';
 
@@ -130,7 +132,7 @@ export function clampCalibrationRatio(ratio: number): number {
 }
 
 export type PruneMessagesFactoryParams = {
-  provider?: Providers;
+  provider?: ProviderName;
   maxTokens: number;
   /** Per-tool-result character cap applied while reconciling cached counts. */
   maxToolResultChars?: number;
@@ -2065,6 +2067,15 @@ type ThinkingBlocks = {
 };
 
 export function createPruneMessages(factoryParams: PruneMessagesFactoryParams) {
+  const providerFamily =
+    factoryParams.provider == null
+      ? undefined
+      : getProviderFamily(factoryParams.provider);
+  const usesBedrockThinking =
+    factoryParams.provider === Providers.BEDROCK ||
+    providerFamily === 'bedrock';
+  const usesOpenAIThinking =
+    factoryParams.provider === Providers.OPENAI || providerFamily === 'openai';
   const indexTokenCountMap = { ...factoryParams.indexTokenCountMap };
   let lastTurnStartIndex = factoryParams.startIndex;
   let lastCutOffIndex = 0;
@@ -2152,10 +2163,7 @@ export function createPruneMessages(factoryParams: PruneMessagesFactoryParams) {
       };
     }
 
-    if (
-      factoryParams.provider === Providers.OPENAI &&
-      factoryParams.thinkingEnabled === true
-    ) {
+    if (usesOpenAIThinking && factoryParams.thinkingEnabled === true) {
       for (let i = lastTurnStartIndex; i < params.messages.length; i++) {
         const m = params.messages[i];
         if (
@@ -2729,10 +2737,9 @@ export function createPruneMessages(factoryParams: PruneMessagesFactoryParams) {
       thinkingEnabled: factoryParams.thinkingEnabled,
       tokenCounter: factoryParams.tokenCounter,
       instructionTokens: rawSpaceInstructionTokens,
-      reasoningType:
-        factoryParams.provider === Providers.BEDROCK
-          ? ContentTypes.REASONING_CONTENT
-          : ContentTypes.THINKING,
+      reasoningType: usesBedrockThinking
+        ? ContentTypes.REASONING_CONTENT
+        : ContentTypes.THINKING,
       thinkingStartIndex:
         factoryParams.thinkingEnabled === true
           ? runThinkingStartIndex
@@ -2826,10 +2833,9 @@ export function createPruneMessages(factoryParams: PruneMessagesFactoryParams) {
         thinkingEnabled: factoryParams.thinkingEnabled,
         tokenCounter: factoryParams.tokenCounter,
         instructionTokens: currentInstructionTokens,
-        reasoningType:
-          factoryParams.provider === Providers.BEDROCK
-            ? ContentTypes.REASONING_CONTENT
-            : ContentTypes.THINKING,
+        reasoningType: usesBedrockThinking
+          ? ContentTypes.REASONING_CONTENT
+          : ContentTypes.THINKING,
         thinkingStartIndex:
           factoryParams.thinkingEnabled === true
             ? runThinkingStartIndex
@@ -2963,10 +2969,9 @@ export function createPruneMessages(factoryParams: PruneMessagesFactoryParams) {
           thinkingEnabled: factoryParams.thinkingEnabled,
           tokenCounter: factoryParams.tokenCounter,
           instructionTokens: currentInstructionTokens,
-          reasoningType:
-            factoryParams.provider === Providers.BEDROCK
-              ? ContentTypes.REASONING_CONTENT
-              : ContentTypes.THINKING,
+          reasoningType: usesBedrockThinking
+            ? ContentTypes.REASONING_CONTENT
+            : ContentTypes.THINKING,
           thinkingStartIndex:
             factoryParams.thinkingEnabled === true
               ? runThinkingStartIndex

package/src/provider-registration.ts

@@ -0,0 +1,29 @@
+import type { BaseChatModel } from '@langchain/core/language_models/chat_models';
+
+declare const CUSTOM_PROVIDER_OPTIONS_TYPE: unique symbol;
+
+/** Declaration-merge this map to type host-registered provider options. */
+export interface CustomProviderOptionsMap {
+  readonly [CUSTOM_PROVIDER_OPTIONS_TYPE]?: never;
+}
+
+export type ProviderFamily =
+  | 'openai'
+  | 'anthropic'
+  | 'bedrock'
+  | 'google'
+  | 'mistral'
+  | 'generic';
+
+export interface ProviderRegistrationOptions<
+  TOptions extends object,
+  TModel extends BaseChatModel,
+> {
+  provider: string;
+  model: new (config: TOptions) => TModel;
+  family?: ProviderFamily;
+  manualToolStream?: boolean;
+  strictAlternation?: boolean;
+}
+
+export { registerProvider } from './llm/providers';

package/src/run.ts

@@ -452,7 +452,7 @@ export class Run<_T extends t.BaseGraphState> {
         provider,
         clientOptions,
         agentId: 'default',
-      };
+      } as t.AgentInputs;
       signal = legacySignal;
     }
 

package/src/session/AgentSession.ts

@@ -588,7 +588,7 @@ function createAgentInputFromGraphConfig(
       provider,
       clientOptions,
       agentId: 'default',
-    };
+    } as t.AgentInputs;
   }
   const summarizationConfig: t.SummarizationConfig = {
     ...(agent.summarizationConfig ?? {}),

package/src/stream.ts

@@ -820,12 +820,11 @@ function startEagerToolExecutions(args: {
       toolCalls: entries.map((entry) => entry.request),
       userId: graph.config?.configurable?.user_id as string | undefined,
       agentId: agentContext?.agentId,
-      callerCapabilityProjection:
-        (
-          agentContext as
-            | Partial<Pick<AgentContext, 'getCallerCapabilityProjectionSnapshot'>>
-            | undefined
-        )?.getCallerCapabilityProjectionSnapshot?.(),
+      callerCapabilityProjection: (
+        agentContext as
+          | Partial<Pick<AgentContext, 'getCallerCapabilityProjectionSnapshot'>>
+          | undefined
+      )?.getCallerCapabilityProjectionSnapshot?.(),
       configurable: graph.config?.configurable as
         | Record<string, unknown>
         | undefined,
@@ -1327,7 +1326,7 @@ export function getChunkContent({
   reasoningKey,
 }: {
   chunk?: Partial<AIMessageChunk>;
-  provider?: Providers;
+  provider?: t.ProviderName;
   reasoningKey: 'reasoning_content' | 'reasoning';
 }): string | t.MessageContentComplex[] | undefined {
   if (
@@ -1851,7 +1850,7 @@ export class ChatModelStreamHandler implements t.EventHandler {
 
     if (Array.isArray(content) && content.every(isTextContentPart)) {
       const contentGroups = splitAssistantTextContentByPhase(content);
-      const currentStepId = graph.stepKeyIds?.get(stepKey)?.at(-1);
+      const currentStepId = graph.stepKeyIds.get(stepKey)?.at(-1);
       const currentStep =
         currentStepId == null ? undefined : graph.getRunStep(currentStepId);
       const currentPhase =