mirror of
https://github.com/langgenius/dify.git
synced 2026-11-12 22:31:24 +08:00
781 lines
27 KiB
Python
781 lines
27 KiB
Python
import binascii
|
|
from collections.abc import Generator, Sequence
|
|
from typing import IO, Any, override
|
|
|
|
from core.plugin.entities.plugin_daemon import (
|
|
PluginBasicBooleanResponse,
|
|
PluginDaemonInnerError,
|
|
PluginLLMNumTokensResponse,
|
|
PluginModelProviderBinding,
|
|
PluginModelProviderEntity,
|
|
PluginModelSchemaEntity,
|
|
PluginStringResultResponse,
|
|
PluginTextEmbeddingNumTokensResponse,
|
|
PluginTTSResultResponse,
|
|
PluginVoicesResponse,
|
|
TTSAudioChunk,
|
|
)
|
|
from core.plugin.impl.base import BasePluginClient
|
|
from core.plugin.impl.exc import PluginInvokeError, PluginLLMPollingUnsupportedError
|
|
from graphon.model_runtime.entities.llm_entities import LLMPollingResult, LLMResultChunk
|
|
from graphon.model_runtime.entities.message_entities import PromptMessage, PromptMessageTool
|
|
from graphon.model_runtime.entities.model_entities import AIModelEntity, ModelType
|
|
from graphon.model_runtime.entities.rerank_entities import MultimodalRerankInput, RerankResult
|
|
from graphon.model_runtime.entities.text_embedding_entities import EmbeddingResult
|
|
from graphon.model_runtime.protocols.tts_runtime import TTSModelVoice
|
|
from graphon.model_runtime.utils.encoders import jsonable_encoder
|
|
from services.plugin.dispatch_identity import plugin_dispatch_headers
|
|
|
|
_POLLING_UNSUPPORTED_INVOKE_ERROR_TYPES = frozenset((NotImplementedError.__name__,))
|
|
_POLLING_UNSUPPORTED_ERROR_MESSAGE = "does not support polling"
|
|
|
|
|
|
class PluginModelClient(BasePluginClient):
|
|
@override
|
|
def _prepare_request(self, path, headers, data, params, files):
|
|
if isinstance(data, dict) and "redirect" in data:
|
|
prefix, separator, operation = path.partition("/dispatch/")
|
|
if not separator or operation.startswith("redirect/") or "validate" in operation:
|
|
raise ValueError("Invalid model redirect operation")
|
|
context = data.get("_route_context", {})
|
|
if prefix != f"plugin/{context.get('tenant_id')}" or operation not in context.get("operations", ()):
|
|
raise ValueError("Model redirect binding mismatch")
|
|
from models.provider_ids import ModelProviderID
|
|
|
|
logical = ModelProviderID(context["logical_provider"])
|
|
if (headers or {}).get("X-Plugin-ID") != logical.plugin_id or data["data"].get(
|
|
"provider"
|
|
) != logical.provider_name:
|
|
raise ValueError("Model redirect provider binding mismatch")
|
|
data = {key: value for key, value in data.items() if key != "_route_context"}
|
|
path = f"{prefix}/dispatch/redirect/v1/{operation}"
|
|
return super()._prepare_request(path, headers, data, params, files)
|
|
|
|
@staticmethod
|
|
def _dispatch_payload(*, user_id: str | None, data: dict[str, Any], app_id: str | None = None) -> dict[str, Any]:
|
|
from core.model_invocation_routing import RoutedModelCredentials, redirect_payload
|
|
|
|
payload: dict[str, Any] = {"data": data}
|
|
credentials = data.get("credentials")
|
|
if isinstance(credentials, RoutedModelCredentials):
|
|
payload["redirect"] = redirect_payload(credentials.plan, data)
|
|
# Transport-private admission metadata is stripped in _prepare_request.
|
|
# Never use the daemon's persistent Context for this or for keys.
|
|
payload["_route_context"] = {
|
|
"tenant_id": credentials.plan.tenant_id,
|
|
"logical_provider": credentials.plan.logical_provider,
|
|
"operations": credentials.plan.operations,
|
|
}
|
|
payload["data"] = {**data, "credentials": {}}
|
|
payload["user_id"] = user_id or ""
|
|
if user_id is not None:
|
|
payload["user_id"] = user_id
|
|
if app_id is not None:
|
|
payload["app_id"] = app_id
|
|
return payload
|
|
|
|
def fetch_model_providers(self, tenant_id: str) -> Sequence[PluginModelProviderEntity]:
|
|
"""
|
|
Fetch model providers for the given tenant.
|
|
"""
|
|
response = self._request_with_plugin_daemon_response(
|
|
"GET",
|
|
f"plugin/{tenant_id}/management/models",
|
|
list[PluginModelProviderEntity],
|
|
params={"page": 1, "page_size": 256},
|
|
)
|
|
return response
|
|
|
|
def fetch_model_provider_bindings(self, tenant_id: str) -> Sequence[PluginModelProviderBinding]:
|
|
"""Fetch only model-provider installation identities from the daemon."""
|
|
return self._request_with_plugin_daemon_response(
|
|
"GET",
|
|
f"plugin/{tenant_id}/management/models/bindings",
|
|
list[PluginModelProviderBinding],
|
|
)
|
|
|
|
def get_model_schema(
|
|
self,
|
|
tenant_id: str,
|
|
user_id: str | None,
|
|
plugin_id: str,
|
|
provider: str,
|
|
model_type: str,
|
|
model: str,
|
|
credentials: dict[str, Any],
|
|
*,
|
|
plugin_unique_identifier: str | None = None,
|
|
) -> AIModelEntity | None:
|
|
"""
|
|
Get model schema
|
|
"""
|
|
response = self._request_with_plugin_daemon_response_stream(
|
|
"POST",
|
|
f"plugin/{tenant_id}/dispatch/model/schema",
|
|
PluginModelSchemaEntity,
|
|
data=self._dispatch_payload(
|
|
user_id=user_id,
|
|
data={
|
|
"provider": provider,
|
|
"model_type": model_type,
|
|
"model": model,
|
|
"credentials": credentials,
|
|
},
|
|
),
|
|
headers=plugin_dispatch_headers(plugin_id, plugin_unique_identifier),
|
|
)
|
|
|
|
for resp in response:
|
|
return resp.model_schema
|
|
|
|
return None
|
|
|
|
def validate_provider_credentials(
|
|
self,
|
|
tenant_id: str,
|
|
user_id: str | None,
|
|
plugin_id: str,
|
|
provider: str,
|
|
credentials: dict[str, Any],
|
|
*,
|
|
plugin_unique_identifier: str | None = None,
|
|
) -> bool:
|
|
"""
|
|
validate the credentials of the provider
|
|
"""
|
|
response = self._request_with_plugin_daemon_response_stream(
|
|
"POST",
|
|
f"plugin/{tenant_id}/dispatch/model/validate_provider_credentials",
|
|
PluginBasicBooleanResponse,
|
|
data=self._dispatch_payload(
|
|
user_id=user_id,
|
|
data={
|
|
"provider": provider,
|
|
"credentials": credentials,
|
|
},
|
|
),
|
|
headers=plugin_dispatch_headers(plugin_id, plugin_unique_identifier),
|
|
)
|
|
|
|
for resp in response:
|
|
if resp.credentials and isinstance(resp.credentials, dict):
|
|
credentials.update(resp.credentials)
|
|
|
|
return resp.result
|
|
|
|
return False
|
|
|
|
def validate_model_credentials(
|
|
self,
|
|
tenant_id: str,
|
|
user_id: str | None,
|
|
plugin_id: str,
|
|
provider: str,
|
|
model_type: str,
|
|
model: str,
|
|
credentials: dict[str, Any],
|
|
*,
|
|
plugin_unique_identifier: str | None = None,
|
|
) -> bool:
|
|
"""
|
|
validate the credentials of the provider
|
|
"""
|
|
response = self._request_with_plugin_daemon_response_stream(
|
|
"POST",
|
|
f"plugin/{tenant_id}/dispatch/model/validate_model_credentials",
|
|
PluginBasicBooleanResponse,
|
|
data=self._dispatch_payload(
|
|
user_id=user_id,
|
|
data={
|
|
"provider": provider,
|
|
"model_type": model_type,
|
|
"model": model,
|
|
"credentials": credentials,
|
|
},
|
|
),
|
|
headers=plugin_dispatch_headers(plugin_id, plugin_unique_identifier),
|
|
)
|
|
|
|
for resp in response:
|
|
if resp.credentials and isinstance(resp.credentials, dict):
|
|
credentials.update(resp.credentials)
|
|
|
|
return resp.result
|
|
|
|
return False
|
|
|
|
def invoke_llm(
|
|
self,
|
|
tenant_id: str,
|
|
user_id: str | None,
|
|
plugin_id: str,
|
|
provider: str,
|
|
model: str,
|
|
credentials: dict[str, Any],
|
|
prompt_messages: list[PromptMessage],
|
|
model_parameters: dict[str, Any] | None = None,
|
|
tools: list[PromptMessageTool] | None = None,
|
|
stop: list[str] | None = None,
|
|
stream: bool = True,
|
|
app_id: str | None = None,
|
|
*,
|
|
plugin_unique_identifier: str | None = None,
|
|
) -> Generator[LLMResultChunk]:
|
|
"""
|
|
Invoke llm
|
|
"""
|
|
response = self._request_with_plugin_daemon_response_stream(
|
|
method="POST",
|
|
path=f"plugin/{tenant_id}/dispatch/llm/invoke",
|
|
type_=LLMResultChunk,
|
|
data=jsonable_encoder(
|
|
self._dispatch_payload(
|
|
user_id=user_id,
|
|
data={
|
|
"provider": provider,
|
|
"model_type": "llm",
|
|
"model": model,
|
|
"credentials": credentials,
|
|
"prompt_messages": prompt_messages,
|
|
"model_parameters": model_parameters,
|
|
"tools": tools,
|
|
"stop": stop,
|
|
"stream": stream,
|
|
},
|
|
app_id=app_id,
|
|
)
|
|
),
|
|
headers=plugin_dispatch_headers(plugin_id, plugin_unique_identifier),
|
|
)
|
|
|
|
try:
|
|
yield from response
|
|
except PluginDaemonInnerError as e:
|
|
raise ValueError(e.message + str(e.code)) from e
|
|
|
|
def start_llm_polling(
|
|
self,
|
|
tenant_id: str,
|
|
user_id: str | None,
|
|
plugin_id: str,
|
|
provider: str,
|
|
model: str,
|
|
credentials: dict[str, Any],
|
|
prompt_messages: list[PromptMessage],
|
|
model_parameters: dict[str, Any] | None = None,
|
|
tools: list[PromptMessageTool] | None = None,
|
|
stop: list[str] | None = None,
|
|
json_schema: dict[str, Any] | None = None,
|
|
*,
|
|
plugin_unique_identifier: str | None = None,
|
|
) -> LLMPollingResult:
|
|
"""Start an LLM polling request for plugin-backed long-running jobs."""
|
|
try:
|
|
return self._request_with_plugin_daemon_response(
|
|
method="POST",
|
|
path=f"plugin/{tenant_id}/dispatch/model/polling/start",
|
|
type_=LLMPollingResult,
|
|
data=jsonable_encoder(
|
|
self._dispatch_payload(
|
|
user_id=user_id,
|
|
data={
|
|
"provider": provider,
|
|
"model_type": ModelType.LLM.value,
|
|
"model": model,
|
|
"credentials": credentials,
|
|
"prompt_messages": prompt_messages,
|
|
"model_parameters": model_parameters,
|
|
"tools": tools,
|
|
"stop": stop,
|
|
"stream": False,
|
|
"json_schema": json_schema,
|
|
},
|
|
)
|
|
),
|
|
headers=plugin_dispatch_headers(plugin_id, plugin_unique_identifier),
|
|
)
|
|
except PluginInvokeError as error:
|
|
self._raise_typed_polling_unsupported_error(error)
|
|
raise
|
|
|
|
def check_llm_polling(
|
|
self,
|
|
tenant_id: str,
|
|
user_id: str | None,
|
|
plugin_id: str,
|
|
provider: str,
|
|
model: str,
|
|
credentials: dict[str, Any],
|
|
plugin_state: dict[str, Any],
|
|
*,
|
|
plugin_unique_identifier: str | None = None,
|
|
) -> LLMPollingResult:
|
|
"""Check the latest state for a plugin-backed LLM polling job."""
|
|
try:
|
|
return self._request_with_plugin_daemon_response(
|
|
method="POST",
|
|
path=f"plugin/{tenant_id}/dispatch/model/polling/check",
|
|
type_=LLMPollingResult,
|
|
data=jsonable_encoder(
|
|
self._dispatch_payload(
|
|
user_id=user_id,
|
|
data={
|
|
"provider": provider,
|
|
"model_type": ModelType.LLM.value,
|
|
"model": model,
|
|
"credentials": credentials,
|
|
"plugin_state": plugin_state,
|
|
},
|
|
)
|
|
),
|
|
headers=plugin_dispatch_headers(plugin_id, plugin_unique_identifier),
|
|
)
|
|
except PluginInvokeError as error:
|
|
self._raise_typed_polling_unsupported_error(error)
|
|
raise
|
|
|
|
@staticmethod
|
|
def _raise_typed_polling_unsupported_error(error: PluginInvokeError) -> None:
|
|
"""Convert plugin polling capability failures into a dedicated Dify exception."""
|
|
if error.get_error_type() == PluginLLMPollingUnsupportedError.__name__:
|
|
raise PluginLLMPollingUnsupportedError(description=error.description) from error
|
|
|
|
if (
|
|
error.get_error_type() in _POLLING_UNSUPPORTED_INVOKE_ERROR_TYPES
|
|
# This is ugly, we should not rely on error messages while checking
|
|
# error types.
|
|
and _POLLING_UNSUPPORTED_ERROR_MESSAGE in error.get_error_message().lower()
|
|
):
|
|
raise PluginLLMPollingUnsupportedError(description=error.description) from error
|
|
|
|
def get_llm_num_tokens(
|
|
self,
|
|
tenant_id: str,
|
|
user_id: str | None,
|
|
plugin_id: str,
|
|
provider: str,
|
|
model_type: str,
|
|
model: str,
|
|
credentials: dict[str, Any],
|
|
prompt_messages: list[PromptMessage],
|
|
tools: list[PromptMessageTool] | None = None,
|
|
*,
|
|
plugin_unique_identifier: str | None = None,
|
|
) -> int:
|
|
"""
|
|
Get number of tokens for llm
|
|
"""
|
|
response = self._request_with_plugin_daemon_response_stream(
|
|
method="POST",
|
|
path=f"plugin/{tenant_id}/dispatch/llm/num_tokens",
|
|
type_=PluginLLMNumTokensResponse,
|
|
data=jsonable_encoder(
|
|
self._dispatch_payload(
|
|
user_id=user_id,
|
|
data={
|
|
"provider": provider,
|
|
"model_type": model_type,
|
|
"model": model,
|
|
"credentials": credentials,
|
|
"prompt_messages": prompt_messages,
|
|
"tools": tools,
|
|
},
|
|
)
|
|
),
|
|
headers=plugin_dispatch_headers(plugin_id, plugin_unique_identifier),
|
|
)
|
|
|
|
for resp in response:
|
|
return resp.num_tokens
|
|
|
|
return 0
|
|
|
|
def invoke_text_embedding(
|
|
self,
|
|
tenant_id: str,
|
|
user_id: str | None,
|
|
plugin_id: str,
|
|
provider: str,
|
|
model: str,
|
|
credentials: dict[str, Any],
|
|
texts: list[str],
|
|
input_type: str,
|
|
*,
|
|
plugin_unique_identifier: str | None = None,
|
|
) -> EmbeddingResult:
|
|
"""
|
|
Invoke text embedding
|
|
"""
|
|
response = self._request_with_plugin_daemon_response_stream(
|
|
method="POST",
|
|
path=f"plugin/{tenant_id}/dispatch/text_embedding/invoke",
|
|
type_=EmbeddingResult,
|
|
data=jsonable_encoder(
|
|
self._dispatch_payload(
|
|
user_id=user_id,
|
|
data={
|
|
"provider": provider,
|
|
"model_type": "text-embedding",
|
|
"model": model,
|
|
"credentials": credentials,
|
|
"texts": texts,
|
|
"input_type": input_type,
|
|
},
|
|
)
|
|
),
|
|
headers=plugin_dispatch_headers(plugin_id, plugin_unique_identifier),
|
|
)
|
|
|
|
for resp in response:
|
|
return resp
|
|
|
|
raise ValueError("Failed to invoke text embedding")
|
|
|
|
def invoke_multimodal_embedding(
|
|
self,
|
|
tenant_id: str,
|
|
user_id: str | None,
|
|
plugin_id: str,
|
|
provider: str,
|
|
model: str,
|
|
credentials: dict[str, Any],
|
|
documents: list[dict],
|
|
input_type: str,
|
|
*,
|
|
plugin_unique_identifier: str | None = None,
|
|
) -> EmbeddingResult:
|
|
"""
|
|
Invoke file embedding
|
|
"""
|
|
response = self._request_with_plugin_daemon_response_stream(
|
|
method="POST",
|
|
path=f"plugin/{tenant_id}/dispatch/multimodal_embedding/invoke",
|
|
type_=EmbeddingResult,
|
|
data=jsonable_encoder(
|
|
self._dispatch_payload(
|
|
user_id=user_id,
|
|
data={
|
|
"provider": provider,
|
|
"model_type": "text-embedding",
|
|
"model": model,
|
|
"credentials": credentials,
|
|
"documents": documents,
|
|
"input_type": input_type,
|
|
},
|
|
)
|
|
),
|
|
headers=plugin_dispatch_headers(plugin_id, plugin_unique_identifier),
|
|
)
|
|
|
|
for resp in response:
|
|
return resp
|
|
|
|
raise ValueError("Failed to invoke file embedding")
|
|
|
|
def get_text_embedding_num_tokens(
|
|
self,
|
|
tenant_id: str,
|
|
user_id: str | None,
|
|
plugin_id: str,
|
|
provider: str,
|
|
model: str,
|
|
credentials: dict[str, Any],
|
|
texts: list[str],
|
|
*,
|
|
plugin_unique_identifier: str | None = None,
|
|
) -> list[int]:
|
|
"""
|
|
Get number of tokens for text embedding
|
|
"""
|
|
response = self._request_with_plugin_daemon_response_stream(
|
|
method="POST",
|
|
path=f"plugin/{tenant_id}/dispatch/text_embedding/num_tokens",
|
|
type_=PluginTextEmbeddingNumTokensResponse,
|
|
data=jsonable_encoder(
|
|
self._dispatch_payload(
|
|
user_id=user_id,
|
|
data={
|
|
"provider": provider,
|
|
"model_type": "text-embedding",
|
|
"model": model,
|
|
"credentials": credentials,
|
|
"texts": texts,
|
|
},
|
|
)
|
|
),
|
|
headers=plugin_dispatch_headers(plugin_id, plugin_unique_identifier),
|
|
)
|
|
|
|
for resp in response:
|
|
return resp.num_tokens
|
|
|
|
return []
|
|
|
|
def invoke_rerank(
|
|
self,
|
|
tenant_id: str,
|
|
user_id: str | None,
|
|
plugin_id: str,
|
|
provider: str,
|
|
model: str,
|
|
credentials: dict[str, Any],
|
|
query: str,
|
|
docs: list[str],
|
|
score_threshold: float | None = None,
|
|
top_n: int | None = None,
|
|
*,
|
|
plugin_unique_identifier: str | None = None,
|
|
) -> RerankResult:
|
|
"""
|
|
Invoke rerank
|
|
"""
|
|
response = self._request_with_plugin_daemon_response_stream(
|
|
method="POST",
|
|
path=f"plugin/{tenant_id}/dispatch/rerank/invoke",
|
|
type_=RerankResult,
|
|
data=jsonable_encoder(
|
|
self._dispatch_payload(
|
|
user_id=user_id,
|
|
data={
|
|
"provider": provider,
|
|
"model_type": "rerank",
|
|
"model": model,
|
|
"credentials": credentials,
|
|
"query": query,
|
|
"docs": docs,
|
|
"score_threshold": score_threshold,
|
|
"top_n": top_n,
|
|
},
|
|
)
|
|
),
|
|
headers=plugin_dispatch_headers(plugin_id, plugin_unique_identifier),
|
|
)
|
|
|
|
for resp in response:
|
|
return resp
|
|
|
|
raise ValueError("Failed to invoke rerank")
|
|
|
|
def invoke_multimodal_rerank(
|
|
self,
|
|
tenant_id: str,
|
|
user_id: str | None,
|
|
plugin_id: str,
|
|
provider: str,
|
|
model: str,
|
|
credentials: dict[str, Any],
|
|
query: MultimodalRerankInput,
|
|
docs: list[MultimodalRerankInput],
|
|
score_threshold: float | None = None,
|
|
top_n: int | None = None,
|
|
*,
|
|
plugin_unique_identifier: str | None = None,
|
|
) -> RerankResult:
|
|
"""
|
|
Invoke multimodal rerank
|
|
"""
|
|
response = self._request_with_plugin_daemon_response_stream(
|
|
method="POST",
|
|
path=f"plugin/{tenant_id}/dispatch/multimodal_rerank/invoke",
|
|
type_=RerankResult,
|
|
data=jsonable_encoder(
|
|
self._dispatch_payload(
|
|
user_id=user_id,
|
|
data={
|
|
"provider": provider,
|
|
"model_type": "rerank",
|
|
"model": model,
|
|
"credentials": credentials,
|
|
"query": query,
|
|
"docs": docs,
|
|
"score_threshold": score_threshold,
|
|
"top_n": top_n,
|
|
},
|
|
)
|
|
),
|
|
headers=plugin_dispatch_headers(plugin_id, plugin_unique_identifier),
|
|
)
|
|
for resp in response:
|
|
return resp
|
|
|
|
raise ValueError("Failed to invoke multimodal rerank")
|
|
|
|
def invoke_tts(
|
|
self,
|
|
tenant_id: str,
|
|
user_id: str | None,
|
|
plugin_id: str,
|
|
provider: str,
|
|
model: str,
|
|
credentials: dict[str, Any],
|
|
content_text: str,
|
|
voice: str,
|
|
*,
|
|
plugin_unique_identifier: str | None = None,
|
|
) -> Generator[TTSAudioChunk]:
|
|
"""
|
|
Invoke tts
|
|
"""
|
|
from core.model_invocation_routing import ModelRouteUnavailable, RoutedModelCredentials, normalize_tts_voice
|
|
|
|
if isinstance(credentials, RoutedModelCredentials) and (contract := credentials.plan.tts_voice_contract):
|
|
plan = credentials.plan
|
|
if (contract.source_provider, contract.source_model, plan.model_type) != (
|
|
plan.logical_provider,
|
|
plan.logical_model,
|
|
ModelType.TTS,
|
|
) or plugin_unique_identifier != contract.source_plugin_unique_identifier:
|
|
raise ModelRouteUnavailable
|
|
# Only a newly versioned, source-verified mapping opts into this.
|
|
# Native/BYOK and older identity mappings keep their own defaults.
|
|
voice = normalize_tts_voice(contract, voice)
|
|
|
|
response = self._request_with_plugin_daemon_response_stream(
|
|
method="POST",
|
|
path=f"plugin/{tenant_id}/dispatch/tts/invoke",
|
|
type_=PluginTTSResultResponse,
|
|
data=jsonable_encoder(
|
|
self._dispatch_payload(
|
|
user_id=user_id,
|
|
data={
|
|
"provider": provider,
|
|
"model_type": "tts",
|
|
"model": model,
|
|
"credentials": credentials,
|
|
"tenant_id": tenant_id,
|
|
"content_text": content_text,
|
|
"voice": voice,
|
|
},
|
|
)
|
|
),
|
|
headers=plugin_dispatch_headers(plugin_id, plugin_unique_identifier),
|
|
)
|
|
|
|
try:
|
|
for result in response:
|
|
hex_str = result.result
|
|
yield TTSAudioChunk(binascii.unhexlify(hex_str), mime_type=result.mime_type)
|
|
except PluginDaemonInnerError as e:
|
|
raise ValueError(e.message + str(e.code)) from e
|
|
|
|
def get_tts_model_voices(
|
|
self,
|
|
tenant_id: str,
|
|
user_id: str | None,
|
|
plugin_id: str,
|
|
provider: str,
|
|
model: str,
|
|
credentials: dict[str, Any],
|
|
language: str | None = None,
|
|
*,
|
|
plugin_unique_identifier: str | None = None,
|
|
) -> list[TTSModelVoice]:
|
|
"""
|
|
Get tts model voices
|
|
"""
|
|
response = self._request_with_plugin_daemon_response_stream(
|
|
method="POST",
|
|
path=f"plugin/{tenant_id}/dispatch/tts/model/voices",
|
|
type_=PluginVoicesResponse,
|
|
data=jsonable_encoder(
|
|
self._dispatch_payload(
|
|
user_id=user_id,
|
|
data={
|
|
"provider": provider,
|
|
"model_type": "tts",
|
|
"model": model,
|
|
"credentials": credentials,
|
|
"language": language,
|
|
},
|
|
)
|
|
),
|
|
headers=plugin_dispatch_headers(plugin_id, plugin_unique_identifier),
|
|
)
|
|
|
|
for resp in response:
|
|
voices: list[TTSModelVoice] = []
|
|
for voice in resp.voices:
|
|
voices.append({"name": voice.name, "value": voice.value})
|
|
|
|
return voices
|
|
|
|
return []
|
|
|
|
def invoke_speech_to_text(
|
|
self,
|
|
tenant_id: str,
|
|
user_id: str | None,
|
|
plugin_id: str,
|
|
provider: str,
|
|
model: str,
|
|
credentials: dict[str, Any],
|
|
file: IO[bytes],
|
|
*,
|
|
plugin_unique_identifier: str | None = None,
|
|
) -> str:
|
|
"""
|
|
Invoke speech to text
|
|
"""
|
|
response = self._request_with_plugin_daemon_response_stream(
|
|
method="POST",
|
|
path=f"plugin/{tenant_id}/dispatch/speech2text/invoke",
|
|
type_=PluginStringResultResponse,
|
|
data=jsonable_encoder(
|
|
self._dispatch_payload(
|
|
user_id=user_id,
|
|
data={
|
|
"provider": provider,
|
|
"model_type": "speech2text",
|
|
"model": model,
|
|
"credentials": credentials,
|
|
"file": binascii.hexlify(file.read()).decode(),
|
|
},
|
|
)
|
|
),
|
|
headers=plugin_dispatch_headers(plugin_id, plugin_unique_identifier),
|
|
)
|
|
|
|
for resp in response:
|
|
return resp.result
|
|
|
|
raise ValueError("Failed to invoke speech to text")
|
|
|
|
def invoke_moderation(
|
|
self,
|
|
tenant_id: str,
|
|
user_id: str | None,
|
|
plugin_id: str,
|
|
provider: str,
|
|
model: str,
|
|
credentials: dict[str, Any],
|
|
text: str,
|
|
*,
|
|
plugin_unique_identifier: str | None = None,
|
|
) -> bool:
|
|
"""
|
|
Invoke moderation
|
|
"""
|
|
response = self._request_with_plugin_daemon_response_stream(
|
|
method="POST",
|
|
path=f"plugin/{tenant_id}/dispatch/moderation/invoke",
|
|
type_=PluginBasicBooleanResponse,
|
|
data=jsonable_encoder(
|
|
self._dispatch_payload(
|
|
user_id=user_id,
|
|
data={
|
|
"provider": provider,
|
|
"model_type": "moderation",
|
|
"model": model,
|
|
"credentials": credentials,
|
|
"text": text,
|
|
},
|
|
)
|
|
),
|
|
headers=plugin_dispatch_headers(plugin_id, plugin_unique_identifier),
|
|
)
|
|
|
|
for resp in response:
|
|
return resp.result
|
|
|
|
raise ValueError("Failed to invoke moderation")
|