Method _createModelCore

src/node/services/providerModelFactory.ts:1001–1961

(
    modelString: string,
    muxProviderOptions?: MuxProviderOptions,
    opts?: { agentInitiated?: boolean; routeContext?: RouteContext }
  )

  }

  private async _createModelCore(
    modelString: string,
    muxProviderOptions?: MuxProviderOptions,
    opts?: { agentInitiated?: boolean; routeContext?: RouteContext }
  ): Promise<Result<LanguageModel, SendMessageError>> {
    try {
      // Route resolution is centralized here so every caller gets identical,
      // provider-agnostic dispatch behavior. resolveGatewayModelString is idempotent,
      // so already-routed strings pass through unchanged.
      const explicitGateway = getExplicitGatewayProvider(modelString);
      modelString = this.resolveGatewayModelString(
        modelString,
        opts?.routeContext,
        explicitGateway
      );

      // Parse model string (format: "provider:model-id")
      const [providerName, modelId] = parseModelString(modelString);

      if (!providerName || !modelId) {
        return Err({
          type: "invalid_model_string",
          message: `Invalid model string format: "${modelString}". Expected "provider:model-id"`,
        });
      }

      // Load providers configuration - the ONLY source of truth
      const providersConfig = this.config.loadProvidersConfig() ?? {};
      const providerConfigEntry = providersConfig[providerName];
      const providerIsBuiltIn = isBuiltInProvider(providerName);
      const providerIsCustomOpenAICompatible =
        providerConfigEntry != null && isCustomOpenAICompatibleProviderConfig(providerConfigEntry);

      // Check if provider is supported. Explicit custom OpenAI-compatible config wins
      // even if a future release adds a built-in provider with the same id.
      if (!providerIsCustomOpenAICompatible && providerIsBuiltIn) {
        if (!Object.hasOwn(PROVIDER_REGISTRY, providerName)) {
          return Err({
            type: "provider_not_supported",
            provider: providerName,
          });
        }
      } else if (!providerIsCustomOpenAICompatible) {
        return Err({
          type: "provider_not_supported",
          provider: providerName,
        });
      }

      if (this.policyService?.isEnforced()) {
        if (!this.policyService.isProviderAllowed(providerName)) {
          return Err({
            type: "policy_denied",
            message: `Provider ${providerName} is not allowed by policy`,
          });
        }

        if (!this.policyService.isModelAllowed(providerName, modelId)) {