fix: models/tongyi has global side effect on base_url (langgenius#2473)

* fix: global side effect

* chore: bump version

* chore: add .venv to .difyignore

Author: Stream29

models/tongyi/.difyignore

@@ -0,0 +1 @@
+.venv

models/tongyi/manifest.yaml

@@ -25,5 +25,5 @@ resource:
     model:
       enabled: false
 type: plugin
-version: 0.1.19
+version: 0.1.20
 created_at: "2024-12-10T16:13:50.29298939+08:00"

models/tongyi/models/_common.py

@@ -1,3 +1,5 @@
+from typing import Mapping
+
 from dashscope.common.error import (
     AuthenticationError,
     InvalidParameter,
@@ -16,6 +18,23 @@
     InvokeServerUnavailableError,
 )
 
+DEFAULT_HTTP_BASE_ADDRESS = "https://dashscope.aliyuncs.com/api/v1"
+DEFAULT_WS_BASE_ADDRESS = "wss://dashscope.aliyuncs.com/api-ws/v1/inference"
+INTL_HTTP_BASE_ADDRESS = "https://dashscope-intl.aliyuncs.com/api/v1"
+INTL_WS_BASE_ADDRESS = "wss://dashscope-intl.aliyuncs.com/api-ws/v1/inference"
+
+
+def get_http_base_address(credentials: Mapping[str, str]) -> str:
+    if credentials.get("use_international_endpoint", "false") == "true":
+        return INTL_HTTP_BASE_ADDRESS
+    return DEFAULT_HTTP_BASE_ADDRESS
+
+
+def get_ws_base_address(credentials: Mapping[str, str]) -> str:
+    if credentials.get("use_international_endpoint", "false") == "true":
+        return INTL_WS_BASE_ADDRESS
+    return DEFAULT_WS_BASE_ADDRESS
+
 
 class _CommonTongyi:
     @staticmethod

models/tongyi/models/llm/llm.py

@@ -61,6 +61,7 @@
 )
 from dify_plugin.interfaces.model.large_language_model import LargeLanguageModel
 from openai import OpenAI
+from models._common import get_http_base_address
 from ..constant import BURY_POINT_HEADER
 
 logger = logging.getLogger(__name__)
@@ -238,7 +239,7 @@ def _generate(
         if common_force_condition or model.startswith(("qwq-", "qvq-")):
             incremental_output = True
 
-        base_address =  "https://dashscope-intl.aliyuncs.com/api/v1" if credentials.get("use_international_endpoint") == "true" else None
+        base_address = get_http_base_address(credentials)
 
         # The parameter `enable_omni_output_audio_url` must be set to true when using the Omni model in non-streaming mode.
         if model.startswith("qwen3-omni-") and not stream:

models/tongyi/models/rerank/rerank.py

@@ -19,6 +19,7 @@
     InvokeServerUnavailableError,
 )
 from dify_plugin.interfaces.model.rerank_model import RerankModel
+from models._common import get_http_base_address
 from ..constant import BURY_POINT_HEADER
 
 class GTERerankModel(RerankModel):
@@ -50,11 +51,16 @@ def _invoke(
         """
         if len(docs) == 0:
             return RerankResult(model=model, docs=docs)
-        if credentials.get("use_international_endpoint", "false") == "true":
-            dashscope.base_http_api_url = "https://dashscope-intl.aliyuncs.com/api/v1"
-        dashscope.api_key = credentials["dashscope_api_key"]
+        http_base_address = get_http_base_address(credentials)
         response = dashscope.TextReRank.call(
-            query=query, headers=BURY_POINT_HEADER, documents=docs, model=model, top_n=top_n, return_documents=True
+            query=query,
+            headers=BURY_POINT_HEADER,
+            documents=docs,
+            model=model,
+            top_n=top_n,
+            return_documents=True,
+            api_key=credentials["dashscope_api_key"],
+            base_address=http_base_address,
         )
         rerank_documents = []
         if not response.output:

models/tongyi/models/speech2text/speech2text.py

@@ -3,9 +3,9 @@
 from pydub import AudioSegment
 import tempfile
 from typing import IO, Optional
-import dashscope
 from dify_plugin import OAICompatSpeech2TextModel
 from dashscope.audio.asr import *
+from models._common import get_ws_base_address
 from ..constant import BURY_POINT_HEADER
 
 class TongyiSpeech2TextModel(OAICompatSpeech2TextModel):
@@ -24,9 +24,7 @@ def _invoke(self, model: str, credentials: dict, file: IO[bytes], user: Optional
         :return: text for given audio file
         """
         try:
-            if credentials.get("use_international_endpoint", "false") == "true":
-                dashscope.base_http_api_url = "https://dashscope-intl.aliyuncs.com/api/v1"
-            dashscope.api_key = credentials["dashscope_api_key"]
+            ws_base_address = get_ws_base_address(credentials)
             file.seek(0)
             audio = AudioSegment.from_file(file)
             sample_rate = audio.frame_rate
@@ -42,7 +40,12 @@ def _invoke(self, model: str, credentials: dict, file: IO[bytes], user: Optional
                 sample_rate=int(sample_rate),
                 callback=None,
             )
-            result = recognition.call(file=file_path, headers=BURY_POINT_HEADER)
+            result = recognition.call(
+                file=file_path,
+                headers=BURY_POINT_HEADER,
+                api_key=credentials["dashscope_api_key"],
+                base_address=ws_base_address,
+            )
             sentence_list = result.get_sentence()
             if sentence_list is None:
                 return ''

models/tongyi/models/text_embedding/text_embedding.py

@@ -9,7 +9,7 @@
 from dify_plugin.entities.model.text_embedding import EmbeddingUsage, MultiModalContent, MultiModalContentType, MultiModalEmbeddingResult, TextEmbeddingResult
 from dify_plugin.errors.model import CredentialsValidateFailedError
 from dify_plugin.interfaces.model.text_embedding_model import TextEmbeddingModel
-from models._common import _CommonTongyi
+from models._common import _CommonTongyi, get_http_base_address
 from ..constant import BURY_POINT_HEADER
 
 vision_models = dict()
@@ -37,8 +37,7 @@ def _invoke(
         :param input_type: input type
         :return: embeddings result
         """
-        if credentials.get("use_international_endpoint", "false") == "true":
-            dashscope.base_http_api_url = "https://dashscope-intl.aliyuncs.com/api/v1"
+        http_base_address = get_http_base_address(credentials)
         credentials_kwargs = self._to_credential_kwargs(credentials)
         context_size = self._get_context_size(model, credentials)
         max_chunks = self._get_max_chunks(model, credentials)
@@ -57,7 +56,10 @@ def _invoke(
         _iter = range(0, len(inputs), max_chunks)
         for i in _iter:
             (embeddings_batch, embedding_used_tokens) = self.embed_documents(
-                credentials_kwargs=credentials_kwargs, model=model, texts=inputs[i : i + max_chunks]
+                credentials_kwargs=credentials_kwargs,
+                model=model,
+                texts=inputs[i : i + max_chunks],
+                base_address=http_base_address,
             )
             used_tokens += embedding_used_tokens
             batched_embeddings += embeddings_batch
@@ -90,12 +92,23 @@ def validate_credentials(self, model: str, credentials: dict) -> None:
         """
         try:
             credentials_kwargs = self._to_credential_kwargs(credentials)
-            self.embed_documents(credentials_kwargs=credentials_kwargs, model=model, texts=["ping"])
+            http_base_address = get_http_base_address(credentials)
+            self.embed_documents(
+                credentials_kwargs=credentials_kwargs,
+                model=model,
+                texts=["ping"],
+                base_address=http_base_address,
+            )
         except Exception as ex:
             raise CredentialsValidateFailedError(str(ex))
 
     @staticmethod
-    def embed_documents(credentials_kwargs: dict, model: str, texts: list[str]) -> tuple[list[list[float]], int]:
+    def embed_documents(
+        credentials_kwargs: dict,
+        model: str,
+        texts: list[str],
+        base_address: str,
+    ) -> tuple[list[list[float]], int]:
         """Call out to Tongyi's embedding endpoint.
 
         Args:
@@ -111,7 +124,12 @@ def embed_documents(credentials_kwargs: dict, model: str, texts: list[str]) -> t
         # transfer and call embed_multimodal_documents
         if TongyiTextEmbeddingModel._is_vision_model(model):
             documents = [MultiModalContent(content_type=MultiModalContentType.TEXT, content=text) for text in texts]
-            return TongyiTextEmbeddingModel.embed_multimodal_documents(credentials_kwargs, model, documents)
+            return TongyiTextEmbeddingModel.embed_multimodal_documents(
+                credentials_kwargs,
+                model,
+                documents,
+                base_address,
+            )
 
         embeddings = []
         embedding_used_tokens = 0
@@ -124,14 +142,16 @@ def call_embedding_api(text):
                         api_key=credentials_kwargs["dashscope_api_key"],
                         model=model,
                         input=[{"text": text}],
+                        base_address=base_address,
                     )
                 else:
                     return dashscope.TextEmbedding.call(
                         api_key=credentials_kwargs["dashscope_api_key"],
                         model=model,
                         input=text,
                         headers=BURY_POINT_HEADER,
-                        text_type="document"
+                        text_type="document",
+                        base_address=base_address,
                     )
             except Exception as e:
                 # Return the exception to be handled by the caller
@@ -236,11 +256,13 @@ def _invoke_multimodal(
         :param input_type: input type
         :return: embeddings result
         """
-        if credentials.get("use_international_endpoint", "false") == "true":
-            dashscope.base_http_api_url = "https://dashscope-intl.aliyuncs.com/api/v1"
+        http_base_address = get_http_base_address(credentials)
         credentials_kwargs = self._to_credential_kwargs(credentials)
         (embeddings_batch, embedding_used_tokens) = self.embed_multimodal_documents(
-            credentials_kwargs=credentials_kwargs, model=model, documents=documents
+            credentials_kwargs=credentials_kwargs,
+            model=model,
+            documents=documents,
+            base_address=http_base_address,
         )
         usage = self._calc_response_usage(model=model, credentials=credentials, tokens=embedding_used_tokens)
         return MultiModalEmbeddingResult(
@@ -250,7 +272,12 @@ def _invoke_multimodal(
         )     
 
     @staticmethod
-    def embed_multimodal_documents(credentials_kwargs: dict, model: str, documents: list[MultiModalContent]) -> tuple[list[list[float]], int]:
+    def embed_multimodal_documents(
+        credentials_kwargs: dict,
+        model: str,
+        documents: list[MultiModalContent],
+        base_address: str,
+    ) -> tuple[list[list[float]], int]:
         """Call out to Tongyi's embedding endpoint.
 
         Args:
@@ -292,7 +319,8 @@ def call_embedding_api(input):
                 return dashscope.MultiModalEmbedding.call(
                     api_key=credentials_kwargs["dashscope_api_key"], 
                     model=model, 
-                    input=[input], 
+                    input=[input],
+                    base_address=base_address,
                 )
             except Exception as e:
                 # Return the exception to be handled by the caller

models/tongyi/models/tts/tts.py

@@ -1,13 +1,12 @@
 import threading
 from queue import Queue
 from typing import Any, Optional
-import dashscope
 from dashscope import SpeechSynthesizer
 from dashscope.api_entities.dashscope_response import SpeechSynthesisResponse
 from dashscope.audio.tts import ResultCallback, SpeechSynthesisResult
 from dify_plugin.errors.model import CredentialsValidateFailedError, InvokeBadRequestError
 from dify_plugin.interfaces.model.tts_model import TTSModel
-from models._common import _CommonTongyi
+from models._common import _CommonTongyi, get_ws_base_address
 from ..constant import BURY_POINT_HEADER
 
 class TongyiText2SpeechModel(_CommonTongyi, TTSModel):
@@ -66,11 +65,12 @@ def _tts_invoke_streaming(self, model: str, credentials: dict, content_text: str
         """
         word_limit = self._get_model_word_limit(model, credentials)
         audio_type = self._get_model_audio_type(model, credentials)
+        ws_base_address = get_ws_base_address(credentials)
         try:
             audio_queue: Queue = Queue()
             callback = Callback(queue=audio_queue)
 
-            def invoke_remote(content, v, api_key, cb, at, wl):
+            def invoke_remote(content, v, api_key, cb, at, wl, base_address):
                 if len(content) < word_limit:
                     sentences = [content]
                 else:
@@ -85,11 +85,20 @@ def invoke_remote(content, v, api_key, cb, at, wl):
                         format=at,
                         word_timestamp_enabled=True,
                         phoneme_timestamp_enabled=True,
+                        base_address=base_address,
                     )
 
             threading.Thread(
                 target=invoke_remote,
-                args=(content_text, voice, credentials.get("dashscope_api_key"), callback, audio_type, word_limit),
+                args=(
+                    content_text,
+                    voice,
+                    credentials.get("dashscope_api_key"),
+                    callback,
+                    audio_type,
+                    word_limit,
+                    ws_base_address,
+                ),
             ).start()
             while True:
                 audio = audio_queue.get()
@@ -110,15 +119,15 @@ def _process_sentence(sentence: str, credentials: dict, voice: str, audio_type:
         :param audio_type: audio file type
         :return: text translated to audio file
         """
-        if credentials.get("use_international_endpoint", "false") == "true":
-            dashscope.base_http_api_url = "https://dashscope-intl.aliyuncs.com/api/v1"
-        response = dashscope.audio.tts.SpeechSynthesizer.call(
+        ws_base_address = get_ws_base_address(credentials)
+        response = SpeechSynthesizer.call(
             model=voice,
             sample_rate=48000,
             api_key=credentials.get("dashscope_api_key"),
             text=sentence.strip(),
             headers=BURY_POINT_HEADER,
             format=audio_type,
+            base_address=ws_base_address,
         )
         if isinstance(response.get_audio_data(), bytes):
             return response.get_audio_data()