This is page 16 of 16. Use http://codebase.md/fujitsu-ai/mcp-server-for-mas-developments?page={x} to view the full context.
# Directory Structure
```
├── .gitattributes
├── .gitignore
├── agents
│ ├── __init__.py
│ ├── AgentInterface
│ │ ├── __init__.py
│ │ ├── Python
│ │ │ ├── __init__.py
│ │ │ ├── agent.py
│ │ │ ├── color.py
│ │ │ ├── config.py
│ │ │ ├── language.py
│ │ │ ├── local_file_handler.py
│ │ │ └── network.py
│ │ └── requirements.txt
│ ├── AgentMonitoring
│ │ ├── ChatBot-Agent Dashboard Example - Grafana.json
│ │ ├── images
│ │ │ ├── Grafana.png
│ │ │ └── Prometheus.png
│ │ ├── IoT-Agent Dashboard Example - Grafana.json
│ │ ├── OpenAI compatible API - Agent Dashboard Example - Grafana.json
│ │ ├── prometheus Example.yml
│ │ └── README.md
│ ├── ChatBotAgent
│ │ ├── __init__.py
│ │ ├── config.json.example
│ │ ├── html
│ │ │ ├── favicon.ico
│ │ │ ├── index_de.html
│ │ │ ├── index.html
│ │ │ ├── Logo_light.svg
│ │ │ ├── start_http_server.ps1
│ │ │ └── start_http_server.sh
│ │ ├── Python
│ │ │ ├── __init__.py
│ │ │ └── chatbot_agent.py
│ │ ├── README.md
│ │ └── requirements.txt
│ ├── IoTAgent
│ │ ├── config_example.json
│ │ ├── Python
│ │ │ ├── iot_mqtt_agent.py
│ │ │ └── language.py
│ │ ├── README.md
│ │ └── requirements.txt
│ ├── MCP-Client
│ │ ├── __init__.py
│ │ ├── .env.example
│ │ ├── Python
│ │ │ ├── __init__.py
│ │ │ ├── chat_handler.py
│ │ │ ├── config.py
│ │ │ ├── environment.py
│ │ │ ├── llm_client.py
│ │ │ ├── mcp_client_sse.py
│ │ │ ├── mcp_client.py
│ │ │ ├── messages
│ │ │ │ ├── __init__.py
│ │ │ │ ├── message_types
│ │ │ │ │ ├── __init__.py
│ │ │ │ │ ├── incrementing_id_message.py
│ │ │ │ │ ├── initialize_message.py
│ │ │ │ │ ├── json_rpc_message.py
│ │ │ │ │ ├── ping_message.py
│ │ │ │ │ ├── prompts_messages.py
│ │ │ │ │ ├── prompts_models.py
│ │ │ │ │ ├── resources_messages.py
│ │ │ │ │ └── tools_messages.py
│ │ │ │ ├── send_call_tool.py
│ │ │ │ ├── send_initialize_message.py
│ │ │ │ ├── send_message.py
│ │ │ │ ├── send_ping.py
│ │ │ │ ├── send_prompts.py
│ │ │ │ ├── send_resources.py
│ │ │ │ └── send_tools_list.py
│ │ │ ├── system_prompt_generator.py
│ │ │ ├── tools_handler.py
│ │ │ └── transport
│ │ │ ├── __init__.py
│ │ │ └── stdio
│ │ │ ├── __init__.py
│ │ │ ├── stdio_client.py
│ │ │ ├── stdio_server_parameters.py
│ │ │ └── stdio_server_shutdown.py
│ │ ├── README.md
│ │ ├── requirements.txt
│ │ └── server_config.json
│ ├── OpenAI_Compatible_API_Agent
│ │ ├── __init__.py
│ │ ├── docker-compose.yml
│ │ ├── Dockerfile
│ │ ├── pgpt_openai_api_mcp.json.example
│ │ ├── pgpt_openai_api_proxy.json.example
│ │ ├── Python
│ │ │ ├── __init__.py
│ │ │ ├── client_tests
│ │ │ │ ├── __init__.py
│ │ │ │ ├── openai_test_client_structured.py
│ │ │ │ ├── openai_test_client_tools.py
│ │ │ │ ├── openai_test_client.py
│ │ │ │ ├── vllm_client_multimodal.py
│ │ │ │ ├── vllm_client.py
│ │ │ │ ├── vllm_structured.py
│ │ │ │ └── vllm_structured2.py
│ │ │ ├── generate_api_key.py
│ │ │ ├── open_ai_helper.py
│ │ │ ├── openai_compatible_api.py
│ │ │ ├── openai_mcp_api.py
│ │ │ ├── pgpt_api.py
│ │ │ ├── privategpt_api.py
│ │ │ └── vllmproxy.py
│ │ ├── README.md
│ │ └── requirements.txt
│ └── SourceManagerAgent
│ ├── __init__.py
│ ├── config.json.example
│ └── Python
│ ├── __init__.py
│ ├── file_tools
│ │ └── loader_factory.py
│ ├── file_upload_agent.py
│ └── local_db.py
├── clients
│ ├── __init__.py
│ ├── C# .Net
│ │ ├── 1.0 mcp_login
│ │ │ ├── bin
│ │ │ │ └── Debug
│ │ │ │ └── net9.0
│ │ │ │ ├── mcp_login.deps.json
│ │ │ │ ├── mcp_login.dll
│ │ │ │ ├── mcp_login.exe
│ │ │ │ ├── mcp_login.pdb
│ │ │ │ ├── mcp_login.runtimeconfig.json
│ │ │ │ └── Newtonsoft.Json.dll
│ │ │ ├── mcp_login.csproj
│ │ │ ├── obj
│ │ │ │ ├── Debug
│ │ │ │ │ └── net9.0
│ │ │ │ │ ├── .NETCoreApp,Version=v9.0.AssemblyAttributes.cs
│ │ │ │ │ ├── apphost.exe
│ │ │ │ │ ├── mcp_login.AssemblyInfo.cs
│ │ │ │ │ ├── mcp_login.AssemblyInfoInputs.cache
│ │ │ │ │ ├── mcp_login.assets.cache
│ │ │ │ │ ├── mcp_login.csproj.AssemblyReference.cache
│ │ │ │ │ ├── mcp_login.csproj.CoreCompileInputs.cache
│ │ │ │ │ ├── mcp_login.csproj.FileListAbsolute.txt
│ │ │ │ │ ├── mcp_login.csproj.Up2Date
│ │ │ │ │ ├── mcp_login.dll
│ │ │ │ │ ├── mcp_login.GeneratedMSBuildEditorConfig.editorconfig
│ │ │ │ │ ├── mcp_login.genruntimeconfig.cache
│ │ │ │ │ ├── mcp_login.GlobalUsings.g.cs
│ │ │ │ │ ├── mcp_login.pdb
│ │ │ │ │ ├── ref
│ │ │ │ │ │ └── mcp_login.dll
│ │ │ │ │ └── refint
│ │ │ │ │ └── mcp_login.dll
│ │ │ │ ├── mcp_login.csproj.nuget.dgspec.json
│ │ │ │ ├── mcp_login.csproj.nuget.g.props
│ │ │ │ ├── mcp_login.csproj.nuget.g.targets
│ │ │ │ ├── project.assets.json
│ │ │ │ └── project.nuget.cache
│ │ │ └── Program.cs
│ │ ├── 1.1 mcp_logout
│ │ │ ├── bin
│ │ │ │ └── Debug
│ │ │ │ └── net9.0
│ │ │ │ ├── mcp_logout.deps.json
│ │ │ │ ├── mcp_logout.dll
│ │ │ │ ├── mcp_logout.exe
│ │ │ │ ├── mcp_logout.pdb
│ │ │ │ ├── mcp_logout.runtimeconfig.json
│ │ │ │ └── Newtonsoft.Json.dll
│ │ │ ├── mcp_logout.csproj
│ │ │ ├── obj
│ │ │ │ ├── Debug
│ │ │ │ │ └── net9.0
│ │ │ │ │ ├── .NETCoreApp,Version=v9.0.AssemblyAttributes.cs
│ │ │ │ │ ├── apphost.exe
│ │ │ │ │ ├── mcp_logout.AssemblyInfo.cs
│ │ │ │ │ ├── mcp_logout.AssemblyInfoInputs.cache
│ │ │ │ │ ├── mcp_logout.assets.cache
│ │ │ │ │ ├── mcp_logout.csproj.AssemblyReference.cache
│ │ │ │ │ ├── mcp_logout.csproj.CoreCompileInputs.cache
│ │ │ │ │ ├── mcp_logout.csproj.FileListAbsolute.txt
│ │ │ │ │ ├── mcp_logout.csproj.Up2Date
│ │ │ │ │ ├── mcp_logout.dll
│ │ │ │ │ ├── mcp_logout.GeneratedMSBuildEditorConfig.editorconfig
│ │ │ │ │ ├── mcp_logout.genruntimeconfig.cache
│ │ │ │ │ ├── mcp_logout.GlobalUsings.g.cs
│ │ │ │ │ ├── mcp_logout.pdb
│ │ │ │ │ ├── ref
│ │ │ │ │ │ └── mcp_logout.dll
│ │ │ │ │ └── refint
│ │ │ │ │ └── mcp_logout.dll
│ │ │ │ ├── mcp_logout.csproj.nuget.dgspec.json
│ │ │ │ ├── mcp_logout.csproj.nuget.g.props
│ │ │ │ ├── mcp_logout.csproj.nuget.g.targets
│ │ │ │ ├── project.assets.json
│ │ │ │ └── project.nuget.cache
│ │ │ └── Program.cs
│ │ ├── 2.0 mcp_chat
│ │ │ ├── bin
│ │ │ │ └── Debug
│ │ │ │ └── net9.0
│ │ │ │ ├── mcp_chat.deps.json
│ │ │ │ ├── mcp_chat.dll
│ │ │ │ ├── mcp_chat.exe
│ │ │ │ ├── mcp_chat.pdb
│ │ │ │ ├── mcp_chat.runtimeconfig.json
│ │ │ │ └── Newtonsoft.Json.dll
│ │ │ ├── mcp_chat.csproj
│ │ │ ├── obj
│ │ │ │ ├── Debug
│ │ │ │ │ └── net9.0
│ │ │ │ │ ├── .NETCoreApp,Version=v9.0.AssemblyAttributes.cs
│ │ │ │ │ ├── apphost.exe
│ │ │ │ │ ├── mcp_chat.AssemblyInfo.cs
│ │ │ │ │ ├── mcp_chat.AssemblyInfoInputs.cache
│ │ │ │ │ ├── mcp_chat.assets.cache
│ │ │ │ │ ├── mcp_chat.csproj.AssemblyReference.cache
│ │ │ │ │ ├── mcp_chat.csproj.CoreCompileInputs.cache
│ │ │ │ │ ├── mcp_chat.csproj.FileListAbsolute.txt
│ │ │ │ │ ├── mcp_chat.csproj.Up2Date
│ │ │ │ │ ├── mcp_chat.dll
│ │ │ │ │ ├── mcp_chat.GeneratedMSBuildEditorConfig.editorconfig
│ │ │ │ │ ├── mcp_chat.genruntimeconfig.cache
│ │ │ │ │ ├── mcp_chat.GlobalUsings.g.cs
│ │ │ │ │ ├── mcp_chat.pdb
│ │ │ │ │ ├── ref
│ │ │ │ │ │ └── mcp_chat.dll
│ │ │ │ │ └── refint
│ │ │ │ │ └── mcp_chat.dll
│ │ │ │ ├── mcp_chat.csproj.nuget.dgspec.json
│ │ │ │ ├── mcp_chat.csproj.nuget.g.props
│ │ │ │ ├── mcp_chat.csproj.nuget.g.targets
│ │ │ │ ├── project.assets.json
│ │ │ │ └── project.nuget.cache
│ │ │ └── Program.cs
│ │ ├── 2.1 mcp_continue_chat
│ │ │ ├── bin
│ │ │ │ └── Debug
│ │ │ │ └── net9.0
│ │ │ │ ├── mcp_continue_chat.deps.json
│ │ │ │ ├── mcp_continue_chat.dll
│ │ │ │ ├── mcp_continue_chat.exe
│ │ │ │ ├── mcp_continue_chat.pdb
│ │ │ │ ├── mcp_continue_chat.runtimeconfig.json
│ │ │ │ └── Newtonsoft.Json.dll
│ │ │ ├── mcp_continue_chat.csproj
│ │ │ ├── obj
│ │ │ │ ├── Debug
│ │ │ │ │ └── net9.0
│ │ │ │ │ ├── .NETCoreApp,Version=v9.0.AssemblyAttributes.cs
│ │ │ │ │ ├── apphost.exe
│ │ │ │ │ ├── mcp_cont.EF178231.Up2Date
│ │ │ │ │ ├── mcp_continue_chat.AssemblyInfo.cs
│ │ │ │ │ ├── mcp_continue_chat.AssemblyInfoInputs.cache
│ │ │ │ │ ├── mcp_continue_chat.assets.cache
│ │ │ │ │ ├── mcp_continue_chat.csproj.AssemblyReference.cache
│ │ │ │ │ ├── mcp_continue_chat.csproj.CoreCompileInputs.cache
│ │ │ │ │ ├── mcp_continue_chat.csproj.FileListAbsolute.txt
│ │ │ │ │ ├── mcp_continue_chat.dll
│ │ │ │ │ ├── mcp_continue_chat.GeneratedMSBuildEditorConfig.editorconfig
│ │ │ │ │ ├── mcp_continue_chat.genruntimeconfig.cache
│ │ │ │ │ ├── mcp_continue_chat.GlobalUsings.g.cs
│ │ │ │ │ ├── mcp_continue_chat.pdb
│ │ │ │ │ ├── ref
│ │ │ │ │ │ └── mcp_continue_chat.dll
│ │ │ │ │ └── refint
│ │ │ │ │ └── mcp_continue_chat.dll
│ │ │ │ ├── mcp_continue_chat.csproj.nuget.dgspec.json
│ │ │ │ ├── mcp_continue_chat.csproj.nuget.g.props
│ │ │ │ ├── mcp_continue_chat.csproj.nuget.g.targets
│ │ │ │ ├── project.assets.json
│ │ │ │ └── project.nuget.cache
│ │ │ └── Program.cs
│ │ ├── 2.2 mcp_get_chat_info
│ │ │ ├── bin
│ │ │ │ └── Debug
│ │ │ │ └── net9.0
│ │ │ │ ├── mcp_get_chat_info.deps.json
│ │ │ │ ├── mcp_get_chat_info.dll
│ │ │ │ ├── mcp_get_chat_info.exe
│ │ │ │ ├── mcp_get_chat_info.pdb
│ │ │ │ ├── mcp_get_chat_info.runtimeconfig.json
│ │ │ │ └── Newtonsoft.Json.dll
│ │ │ ├── Dokumente - Verknüpfung.lnk
│ │ │ ├── mcp_get_chat_info.csproj
│ │ │ ├── obj
│ │ │ │ ├── Debug
│ │ │ │ │ └── net9.0
│ │ │ │ │ ├── .NETCoreApp,Version=v9.0.AssemblyAttributes.cs
│ │ │ │ │ ├── apphost.exe
│ │ │ │ │ ├── mcp_get_.DFF47B4E.Up2Date
│ │ │ │ │ ├── mcp_get_chat_info.AssemblyInfo.cs
│ │ │ │ │ ├── mcp_get_chat_info.AssemblyInfoInputs.cache
│ │ │ │ │ ├── mcp_get_chat_info.assets.cache
│ │ │ │ │ ├── mcp_get_chat_info.csproj.AssemblyReference.cache
│ │ │ │ │ ├── mcp_get_chat_info.csproj.CoreCompileInputs.cache
│ │ │ │ │ ├── mcp_get_chat_info.csproj.FileListAbsolute.txt
│ │ │ │ │ ├── mcp_get_chat_info.dll
│ │ │ │ │ ├── mcp_get_chat_info.GeneratedMSBuildEditorConfig.editorconfig
│ │ │ │ │ ├── mcp_get_chat_info.genruntimeconfig.cache
│ │ │ │ │ ├── mcp_get_chat_info.GlobalUsings.g.cs
│ │ │ │ │ ├── mcp_get_chat_info.pdb
│ │ │ │ │ ├── ref
│ │ │ │ │ │ └── mcp_get_chat_info.dll
│ │ │ │ │ └── refint
│ │ │ │ │ └── mcp_get_chat_info.dll
│ │ │ │ ├── mcp_get_chat_info.csproj.nuget.dgspec.json
│ │ │ │ ├── mcp_get_chat_info.csproj.nuget.g.props
│ │ │ │ ├── mcp_get_chat_info.csproj.nuget.g.targets
│ │ │ │ ├── project.assets.json
│ │ │ │ └── project.nuget.cache
│ │ │ └── Program.cs
│ │ ├── 3.0 mcp_create_source
│ │ │ ├── bin
│ │ │ │ └── Debug
│ │ │ │ └── net9.0
│ │ │ │ ├── mcp_create_source.deps.json
│ │ │ │ ├── mcp_create_source.dll
│ │ │ │ ├── mcp_create_source.exe
│ │ │ │ ├── mcp_create_source.pdb
│ │ │ │ ├── mcp_create_source.runtimeconfig.json
│ │ │ │ └── Newtonsoft.Json.dll
│ │ │ ├── mcp_create_source.csproj
│ │ │ ├── obj
│ │ │ │ ├── Debug
│ │ │ │ │ └── net9.0
│ │ │ │ │ ├── .NETCoreApp,Version=v9.0.AssemblyAttributes.cs
│ │ │ │ │ ├── apphost.exe
│ │ │ │ │ ├── mcp_crea.CB4ED912.Up2Date
│ │ │ │ │ ├── mcp_create_source.AssemblyInfo.cs
│ │ │ │ │ ├── mcp_create_source.AssemblyInfoInputs.cache
│ │ │ │ │ ├── mcp_create_source.assets.cache
│ │ │ │ │ ├── mcp_create_source.csproj.AssemblyReference.cache
│ │ │ │ │ ├── mcp_create_source.csproj.CoreCompileInputs.cache
│ │ │ │ │ ├── mcp_create_source.csproj.FileListAbsolute.txt
│ │ │ │ │ ├── mcp_create_source.dll
│ │ │ │ │ ├── mcp_create_source.GeneratedMSBuildEditorConfig.editorconfig
│ │ │ │ │ ├── mcp_create_source.genruntimeconfig.cache
│ │ │ │ │ ├── mcp_create_source.GlobalUsings.g.cs
│ │ │ │ │ ├── mcp_create_source.pdb
│ │ │ │ │ ├── ref
│ │ │ │ │ │ └── mcp_create_source.dll
│ │ │ │ │ └── refint
│ │ │ │ │ └── mcp_create_source.dll
│ │ │ │ ├── mcp_create_source.csproj.nuget.dgspec.json
│ │ │ │ ├── mcp_create_source.csproj.nuget.g.props
│ │ │ │ ├── mcp_create_source.csproj.nuget.g.targets
│ │ │ │ ├── project.assets.json
│ │ │ │ └── project.nuget.cache
│ │ │ └── Program.cs
│ │ ├── 3.1 mcp_get_source
│ │ │ ├── bin
│ │ │ │ └── Debug
│ │ │ │ └── net9.0
│ │ │ │ ├── mcp_get_source.deps.json
│ │ │ │ ├── mcp_get_source.dll
│ │ │ │ ├── mcp_get_source.exe
│ │ │ │ ├── mcp_get_source.pdb
│ │ │ │ ├── mcp_get_source.runtimeconfig.json
│ │ │ │ └── Newtonsoft.Json.dll
│ │ │ ├── mcp_get_source.csproj
│ │ │ ├── obj
│ │ │ │ ├── Debug
│ │ │ │ │ └── net9.0
│ │ │ │ │ ├── .NETCoreApp,Version=v9.0.AssemblyAttributes.cs
│ │ │ │ │ ├── apphost.exe
│ │ │ │ │ ├── mcp_get_.4E61956F.Up2Date
│ │ │ │ │ ├── mcp_get_source.AssemblyInfo.cs
│ │ │ │ │ ├── mcp_get_source.AssemblyInfoInputs.cache
│ │ │ │ │ ├── mcp_get_source.assets.cache
│ │ │ │ │ ├── mcp_get_source.csproj.AssemblyReference.cache
│ │ │ │ │ ├── mcp_get_source.csproj.CoreCompileInputs.cache
│ │ │ │ │ ├── mcp_get_source.csproj.FileListAbsolute.txt
│ │ │ │ │ ├── mcp_get_source.dll
│ │ │ │ │ ├── mcp_get_source.GeneratedMSBuildEditorConfig.editorconfig
│ │ │ │ │ ├── mcp_get_source.genruntimeconfig.cache
│ │ │ │ │ ├── mcp_get_source.GlobalUsings.g.cs
│ │ │ │ │ ├── mcp_get_source.pdb
│ │ │ │ │ ├── ref
│ │ │ │ │ │ └── mcp_get_source.dll
│ │ │ │ │ └── refint
│ │ │ │ │ └── mcp_get_source.dll
│ │ │ │ ├── mcp_get_source.csproj.nuget.dgspec.json
│ │ │ │ ├── mcp_get_source.csproj.nuget.g.props
│ │ │ │ ├── mcp_get_source.csproj.nuget.g.targets
│ │ │ │ ├── project.assets.json
│ │ │ │ └── project.nuget.cache
│ │ │ └── Program.cs
│ │ ├── 3.2 mcp_list_sources
│ │ │ ├── bin
│ │ │ │ └── Debug
│ │ │ │ └── net9.0
│ │ │ │ ├── mcp_list_sources.deps.json
│ │ │ │ ├── mcp_list_sources.dll
│ │ │ │ ├── mcp_list_sources.exe
│ │ │ │ ├── mcp_list_sources.pdb
│ │ │ │ ├── mcp_list_sources.runtimeconfig.json
│ │ │ │ └── Newtonsoft.Json.dll
│ │ │ ├── mcp_list_sources.csproj
│ │ │ ├── obj
│ │ │ │ ├── Debug
│ │ │ │ │ └── net9.0
│ │ │ │ │ ├── .NETCoreApp,Version=v9.0.AssemblyAttributes.cs
│ │ │ │ │ ├── apphost.exe
│ │ │ │ │ ├── mcp_list_sources.AssemblyInfo.cs
│ │ │ │ │ ├── mcp_list_sources.AssemblyInfoInputs.cache
│ │ │ │ │ ├── mcp_list_sources.assets.cache
│ │ │ │ │ ├── mcp_list_sources.csproj.AssemblyReference.cache
│ │ │ │ │ ├── mcp_list_sources.csproj.CoreCompileInputs.cache
│ │ │ │ │ ├── mcp_list_sources.csproj.FileListAbsolute.txt
│ │ │ │ │ ├── mcp_list_sources.dll
│ │ │ │ │ ├── mcp_list_sources.GeneratedMSBuildEditorConfig.editorconfig
│ │ │ │ │ ├── mcp_list_sources.genruntimeconfig.cache
│ │ │ │ │ ├── mcp_list_sources.GlobalUsings.g.cs
│ │ │ │ │ ├── mcp_list_sources.pdb
│ │ │ │ │ ├── mcp_list.A720E197.Up2Date
│ │ │ │ │ ├── ref
│ │ │ │ │ │ └── mcp_list_sources.dll
│ │ │ │ │ └── refint
│ │ │ │ │ └── mcp_list_sources.dll
│ │ │ │ ├── mcp_list_sources.csproj.nuget.dgspec.json
│ │ │ │ ├── mcp_list_sources.csproj.nuget.g.props
│ │ │ │ ├── mcp_list_sources.csproj.nuget.g.targets
│ │ │ │ ├── project.assets.json
│ │ │ │ └── project.nuget.cache
│ │ │ └── Program.cs
│ │ ├── 3.3 mcp_edit_source
│ │ │ ├── bin
│ │ │ │ └── Debug
│ │ │ │ └── net9.0
│ │ │ │ ├── mcp_edit_source.deps.json
│ │ │ │ ├── mcp_edit_source.dll
│ │ │ │ ├── mcp_edit_source.exe
│ │ │ │ ├── mcp_edit_source.pdb
│ │ │ │ ├── mcp_edit_source.runtimeconfig.json
│ │ │ │ └── Newtonsoft.Json.dll
│ │ │ ├── mcp_edit_source.csproj
│ │ │ ├── obj
│ │ │ │ ├── Debug
│ │ │ │ │ └── net9.0
│ │ │ │ │ ├── .NETCoreApp,Version=v9.0.AssemblyAttributes.cs
│ │ │ │ │ ├── apphost.exe
│ │ │ │ │ ├── mcp_edit_source.AssemblyInfo.cs
│ │ │ │ │ ├── mcp_edit_source.AssemblyInfoInputs.cache
│ │ │ │ │ ├── mcp_edit_source.assets.cache
│ │ │ │ │ ├── mcp_edit_source.csproj.AssemblyReference.cache
│ │ │ │ │ ├── mcp_edit_source.csproj.CoreCompileInputs.cache
│ │ │ │ │ ├── mcp_edit_source.csproj.FileListAbsolute.txt
│ │ │ │ │ ├── mcp_edit_source.dll
│ │ │ │ │ ├── mcp_edit_source.GeneratedMSBuildEditorConfig.editorconfig
│ │ │ │ │ ├── mcp_edit_source.genruntimeconfig.cache
│ │ │ │ │ ├── mcp_edit_source.GlobalUsings.g.cs
│ │ │ │ │ ├── mcp_edit_source.pdb
│ │ │ │ │ ├── mcp_edit.7303BE3B.Up2Date
│ │ │ │ │ ├── ref
│ │ │ │ │ │ └── mcp_edit_source.dll
│ │ │ │ │ └── refint
│ │ │ │ │ └── mcp_edit_source.dll
│ │ │ │ ├── mcp_edit_source.csproj.nuget.dgspec.json
│ │ │ │ ├── mcp_edit_source.csproj.nuget.g.props
│ │ │ │ ├── mcp_edit_source.csproj.nuget.g.targets
│ │ │ │ ├── project.assets.json
│ │ │ │ └── project.nuget.cache
│ │ │ └── Program.cs
│ │ ├── 3.4 mcp_delete_source
│ │ │ ├── bin
│ │ │ │ └── Debug
│ │ │ │ └── net9.0
│ │ │ │ ├── mcp_delete_source.deps.json
│ │ │ │ ├── mcp_delete_source.dll
│ │ │ │ ├── mcp_delete_source.exe
│ │ │ │ ├── mcp_delete_source.pdb
│ │ │ │ ├── mcp_delete_source.runtimeconfig.json
│ │ │ │ └── Newtonsoft.Json.dll
│ │ │ ├── mcp_delete_source.csproj
│ │ │ ├── obj
│ │ │ │ ├── Debug
│ │ │ │ │ └── net9.0
│ │ │ │ │ ├── .NETCoreApp,Version=v9.0.AssemblyAttributes.cs
│ │ │ │ │ ├── apphost.exe
│ │ │ │ │ ├── mcp_dele.67DD13F9.Up2Date
│ │ │ │ │ ├── mcp_delete_source.AssemblyInfo.cs
│ │ │ │ │ ├── mcp_delete_source.AssemblyInfoInputs.cache
│ │ │ │ │ ├── mcp_delete_source.assets.cache
│ │ │ │ │ ├── mcp_delete_source.csproj.AssemblyReference.cache
│ │ │ │ │ ├── mcp_delete_source.csproj.CoreCompileInputs.cache
│ │ │ │ │ ├── mcp_delete_source.csproj.FileListAbsolute.txt
│ │ │ │ │ ├── mcp_delete_source.dll
│ │ │ │ │ ├── mcp_delete_source.GeneratedMSBuildEditorConfig.editorconfig
│ │ │ │ │ ├── mcp_delete_source.genruntimeconfig.cache
│ │ │ │ │ ├── mcp_delete_source.GlobalUsings.g.cs
│ │ │ │ │ ├── mcp_delete_source.pdb
│ │ │ │ │ ├── ref
│ │ │ │ │ │ └── mcp_delete_source.dll
│ │ │ │ │ └── refint
│ │ │ │ │ └── mcp_delete_source.dll
│ │ │ │ ├── mcp_delete_source.csproj.nuget.dgspec.json
│ │ │ │ ├── mcp_delete_source.csproj.nuget.g.props
│ │ │ │ ├── mcp_delete_source.csproj.nuget.g.targets
│ │ │ │ ├── project.assets.json
│ │ │ │ └── project.nuget.cache
│ │ │ └── Program.cs
│ │ ├── 4.0 mcp_list_groups
│ │ │ ├── bin
│ │ │ │ └── Debug
│ │ │ │ └── net9.0
│ │ │ │ ├── mcp_list_groups.deps.json
│ │ │ │ ├── mcp_list_groups.dll
│ │ │ │ ├── mcp_list_groups.exe
│ │ │ │ ├── mcp_list_groups.pdb
│ │ │ │ ├── mcp_list_groups.runtimeconfig.json
│ │ │ │ └── Newtonsoft.Json.dll
│ │ │ ├── mcp_list_groups.csproj
│ │ │ ├── obj
│ │ │ │ ├── Debug
│ │ │ │ │ └── net9.0
│ │ │ │ │ ├── .NETCoreApp,Version=v9.0.AssemblyAttributes.cs
│ │ │ │ │ ├── apphost.exe
│ │ │ │ │ ├── mcp_list_groups.AssemblyInfo.cs
│ │ │ │ │ ├── mcp_list_groups.AssemblyInfoInputs.cache
│ │ │ │ │ ├── mcp_list_groups.assets.cache
│ │ │ │ │ ├── mcp_list_groups.csproj.AssemblyReference.cache
│ │ │ │ │ ├── mcp_list_groups.csproj.CoreCompileInputs.cache
│ │ │ │ │ ├── mcp_list_groups.csproj.FileListAbsolute.txt
│ │ │ │ │ ├── mcp_list_groups.dll
│ │ │ │ │ ├── mcp_list_groups.GeneratedMSBuildEditorConfig.editorconfig
│ │ │ │ │ ├── mcp_list_groups.genruntimeconfig.cache
│ │ │ │ │ ├── mcp_list_groups.GlobalUsings.g.cs
│ │ │ │ │ ├── mcp_list_groups.pdb
│ │ │ │ │ ├── mcp_list.EBD5E0D2.Up2Date
│ │ │ │ │ ├── ref
│ │ │ │ │ │ └── mcp_list_groups.dll
│ │ │ │ │ └── refint
│ │ │ │ │ └── mcp_list_groups.dll
│ │ │ │ ├── mcp_list_groups.csproj.nuget.dgspec.json
│ │ │ │ ├── mcp_list_groups.csproj.nuget.g.props
│ │ │ │ ├── mcp_list_groups.csproj.nuget.g.targets
│ │ │ │ ├── project.assets.json
│ │ │ │ └── project.nuget.cache
│ │ │ └── Program.cs
│ │ ├── 4.1 mcp_store_group
│ │ │ ├── bin
│ │ │ │ └── Debug
│ │ │ │ └── net9.0
│ │ │ │ ├── mcp_store_group.deps.json
│ │ │ │ ├── mcp_store_group.dll
│ │ │ │ ├── mcp_store_group.exe
│ │ │ │ ├── mcp_store_group.pdb
│ │ │ │ ├── mcp_store_group.runtimeconfig.json
│ │ │ │ └── Newtonsoft.Json.dll
│ │ │ ├── mcp_store_group.csproj
│ │ │ ├── obj
│ │ │ │ ├── Debug
│ │ │ │ │ └── net9.0
│ │ │ │ │ ├── .NETCoreApp,Version=v9.0.AssemblyAttributes.cs
│ │ │ │ │ ├── apphost.exe
│ │ │ │ │ ├── mcp_stor.AFB4AA35.Up2Date
│ │ │ │ │ ├── mcp_store_group.AssemblyInfo.cs
│ │ │ │ │ ├── mcp_store_group.AssemblyInfoInputs.cache
│ │ │ │ │ ├── mcp_store_group.assets.cache
│ │ │ │ │ ├── mcp_store_group.csproj.AssemblyReference.cache
│ │ │ │ │ ├── mcp_store_group.csproj.CoreCompileInputs.cache
│ │ │ │ │ ├── mcp_store_group.csproj.FileListAbsolute.txt
│ │ │ │ │ ├── mcp_store_group.dll
│ │ │ │ │ ├── mcp_store_group.GeneratedMSBuildEditorConfig.editorconfig
│ │ │ │ │ ├── mcp_store_group.genruntimeconfig.cache
│ │ │ │ │ ├── mcp_store_group.GlobalUsings.g.cs
│ │ │ │ │ ├── mcp_store_group.pdb
│ │ │ │ │ ├── ref
│ │ │ │ │ │ └── mcp_store_group.dll
│ │ │ │ │ └── refint
│ │ │ │ │ └── mcp_store_group.dll
│ │ │ │ ├── mcp_store_group.csproj.nuget.dgspec.json
│ │ │ │ ├── mcp_store_group.csproj.nuget.g.props
│ │ │ │ ├── mcp_store_group.csproj.nuget.g.targets
│ │ │ │ ├── project.assets.json
│ │ │ │ └── project.nuget.cache
│ │ │ └── Program.cs
│ │ ├── 4.2 mcp_delete_group
│ │ │ ├── bin
│ │ │ │ └── Debug
│ │ │ │ └── net9.0
│ │ │ │ ├── mcp_delete_group.deps.json
│ │ │ │ ├── mcp_delete_group.dll
│ │ │ │ ├── mcp_delete_group.exe
│ │ │ │ ├── mcp_delete_group.pdb
│ │ │ │ ├── mcp_delete_group.runtimeconfig.json
│ │ │ │ └── Newtonsoft.Json.dll
│ │ │ ├── mcp_delete_group.csproj
│ │ │ ├── obj
│ │ │ │ ├── Debug
│ │ │ │ │ └── net9.0
│ │ │ │ │ ├── .NETCoreApp,Version=v9.0.AssemblyAttributes.cs
│ │ │ │ │ ├── apphost.exe
│ │ │ │ │ ├── mcp_dele.FE1C6298.Up2Date
│ │ │ │ │ ├── mcp_delete_group.AssemblyInfo.cs
│ │ │ │ │ ├── mcp_delete_group.AssemblyInfoInputs.cache
│ │ │ │ │ ├── mcp_delete_group.assets.cache
│ │ │ │ │ ├── mcp_delete_group.csproj.AssemblyReference.cache
│ │ │ │ │ ├── mcp_delete_group.csproj.CoreCompileInputs.cache
│ │ │ │ │ ├── mcp_delete_group.csproj.FileListAbsolute.txt
│ │ │ │ │ ├── mcp_delete_group.dll
│ │ │ │ │ ├── mcp_delete_group.GeneratedMSBuildEditorConfig.editorconfig
│ │ │ │ │ ├── mcp_delete_group.genruntimeconfig.cache
│ │ │ │ │ ├── mcp_delete_group.GlobalUsings.g.cs
│ │ │ │ │ ├── mcp_delete_group.pdb
│ │ │ │ │ ├── ref
│ │ │ │ │ │ └── mcp_delete_group.dll
│ │ │ │ │ └── refint
│ │ │ │ │ └── mcp_delete_group.dll
│ │ │ │ ├── mcp_delete_group.csproj.nuget.dgspec.json
│ │ │ │ ├── mcp_delete_group.csproj.nuget.g.props
│ │ │ │ ├── mcp_delete_group.csproj.nuget.g.targets
│ │ │ │ ├── project.assets.json
│ │ │ │ └── project.nuget.cache
│ │ │ └── Program.cs
│ │ ├── 5.0 mcp_store_user
│ │ │ ├── bin
│ │ │ │ └── Debug
│ │ │ │ └── net9.0
│ │ │ │ ├── mcp_store_user.deps.json
│ │ │ │ ├── mcp_store_user.dll
│ │ │ │ ├── mcp_store_user.exe
│ │ │ │ ├── mcp_store_user.pdb
│ │ │ │ ├── mcp_store_user.runtimeconfig.json
│ │ │ │ └── Newtonsoft.Json.dll
│ │ │ ├── mcp_store_user.csproj
│ │ │ ├── obj
│ │ │ │ ├── Debug
│ │ │ │ │ └── net9.0
│ │ │ │ │ ├── .NETCoreApp,Version=v9.0.AssemblyAttributes.cs
│ │ │ │ │ ├── apphost.exe
│ │ │ │ │ ├── mcp_stor.6C0F0C8A.Up2Date
│ │ │ │ │ ├── mcp_store_user.AssemblyInfo.cs
│ │ │ │ │ ├── mcp_store_user.AssemblyInfoInputs.cache
│ │ │ │ │ ├── mcp_store_user.assets.cache
│ │ │ │ │ ├── mcp_store_user.csproj.AssemblyReference.cache
│ │ │ │ │ ├── mcp_store_user.csproj.CoreCompileInputs.cache
│ │ │ │ │ ├── mcp_store_user.csproj.FileListAbsolute.txt
│ │ │ │ │ ├── mcp_store_user.dll
│ │ │ │ │ ├── mcp_store_user.GeneratedMSBuildEditorConfig.editorconfig
│ │ │ │ │ ├── mcp_store_user.genruntimeconfig.cache
│ │ │ │ │ ├── mcp_store_user.GlobalUsings.g.cs
│ │ │ │ │ ├── mcp_store_user.pdb
│ │ │ │ │ ├── ref
│ │ │ │ │ │ └── mcp_store_user.dll
│ │ │ │ │ └── refint
│ │ │ │ │ └── mcp_store_user.dll
│ │ │ │ ├── mcp_store_user.csproj.nuget.dgspec.json
│ │ │ │ ├── mcp_store_user.csproj.nuget.g.props
│ │ │ │ ├── mcp_store_user.csproj.nuget.g.targets
│ │ │ │ ├── project.assets.json
│ │ │ │ └── project.nuget.cache
│ │ │ └── Program.cs
│ │ ├── 5.1 mcp_edit_user
│ │ │ ├── bin
│ │ │ │ └── Debug
│ │ │ │ └── net9.0
│ │ │ │ ├── mcp_edit_user.deps.json
│ │ │ │ ├── mcp_edit_user.dll
│ │ │ │ ├── mcp_edit_user.exe
│ │ │ │ ├── mcp_edit_user.pdb
│ │ │ │ ├── mcp_edit_user.runtimeconfig.json
│ │ │ │ └── Newtonsoft.Json.dll
│ │ │ ├── mcp_edit_user.csproj
│ │ │ ├── obj
│ │ │ │ ├── Debug
│ │ │ │ │ └── net9.0
│ │ │ │ │ ├── .NETCoreApp,Version=v9.0.AssemblyAttributes.cs
│ │ │ │ │ ├── apphost.exe
│ │ │ │ │ ├── mcp_edit_user.AssemblyInfo.cs
│ │ │ │ │ ├── mcp_edit_user.AssemblyInfoInputs.cache
│ │ │ │ │ ├── mcp_edit_user.assets.cache
│ │ │ │ │ ├── mcp_edit_user.csproj.AssemblyReference.cache
│ │ │ │ │ ├── mcp_edit_user.csproj.CoreCompileInputs.cache
│ │ │ │ │ ├── mcp_edit_user.csproj.FileListAbsolute.txt
│ │ │ │ │ ├── mcp_edit_user.dll
│ │ │ │ │ ├── mcp_edit_user.GeneratedMSBuildEditorConfig.editorconfig
│ │ │ │ │ ├── mcp_edit_user.genruntimeconfig.cache
│ │ │ │ │ ├── mcp_edit_user.GlobalUsings.g.cs
│ │ │ │ │ ├── mcp_edit_user.pdb
│ │ │ │ │ ├── mcp_edit.94A30270.Up2Date
│ │ │ │ │ ├── ref
│ │ │ │ │ │ └── mcp_edit_user.dll
│ │ │ │ │ └── refint
│ │ │ │ │ └── mcp_edit_user.dll
│ │ │ │ ├── mcp_edit_user.csproj.nuget.dgspec.json
│ │ │ │ ├── mcp_edit_user.csproj.nuget.g.props
│ │ │ │ ├── mcp_edit_user.csproj.nuget.g.targets
│ │ │ │ ├── project.assets.json
│ │ │ │ └── project.nuget.cache
│ │ │ └── Program.cs
│ │ ├── 5.2 mcp_delete_user
│ │ │ ├── bin
│ │ │ │ └── Debug
│ │ │ │ └── net9.0
│ │ │ │ ├── mcp_delete_user.deps.json
│ │ │ │ ├── mcp_delete_user.dll
│ │ │ │ ├── mcp_delete_user.exe
│ │ │ │ ├── mcp_delete_user.pdb
│ │ │ │ ├── mcp_delete_user.runtimeconfig.json
│ │ │ │ └── Newtonsoft.Json.dll
│ │ │ ├── mcp_delete_user.csproj
│ │ │ ├── obj
│ │ │ │ ├── Debug
│ │ │ │ │ └── net9.0
│ │ │ │ │ ├── .NETCoreApp,Version=v9.0.AssemblyAttributes.cs
│ │ │ │ │ ├── apphost.exe
│ │ │ │ │ ├── mcp_dele.CEB7E33D.Up2Date
│ │ │ │ │ ├── mcp_delete_user.AssemblyInfo.cs
│ │ │ │ │ ├── mcp_delete_user.AssemblyInfoInputs.cache
│ │ │ │ │ ├── mcp_delete_user.assets.cache
│ │ │ │ │ ├── mcp_delete_user.csproj.AssemblyReference.cache
│ │ │ │ │ ├── mcp_delete_user.csproj.CoreCompileInputs.cache
│ │ │ │ │ ├── mcp_delete_user.csproj.FileListAbsolute.txt
│ │ │ │ │ ├── mcp_delete_user.dll
│ │ │ │ │ ├── mcp_delete_user.GeneratedMSBuildEditorConfig.editorconfig
│ │ │ │ │ ├── mcp_delete_user.genruntimeconfig.cache
│ │ │ │ │ ├── mcp_delete_user.GlobalUsings.g.cs
│ │ │ │ │ ├── mcp_delete_user.pdb
│ │ │ │ │ ├── ref
│ │ │ │ │ │ └── mcp_delete_user.dll
│ │ │ │ │ └── refint
│ │ │ │ │ └── mcp_delete_user.dll
│ │ │ │ ├── mcp_delete_user.csproj.nuget.dgspec.json
│ │ │ │ ├── mcp_delete_user.csproj.nuget.g.props
│ │ │ │ ├── mcp_delete_user.csproj.nuget.g.targets
│ │ │ │ ├── project.assets.json
│ │ │ │ └── project.nuget.cache
│ │ │ └── Program.cs
│ │ ├── Code Archiv
│ │ │ ├── mcp_chat.cs
│ │ │ ├── mcp_continue_chat.cs
│ │ │ ├── mcp_create_source.cs
│ │ │ ├── mcp_delete_group.cs
│ │ │ ├── mcp_delete_source.cs
│ │ │ ├── mcp_delete_user.cs
│ │ │ ├── mcp_edit_source.cs
│ │ │ ├── mcp_edit_user.cs
│ │ │ ├── mcp_get_chat_info.cs
│ │ │ ├── mcp_get_source.cs
│ │ │ ├── mcp_list_groups.cs
│ │ │ ├── mcp_list_sources.cs
│ │ │ ├── mcp_login.cs
│ │ │ ├── mcp_logout.cs
│ │ │ ├── mcp_store_group.cs
│ │ │ └── mcp_store_user.cs
│ │ └── README.md
│ ├── C++
│ │ ├── .vscode
│ │ │ └── launch.json
│ │ ├── 1.0 mcp_login
│ │ │ ├── MCPLoginClient.cpp
│ │ │ └── Non-TLS version
│ │ │ ├── MCPLoginClient.cpp
│ │ │ └── MCPLoginClient.exe
│ │ ├── 1.1 mcp_logout
│ │ │ ├── MCPLogoutClient.cpp
│ │ │ └── MCPLogoutClient.exe
│ │ ├── 2.0 mcp_chat
│ │ │ ├── MCPChatClient.cpp
│ │ │ └── MCPChatClient.exe
│ │ ├── 2.1 mcp_continue_chat
│ │ │ ├── MCPChatContinuationClient.cpp
│ │ │ └── MCPChatContinuationClient.exe
│ │ ├── 2.2 mcp_get_chat_info
│ │ │ ├── MCPGetChatInfoClient.cpp
│ │ │ └── MCPGetChatInfoClient.exe
│ │ ├── 3.0 mcp_create_source
│ │ │ ├── MCPCreateSourceClient.cpp
│ │ │ └── MCPCreateSourceClient.exe
│ │ ├── 3.1 mcp_get_source
│ │ │ ├── MCPGetSourceClient.cpp
│ │ │ └── MCPGetSourceClient.exe
│ │ ├── 3.2 mcp_list_sources
│ │ │ ├── MCPListSourcesClient.cpp
│ │ │ └── MCPListSourcesClient.exe
│ │ ├── 3.3 mcp_edit_source
│ │ │ ├── MCPEditSourceClient.cpp
│ │ │ └── MCPEditSourceClient.exe
│ │ ├── 3.4 mcp_delete_source
│ │ │ ├── MCPDeleteSourceClient.cpp
│ │ │ └── MCPDeleteSourceClient.exe
│ │ ├── 4.0 mcp_list_groups
│ │ │ ├── MCPListGroupsClient.cpp
│ │ │ └── MCPListGroupsClient.exe
│ │ ├── 4.1 mcp_store_group
│ │ │ ├── MCPStoreGroupClient.cpp
│ │ │ └── MCPStoreGroupClient.exe
│ │ ├── 4.2 mcp_delete_group
│ │ │ ├── MPCDeleteGroupClient.cpp
│ │ │ └── MPCDeleteGroupClient.exe
│ │ ├── 5.0 mcp_store_user
│ │ │ ├── MCPStoreUserClient.cpp
│ │ │ └── MCPStoreUserClient.exe
│ │ ├── 5.1 mcp_edit_user
│ │ │ ├── MCPEditUserClient.cpp
│ │ │ └── MCPEditUserClient.exe
│ │ ├── 5.2 mcp_delete_user
│ │ │ ├── MCPDeleteUserClient.cpp
│ │ │ └── MCPDeleteUserClient.exe
│ │ ├── 9.0 mcp_keygen
│ │ │ ├── MCPKeygenClient.cpp
│ │ │ └── MCPKeygenClient.exe
│ │ └── README.md
│ ├── Go
│ │ ├── 1.0 mcp_login
│ │ │ ├── go.mod
│ │ │ ├── MCPLoginClient.exe
│ │ │ └── MCPLoginClient.go
│ │ ├── 1.1 mcp_logout
│ │ │ ├── MCPLogoutClient.exe
│ │ │ └── MCPLogoutClient.go
│ │ ├── 2.0 mcp_chat
│ │ │ ├── MCPChatClient.exe
│ │ │ └── MCPChatClient.go
│ │ ├── 2.1 mcp_continue_chat
│ │ │ ├── MCPChatContinuationClient.exe
│ │ │ └── MCPChatContinuationClient.go
│ │ ├── 2.2 mcp_get_chat_info
│ │ │ ├── MCPGetChatInfoClient.exe
│ │ │ └── MCPGetChatInfoClient.go
│ │ ├── 3.0 mcp_create_source
│ │ │ ├── MCPCreateSourceClient.exe
│ │ │ └── MCPCreateSourceClient.go
│ │ ├── 3.1 mcp_get_source
│ │ │ ├── MCPGetSourceClient.exe
│ │ │ └── MCPGetSourceClient.go
│ │ ├── 3.2 mcp_list_sources
│ │ │ ├── MCPListSourcesClient.exe
│ │ │ └── MCPListSourcesClient.go
│ │ ├── 3.3 mcp_edit_source
│ │ │ ├── MCPEditSourceClient.exe
│ │ │ └── MCPEditSourceClient.go
│ │ ├── 3.4 mcp_delete_source
│ │ │ ├── MCPDeleteSourceClient.exe
│ │ │ └── MCPDeleteSourceClient.go
│ │ ├── 4.0 mcp_list_groups
│ │ │ ├── MCPListGroupsClient.exe
│ │ │ └── MCPListGroupsClient.go
│ │ ├── 4.1 mcp_store_group
│ │ │ ├── MCPStoreGroupClient.exe
│ │ │ └── MCPStoreGroupClient.go
│ │ ├── 4.2 mcp_delete_group
│ │ │ ├── MCPDeleteGroupClient.exe
│ │ │ └── MCPDeleteGroupClient.go
│ │ ├── 5.0 mcp_store_user
│ │ │ ├── MCPStoreUserClient.exe
│ │ │ └── MCPStoreUserClient.go
│ │ ├── 5.1 mcp_edit_user
│ │ │ ├── MCPEditUserClient.exe
│ │ │ └── MCPEditUserClient.go
│ │ ├── 5.2 mcp_delete_user
│ │ │ ├── MCPDeleteUserClient.exe
│ │ │ └── MCPDeleteUserClient.go
│ │ ├── 9.0 mcp_keygen
│ │ │ ├── MCPKeygenClient.exe
│ │ │ └── MCPKeygenClient.go
│ │ └── README.md
│ ├── Gradio
│ │ ├── Api.py
│ │ ├── config.json.example
│ │ ├── config.py
│ │ ├── favicon.ico
│ │ ├── file_tools
│ │ │ └── loader_factory.py
│ │ ├── language.py
│ │ ├── logos
│ │ │ ├── fsas.png
│ │ │ └── Logo_dark.svg
│ │ ├── main.py
│ │ ├── mcp_client.py
│ │ ├── mcp_servers
│ │ │ ├── arxiv
│ │ │ │ ├── arxiv-stdio.js
│ │ │ │ ├── package.json
│ │ │ │ ├── README.md
│ │ │ │ ├── requirements.txt
│ │ │ │ └── server_config.example.json
│ │ │ ├── demo-mcp-server
│ │ │ │ ├── demo-tools-sse.js
│ │ │ │ ├── demo-tools-stdio.js
│ │ │ │ └── tools
│ │ │ │ ├── assets.js
│ │ │ │ ├── calculator.js
│ │ │ │ └── weather.js
│ │ │ ├── filesystem
│ │ │ │ ├── Dockerfile
│ │ │ │ ├── index.ts
│ │ │ │ ├── package.json
│ │ │ │ ├── README.md
│ │ │ │ ├── test
│ │ │ │ │ └── new.txt
│ │ │ │ └── tsconfig.json
│ │ │ ├── moondream
│ │ │ │ └── server.py
│ │ │ ├── pgpt
│ │ │ │ ├── __init__.py
│ │ │ │ ├── Api.py
│ │ │ │ ├── config.json.example
│ │ │ │ ├── config.py
│ │ │ │ ├── language.py
│ │ │ │ ├── pyproject.toml
│ │ │ │ ├── README.md
│ │ │ │ └── server.py
│ │ │ ├── replicate_flux
│ │ │ │ └── server.py
│ │ │ └── sqlite
│ │ │ ├── .python-version
│ │ │ ├── Dockerfile
│ │ │ ├── pyproject.toml
│ │ │ ├── README.md
│ │ │ └── src
│ │ │ └── mcp_server_sqlite
│ │ │ ├── __init__.py
│ │ │ └── server.py
│ │ ├── messages
│ │ │ ├── __init__.py
│ │ │ ├── message_types
│ │ │ │ ├── __init__.py
│ │ │ │ ├── incrementing_id_message.py
│ │ │ │ ├── initialize_message.py
│ │ │ │ ├── json_rpc_message.py
│ │ │ │ ├── ping_message.py
│ │ │ │ ├── prompts_messages.py
│ │ │ │ ├── prompts_models.py
│ │ │ │ ├── resources_messages.py
│ │ │ │ └── tools_messages.py
│ │ │ ├── send_call_tool.py
│ │ │ ├── send_initialize_message.py
│ │ │ ├── send_message.py
│ │ │ ├── send_ping.py
│ │ │ ├── send_prompts.py
│ │ │ ├── send_resources.py
│ │ │ └── send_tools_list.py
│ │ ├── README.md
│ │ ├── requirements.txt
│ │ ├── server_config.json
│ │ ├── SourceManagement.py
│ │ ├── transport
│ │ │ ├── __init__.py
│ │ │ └── stdio
│ │ │ ├── __init__.py
│ │ │ ├── stdio_client.py
│ │ │ ├── stdio_server_parameters.py
│ │ │ └── stdio_server_shutdown.py
│ │ ├── tsconfig.json
│ │ └── UserManagement.py
│ ├── Java
│ │ ├── 1.0 mcp_login
│ │ │ ├── json-20241224.jar
│ │ │ ├── MCPLoginClient.class
│ │ │ └── MCPLoginClient.java
│ │ ├── 1.1 mcp_logout
│ │ │ ├── json-20241224.jar
│ │ │ ├── MCPLogoutClient.class
│ │ │ └── MCPLogoutClient.java
│ │ ├── 2.0 mcp_chat
│ │ │ ├── json-20241224.jar
│ │ │ ├── MCPChatClient.class
│ │ │ └── MCPChatClient.java
│ │ ├── 2.1 mcp_continue_chat
│ │ │ ├── json-20241224.jar
│ │ │ ├── MCPContinueChatClient.class
│ │ │ └── MCPContinueChatClient.java
│ │ ├── 2.2 mcp_get_chat_info
│ │ │ ├── json-20241224.jar
│ │ │ ├── MCPGetChatInfoClient.class
│ │ │ └── MCPGetChatInfoClient.java
│ │ ├── 3.0 mcp_create_source
│ │ │ ├── json-20241224.jar
│ │ │ ├── MCPCreateSourceClient.class
│ │ │ └── MCPCreateSourceClient.java
│ │ ├── 3.1 mcp_get_source
│ │ │ ├── json-20241224.jar
│ │ │ ├── MCPGetSourceClient.class
│ │ │ └── MCPGetSourceClient.java
│ │ ├── 3.2 mcp_list_sources
│ │ │ ├── json-20241224.jar
│ │ │ ├── MCPListSourcesClient.class
│ │ │ └── MCPListSourcesClient.java
│ │ ├── 3.3 mcp_edit_source
│ │ │ ├── json-20241224.jar
│ │ │ ├── MCPEditSourceClient.class
│ │ │ └── MCPEditSourceClient.java
│ │ ├── 3.4 mcp_delete_source
│ │ │ ├── json-20241224.jar
│ │ │ ├── MCPDeleteSourceClient.class
│ │ │ └── MCPDeleteSourceClient.java
│ │ ├── 4.0 mcp_list_groups
│ │ │ ├── json-20241224.jar
│ │ │ ├── MCPListGroupsClient.class
│ │ │ └── MCPListGroupsClient.java
│ │ ├── 4.1 mcp_store_group
│ │ │ ├── json-20241224.jar
│ │ │ ├── MCPStoreGroupClient.class
│ │ │ └── MCPStoreGroupClient.java
│ │ ├── 4.2 mcp_delete_group
│ │ │ ├── json-20241224.jar
│ │ │ ├── MCPDeleteGroupClient.class
│ │ │ └── MCPDeleteGroupClient.java
│ │ ├── 5.0 mcp_store_user
│ │ │ ├── json-20241224.jar
│ │ │ ├── MCPStoreUserClient.class
│ │ │ └── MCPStoreUserClient.java
│ │ ├── 5.1 mcp_edit_user
│ │ │ ├── json-20241224.jar
│ │ │ ├── MCPEditUserClient.class
│ │ │ └── MCPEditUserClient.java
│ │ ├── 5.2 mcp_delete_user
│ │ │ ├── json-20241224.jar
│ │ │ ├── MCPDeleteUserClient.class
│ │ │ └── MCPDeleteUserClient.java
│ │ └── README.md
│ ├── JavaScript
│ │ ├── 1.0 mcp_login
│ │ │ └── MCPLoginClient.js
│ │ ├── 1.1 mcp_logout
│ │ │ └── MCPLogoutClient.js
│ │ ├── 2.0 mcp_chat
│ │ │ └── MCPChatClient.js
│ │ ├── 2.1 mcp_continue_chat
│ │ │ └── MCPContinueChatClient.js
│ │ ├── 2.2 mcp_get_chat_info
│ │ │ └── MCPGetChatInfoClient.js
│ │ ├── 3.0 mcp_create_source
│ │ │ └── MCPCreateSourceClient.js
│ │ ├── 3.1 mcp_get_source
│ │ │ └── MCPGetSourceClient.js
│ │ ├── 3.2 mcp_list_sources
│ │ │ └── MCPListSourcesClient.js
│ │ ├── 3.3 mcp_edit_source
│ │ │ └── MCPEditSourceClient.js
│ │ ├── 3.4 mcp_delete_source
│ │ │ └── MCPDeleteSourceClient.js
│ │ ├── 4.0 mcp_list_groups
│ │ │ └── MCPListGroupsClient.js
│ │ ├── 4.1 mcp_store_group
│ │ │ └── MCPStoreGroupClient.js
│ │ ├── 4.2 mcp_delete_group
│ │ │ └── MCPDeleteGroupClient.js
│ │ ├── 5.0 mcp_store_user
│ │ │ └── MCPStoreUserClient.js
│ │ ├── 5.1 mcp_edit_user
│ │ │ └── MCPEditUserClient.js
│ │ ├── 5.2 mcp_delete_user
│ │ │ └── MCPDeleteUserClient.js
│ │ ├── 9.0 mcp_keygen
│ │ │ └── MCPKeygenClient.js
│ │ └── README.md
│ ├── PHP
│ │ ├── 1.0 mcp_login
│ │ │ └── MCPLoginClient.php
│ │ ├── 1.1 mcp_logout
│ │ │ └── MCPLogoutClient.php
│ │ ├── 2.0 mcp_chat
│ │ │ └── MCPChatClient.php
│ │ ├── 2.1 mcp_continue_chat
│ │ │ └── MCPContinueChatClient.php
│ │ ├── 2.2 mcp_get_chat_info
│ │ │ └── MCPGetChatInfoClient.php
│ │ ├── 3.0 mcp_create_source
│ │ │ └── MCPCreateSourceClient.php
│ │ ├── 3.1 mcp_get_source
│ │ │ └── MCPGetSourceClient.php
│ │ ├── 3.2 mcp_list_sources
│ │ │ └── MCPListSourcesClient.php
│ │ ├── 3.3 mcp_edit_source
│ │ │ └── MCPEditSourceClient.php
│ │ ├── 3.4 mcp_delete_source
│ │ │ └── MCPDeleteSourceClient.php
│ │ ├── 4.0 mcp_list_groups
│ │ │ └── MCPListGroupsClient.php
│ │ ├── 4.1 mcp_store_group
│ │ │ └── MCPStoreGroupClient.php
│ │ ├── 4.2 mcp_delete_group
│ │ │ └── MCPDeleteGroupClient.php
│ │ ├── 5.0 mcp_store_user
│ │ │ └── MCPStoreUserClient.php
│ │ ├── 5.1 mcp_edit_user
│ │ │ └── MCPEditUserClient.php
│ │ ├── 5.2 mcp_delete_user
│ │ │ └── MCPDeleteUserClient.php
│ │ ├── 9.0 mcp_keygen
│ │ │ └── MCPKeygenClient.php
│ │ └── README.md
│ └── Python
│ ├── __init__.py
│ ├── 1.0 mcp_login
│ │ └── MCPLoginClient.py
│ ├── 1.1 mcp_logout
│ │ └── MCPLogoutClient.py
│ ├── 2.0 mcp_chat
│ │ └── MCPChatClient.py
│ ├── 2.1 mcp_continue_chat
│ │ └── MCPContinueChatClient.py
│ ├── 2.2 mcp_get_chat_info
│ │ └── MCPGetChatInfoClient.py
│ ├── 2.3 mcp_delete_all_chats
│ │ └── MCPDeleteAllChatsClient.py
│ ├── 2.4 mcp_delete_chat
│ │ └── MCPDeleteChatClient.py
│ ├── 3.0 mcp_create_source
│ │ └── MCPCreateSourceClient.py
│ ├── 3.1 mcp_get_source
│ │ └── MCPGetSourceClient.py
│ ├── 3.2 mcp_list_sources
│ │ └── MCPListSourcesClient.py
│ ├── 3.3 mcp_edit_source
│ │ └── MCPEditSourceClient.py
│ ├── 3.4 mcp_delete_source
│ │ └── MCPDeleteSourceClient.py
│ ├── 4.0 mcp_list_groups
│ │ └── MCPListGroupsClient.py
│ ├── 4.1 mcp_store_group
│ │ └── MCPStoreGroupClient.py
│ ├── 4.2 mcp_delete_group
│ │ └── MCPDeleteGroupClient.py
│ ├── 5.0 mcp_store_user
│ │ └── MCPStoreUserClient.py
│ ├── 5.1 mcp_edit_user
│ │ └── MCPEditUserClient.py
│ ├── 5.2 mcp_delete_user
│ │ └── MCPDeleteUserClient.py
│ ├── 9.0 mcp_keygen
│ │ └── MCPKeygenClient.py
│ ├── Gradio
│ │ ├── __init__.py
│ │ └── server_config.json
│ └── README.md
├── examples
│ ├── create_users_from_csv
│ │ ├── config.json.example
│ │ ├── config.py
│ │ ├── create_users_from_csv.py
│ │ └── language.py
│ ├── dynamic_sources
│ │ └── rss_reader
│ │ ├── Api.py
│ │ ├── config.json.example
│ │ ├── config.py
│ │ ├── demo_dynamic_sources.py
│ │ └── rss_parser.py
│ ├── example_users_to_add_no_tz.csv
│ └── sftp_upload_with_id
│ ├── Api.py
│ ├── config_ftp.json.example
│ ├── config.py
│ ├── demo_upload.py
│ ├── language.py
│ └── requirements.txt
├── images
│ ├── alternative mcp client.png
│ ├── favicon
│ │ ├── android-chrome-192x192.png
│ │ ├── android-chrome-512x512.png
│ │ ├── apple-touch-icon.png
│ │ ├── favicon-16x16.png
│ │ ├── favicon-32x32.png
│ │ ├── favicon.ico
│ │ └── site.webmanifest
│ ├── mcp-general-architecture.png
│ ├── privateGPT-MCP.png
│ └── privateGPT.png
├── InstallMPCServer.sh
├── jest.config.js
├── LICENSE
├── package.json
├── pgpt.env.json.example
├── README.md
├── security
│ ├── generate_decrypted_password.js
│ └── generate_encrypted_password.js
├── src
│ ├── helper.js
│ ├── index.js
│ ├── logger.js
│ ├── pgpt-messages.js
│ ├── public
│ │ ├── index.html
│ │ └── pgpt-mcp-logo.png
│ ├── services
│ │ └── pgpt-service.ts
│ └── types
│ └── api.ts
├── start_chatbot_agent.ps1
├── start_chatbot_agent.sh
├── start_iot_agent.ps1
├── start_iot_agent.sh
├── start_openai_compatible_api_agent.ps1
├── start_openai_compatible_api_agent.sh
├── tsconfig.json
├── ver
│ ├── index_np.js
│ └── index_proxy_np.js
└── WORKLOG.md
```
# Files
--------------------------------------------------------------------------------
/src/pgpt-messages.js:
--------------------------------------------------------------------------------
```javascript
const templates = {
success: '✔️ ${action}: ${details}',
error: '❌ ${action}: ${details}',
warning: '⚠️ ${action}: ${details}',
configStart: '🚀 ${action}: ${details}',
info: '📤 ${action}...',
closed: '🔌${action}: ${details}',
stopped: '🛑 ${action}: ${details}',
receive: '📥 ${action}: ${details}',
};
function formatMessage(template, variables) {
return template.replace(/\$\{(\w+)\}/g, (_, key) => variables[key] || '');
}
export const prefixMessages = {
en: {
prefix_openaicompAPI: 'Open AI cmp. API',
prefix_delete_all_chats: 'DelAllChats',
prefix_delete_all_chatsRequest: 'DelAllChats: Request',
prefix_delete_all_chatsSuccess: 'DelAllChats: Success',
prefix_delete_all_chatsError: 'DelAllChats: ApiError',
prefix_delete_all_chatsWarning: 'DelAllChats: Warning',
prefix_delete_chat: 'DeleteChat',
prefix_delete_chatRequest: 'DeleteChat: Request',
prefix_delete_chatSuccess: 'DeleteChat: Success',
prefix_delete_chatError: 'DeleteChat: ApiError',
prefix_delete_chatWarning: 'DeleteChat: Warning',
prefix_reactivate_user: 'ReactivateUser',
prefix_reactivate_userSuccess: 'ReactivateUser: Success',
prefix_reactivate_userError: 'ReactivateUser: Error',
prefix_EnableTLS: 'ENABLE_TLS',
prefix_sslKeyPath: 'SSL_KEY_PATH',
prefix_sslCertPath: 'SSL_CERT_PATH',
prefix_sslError: 'No certificate found.',
prefix_All_Funcs: 'All Funcs',
prefix_Allow_Keygen: 'Allow Keygen',
prefix_ANONYMOUS_MODE: 'ANONYMOUS_MODE',
prefix_chat: 'Chat',
prefix_chatApiError: 'Chat: ApiError',
prefix_chatRequest: 'Chat: Request',
prefix_chatSuccess: 'Chat: Success',
prefix_chatWarning: 'Chat: Warning',
prefix_get_chat_info: 'Get Chat Info',
prefix_get_chat_infoError: 'Get Chat Info: Error',
prefix_continue_chat: 'Continue Chat',
prefix_continue_chatError: 'Continue Chat: Error',
prefix_continue_chatSuccess: 'Continue Chat: Success',
prefix_create_sourceError: 'Create Source: Error',
prefix_create_sourceGroupCheck: 'Create Source: GroupCheck',
prefix_create_sourceInvalidGroups: 'Create SourceInvalidGroups',
prefix_create_sourceNoResponse: 'Create SourceNoResponse',
prefix_create_sourceResponseError: 'Create SourceResponseError',
prefix_create_sourceSuccess: 'Create SourceSuccess',
prefix_create_sourceUnknownError: 'Create SourceUnknownError',
prefix_Deact_Funcs: 'Deact Funcs',
prefix_delete_groupError: 'Delete Group: Error',
prefix_delete_groupRequest: 'Delete Group: Request',
prefix_delete_groupSuccess: 'Delete Group: Success',
prefix_delete_source: 'Delete Source',
prefix_delete_sourceError: 'Delete Source: Error',
prefix_delete_sourceSuccess: 'Delete Source: Success',
prefix_delete_user: 'Delete User',
prefix_edit_user: 'Edit User',
prefix_edit_userError: 'Edit User: Error',
prefix_edit_userSuccess: 'Edit_User: Success',
prefix_Env_Load_Err: 'Env: LoadErr',
prefix_File_Path: 'File Path',
prefix_Handling_Tool_Request: 'Handling Tool Request',
prefix_Incoming_Message: 'Incoming Message',
prefix_Lang_Warning: 'Lang Warning',
prefix_Language: 'Language',
prefix_LOG_IPs: 'LOG_IPs',
prefix_login: 'Login',
prefix_loginError: 'Login: Error',
prefix_loginSuccess: 'Login: Success',
prefix_logout: 'Logout',
prefix_logoutError: 'Logout: Error',
prefix_logoutSuccess: 'Logout: Success',
prefix_MCP_Error: 'MCP Error',
prefix_Missing_Config: 'Missing Config',
prefix_Port: 'Port',
prefix_Port_Check: 'Port Check',
prefix_Port_Invalid: 'Port Invalid',
prefix_Port_Validated: 'Port Validated',
prefix_Private_API_URL: 'Private API URL',
prefix_Proxy_Config: 'Proxy Config',
prefix_Public_API_URL: 'Public API URL',
prefix_PW_Encryption: 'PW Encryption',
prefix_requestHeaders: 'Request Headers',
prefix_Restricted_Groups: 'Restricted Groups',
prefix_Server_Config: 'Server Config',
prefix_Shutdown: 'Shutdown',
prefix_SSL_Validation: 'SSL Validation',
prefix_Tool_Disabled: 'Tool Disabled',
prefix_Tool_Warn: 'Tool Warn',
prefix_URL_Invalid: 'URL Invalid',
prefix_URL_Warning: 'URL Warning',
prefix_URL_Warning_V1: 'URL Warning V1',
prefix_Validation_Err: 'Validation Err',
prefix_WRITTEN_LOGFILE: 'WRITTEN_LOGFILE',
prefix_unknownCommand: 'unknownCommand',
prefix_get_sourceError: 'Get Source: Error',
prefix_get_sourceRequest: 'Get Source: Request',
prefix_get_sourceSuccess: 'Get Source: Success',
prefix_list_groupsError: 'List Groups: Error',
prefix_list_groupsRequest: 'List Groups: Request',
prefix_list_groupsSuccess: 'List Groups: Success',
prefix_list_sourcesError: 'list sources: Error',
prefix_list_sourcesRequest: 'list sources: Request',
prefix_list_sourcesSuccess: 'list sources: Success',
prefix_responseReceived: 'Response received',
prefix_store_groupError: 'Store Group: Error',
prefix_store_groupRequest: 'Store Group: Request',
prefix_store_groupSuccess: 'Store Group: Success',
prefix_store_user: 'Store User',
prefix_store_userError: 'Store User: Error',
prefix_store_userSuccess: 'Store User: Success',
prefix_delete_userSuccess: 'Delete User: Success',
prefix_delete_userError: 'Delete User: Error',
prefix_apiRequestError: 'API request: Error',
prefix_create_source: 'Create Source',
prefix_get_source: 'Get Source',
prefix_list_sources: 'List Sources',
prefix_edit_source: 'Edit Source',
prefix_edit_sourceSuccess: 'Edit Source: Success',
prefix_edit_sourceError: 'Edit Source: Error',
prefix_delete_group: 'Delete Group',
prefix_list_groups: 'List Groups',
prefix_store_group: 'Store Group',
prefix_clientConnected: 'Client: Connected',
prefix_clientDisconnected: 'Client: Disconnected',
prefix_logReadError: 'Log read: Error',
prefix_logChangeError: 'Log change: Error',
prefix_logViewerRunning: 'LogViewer: Running',
prefix_serverError: 'Server: Error',
prefix_tcpServerError: 'tcpServer: Error',
prefix_keygenError: 'Keygen: Error',
prefix_edit_sourceRequest: 'Edit Source: Request',
prefix_delete_sourceRequest: 'Delete Source: Request',
prefix_store_userRequest: 'Store User: Request',
prefix_edit_userRequest: 'Edit User: Request',
prefix_delete_userRequest: 'Delete User: Request',
prefix_get_chat_infoSuccess: 'Get Chat Info: Success',
prefix_keygen: 'Keygen',
prefix_list_groupsWarning: 'List Groups: Warning'
},
// Portuguese (pt)
pt: {
prefix_openaicompAPI: 'API compatível com OpenAI',
prefix_delete_all_chats: 'DelAllChats',
prefix_delete_all_chatsRequest: 'DelAllChats: Solicitação',
prefix_delete_all_chatsSuccess: 'DelAllChats: Sucesso',
prefix_delete_all_chatsError: 'DelAllChats: Erro da API',
prefix_delete_all_chatsWarning: 'DelAllChats: Aviso',
prefix_delete_chat: 'ExcluirChat',
prefix_delete_chatRequest: 'ExcluirChat: Solicitação',
prefix_delete_chatSuccess: 'ExcluirChat: Sucesso',
prefix_delete_chatError: 'ExcluirChat: Erro da API',
prefix_delete_chatWarning: 'ExcluirChat: Aviso',
prefix_reactivate_user: 'ReativarUsuário',
prefix_reactivate_userSuccess: 'ReativarUsuário: Sucesso',
prefix_reactivate_userError: 'ReativarUsuário: Erro',
prefix_EnableTLS: 'HABILITAR_TLS',
prefix_sslKeyPath: 'CAMINHO_CHAVE_SSL',
prefix_sslCertPath: 'CAMINHO_CERTIFICADO_SSL',
prefix_sslError: 'Nenhum certificado encontrado.',
prefix_All_Funcs: 'Todas as Funções',
prefix_Allow_Keygen: 'Permitir Keygen',
prefix_ANONYMOUS_MODE: 'MODO_ANÔNIMO',
prefix_chat: 'Chat',
prefix_chatApiError: 'Chat: ErroApi',
prefix_chatRequest: 'Chat: Solicitação',
prefix_chatSuccess: 'Chat: Sucesso',
prefix_chatWarning: 'Chat: Aviso',
prefix_get_chat_info: 'Obter Informações do Chat',
prefix_get_chat_infoError: 'Obter Informações do Chat: Erro',
prefix_continue_chat: 'Continuar Chat',
prefix_continue_chatError: 'Continuar Chat: Erro',
prefix_continue_chatSuccess: 'Continuar Chat: Sucesso',
prefix_create_sourceError: 'Criar Fonte: Erro',
prefix_create_sourceGroupCheck: 'Criar Fonte: Verificação de Grupo',
prefix_create_sourceInvalidGroups: 'Criar Fonte: Grupos Inválidos',
prefix_create_sourceNoResponse: 'Criar Fonte: Sem Resposta',
prefix_create_sourceResponseError: 'Criar Fonte: Erro na Resposta',
prefix_create_sourceSuccess: 'Criar Fonte: Sucesso',
prefix_create_sourceUnknownError: 'Criar Fonte: Erro Desconhecido',
prefix_Deact_Funcs: 'Desativar Funções',
prefix_delete_groupError: 'Excluir Grupo: Erro',
prefix_delete_groupRequest: 'Excluir Grupo: Solicitação',
prefix_delete_groupSuccess: 'Excluir Grupo: Sucesso',
prefix_delete_source: 'Excluir Fonte',
prefix_delete_sourceError: 'Excluir Fonte: Erro',
prefix_delete_sourceSuccess: 'Excluir Fonte: Sucesso',
prefix_delete_user: 'Excluir Usuário',
prefix_edit_user: 'Editar Usuário',
prefix_edit_userError: 'Editar Usuário: Erro',
prefix_edit_userSuccess: 'Editar Usuário: Sucesso',
prefix_Env_Load_Err: 'Ambiente: ErroCarregamento',
prefix_File_Path: 'Caminho do Arquivo',
prefix_Handling_Tool_Request: 'Manipulando Solicitação de Ferramenta',
prefix_Incoming_Message: 'Mensagem Entrante',
prefix_Lang_Warning: 'Aviso de Idioma',
prefix_Language: 'Idioma',
prefix_LOG_IPs: 'LOG_IPs',
prefix_login: 'Login',
prefix_loginError: 'Login: Erro',
prefix_loginSuccess: 'Login: Sucesso',
prefix_logout: 'Logout',
prefix_logoutError: 'Logout: Erro',
prefix_logoutSuccess: 'Logout: Sucesso',
prefix_MCP_Error: 'Erro MCP',
prefix_Missing_Config: 'Configuração Ausente',
prefix_Port: 'Porta',
prefix_Port_Check: 'Verificação de Porta',
prefix_Port_Invalid: 'Porta Inválida',
prefix_Port_Validated: 'Porta Validada',
prefix_Private_API_URL: 'URL da API Privada',
prefix_Proxy_Config: 'Configuração de Proxy',
prefix_Public_API_URL: 'URL da API Pública',
prefix_PW_Encryption: 'Criptografia de Senha',
prefix_requestHeaders: 'Cabeçalhos da Solicitação',
prefix_Restricted_Groups: 'Grupos Restritos',
prefix_Server_Config: 'Configuração do Servidor',
prefix_Shutdown: 'Desligamento',
prefix_SSL_Validation: 'Validação SSL',
prefix_Tool_Disabled: 'Ferramenta Desativada',
prefix_Tool_Warn: 'Aviso da Ferramenta',
prefix_URL_Invalid: 'URL Inválida',
prefix_URL_Warning: 'Aviso de URL',
prefix_URL_Warning_V1: 'Aviso de URL V1',
prefix_Validation_Err: 'Erro de Validação',
prefix_WRITTEN_LOGFILE: 'ARQUIVO_DE_LOG_ESCRITO',
prefix_unknownCommand: 'comandoDesconhecido',
prefix_get_sourceError: 'Obter Fonte: Erro',
prefix_get_sourceRequest: 'Obter Fonte: Solicitação',
prefix_get_sourceSuccess: 'Obter Fonte: Sucesso',
prefix_list_groupsError: 'Listar Grupos: Erro',
prefix_list_groupsRequest: 'Listar Grupos: Solicitação',
prefix_list_groupsSuccess: 'Listar Grupos: Sucesso',
prefix_list_sourcesError: 'Listar Fontes: Erro',
prefix_list_sourcesRequest: 'Listar Fontes: Solicitação',
prefix_list_sourcesSuccess: 'Listar Fontes: Sucesso',
prefix_responseReceived: 'Resposta Recebida',
prefix_store_groupError: 'Armazenar Grupo: Erro',
prefix_store_groupRequest: 'Armazenar Grupo: Solicitação',
prefix_store_groupSuccess: 'Armazenar Grupo: Sucesso',
prefix_store_user: 'Armazenar Usuário',
prefix_store_userError: 'Armazenar Usuário: Erro',
prefix_store_userSuccess: 'Armazenar Usuário: Sucesso',
prefix_delete_userSuccess: 'Excluir Usuário: Sucesso',
prefix_delete_userError: 'Excluir Usuário: Erro',
prefix_apiRequestError: 'Solicitação de API: Erro',
prefix_create_source: 'Criar Fonte',
prefix_get_source: 'Obter Fonte',
prefix_list_sources: 'Listar Fontes',
prefix_edit_source: 'Editar Fonte',
prefix_edit_sourceSuccess: 'Editar Fonte: Sucesso',
prefix_edit_sourceError: 'Editar Fonte: Erro',
prefix_delete_group: 'Excluir Grupo',
prefix_list_groups: 'Listar Grupos',
prefix_store_group: 'Armazenar Grupo',
prefix_clientConnected: 'Cliente: Conectado',
prefix_clientDisconnected: 'Cliente: Desconectado',
prefix_logReadError: 'Leitura de Log: Erro',
prefix_logChangeError: 'Alteração de Log: Erro',
prefix_logViewerRunning: 'Visualizador de Logs: Em Execução',
prefix_serverError: 'Servidor: Erro',
prefix_tcpServerError: 'tcpServer: Erro',
prefix_keygenError: 'Keygen: Erro',
prefix_edit_sourceRequest: 'Editar Fonte: Solicitação',
prefix_delete_sourceRequest: 'Excluir Fonte: Solicitação',
prefix_store_userRequest: 'Armazenar Usuário: Solicitação',
prefix_edit_userRequest: 'Editar Usuário: Solicitação',
prefix_delete_userRequest: 'Excluir Usuário: Solicitação',
prefix_get_chat_infoSuccess: 'Obter Informações do Chat: Sucesso',
prefix_keygen: 'Keygen',
prefix_list_groupsWarning: 'Listar Grupos: Aviso'
}, de:
{
prefix_openaicompAPI: 'Open AI komp. API',
prefix_delete_all_chats: 'AlleChatsLöschen',
prefix_delete_all_chatsRequest: 'AlleChatsLöschen: Anfrage',
prefix_delete_all_chatsSuccess: 'AlleChatsLöschen: Erfolg',
prefix_delete_all_chatsError: 'AlleChatsLöschen: API-Fehler',
prefix_delete_all_chatsWarning: 'AlleChatsLöschen: Warnung',
prefix_delete_chat: 'ChatLöschen',
prefix_delete_chatRequest: 'ChatLöschen: Anfrage',
prefix_delete_chatSuccess: 'ChatLöschen: Erfolg',
prefix_delete_chatError: 'ChatLöschen: API-Fehler',
prefix_delete_chatWarning: 'ChatLöschen: Warnung',
prefix_reactivate_user: 'BenutzerReaktivieren',
prefix_reactivate_userSuccess: 'BenutzerReaktivieren: Erfolg',
prefix_reactivate_userError: 'BenutzerReaktivieren: Fehler',
prefix_EnableTLS: 'TLS_AKTIVIEREN',
prefix_sslKeyPath: 'SSL_SCHLÜSSEL_PFAD',
prefix_sslCertPath: 'SSL_ZERTIFIKAT_PFAD',
prefix_sslError: 'Kein Zertifikat gefunden.',
// #######################################################
prefix_All_Funcs: 'Alle Funktionen',
prefix_Allow_Keygen: 'Keygen erlauben',
prefix_ANONYMOUS_MODE: 'ANONYMOUS_MODE',
prefix_chat: 'Chat',
prefix_chatApiError: 'Chat: API-Fehler',
prefix_chatRequest: 'Chat: Anfrage',
prefix_chatSuccess: 'Chat: Erfolg',
prefix_chatWarning: 'Chat: Warnung',
prefix_get_chat_info: 'Chat-Info abrufen',
prefix_get_chat_infoError: 'Chat-Info: Fehler',
prefix_continue_chat: 'Chat fortsetzen',
prefix_continue_chatError: 'Chat fortsetzen: Fehler',
prefix_continue_chatSuccess: 'Chat fortsetzen: Erfolg',
prefix_create_sourceError: 'Quelle erstellen: Fehler',
prefix_create_sourceGroupCheck: 'Quelle erstellen: Gruppenprüfung',
prefix_create_sourceInvalidGroups: 'Quelle erstellen: Ungültige Gruppen',
prefix_create_sourceNoResponse: 'Quelle erstellen: Keine Antwort',
prefix_create_sourceResponseError: 'Quelle erstellen: Antwortfehler',
prefix_create_sourceSuccess: 'Quelle erstellen: Erfolg',
prefix_create_sourceUnknownError: 'Quelle erstellen: Unbekannter Fehler',
prefix_Deact_Funcs: 'Funktionen deaktivieren',
prefix_delete_groupError: 'Gruppe löschen: Fehler',
prefix_delete_groupRequest: 'Gruppe löschen: Anfrage',
prefix_delete_groupSuccess: 'Gruppe löschen: Erfolg',
prefix_delete_source: 'Quelle löschen',
prefix_delete_sourceError: 'Quelle löschen: Fehler',
prefix_delete_sourceSuccess: 'Quelle löschen: Erfolg',
prefix_delete_user: 'Benutzer löschen',
prefix_edit_user: 'Benutzer bearbeiten',
prefix_edit_userError: 'Benutzer bearbeiten: Fehler',
prefix_edit_userSuccess: 'Benutzer bearbeiten: Erfolg',
prefix_Env_Load_Err: 'Umgebung: Ladefehler',
prefix_File_Path: 'Dateipfad',
prefix_Handling_Tool_Request: 'Tool-Anfrage bearbeiten',
prefix_Incoming_Message: 'Eingehende Nachricht',
prefix_Lang_Warning: 'Sprachwarnung',
prefix_Language: 'Sprache',
prefix_LOG_IPs: 'LOG_IPs',
prefix_login: 'Anmelden',
prefix_loginError: 'Anmelden: Fehler',
prefix_loginSuccess: 'Anmelden: Erfolg',
prefix_logout: 'Abmelden',
prefix_logoutError: 'Abmelden: Fehler',
prefix_logoutSuccess: 'Abmelden: Erfolg',
prefix_MCP_Error: 'MCP-Fehler',
prefix_Missing_Config: 'Konfiguration fehlt',
prefix_Port: 'Port',
prefix_Port_Check: 'Port-Überprüfung',
prefix_Port_Invalid: 'Ungültiger Port',
prefix_Port_Validated: 'Port validiert',
prefix_Private_API_URL: 'Private API URL',
prefix_Proxy_Config: 'Proxy-Konfiguration',
prefix_Public_API_URL: 'Öffentliche API URL',
prefix_PW_Encryption: 'PW-Verschlüsselung',
prefix_requestHeaders: 'Anfrageheader',
prefix_Restricted_Groups: 'Eingeschränkte Gruppen',
prefix_Server_Config: 'Server-Konfiguration',
prefix_Shutdown: 'Herunterfahren',
prefix_SSL_Validation: 'SSL-Validierung',
prefix_Tool_Disabled: 'Tool deaktiviert',
prefix_Tool_Warn: 'Tool-Warnung',
prefix_URL_Invalid: 'Ungültige URL',
prefix_URL_Warning: 'URL-Warnung',
prefix_URL_Warning_V1: 'URL-Warnung V1',
prefix_Validation_Err: 'Validierungsfehler',
prefix_WRITTEN_LOGFILE: 'GESCHRIEBENE_LOGDATEI',
prefix_unknownCommand: 'unbekannterBefehl',
prefix_get_sourceError: 'Quelle abrufen: Fehler',
prefix_get_sourceRequest: 'Quelle abrufen: Anfrage',
prefix_get_sourceSuccess: 'Quelle abrufen: Erfolg',
prefix_list_groupsError: 'Gruppen auflisten: Fehler',
prefix_list_groupsRequest: 'Gruppen auflisten: Anfrage',
prefix_list_groupsSuccess: 'Gruppen auflisten: Erfolg',
prefix_list_sourcesError: 'Quellen auflisten: Fehler',
prefix_list_sourcesRequest: 'Quellen auflisten: Anfrage',
prefix_list_sourcesSuccess: 'Quellen auflisten: Erfolg',
prefix_responseReceived: 'Antwort erhalten',
prefix_store_groupError: 'Gruppe speichern: Fehler',
prefix_store_groupRequest: 'Gruppe speichern: Anfrage',
prefix_store_groupSuccess: 'Gruppe speichern: Erfolg',
prefix_store_user: 'Benutzer speichern',
prefix_store_userError: 'Benutzer speichern: Fehler',
prefix_store_userSuccess: 'Benutzer speichern: Erfolg',
prefix_delete_userSuccess: 'Benutzer löschen: Erfolg',
prefix_delete_userError: 'Benutzer löschen: Fehler',
prefix_apiRequestError: 'API-Anfrage: Fehler',
prefix_create_source: 'Quelle erstellen',
prefix_get_source: 'Quelle abrufen',
prefix_list_sources: 'Quellen auflisten',
prefix_edit_source: 'Quelle bearbeiten',
prefix_edit_sourceSuccess: 'Quelle bearbeiten: Erfolg',
prefix_edit_sourceError: 'Quelle bearbeiten: Fehler',
prefix_delete_group: 'Gruppe löschen',
prefix_list_groups: 'Gruppen auflisten',
prefix_store_group: 'Gruppe speichern',
prefix_clientConnected: 'Client: Verbunden',
prefix_clientDisconnected: 'Client: Getrennt',
prefix_logReadError: 'Log lesen: Fehler',
prefix_logChangeError: 'Log ändern: Fehler',
prefix_logViewerRunning: 'LogViewer: Läuft',
prefix_serverError: 'Server: Fehler',
prefix_tcpServerError: 'tcpServer: Fehler',
prefix_keygenError: 'Keygen: Fehler',
prefix_edit_sourceRequest: 'Quelle bearbeiten: Anfrage',
prefix_delete_sourceRequest: 'Quelle löschen: Anfrage',
prefix_store_userRequest: 'Benutzer speichern: Anfrage',
prefix_edit_userRequest: 'Benutzer bearbeiten: Anfrage',
prefix_delete_userRequest: 'Benutzer löschen: Anfrage',
prefix_get_chat_infoSuccess: 'Chat-Info: Erfolg',
prefix_keygen: 'Keygen',
prefix_list_groupsWarning: 'Gruppen auflisten: Warnung'
}, bg:
{
prefix_openaicompAPI: 'API, съвместим с OpenAI',
prefix_delete_all_chats: 'ИзтрВсичкиЧатове',
prefix_delete_all_chatsRequest: 'ИзтрВсичкиЧатове: Заявка',
prefix_delete_all_chatsSuccess: 'ИзтрВсичкиЧатове: Успех',
prefix_delete_all_chatsError: 'ИзтрВсичкиЧатове: ГрешкаApi',
prefix_delete_all_chatsWarning: 'ИзтрВсичкиЧатове: Предупреждение',
prefix_delete_chat: 'ИзтрийЧат',
prefix_delete_chatRequest: 'ИзтрийЧат: Заявка',
prefix_delete_chatSuccess: 'ИзтрийЧат: Успех',
prefix_delete_chatError: 'ИзтрийЧат: ГрешкаApi',
prefix_delete_chatWarning: 'ИзтрийЧат: Предупреждение',
prefix_reactivate_user: 'РеактивиранеНаПотребител',
prefix_reactivate_userSuccess: 'РеактивиранеНаПотребител: Успех',
prefix_reactivate_userError: 'РеактивиранеНаПотребител: Грешка',
prefix_EnableTLS: 'АКТИВИРАЙ_TLS',
prefix_sslKeyPath: 'ПЪТ_КЪМ_SSL_КЛЮЧ',
prefix_sslCertPath: 'ПЪТ_КЪМ_SSL_СЕРТИФИКАТ',
prefix_sslError: 'Няма намерен сертификат.',
prefix_All_Funcs: 'Всички функции',
prefix_Allow_Keygen: 'Разреши Keygen',
prefix_ANONYMOUS_MODE: 'ANONYMOUS_MODE',
prefix_chat: 'Чат',
prefix_chatApiError: 'Чат: Грешка в API',
prefix_chatRequest: 'Чат: Запитване',
prefix_chatSuccess: 'Чат: Успех',
prefix_chatWarning: 'Чат: Предупреждение',
prefix_get_chat_info: 'Вземи информация за чата',
prefix_get_chat_infoError: 'Вземи информация за чата: Грешка',
prefix_continue_chat: 'Продължи чата',
prefix_continue_chatError: 'Продължи чата: Грешка',
prefix_continue_chatSuccess: 'Продължи чата: Успех',
prefix_create_sourceError: 'Създай източник: Грешка',
prefix_create_sourceGroupCheck: 'Създай източник: Проверка на групата',
prefix_create_sourceInvalidGroups: 'Създай източник: Невалидни групи',
prefix_create_sourceNoResponse: 'Създай източник: Няма отговор',
prefix_create_sourceResponseError: 'Създай източник: Грешка в отговора',
prefix_create_sourceSuccess: 'Създай източник: Успех',
prefix_create_sourceUnknownError: 'Създай източник: Непозната грешка',
prefix_Deact_Funcs: 'Деактивирай функции',
prefix_delete_groupError: 'Изтриване на група: Грешка',
prefix_delete_groupRequest: 'Изтриване на група: Запитване',
prefix_delete_groupSuccess: 'Изтриване на група: Успех',
prefix_delete_source: 'Изтрий източник',
prefix_delete_sourceError: 'Изтрий източник: Грешка',
prefix_delete_sourceSuccess: 'Изтрий източник: Успех',
prefix_delete_user: 'Изтрий потребител',
prefix_edit_user: 'Редактирай потребител',
prefix_edit_userError: 'Редактирай потребител: Грешка',
prefix_edit_userSuccess: 'Редактирай потребител: Успех',
prefix_Env_Load_Err: 'Околна среда: Грешка при зареждане',
prefix_File_Path: 'Път до файл',
prefix_Handling_Tool_Request: 'Обработка на заявка за инструмент',
prefix_Incoming_Message: 'Входящо съобщение',
prefix_Lang_Warning: 'Предупреждение за езика',
prefix_Language: 'Език',
prefix_LOG_IPs: 'LOG_IPs',
prefix_login: 'Вход',
prefix_loginError: 'Вход: Грешка',
prefix_loginSuccess: 'Вход: Успех',
prefix_logout: 'Изход',
prefix_logoutError: 'Изход: Грешка',
prefix_logoutSuccess: 'Изход: Успех',
prefix_MCP_Error: 'MCP Грешка',
prefix_Missing_Config: 'Липсваща конфигурация',
prefix_Port: 'Порт',
prefix_Port_Check: 'Проверка на порта',
prefix_Port_Invalid: 'Невалиден порт',
prefix_Port_Validated: 'Порт валидиран',
prefix_Private_API_URL: 'Частен API URL',
prefix_Proxy_Config: 'Прокси конфигурация',
prefix_Public_API_URL: 'Публичен API URL',
prefix_PW_Encryption: 'Шифроване на парола',
prefix_requestHeaders: 'Заглавки на заявката',
prefix_Restricted_Groups: 'Ограничени групи',
prefix_Server_Config: 'Сървърна конфигурация',
prefix_Shutdown: 'Изключване',
prefix_SSL_Validation: 'SSL валидация',
prefix_Tool_Disabled: 'Инструментът е деактивиран',
prefix_Tool_Warn: 'Предупреждение за инструмента',
prefix_URL_Invalid: 'Невалиден URL',
prefix_URL_Warning: 'Предупреждение за URL',
prefix_URL_Warning_V1: 'Предупреждение за URL V1',
prefix_Validation_Err: 'Грешка при валидация',
prefix_WRITTEN_LOGFILE: 'ПИСАН ЛОГ ФАЙЛ',
prefix_unknownCommand: 'непознатаКоманда',
prefix_get_sourceError: 'Вземи източник: Грешка',
prefix_get_sourceRequest: 'Вземи източник: Запитване',
prefix_get_sourceSuccess: 'Вземи източник: Успех',
prefix_list_groupsError: 'Изброяване на групи: Грешка',
prefix_list_groupsRequest: 'Изброяване на групи: Запитване',
prefix_list_groupsSuccess: 'Изброяване на групи: Успех',
prefix_list_sourcesError: 'Изброяване на източници: Грешка',
prefix_list_sourcesRequest: 'Изброяване на източници: Запитване',
prefix_list_sourcesSuccess: 'Изброяване на източници: Успех',
prefix_responseReceived: 'Отговор получен',
prefix_store_groupError: 'Съхранение на група: Грешка',
prefix_store_groupRequest: 'Съхранение на група: Запитване',
prefix_store_groupSuccess: 'Съхранение на група: Успех',
prefix_store_user: 'Съхранение на потребител',
prefix_store_userError: 'Съхранение на потребител: Грешка',
prefix_store_userSuccess: 'Съхранение на потребител: Успех',
prefix_delete_userSuccess: 'Изтриване на потребител: Успех',
prefix_delete_userError: 'Изтриване на потребител: Грешка',
prefix_apiRequestError: 'API заявка: Грешка',
prefix_create_source: 'Създай източник',
prefix_get_source: 'Вземи източник',
prefix_list_sources: 'Изброяване на източници',
prefix_edit_source: 'Редактирай източник',
prefix_edit_sourceSuccess: 'Редактирай източник: Успех',
prefix_edit_sourceError: 'Редактирай източник: Грешка',
prefix_delete_group: 'Изтрий група',
prefix_list_groups: 'Изброяване на групи',
prefix_store_group: 'Съхрани група',
prefix_clientConnected: 'Клиент: Свързан',
prefix_clientDisconnected: 'Клиент: Отключен',
prefix_logReadError: 'Четене на лог: Грешка',
prefix_logChangeError: 'Промяна на лог: Грешка',
prefix_logViewerRunning: 'LogViewer: Работи',
prefix_serverError: 'Сървър: Грешка',
prefix_tcpServerError: 'tcpServer: Грешка',
prefix_keygenError: 'Keygen: Грешка',
prefix_edit_sourceRequest: 'Редактирай източник: Запитване',
prefix_delete_sourceRequest: 'Изтрий източник: Запитване',
prefix_store_userRequest: 'Съхрани потребител: Запитване',
prefix_edit_userRequest: 'Редактирай потребител: Запитване',
prefix_delete_userRequest: 'Изтрий потребител: Запитване',
prefix_get_chat_infoSuccess: 'Вземи информация за чата: Успех',
prefix_keygen: 'Keygen',
prefix_list_groupsWarning: 'Изброяване на групи: Предупреждение'
},
// Spanish (es)
es: {
prefix_openaicompAPI: 'API compatible con OpenAI',
prefix_delete_all_chats: 'EliminarTodosChats',
prefix_delete_all_chatsRequest: 'EliminarTodosChats: Solicitud',
prefix_delete_all_chatsSuccess: 'EliminarTodosChats: Éxito',
prefix_delete_all_chatsError: 'EliminarTodosChats: ErrorApi',
prefix_delete_all_chatsWarning: 'EliminarTodosChats: Advertencia',
prefix_delete_chat: 'EliminarChat',
prefix_delete_chatRequest: 'EliminarChat: Solicitud',
prefix_delete_chatSuccess: 'EliminarChat: Éxito',
prefix_delete_chatError: 'EliminarChat: ErrorApi',
prefix_delete_chatWarning: 'EliminarChat: Advertencia',
prefix_reactivate_user: 'ReactivarUsuario',
prefix_reactivate_userSuccess: 'ReactivarUsuario: Éxito',
prefix_reactivate_userError: 'ReactivarUsuario: Error',
prefix_EnableTLS: 'HABILITAR_TLS',
prefix_sslKeyPath: 'RUTA_CLAVE_SSL',
prefix_sslCertPath: 'RUTA_CERTIFICADO_SSL',
prefix_sslError: 'No se encontró ningún certificado.',
prefix_All_Funcs: 'Todas las Funciones',
prefix_Allow_Keygen: 'Permitir Keygen',
prefix_ANONYMOUS_MODE: 'MODO_ANÓNIMO',
prefix_chat: 'Chat',
prefix_chatApiError: 'Chat: ErrorApi',
prefix_chatRequest: 'Chat: Solicitud',
prefix_chatSuccess: 'Chat: Éxito',
prefix_chatWarning: 'Chat: Advertencia',
prefix_get_chat_info: 'Obtener Información del Chat',
prefix_get_chat_infoError: 'Obtener Información del Chat: Error',
prefix_continue_chat: 'Continuar Chat',
prefix_continue_chatError: 'Continuar Chat: Error',
prefix_continue_chatSuccess: 'Continuar Chat: Éxito',
prefix_create_sourceError: 'Crear Fuente: Error',
prefix_create_sourceGroupCheck: 'Crear Fuente: Verificación de Grupo',
prefix_create_sourceInvalidGroups: 'Crear Fuente: Grupos Inválidos',
prefix_create_sourceNoResponse: 'Crear Fuente: Sin Respuesta',
prefix_create_sourceResponseError: 'Crear Fuente: Error en la Respuesta',
prefix_create_sourceSuccess: 'Crear Fuente: Éxito',
prefix_create_sourceUnknownError: 'Crear Fuente: Error Desconocido',
prefix_Deact_Funcs: 'Desactivar Funciones',
prefix_delete_groupError: 'Eliminar Grupo: Error',
prefix_delete_groupRequest: 'Eliminar Grupo: Solicitud',
prefix_delete_groupSuccess: 'Eliminar Grupo: Éxito',
prefix_delete_source: 'Eliminar Fuente',
prefix_delete_sourceError: 'Eliminar Fuente: Error',
prefix_delete_sourceSuccess: 'Eliminar Fuente: Éxito',
prefix_delete_user: 'Eliminar Usuario',
prefix_edit_user: 'Editar Usuario',
prefix_edit_userError: 'Editar Usuario: Error',
prefix_edit_userSuccess: 'Editar Usuario: Éxito',
prefix_Env_Load_Err: 'Ambiente: ErrorCarga',
prefix_File_Path: 'Ruta del Archivo',
prefix_Handling_Tool_Request: 'Manejando Solicitud de Herramienta',
prefix_Incoming_Message: 'Mensaje Entrante',
prefix_Lang_Warning: 'Advertencia de Idioma',
prefix_Language: 'Idioma',
prefix_LOG_IPs: 'LOG_IPs',
prefix_login: 'Iniciar Sesión',
prefix_loginError: 'Iniciar Sesión: Error',
prefix_loginSuccess: 'Iniciar Sesión: Éxito',
prefix_logout: 'Cerrar Sesión',
prefix_logoutError: 'Cerrar Sesión: Error',
prefix_logoutSuccess: 'Cerrar Sesión: Éxito',
prefix_MCP_Error: 'Error MCP',
prefix_Missing_Config: 'Configuración Faltante',
prefix_Port: 'Puerto',
prefix_Port_Check: 'Verificación de Puerto',
prefix_Port_Invalid: 'Puerto Inválido',
prefix_Port_Validated: 'Puerto Validado',
prefix_Private_API_URL: 'URL de API Privada',
prefix_Proxy_Config: 'Configuración de Proxy',
prefix_Public_API_URL: 'URL de API Pública',
prefix_PW_Encryption: 'Cifrado de Contraseña',
prefix_requestHeaders: 'Encabezados de Solicitud',
prefix_Restricted_Groups: 'Grupos Restringidos',
prefix_Server_Config: 'Configuración del Servidor',
prefix_Shutdown: 'Apagado',
prefix_SSL_Validation: 'Validación SSL',
prefix_Tool_Disabled: 'Herramienta Deshabilitada',
prefix_Tool_Warn: 'Advertencia de Herramienta',
prefix_URL_Invalid: 'URL Inválida',
prefix_URL_Warning: 'Advertencia de URL',
prefix_URL_Warning_V1: 'Advertencia de URL V1',
prefix_Validation_Err: 'Error de Validación',
prefix_WRITTEN_LOGFILE: 'ARCHIVO_DE_LOG_ESCRITO',
prefix_unknownCommand: 'comandoDesconocido',
prefix_get_sourceError: 'Obtener Fuente: Error',
prefix_get_sourceRequest: 'Obtener Fuente: Solicitud',
prefix_get_sourceSuccess: 'Obtener Fuente: Éxito',
prefix_list_groupsError: 'Listar Grupos: Error',
prefix_list_groupsRequest: 'Listar Grupos: Solicitud',
prefix_list_groupsSuccess: 'Listar Grupos: Éxito',
prefix_list_sourcesError: 'Listar Fuentes: Error',
prefix_list_sourcesRequest: 'Listar Fuentes: Solicitud',
prefix_list_sourcesSuccess: 'Listar Fuentes: Éxito',
prefix_responseReceived: 'Respuesta Recibida',
prefix_store_groupError: 'Almacenar Grupo: Error',
prefix_store_groupRequest: 'Almacenar Grupo: Solicitud',
prefix_store_groupSuccess: 'Almacenar Grupo: Éxito',
prefix_store_user: 'Almacenar Usuario',
prefix_store_userError: 'Almacenar Usuario: Error',
prefix_store_userSuccess: 'Almacenar Usuario: Éxito',
prefix_delete_userSuccess: 'Eliminar Usuario: Éxito',
prefix_delete_userError: 'Eliminar Usuario: Error',
prefix_apiRequestError: 'Solicitud de API: Error',
prefix_create_source: 'Crear Fuente',
prefix_get_source: 'Obtener Fuente',
prefix_list_sources: 'Listar Fuentes',
prefix_edit_source: 'Editar Fuente',
prefix_edit_sourceSuccess: 'Editar Fuente: Éxito',
prefix_edit_sourceError: 'Editar Fuente: Error',
prefix_delete_group: 'Eliminar Grupo',
prefix_list_groups: 'Listar Grupos',
prefix_store_group: 'Almacenar Grupo',
prefix_clientConnected: 'Cliente: Conectado',
prefix_clientDisconnected: 'Cliente: Desconectado',
prefix_logReadError: 'Lectura de Log: Error',
prefix_logChangeError: 'Cambio de Log: Error',
prefix_logViewerRunning: 'Visualizador de Logs: En Ejecución',
prefix_serverError: 'Servidor: Error',
prefix_tcpServerError: 'tcpServer: Error',
prefix_keygenError: 'Keygen: Error',
prefix_edit_sourceRequest: 'Editar Fuente: Solicitud',
prefix_delete_sourceRequest: 'Eliminar Fuente: Solicitud',
prefix_store_userRequest: 'Almacenar Usuario: Solicitud',
prefix_edit_userRequest: 'Editar Usuario: Solicitud',
prefix_delete_userRequest: 'Eliminar Usuario: Solicitud',
prefix_get_chat_infoSuccess: 'Obtener Información del Chat: Éxito',
prefix_keygen: 'Keygen',
prefix_list_groupsWarning: 'Listar Grupos: Advertencia'
},
// Dutch (nl)
nl: {
prefix_openaicompAPI: 'OpenAI compatibele API',
prefix_delete_all_chats: 'VerwijderAlleChats',
prefix_delete_all_chatsRequest: 'VerwijderAlleChats: Verzoek',
prefix_delete_all_chatsSuccess: 'VerwijderAlleChats: Succes',
prefix_delete_all_chatsError: 'VerwijderAlleChats: ApiFout',
prefix_delete_all_chatsWarning: 'VerwijderAlleChats: Waarschuwing',
prefix_delete_chat: 'VerwijderChat',
prefix_delete_chatRequest: 'VerwijderChat: Verzoek',
prefix_delete_chatSuccess: 'VerwijderChat: Succes',
prefix_delete_chatError: 'VerwijderChat: ApiFout',
prefix_delete_chatWarning: 'VerwijderChat: Waarschuwing',
prefix_reactivate_user: 'HeractiveerGebruiker',
prefix_reactivate_userSuccess: 'HeractiveerGebruiker: Succes',
prefix_reactivate_userError: 'HeractiveerGebruiker: Fout',
prefix_EnableTLS: 'TLS_INSCHAKELEN',
prefix_sslKeyPath: 'SSL_SLEUTEL_PAD',
prefix_sslCertPath: 'SSL_CERTIFICAAT_PAD',
prefix_sslError: 'Geen certificaat gevonden.',
prefix_All_Funcs: 'Alle Functies',
prefix_Allow_Keygen: 'Sta Keygen Toe',
prefix_ANONYMOUS_MODE: 'ANONIEME_MODE',
prefix_chat: 'Chat',
prefix_chatApiError: 'Chat: ApiFout',
prefix_chatRequest: 'Chat: Verzoek',
prefix_chatSuccess: 'Chat: Succes',
prefix_chatWarning: 'Chat: Waarschuwing',
prefix_get_chat_info: 'Chat Info Ophalen',
prefix_get_chat_infoError: 'Chat Info Ophalen: Fout',
prefix_continue_chat: 'Chat Doorgaan',
prefix_continue_chatError: 'Chat Doorgaan: Fout',
prefix_continue_chatSuccess: 'Chat Doorgaan: Succes',
prefix_create_sourceError: 'Bron Aanmaken: Fout',
prefix_create_sourceGroupCheck: 'Bron Aanmaken: GroepControl',
prefix_create_sourceInvalidGroups: 'Bron Aanmaken: Ongeldige Groepen',
prefix_create_sourceNoResponse: 'Bron Aanmaken: Geen Reactie',
prefix_create_sourceResponseError: 'Bron Aanmaken: ReactieFout',
prefix_create_sourceSuccess: 'Bron Aanmaken: Succes',
prefix_create_sourceUnknownError: 'Bron Aanmaken: Onbekende Fout',
prefix_Deact_Funcs: 'Functies Deactiveren',
prefix_delete_groupError: 'Groep Verwijderen: Fout',
prefix_delete_groupRequest: 'Groep Verwijderen: Verzoek',
prefix_delete_groupSuccess: 'Groep Verwijderen: Succes',
prefix_delete_source: 'Bron Verwijderen',
prefix_delete_sourceError: 'Bron Verwijderen: Fout',
prefix_delete_sourceSuccess: 'Bron Verwijderen: Succes',
prefix_delete_user: 'Gebruiker Verwijderen',
prefix_edit_user: 'Gebruiker Bewerken',
prefix_edit_userError: 'Gebruiker Bewerken: Fout',
prefix_edit_userSuccess: 'Gebruiker Bewerken: Succes',
prefix_Env_Load_Err: 'Omgeving: LaadFout',
prefix_File_Path: 'Bestandspad',
prefix_Handling_Tool_Request: 'Behandelen Hulpmiddelverzoek',
prefix_Incoming_Message: 'Binnenkomend Bericht',
prefix_Lang_Warning: 'Taal Waarschuwing',
prefix_Language: 'Taal',
prefix_LOG_IPs: 'LOG_IPs',
prefix_login: 'Inloggen',
prefix_loginError: 'Inloggen: Fout',
prefix_loginSuccess: 'Inloggen: Succes',
prefix_logout: 'Uitloggen',
prefix_logoutError: 'Uitloggen: Fout',
prefix_logoutSuccess: 'Uitloggen: Succes',
prefix_MCP_Error: 'MCP Fout',
prefix_Missing_Config: 'Configuratie Ontbreekt',
prefix_Port: 'Poort',
prefix_Port_Check: 'Poort Controle',
prefix_Port_Invalid: 'Ongeldige Poort',
prefix_Port_Validated: 'Poort Gevalideerd',
prefix_Private_API_URL: 'Privé API URL',
prefix_Proxy_Config: 'Proxy Configuratie',
prefix_Public_API_URL: 'Publieke API URL',
prefix_PW_Encryption: 'Wachtwoord Encryptie',
prefix_requestHeaders: 'Verzoek Headers',
prefix_Restricted_Groups: 'Beperkte Groepen',
prefix_Server_Config: 'Server Configuratie',
prefix_Shutdown: 'Afsluiten',
prefix_SSL_Validation: 'SSL Validatie',
prefix_Tool_Disabled: 'Hulpmiddel Uitgeschakeld',
prefix_Tool_Warn: 'Hulpmiddel Waarschuwing',
prefix_URL_Invalid: 'Ongeldige URL',
prefix_URL_Warning: 'URL Waarschuwing',
prefix_URL_Warning_V1: 'URL Waarschuwing V1',
prefix_Validation_Err: 'Validatie Fout',
prefix_WRITTEN_LOGFILE: 'GESCHREVEN_LOGFILE',
prefix_unknownCommand: 'onbekendCommando',
prefix_get_sourceError: 'Bron Ophalen: Fout',
prefix_get_sourceRequest: 'Bron Ophalen: Verzoek',
prefix_get_sourceSuccess: 'Bron Ophalen: Succes',
prefix_list_groupsError: 'Groepen Lijst: Fout',
prefix_list_groupsRequest: 'Groepen Lijst: Verzoek',
prefix_list_groupsSuccess: 'Groepen Lijst: Succes',
prefix_list_sourcesError: 'Bronnen Lijst: Fout',
prefix_list_sourcesRequest: 'Bronnen Lijst: Verzoek',
prefix_list_sourcesSuccess: 'Bronnen Lijst: Succes',
prefix_responseReceived: 'Reactie Ontvangen',
prefix_store_groupError: 'Groep Opslaan: Fout',
prefix_store_groupRequest: 'Groep Opslaan: Verzoek',
prefix_store_groupSuccess: 'Groep Opslaan: Succes',
prefix_store_user: 'Gebruiker Opslaan',
prefix_store_userError: 'Gebruiker Opslaan: Fout',
prefix_store_userSuccess: 'Gebruiker Opslaan: Succes',
prefix_delete_userSuccess: 'Gebruiker Verwijderen: Succes',
prefix_delete_userError: 'Gebruiker Verwijderen: Fout',
prefix_apiRequestError: 'API Verzoek: Fout',
prefix_create_source: 'Bron Aanmaken',
prefix_get_source: 'Bron Ophalen',
prefix_list_sources: 'Bronnen Lijst',
prefix_edit_source: 'Bron Bewerken',
prefix_edit_sourceSuccess: 'Bron Bewerken: Succes',
prefix_edit_sourceError: 'Bron Bewerken: Fout',
prefix_delete_group: 'Groep Verwijderen',
prefix_list_groups: 'Groepen Lijst',
prefix_store_group: 'Groep Opslaan',
prefix_clientConnected: 'Client: Verbonden',
prefix_clientDisconnected: 'Client: Verbroken',
prefix_logReadError: 'Log Lezen: Fout',
prefix_logChangeError: 'Log Wijziging: Fout',
prefix_logViewerRunning: 'LogViewer: Draait',
prefix_serverError: 'Server: Fout',
prefix_tcpServerError: 'tcpServer: Fout',
prefix_keygenError: 'Keygen: Fout',
prefix_edit_sourceRequest: 'Bron Bewerken: Verzoek',
prefix_delete_sourceRequest: 'Bron Verwijderen: Verzoek',
prefix_store_userRequest: 'Gebruiker Opslaan: Verzoek',
prefix_edit_userRequest: 'Gebruiker Bewerken: Verzoek',
prefix_delete_userRequest: 'Gebruiker Verwijderen: Verzoek',
prefix_get_chat_infoSuccess: 'Chat Info Ophalen: Succes',
prefix_keygen: 'Keygen',
prefix_list_groupsWarning: 'Groepen Lijst: Waarschuwing'
},
he:
{
prefix_openaicompAPI: 'API תואם OpenAI',
prefix_delete_all_chats: 'מחקאתכלהשיחות',
prefix_delete_all_chatsRequest: 'מחקאתכלהשיחות: בקשה',
prefix_delete_all_chatsSuccess: 'מחקאתכלהשיחות: הצלחה',
prefix_delete_all_chatsError: 'מחקאתכלהשיחות: שגיאתApi',
prefix_delete_all_chatsWarning: 'מחקאתכלהשיחות: אזהרה',
prefix_delete_chat: 'מחקשיחה',
prefix_delete_chatRequest: 'מחקשיחה: בקשה',
prefix_delete_chatSuccess: 'מחקשיחה: הצלחה',
prefix_delete_chatError: 'מחקשיחה: שגיאתApi',
prefix_delete_chatWarning: 'מחקשיחה: אזהרה',
prefix_reactivate_user: 'הפעלמשתמשמחדש',
prefix_reactivate_userSuccess: 'הפעלמשתמשמחדש: הצלחה',
prefix_reactivate_userError: 'הפעלמשתמשמחדש: שגיאה',
prefix_EnableTLS: 'הפעל_TLS',
prefix_sslKeyPath: 'נתיב_מפתח_SSL',
prefix_sslCertPath: 'נתיב_תעודת_SSL',
prefix_sslError: 'לא נמצאה תעודה.',
prefix_All_Funcs: 'כל הפונקציות',
prefix_Allow_Keygen: 'אפשר יצירת מפתחות',
prefix_ANONYMOUS_MODE: 'מצב אנונימי',
prefix_chat: 'צ׳אט',
prefix_chatApiError: 'צ׳אט: שגיאת API',
prefix_chatRequest: 'צ׳אט: בקשה',
prefix_chatSuccess: 'צ׳אט: הצלחה',
prefix_chatWarning: 'צ׳אט: אזהרה',
prefix_get_chat_info: 'קבל מידע על צ׳אט',
prefix_get_chat_infoError: 'קבל מידע על צ׳אט: שגיאה',
prefix_continue_chat: 'המשך צ׳אט',
prefix_continue_chatError: 'המשך צ׳אט: שגיאה',
prefix_continue_chatSuccess: 'המשך צ׳אט: הצלחה',
prefix_create_sourceError: 'צור מקור: שגיאה',
prefix_create_sourceGroupCheck: 'צור מקור: בדיקת קבוצה',
prefix_create_sourceInvalidGroups: 'צור מקור: קבוצות לא חוקיות',
prefix_create_sourceNoResponse: 'צור מקור: אין תגובה',
prefix_create_sourceResponseError: 'צור מקור: שגיאת תגובה',
prefix_create_sourceSuccess: 'צור מקור: הצלחה',
prefix_create_sourceUnknownError: 'צור מקור: שגיאה לא ידועה',
prefix_Deact_Funcs: 'ביטול פונקציות',
prefix_delete_groupError: 'מחק קבוצה: שגיאה',
prefix_delete_groupRequest: 'מחק קבוצה: בקשה',
prefix_delete_groupSuccess: 'מחק קבוצה: הצלחה',
prefix_delete_source: 'מחק מקור',
prefix_delete_sourceError: 'מחק מקור: שגיאה',
prefix_delete_sourceSuccess: 'מחק מקור: הצלחה',
prefix_delete_user: 'מחק משתמש',
prefix_edit_user: 'ערוך משתמש',
prefix_edit_userError: 'ערוך משתמש: שגיאה',
prefix_edit_userSuccess: 'ערוך משתמש: הצלחה',
prefix_Env_Load_Err: 'שגיאת טעינת סביבה',
prefix_File_Path: 'נתיב קובץ',
prefix_Handling_Tool_Request: 'מטפל בבקשת כלי',
prefix_Incoming_Message: 'הודעה נכנסת',
prefix_Lang_Warning: 'אזהרת שפה',
prefix_Language: 'שפה',
prefix_LOG_IPs: 'יומני IP',
prefix_login: 'התחברות',
prefix_loginError: 'התחברות: שגיאה',
prefix_loginSuccess: 'התחברות: הצלחה',
prefix_logout: 'התנתקות',
prefix_logoutError: 'התנתקות: שגיאה',
prefix_logoutSuccess: 'התנתקות: הצלחה',
prefix_MCP_Error: 'שגיאת MCP',
prefix_Missing_Config: 'תצורה חסרה',
prefix_Port: 'פורט',
prefix_Port_Check: 'בדיקת פורט',
prefix_Port_Invalid: 'פורט לא חוקי',
prefix_Port_Validated: 'פורט תקין',
prefix_Private_API_URL: 'כתובת API פרטית',
prefix_Proxy_Config: 'תצורת פרוקסי',
prefix_Public_API_URL: 'כתובת API ציבורית',
prefix_PW_Encryption: 'הצפנת סיסמה',
prefix_requestHeaders: 'כותרות בקשה',
prefix_Restricted_Groups: 'קבוצות מוגבלות',
prefix_Server_Config: 'תצורת שרת',
prefix_Shutdown: 'כיבוי',
prefix_SSL_Validation: 'אימות SSL',
prefix_Tool_Disabled: 'כלי כבוי',
prefix_Tool_Warn: 'אזהרת כלי',
prefix_URL_Invalid: 'כתובת URL לא חוקית',
prefix_URL_Warning: 'אזהרת URL',
prefix_URL_Warning_V1: 'אזהרת URL גרסה 1',
prefix_Validation_Err: 'שגיאת אימות',
prefix_WRITTEN_LOGFILE: 'קובץ יומן כתוב',
prefix_unknownCommand: 'פקודה לא ידועה',
prefix_get_sourceError: 'קבל מקור: שגיאה',
prefix_get_sourceRequest: 'קבל מקור: בקשה',
prefix_get_sourceSuccess: 'קבל מקור: הצלחה',
prefix_list_groupsError: 'רשימת קבוצות: שגיאה',
prefix_list_groupsRequest: 'רשימת קבוצות: בקשה',
prefix_list_groupsSuccess: 'רשימת קבוצות: הצלחה',
prefix_list_sourcesError: 'רשימת מקורות: שגיאה',
prefix_list_sourcesRequest: 'רשימת מקורות: בקשה',
prefix_list_sourcesSuccess: 'רשימת מקורות: הצלחה',
prefix_responseReceived: 'תגובה התקבלה',
prefix_store_groupError: 'שמור קבוצה: שגיאה',
prefix_store_groupRequest: 'שמור קבוצה: בקשה',
prefix_store_groupSuccess: 'שמור קבוצה: הצלחה',
prefix_store_user: 'שמור משתמש',
prefix_store_userError: 'שמור משתמש: שגיאה',
prefix_store_userSuccess: 'שמור משתמש: הצלחה',
prefix_delete_userSuccess: 'מחק משתמש: הצלחה',
prefix_delete_userError: 'מחק משתמש: שגיאה',
prefix_apiRequestError: 'בקשת API: שגיאה',
prefix_create_source: 'צור מקור',
prefix_get_source: 'קבל מקור',
prefix_list_sources: 'רשימת מקורות',
prefix_edit_source: 'ערוך מקור',
prefix_edit_sourceSuccess: 'ערוך מקור: הצלחה',
prefix_edit_sourceError: 'ערוך מקור: שגיאה',
prefix_delete_group: 'מחק קבוצה',
prefix_list_groups: 'רשימת קבוצות',
prefix_store_group: 'שמור קבוצה',
prefix_clientConnected: 'לקוח: מחובר',
prefix_clientDisconnected: 'לקוח: מנותק',
prefix_logReadError: 'קריאת יומן: שגיאה',
prefix_logChangeError: 'שינוי יומן: שגיאה',
prefix_logViewerRunning: 'צופה יומן: פועל',
prefix_serverError: 'שרת: שגיאה',
prefix_tcpServerError: 'שרת TCP: שגיאה',
prefix_keygenError: 'יצירת מפתח: שגיאה',
prefix_edit_sourceRequest: 'ערוך מקור: בקשה',
prefix_delete_sourceRequest: 'מחק מקור: בקשה',
prefix_store_userRequest: 'שמור משתמש: בקשה',
prefix_edit_userRequest: 'ערוך משתמש: בקשה',
prefix_delete_userRequest: 'מחק משתמש: בקשה',
prefix_get_chat_infoSuccess: 'קבל מידע על צ׳אט: הצלחה',
prefix_keygen: 'יצירת מפתח',
prefix_list_groupsWarning: 'רשימת קבוצות: אזהרה'
}
};
export const messages = {
de: {
ErrorConnReset: 'Verbindung wurde vorzeitig vom Client beendet (ECONNRESET).',
NoTLSCertFound: 'Kein SSL-Zertifikat oder Schlüssel gefunden. Bitte erstellen Sie ein Zertifikat. Zum Beispiel können Sie ein selbstsigniertes Zertifikat mit OpenSSL erstellen:',
deleteChatsSuccess: "Der gesamte Chatverlauf wurde erfolgreich gelöscht.",
deleteChatsError: "Beim Löschen des Chatverlaufs ist ein Fehler aufgetreten: ${error}.",
missingAuthToken: "Das Autorisierungstoken fehlt oder ist ungültig.",
deleteChatsUnauthorized: "Sie sind nicht berechtigt, den Chatverlauf zu löschen.",
deleteChatsServerIssue: "Beim Verarbeiten der Anfrage ist ein Serverfehler aufgetreten.",
deleteChatsNotAllowed: "Das Löschen des Chatverlaufs ist für diesen Benutzer nicht erlaubt.",
missingChatId: "Die Chat-ID fehlt. Bitte geben Sie eine gültige Chat-ID an.",
chatDeleted: "Der Chat mit der ID ${chatId} wurde erfolgreich gelöscht.",
deleteChatError: "Beim Löschen des Chats mit der ID ${chatId} ist ein Fehler aufgetreten: ${error}.",
missingAuthToken: "Das Autorisierungstoken fehlt oder ist ungültig.",
deleteChatUnauthorized: "Sie sind nicht berechtigt, diesen Chat zu löschen.",
deleteChatServerIssue: "Beim Verarbeiten der Anfrage ist ein Serverfehler aufgetreten.",
deleteChatNotAllowed: "Das Löschen dieses Chats ist nicht erlaubt.",
toolDisabledLog: formatMessage(templates.error, { action: 'Funktionsaufruf serverseitig deaktiviert:', details: '${toolName}' }),
toolDisabledError: formatMessage(templates.error, { action: 'Funktionsaufruf serverseitig deaktiviert:', details: '${toolName}' }),
emailRequiredForReactivate: "Eine E-Mail-Adresse ist erforderlich, um einen Benutzer zu reaktivieren.",
reactivateUserLog: "Reaktivierungsprozess für Benutzer wird gestartet: ${UserName}.",
reactivateUserSuccess: "Benutzer erfolgreich reaktiviert: ${data}.",
reactivateUserError: "Fehler bei der Reaktivierung des Benutzers: ${error}. Bitte versuchen Sie es später erneut.",
openaicompAPI: 'ENABLE_OPEN_AI_COMP_API Wert: ${val}',
createSourceError: 'Fehler beim Erstellen der Quelle: ${error}',
create_sourceUnknownError: 'Unbekannter Fehler beim Erstellen der Quelle: ${error}',
returnStatus: 'Status: ${Status}',
extractedToken: 'Extrahiertes Token: ${token}',
missingChatId: 'chatId ist erforderlich, um Chat-Informationen abzurufen.',
missingQuestion: 'Frage in den Argumenten fehlt.',
ChatInfoRetrieved: 'Chat-Informationen abgerufen: ${chatData}',
InvalidGroups: 'Ungültige Gruppen: ${GROUPS}',
sourceIdRequiredEditSource: 'sourceId ist erforderlich, um eine Quelle zu bearbeiten.',
sourceIdRequiredRetrieveSource: 'sourceId ist erforderlich, um eine Quelle abzurufen.',
ConnectionEstablished: 'Verbindung hergestellt',
ResponseSuccessfullySent: 'Antwort erfolgreich gesendet',
ConnectionClosed: 'Verbindung geschlossen',
ServerStopped: 'Server wurde gestoppt',
responseReceived: 'Antwort empfangen mit Status: ${status}',
internalServerError: 'Interner Serverfehler',
tcpServerError: 'Ein Fehler ist im TCP-Server aufgetreten:',
unknownErrorOccured: 'Ein unbekannter Fehler ist aufgetreten.',
KeygenRequired: 'Keygen erforderlich',
unknownCommand: 'Unbekannter Befehl',
socketEmitLogNotActivated: 'Protokolldatei ist nicht aktiviert.',
socketEmitLogReadError: 'Fehler beim Lesen der Protokolldatei.',
deletesourceLog: 'Quelle löschen mit Namen: ${SourceName}',
sourceIdRequiredDeleteSource: 'sourceId ist erforderlich, um die Quelle zu löschen.',
listGroupsSuccess: 'Gruppenliste abgerufen: ${GROUPS}',
toolNotDefinedInConfig: 'Ungültiger Funktionsaufruf: ${warn}',
toolDisabledLog: 'Funktionsaufruf serverseitig deaktiviert: ${warn}',
toolDisabledError: 'Funktionsaufruf serverseitig deaktiviert: ${warn}',
accessRestrictedGroups: 'RESTRICTED_GROUPS Wert: ${val}',
allFunctionsEnabled: 'Alle Funktionen sind aktiviert',
allGroupsValid: 'Alle Gruppen sind gültig',
AllowLoggingSuccess: 'ALLOW_LOGGING ist aktiviert: ${status}',
anonymousModeSuccess: 'ANONYMOUS_MODE ist aktiviert: ${status}',
apiErrorDetails: 'API Fehler: Status: ${status}, Daten: ${data}',
apiRequestError: 'API Anforderungsfehler: ${error}',
apiUrlInvalid: 'Ungültige API_URL',
apiUrlValidated: 'API_URL erfolgreich validiert: ${url}',
apiUrlWarning: 'Warnung: API_URL beginnt nicht mit \"https://\". Die URL wird angepasst.',
apiUrlWarningV1: 'Warnung: API_URL endet nicht mit "/api/v1". Die URL wird angepasst.',
authFailed: 'Authentifizierung fehlgeschlagen.',
authStarted: 'Authentifizierung gestartet.',
availableGroups: 'Verfügbare Gruppen: ${availableGroups}',
chatApiErrorDefault: 'Fehler während der Chat-Anfrage.',
chatApiError: 'Fehler in der Chat-API-Anfrage: ${error}',
chatResponseSuccess: 'Chat-Antwort empfangen: ${data}',
checkingGroups: 'Gruppen werden überprüft: ${groups}',
clientConnected: 'WebSocket-Client verbunden',
clientDisconnected: 'WebSocket-Client getrennt',
connection: {
new: 'Neue Verbindung akzeptiert von ${ip}:${port}',
established: 'Verbindung hergestellt',
closed: 'Verbindung geschlossen: ${ip}:${port}',
dataReceived: 'Daten empfangen von ${ip}:${port}: ${data}'
},
errors: {
processMessage: 'Fehler beim Verarbeiten der Nachricht: ${error}',
invalidMessage: 'Ungültiges Nachrichtenformat',
socketError: 'Socket-Fehler bei ${ip}:${port}: ${error}',
serverError: 'Serverfehler: ${error}'
},
server: {
running: 'Server läuft auf Port ${port}',
stopped: 'Server wurde gestoppt'
},
continueConversationError: 'Fehler beim Fortsetzen des Gesprächs.',
conversationContinuation: 'Gespräch wird fortgesetzt, ID: ${chatId}',
conversationSuccess: 'Gespräch erfolgreich fortgesetzt: ${data}',
createGroupSuccess: 'Gruppe erfolgreich erstellt: ${data}',
createSourceLog: 'Quelle bearbeiten mit ID: ${sourceId}, Titel: ${title}',
createSourceSuccess: 'Quelle erfolgreich erstellt: ${data}',
createUserError: 'Fehler beim Erstellen des Benutzers: ${error}',
createUserLog: 'Neuen Benutzer erstellen: ${payload}',
createUserSuccess: 'Benutzer erfolgreich erstellt: ${data}',
deactivatedFunctions: 'Deaktivierte Funktionen:',
deleteGroupInternalError: 'Interner Fehler beim Löschen der Gruppe.',
deleteGroupLog: 'Gruppe löschen mit Namen: ${groupName}',
deleteGroupSuccessLog: 'Gruppe erfolgreich gelöscht: ${data}',
deleteGroupText: 'Gruppe \"${groupName}\" wurde erfolgreich gelöscht.',
deleteSourceError: 'Fehler beim Löschen der Quelle: ${error}',
deleteSourceFailedTryAgain: 'Löschen der Quelle fehlgeschlagen. Bitte versuchen Sie es später erneut.',
deleteUserError: 'Fehler beim Löschen des Benutzers: ${error}',
deleteUserLog: 'Benutzer löschen mit Namen: ${UserName}',
deleteUserSuccess: 'Benutzer erfolgreich gelöscht: ${data}',
decryptPwdError: 'Das Passwort konnte nicht entschlüsselt werden.',
decryptionError: 'Entschlüsselungsfehler.',
dataReceivedMsg: 'Daten empfangen: ${data}',
emailRequiredForDelete: 'E-Mail ist erforderlich, um einen Benutzer zu löschen.',
emailRequiredForEdit: 'Benutzer-E-Mail ist erforderlich, um den Datensatz zu bearbeiten.',
editSourceError: 'Fehler beim Bearbeiten der Quelle: ${error}',
editSourceLog: 'Quelle bearbeiten mit ID: ${sourceId}, Titel: ${title}',
editSourceSuccess: 'Quelle erfolgreich bearbeitet: ${data}',
editUserError: 'Fehler beim Bearbeiten des Benutzers: ${error}',
editUserSuccess: 'Benutzer erfolgreich bearbeitet: ${data}',
encryptPwdError: 'Das Passwort konnte nicht verschlüsselt werden.',
encryptionDisabled: 'Deaktiviert',
encryptionEnabled: 'Aktiviert',
encryptionError: 'Verschlüsselungsfehler.',
errorHandlingRequest: 'Fehler bei der Bearbeitung der Anfrage: ${error}',
errorProcessingMsg: 'Fehler bei der Verarbeitung der Nachricht: ${error}',
fetchChatInfoError: 'Fehler beim Abrufen der Chat-Informationen: ${error}',
fetchGroupsError: 'Fehler beim Abrufen der Gruppen: ${error}',
fetchGroupsErrorBackup: 'Fehler beim Abrufen der Gruppen.',
fetchGroupsErrorPrefix: 'Fehler beim Abrufen der Gruppen:',
fetchSourcesError: 'Fehler beim Abrufen der Quellen.',
fetchingSources: 'Quellen für Gruppe: ${groupName} werden abgerufen.',
fileReadErrorTitle: 'Fehler beim Lesen der Datei.',
functionDisabled: 'deaktiviert',
genericServerErrorPrefix: 'Fehler:',
gotGetSourceResponse: 'Antwort für get_source erhalten: ${data}',
gotListGroupsResponse: 'Antwort für list_groups erhalten: ${response}',
gotListSourcesResponse: 'Antwort für list_sources erhalten: ${data}',
groupFetchError: 'Fehler beim Abrufen der Gruppen: Bitte versuchen Sie es später erneut.',
groupNameRequired: 'Gruppenname ist für diese Anfrage erforderlich.',
groupValidationError: 'Fehler bei der Validierung der Gruppe: ${error}',
groupValidationErrorPrefix: 'Fehler: ${error}',
handlingToolRequest: 'Bearbeite Tool-Anfrage: ${tool}',
headers: 'Header: ${headers}',
incomingMessage: 'Eingehende Nachricht: ${MESSAGE}',
invalidArgumentsError: 'Fehler: Keine gültigen Argumente gefunden in der Eingabe: ${input}',
invalidGroups: 'Ungültige Gruppen: ${groups}',
invalidGroupsError: 'Ungültige Gruppen: ${invalidGroups}',
invalidGroupsLog: 'Ungültig: ${groups}',
invalidMessage: 'Ungültige Nachricht',
invalidOrEmptyRequest: 'Ungültige Nachricht oder leere Anfrage.',
keygenDisabled: 'Deaktiviert',
keygenEnabled: 'Aktiviert',
keygenErrorPrefix: 'Fehler bei der Keygen-Anfrage:',
keygenSuccess: 'Keygen erfolgreich abgeschlossen.',
langNotSupported: 'Sprache \"${lang}\" wird nicht unterstützt. Fallback zu Englisch.',
loginEmailPasswordRequired: 'Anmeldung fehlgeschlagen: E-Mail und Passwort sind erforderlich.',
loginError: 'Anmeldefehler: ${error}',
loginErrorPrefix: 'Fehler: ${error}',
loginMissingCredentials: 'Anmeldung fehlgeschlagen: E-Mail und Passwort sind erforderlich.',
loginMissingCredentialsAlternative: 'Anmeldung fehlgeschlagen: E-Mail und Passwort sind erforderlich.',
loginResponse: 'Anmeldeantwort',
loginSuccess: 'Anmeldung erfolgreich: ${data}',
loginTokenReceived: 'Token empfangen: ${token}',
LogIpsSuccess: 'LOG_IPs ist aktiviert: ${status}',
logChangeError: 'Fehler bei der Verarbeitung von Logdatei-Änderungen: ${error}',
logReadError: 'Fehler beim Lesen der Logdatei: ${error}',
logViewerRunning: 'Log-Viewer läuft unter http://localhost:${port}',
logoutError: 'Fehler beim Logout: ${error}',
logoutFailedTryAgain: 'Logout fehlgeschlagen. Bitte versuchen Sie es später erneut.',
logoutSuccess: 'Logout erfolgreich: ${data}',
makingGetSourceRequest: 'get_source Anfrage erstellen: ${args}',
makingListGroupsRequest: 'list_groups Anfrage erstellen',
makingListSourcesRequest: 'list_sources Anfrage erstellen: ${args}',
mcpVersion: 'Version:',
mcpPort: 'Port:',
mcpStartTime: 'Startzeit:',
mcpLicense: 'Lizenz:',
method: 'Methode: ${method}',
missingArgumentsError: 'Fehlende Argumente: ${args}',
missingChatParams: 'Fehlende erforderliche Parameter: chatId und/oder question.',
missingCommandParameter: 'Fehlender Befehlsparameter in der Nachricht.',
missingConfigError: 'Fehlende .json Konfigurationsvariable: ${key}',
missingGroupNameAndDesc: 'Fehlende erforderliche Parameter: groupName und Beschreibung.',
missingGroupNameParam: 'Fehlender erforderlicher Parameter: groupName.',
missingGroupParameterDelete: 'Löschen: Fehlender erforderlicher Parameter: groupName.',
missingGroupParameterStore: 'Speichern: Fehlender erforderlicher Parameter: groupName.',
missingNameAndContent: 'Fehlende erforderliche Parameter: Name und Inhalt.',
missingNameEmailPwd: 'Fehlende erforderliche Parameter: Name, E-Mail oder Passwort.',
missingParametersError: 'Fehlende Parameter: ${parameters}',
missingParameterError: 'Fehlender erforderlicher Parameter: ${parameter}.',
missingTokenAuth: 'Token fehlt',
missingTokenError: 'Token fehlt. Bitte melden Sie sich an und versuchen Sie es erneut.',
missingTokenGroups: 'Token fehlt. Gruppen können nicht validiert werden.',
missingToolName: 'Name der Funktion fehlt',
missingUriParameter: 'URI-Parameter fehlt.',
noChatData: 'Keine Daten für den angegebenen Chat gefunden.',
noDescriptionProvided: 'Keine Beschreibung angegeben',
noErrorMessage: 'Keine Fehlermeldung.',
noServerResponse: 'Keine Antwort vom Server erhalten.',
passwordEncEnabled: 'Passwortverschlüsselung ist aktiviert.',
passwordIsRequired: 'Passwort ist erforderlich.',
payload: 'Payload: ${payload}',
portInUse: 'Portfehler: Port ${PORT} ist bereits in Benutzung.',
portInvalid: 'Portfehler: PORT muss eine Zahl zwischen 1 und 65535 sein.',
portValidated: 'PORT erfolgreich validiert: ${port}',
proxyAuthMissing: 'Proxy-Authentifizierungsdaten fehlen.',
proxyUseProxy: 'USE_PROXY: ${val}',
publicGroupsConflictWarning: 'Konflikt: usePublic wurde auf false gesetzt, da Gruppen angegeben sind.',
requestError: 'Anforderungsfehler: ${error}',
requestSent: 'Anfrage gesendet',
restrictedGroupsError: "Fehler: Ungültige RESTRICTED_GROUPS Konfiguration. Muss 'true' oder 'false' sein. Aktueller Wert: ${value}",
restrictedGroupsSuccess: 'RESTRICTED_GROUPS ist aktiviert: ${status}',
restrictedGroupsWarning: 'RESTRICTED_GROUPS aktiviert. Verfügbare Gruppen sind eingeschränkt.',
responseError: 'Antwortfehler: ${error}',
responseSentSuccess: 'Status: Erfolg',
serverError: 'Server konnte nicht gestartet werden: ${error}',
serverListeningOnPort: 'Server hört auf Port ${port}',
serverRunning: 'Server läuft auf Port ${port}',
serverShutdownLog: 'Server heruntergefahren',
serverStartedLog: 'Server gestartet.',
serverStoppedLog: 'Server gestoppt',
sendingChatRequest: 'Chat-Anfrage an API senden',
sourcesRetrieved: 'Quellen abgerufen: ${data}',
startingServerWithConfig: 'Server wird mit folgender Konfiguration gestartet:',
sslValidationSet: '${symbol} SSL-Validierung ist eingestellt auf: ${value}',
socketErrorPrefix: 'Fehler:',
storeGroupLog: 'Neue Gruppe speichern mit Namen: ${groupName} und Beschreibung: ${description}',
storeGroupSuccess: 'Gruppe erfolgreich gespeichert: ${data}',
storegroupError: 'Fehler beim Erstellen der Gruppe: ${error}',
storeGroupText: 'Gruppe \"${groupName}\" erfolgreich mit ID: ${id} gespeichert.',
unknownAddress: 'Unbekannte IP',
unknownCommandError: 'Unbekannter Befehl: ${cmd}',
unknownError: 'Unbekannter Fehler',
unknownPort: 'Unbekannter Port',
unknownTool: 'Unbekanntes Tool: ${toolName}',
tokenMissing: 'Token fehlt.'
},
en: {
ErrorConnReset: 'Connection terminated prematurely by the client (ECONNRESET).',
NoTLSCertFound: 'No SSL certificate or key found. Please create a certificate. For example, you can create a self-signed certificate with OpenSSL:',
deleteChatsSuccess: "All chat history has been successfully deleted.",
deleteChatsError: "An error occurred while deleting chat history: ${error}.",
missingAuthToken: "Authorization token is missing or invalid.",
deleteChatsUnauthorized: "You are not authorized to delete chat history.",
deleteChatsServerIssue: "A server error occurred while processing the request.",
deleteChatsNotAllowed: "Deleting chat history is not allowed for this user.",
missingChatId: "Chat ID is missing. Please provide a valid chat ID.",
chatDeleted: "Chat with ID ${chatId} has been successfully deleted.",
deleteChatError: "An error occurred while deleting chat with ID ${chatId}: ${error}.",
missingAuthToken: "Authorization token is missing or invalid.",
deleteChatUnauthorized: "You are not authorized to delete this chat.",
deleteChatServerIssue: "A server error occurred while processing the request.",
deleteChatNotAllowed: "Deleting this chat is not allowed.",
toolDisabledLog: formatMessage(templates.error, { action: 'Function call disabled server-side:', details: '${toolName}' }),
toolDisabledError: formatMessage(templates.error, { action: 'Function call disabled server-side:', details: '${toolName}' }),
emailRequiredForReactivate: "An email address is required to reactivate a user.",
reactivateUserLog: "Starting reactivation process for user: ${UserName}.",
reactivateUserSuccess: "User reactivated successfully: ${data}.",
reactivateUserError: "Error reactivating user: ${error}. Please try again later.",
// NEW ***************************************************
openaicompAPI: 'ENABLE_OPEN_AI_COMP_API value: ${val}',
createSourceError: 'Error creating source: ${error}',
create_sourceUnknownError: 'Unknown error creating source: ${error}',
returnStatus: 'Status: ${Status}',
extractedToken: 'Extracted Token: ${token}',
missingChatId: 'chatId is required to retrieve chat information.',
missingQuestion: 'Missing question in the arguments.',
ChatInfoRetrieved: 'Chat information retrieved: ${chatData}',
InvalidGroups: 'Invalid groups: ${GROUPS}',
sourceIdRequiredEditSource: "sourceId is required to edit a source.",
sourceIdRequiredRetrieveSource: 'sourceId is required to retrieve a source.',
ConnectionEstablished: 'Connection established',
ResponseSuccessfullySent: 'Response successfully sent',
ConnectionClosed: 'Connection closed',
ServerStopped: 'Server has been stopped',
responseReceived: 'Response received with status: ${status}',
internalServerError: 'Internal Server error',
tcpServerError: 'An error occurred in the TCP server:',
unknownErrorOccured: 'An unknown error occurred.',
KeygenRequired: 'Keygen required',
unknownCommand: 'Unknown Command',
socketEmitLogNotActivated: 'Log file is not activated.',
socketEmitLogReadError: 'Error reading Log file.',
deletesourceLog: formatMessage(templates.info, { action: 'Delete Source', details: 'with name: ${SourceName}' }),
sourceIdRequiredDeleteSource: 'sourceId is required to delete source.',
listGroupsSuccess: 'Groups list retrieved: ${GROUPS}',
//Existing ones
toolNotDefinedInConfig: formatMessage(templates.error, { action: 'Invalid function call', details: '${warn}' }),
accessRestrictedGroups: formatMessage(templates.info, { action: 'RESTRICTED_GROUPS Value', details: '${val}' }),
allFunctionsEnabled: formatMessage(templates.success, { action: 'All functions are enabled', details: '' }),
allGroupsValid: formatMessage(templates.success, { action: 'All groups are valid', details: '' }),
AllowLoggingSuccess: formatMessage(templates.success, { action: 'ALLOW_LOGGING', details: 'is enabled: ${status}' }),
anonymousModeSuccess: formatMessage(templates.success, { action: 'ANONYMOUS_MODE', details: 'is enabled: ${status}' }),
apiErrorDetails: formatMessage(templates.error, { action: 'API Error', details: 'Status: ${status}, Data: ${data}' }),
apiRequestError: formatMessage(templates.error, { action: 'API Request Error', details: '${error}' }),
apiUrlInvalid: formatMessage(templates.error, { action: 'Invalid API_URL', details: '' }),
apiUrlValidated: formatMessage(templates.success, { action: 'API_URL successfully validated', details: '${url}' }),
apiUrlWarning: formatMessage(templates.warning, { action: 'Warning', details: 'API_URL does not start with "https://". The URL is being adjusted.' }),
apiUrlWarningV1: formatMessage(templates.warning, { action: 'Warning', details: 'API_URL does not end with "/api/v1". The URL is being adjusted.' }),
authFailed: 'Authentication failed.',
authStarted: 'Authentication started.',
availableGroups: formatMessage(templates.success, { action: 'Available Groups', details: '${availableGroups}' }),
chatApiErrorDefault: 'Error during chat request.',
chatApiError: formatMessage(templates.error, { action: 'Error in Chat API request', details: '${error}' }),
chatResponseSuccess: formatMessage(templates.success, { action: 'Chat response received', details: '${data}' }),
checkingGroups: formatMessage(templates.info, { action: 'Checking groups', details: '${groups}' }),
clientConnected: formatMessage(templates.info, { action: 'WebSocket client connected', details: '' }),
clientDisconnected: formatMessage(templates.info, { action: 'WebSocket client disconnected', details: '' }),
connection: {
new: formatMessage(templates.info, { action: 'New connection accepted', details: 'from ${ip}:${port}' }),
established: formatMessage(templates.success, { action: 'Connection established', details: '' }),
closed: formatMessage(templates.info, { action: 'Connection closed', details: '${ip}:${port}' }),
dataReceived: formatMessage(templates.info, { action: 'Data received', details: 'from ${ip}:${port}: ${data}' }),
},
errors: {
processMessage: formatMessage(templates.error, { action: 'Error processing message', details: '${error}' }),
invalidMessage: formatMessage(templates.error, { action: 'Invalid message format', details: '' }),
socketError: formatMessage(templates.error, { action: 'Socket error', details: 'at ${ip}:${port}: ${error}' }),
serverError: formatMessage(templates.error, { action: 'Server error', details: '${error}' }),
},
server: {
running: formatMessage(templates.success, { action: 'Server is running', details: 'on port ${port}' }),
stopped: formatMessage(templates.info, { action: 'Server has been stopped', details: '' }),
},
continueConversationError: formatMessage(templates.error, { action: 'Error continuing conversation', details: '' }),
conversationContinuation: formatMessage(templates.success, { action: 'Conversation is continuing', details: 'ID: ${chatId}' }),
conversationSuccess: formatMessage(templates.success, { action: 'Conversation successfully continued', details: '${data}' }),
createGroupSuccess: formatMessage(templates.success, { action: 'Group successfully created', details: '${data}' }),
createSourceLog: 'Editing source with ID: ${sourceId}, Title: ${title}',
createSourceSuccess: 'Source successfully created: ${data}',
createUserError: 'Error creating user: ${error}',
createUserLog: 'Creating new user: ${payload}',
createUserSuccess: 'User successfully created: ${data}',
deactivatedFunctions: 'Deactivated functions:',
deleteGroupInternalError: 'Internal error deleting group.',
deleteGroupLog: formatMessage(templates.info, { action: 'Deleting group', details: 'with name: ${groupName}' }),
deleteGroupSuccessLog: formatMessage(templates.success, { action: 'Group successfully deleted', details: '${data}' }),
deleteGroupText: 'Group "${groupName}" was successfully deleted.',
deleteSourceError: 'Error deleting source: ${error}',
deleteSourceFailedTryAgain: 'Deleting the source failed. Please try again later.',
deleteUserError: 'Error deleting user: ${error}',
deleteUserLog: formatMessage(templates.info, { action: 'Deleting user', details: 'with name: ${UserName}' }),
deleteUserSuccess: 'User successfully deleted: ${data}',
decryptPwdError: 'The password could not be decrypted.',
decryptionError: 'Decryption error.',
dataReceivedMsg: 'Data received: ${data}',
emailRequiredForDelete: 'Email is required to delete a user.',
emailRequiredForEdit: 'User email is required to edit the record.',
editSourceError: 'Error editing source: ${error}',
editSourceLog: 'Editing source with ID: ${sourceId}, Title: ${title}',
editSourceSuccess: 'Source successfully edited: ${data}',
editUserError: 'Error editing user: ${error}',
editUserSuccess: 'User successfully edited: ${data}',
encryptPwdError: 'The password could not be encrypted.',
encryptionDisabled: 'Disabled',
encryptionEnabled: 'Enabled',
encryptionError: 'Encryption error.',
errorHandlingRequest: formatMessage(templates.error, { action: 'Error handling request', details: '${error}' }),
errorProcessingMsg: formatMessage(templates.error, { action: 'Error processing message:', details: '${error}' }),
fetchChatInfoError: 'Error fetching chat information: ${error}',
fetchGroupsError: formatMessage(templates.error, { action: 'Error fetching groups', details: '${error}' }),
fetchGroupsErrorBackup: 'Error fetching groups.',
fetchGroupsErrorPrefix: 'Error fetching groups:',
fetchSourcesError: formatMessage(templates.error, { action: 'Error fetching sources', details: '' }),
fetchingSources: formatMessage(templates.info, { action: 'Fetching sources for group: ${groupName}', details: '' }),
fileReadErrorTitle: 'Error reading file.',
functionDisabled: 'disabled',
genericServerErrorPrefix: 'Error:',
gotGetSourceResponse: formatMessage(templates.success, { action: 'Received response for get_source', details: '${data}' }),
gotListGroupsResponse: formatMessage(templates.success, { action: 'Received response for list_groups', details: '${response}' }),
gotListSourcesResponse: formatMessage(templates.success, { action: 'Received response for list_sources', details: '${data}' }),
groupFetchError: 'Error fetching groups: Please try again later.',
groupNameRequired: 'Group name is required for this request.',
groupValidationError: 'Error validating group: ${error}',
groupValidationErrorPrefix: 'Error: ${error}',
handlingToolRequest: 'Handling tool request: ${tool}',
headers: 'Headers: ${headers}',
incomingMessage: 'Incoming message: ${MESSAGE}',
invalidArgumentsError: 'Error: No valid arguments found in input: ${input}',
invalidGroups: 'Invalid groups: ${groups}',
invalidGroupsError: 'Invalid groups: ${invalidGroups}',
invalidGroupsLog: 'Invalid: ${groups}',
invalidMessage: 'Invalid message',
invalidOrEmptyRequest: 'Invalid message or empty request.',
keygenDisabled: 'Disabled',
keygenEnabled: 'Enabled',
keygenErrorPrefix: 'Error with keygen request:',
keygenSuccess: 'Keygen completed successfully.',
langNotSupported: 'Language "${lang}" is not supported. Falling back to English.',
loginEmailPasswordRequired: 'Login failed: Email and password are required.',
loginError: formatMessage(templates.error, { action: 'Login error', details: '${error}' }),
loginErrorPrefix: 'Error: ${error}',
loginMissingCredentials: 'Login failed: Email and password are required.',
loginMissingCredentialsAlternative: 'Login failed: Email and password are required.',
loginResponse: 'Login response',
loginSuccess: formatMessage(templates.success, { action: 'Login successful', details: '${data}' }),
loginTokenReceived: 'Token received: ${token}',
LogIpsSuccess: formatMessage(templates.success, { action: 'LOG_IPs', details: 'is enabled: ${status}' }),
logChangeError: 'Error processing log file changes: ${error}',
logReadError: 'Error reading log file: ${error}',
logViewerRunning: 'Log viewer is running at http://localhost:${port}',
logoutError: 'Error during logout: ${error}',
logoutFailedTryAgain: 'Logout failed. Please try again later.',
logoutSuccess: 'Logout successful: ${data}',
makingGetSourceRequest: 'Creating get_source request: ${args}',
makingListGroupsRequest: 'Creating list_groups request',
makingListSourcesRequest: 'Creating list_sources request: ${args}',
mcpVersion: 'Version:',
mcpPort: 'Port:',
mcpStartTime: 'Start time:',
mcpLicense: 'License:',
method: 'Method: ${method}',
missingArgumentsError: 'Missing arguments: ${args}',
missingChatParams: 'Missing required parameters: chatId and/or question.',
missingCommandParameter: 'Missing command parameter in the message.',
missingConfigError: 'Missing .json configuration variable: ${key}',
missingGroupNameAndDesc: 'Missing required parameters: groupName and description.',
missingGroupNameParam: 'Missing required parameter: groupName.',
missingGroupParameterDelete: 'Delete: Missing required parameter: groupName.',
missingGroupParameterStore: 'Store: Missing required parameter: groupName.',
missingNameAndContent: 'Missing required parameters: name and content.',
missingNameEmailPwd: 'Missing required parameters: name, email, or password.',
missingParametersError: formatMessage(templates.error, { action: 'Missing parameters', details: '${parameters}' }),
missingParameterError: 'Missing required parameter: ${parameter}.',
missingTokenAuth: 'Missing token',
missingTokenError: 'Token missing. Please log in and try again.',
missingTokenGroups: 'Token missing. Groups cannot be validated.',
missingToolName: 'Missing tool name',
missingUriParameter: 'Missing URI parameter.',
noChatData: 'No data found for the specified chat.',
noDescriptionProvided: 'No description provided',
noErrorMessage: 'No error message.',
noServerResponse: 'No response received from server.',
passwordEncEnabled: 'Password encryption is enabled.',
passwordIsRequired: 'Password is required.',
payload: 'Payload: ${payload}',
portInUse: 'Port error: Port ${PORT} is already in use.',
portInvalid: 'Port error: PORT must be a number between 1 and 65535.',
portValidated: 'PORT successfully validated: ${port}',
proxyAuthMissing: 'Proxy authentication data missing.',
proxyUseProxy: 'USE_PROXY: ${val}',
publicGroupsConflictWarning: 'Conflict: usePublic has been set to false because groups are specified.',
requestError: 'Request error: ${error}',
requestSent: 'Request sent',
restrictedGroupsError: 'Error: Invalid RESTRICTED_GROUPS configuration. Must be \'true\' or \'false\'. Current value: ${value}',
restrictedGroupsSuccess: 'RESTRICTED_GROUPS is enabled: ${status}',
restrictedGroupsWarning: 'RESTRICTED_GROUPS enabled. Available groups are restricted.',
responseError: 'Response error: ${error}',
// responseReceived: formatMessage(templates.success, { action: 'Response received', details: '${response}' }),
responseSentSuccess: formatMessage(templates.success, { action: 'Status', details: 'Success' }),
serverError: formatMessage(templates.error, { action: 'Server could not be started', details: '${error}' }),
serverListeningOnPort: 'Server listening on port ${port}',
serverRunning: 'Server is running on port ${port}',
serverShutdownLog: 'Server shutdown',
serverStartedLog: 'Server started.',
serverStoppedLog: 'Server stopped',
sendingChatRequest: 'Sending chat request to API',
sourcesRetrieved: formatMessage(templates.success, { action: 'Sources retrieved', details: '${data}' }),
startingServerWithConfig: 'Starting server with the following configuration:',
sslValidationSet: '${symbol} SSL validation is set to: ${value}',
socketErrorPrefix: 'Error:',
storeGroupLog: 'Storing a new group with name: ${groupName} and description: ${description}',
storeGroupSuccess: 'Group successfully stored: ${data}',
storegroupError: 'Error creating group: ${error}',
storeGroupText: 'Group "${groupName}" successfully stored with ID: ${id}.',
unknownAddress: 'Unknown IP',
unknownCommandError: formatMessage(templates.error, { action: 'Unknown command', details: '${cmd}' }),
unknownError: formatMessage(templates.error, { action: 'Unknown error', details: '' }),
unknownPort: 'Unknown port',
unknownTool: 'Unknown tool: ${toolName}',
tokenMissing: 'Token missing.',
},
pt: {
ErrorConnReset: 'Conexão encerrada prematuramente pelo cliente (ECONNRESET).',
NoTLSCertFound: 'Nenhum certificado ou chave SSL encontrado. Por favor, crie um certificado. Por exemplo, você pode criar um certificado autoassinado com OpenSSL:',
deleteChatsSuccess: "Todo o histórico de chat foi excluído com sucesso.",
deleteChatsError: "Ocorreu um erro ao excluir o histórico de chat: ${error}.",
missingAuthToken: "O token de autorização está ausente ou é inválido.",
deleteChatsUnauthorized: "Você não está autorizado a excluir o histórico de chat.",
deleteChatsServerIssue: "Ocorreu um erro no servidor ao processar a solicitação.",
deleteChatsNotAllowed: "A exclusão do histórico de chat não é permitida para este usuário.",
missingChatId: "O ID do chat está ausente. Por favor, forneça um ID de chat válido.",
chatDeleted: "O chat com ID ${chatId} foi excluído com sucesso.",
deleteChatError: "Ocorreu um erro ao excluir o chat com ID ${chatId}: ${error}.",
missingAuthToken: "O token de autorização está ausente ou é inválido.",
deleteChatUnauthorized: "Você não está autorizado a excluir este chat.",
deleteChatServerIssue: "Ocorreu um erro no servidor ao processar a solicitação.",
deleteChatNotAllowed: "A exclusão deste chat não é permitida.",
toolDisabledLog: formatMessage(templates.error, { action: 'Chamada de função desativada no servidor:', details: '${toolName}' }),
toolDisabledError: formatMessage(templates.error, { action: 'Chamada de função desativada no servidor:', details: '${toolName}' }),
emailRequiredForReactivate: "Um endereço de e-mail é necessário para reativar um usuário.",
reactivateUserLog: "Iniciando o processo de reativação do usuário: ${UserName}.",
reactivateUserSuccess: "Usuário reativado com sucesso: ${data}.",
reactivateUserError: "Erro ao reativar o usuário: ${error}. Por favor, tente novamente mais tarde.",
createSourceError: 'Erro ao criar a fonte: ${error}',
create_sourceUnknownError: 'Erro desconhecido ao criar a fonte: ${error}',
returnStatus: 'Status: ${Status}',
extractedToken: 'Token extraído: ${token}',
missingChatId: 'chatId é necessário para recuperar informações do chat.',
missingQuestion: 'Pergunta ausente nos argumentos.',
ChatInfoRetrieved: 'Informações do chat recuperadas: ${chatData}',
InvalidGroups: 'Grupos inválidos: ${GROUPS}',
sourceIdRequiredEditSource: 'sourceId é necessário para editar uma fonte.',
sourceIdRequiredRetrieveSource: 'sourceId é necessário para recuperar uma fonte.',
ConnectionEstablished: 'Conexão estabelecida',
ResponseSuccessfullySent: 'Resposta enviada com sucesso',
ConnectionClosed: 'Conexão fechada',
ServerStopped: 'Servidor foi parado',
responseReceived: 'Resposta recebida com status: ${status}',
internalServerError: 'Erro interno do servidor',
tcpServerError: 'Ocorreu um erro no servidor TCP:',
unknownErrorOccured: 'Ocorreu um erro desconhecido.',
KeygenRequired: 'Keygen necessário',
unknownCommand: 'Comando desconhecido',
socketEmitLogNotActivated: 'Arquivo de log não está ativado.',
socketEmitLogReadError: 'Erro ao ler o arquivo de log.',
deletesourceLog: 'Excluir fonte com nome: ${SourceName}',
sourceIdRequiredDeleteSource: 'sourceId é necessário para excluir a fonte.',
listGroupsSuccess: 'Lista de grupos recuperada: ${GROUPS}',
toolNotDefinedInConfig: 'Chamada de função inválida: ${warn}',
toolDisabledLog: 'Chamada de função desativada no servidor: ${warn}',
toolDisabledError: 'Chamada de função desativada no servidor: ${warn}',
accessRestrictedGroups: 'Valor de RESTRICTED_GROUPS: ${val}',
allFunctionsEnabled: 'Todas as funções estão habilitadas',
allGroupsValid: 'Todos os grupos são válidos',
AllowLoggingSuccess: 'ALLOW_LOGGING está habilitado: ${status}',
anonymousModeSuccess: 'ANONYMOUS_MODE está habilitado: ${status}',
apiErrorDetails: 'Erro na API: Status: ${status}, Dados: ${data}',
apiRequestError: 'Erro na solicitação da API: ${error}',
apiUrlInvalid: 'API_URL inválida',
apiUrlValidated: 'API_URL validada com sucesso: ${url}',
apiUrlWarning: 'Aviso: API_URL não começa com \"https://\". A URL está sendo ajustada.',
apiUrlWarningV1: 'Aviso: API_URL não termina com \"/api/v1\". A URL está sendo ajustada.',
authFailed: 'Autenticação falhou.',
authStarted: 'Autenticação iniciada.',
availableGroups: 'Grupos disponíveis: ${availableGroups}',
chatApiErrorDefault: 'Erro durante a solicitação de chat.',
chatApiError: 'Erro na solicitação da API de chat: ${error}',
chatResponseSuccess: 'Resposta do chat recebida: ${data}',
checkingGroups: 'Verificando grupos: ${groups}',
clientConnected: 'Cliente WebSocket conectado',
clientDisconnected: 'Cliente WebSocket desconectado',
connection: {
new: 'Nova conexão aceita de ${ip}:${port}',
established: 'Conexão estabelecida',
closed: 'Conexão fechada: ${ip}:${port}',
dataReceived: 'Dados recebidos de ${ip}:${port}: ${data}'
},
errors: {
processMessage: 'Erro ao processar mensagem: ${error}',
invalidMessage: 'Formato de mensagem inválido',
socketError: 'Erro de socket em ${ip}:${port}: ${error}',
serverError: 'Erro do servidor: ${error}'
},
server: {
running: 'Servidor está rodando na porta ${port}',
stopped: 'Servidor foi parado'
},
continueConversationError: 'Erro ao continuar a conversa.',
conversationContinuation: 'Conversa está continuando, ID: ${chatId}',
conversationSuccess: 'Conversa continuada com sucesso: ${data}',
createGroupSuccess: 'Grupo criado com sucesso: ${data}',
createSourceLog: 'Editar fonte com ID: ${sourceId}, Título: ${title}',
createSourceSuccess: 'Fonte criada com sucesso: ${data}',
createUserError: 'Erro ao criar usuário: ${error}',
createUserLog: 'Criando novo usuário: ${payload}',
createUserSuccess: 'Usuário criado com sucesso: ${data}',
deactivatedFunctions: 'Funções desativadas:',
deleteGroupInternalError: 'Erro interno ao excluir o grupo.',
deleteGroupLog: 'Excluir grupo com nome: ${groupName}',
deleteGroupSuccessLog: 'Grupo excluído com sucesso: ${data}',
deleteGroupText: 'Grupo \"${groupName}\" foi excluído com sucesso.',
deleteSourceError: 'Erro ao excluir a fonte: ${error}',
deleteSourceFailedTryAgain: 'Excluir a fonte falhou. Por favor, tente novamente mais tarde.',
deleteUserError: 'Erro ao excluir usuário: ${error}',
deleteUserLog: 'Excluir usuário com nome: ${UserName}',
deleteUserSuccess: 'Usuário excluído com sucesso: ${data}',
decryptPwdError: 'A senha não pôde ser descriptografada.',
decryptionError: 'Erro de descriptografia.',
dataReceivedMsg: 'Dados recebidos: ${data}',
emailRequiredForDelete: 'E-mail é necessário para excluir um usuário.',
emailRequiredForEdit: 'E-mail do usuário é necessário para editar o registro.',
editSourceError: 'Erro ao editar a fonte: ${error}',
editSourceLog: 'Editar fonte com ID: ${sourceId}, Título: ${title}',
editSourceSuccess: 'Fonte editada com sucesso: ${data}',
editUserError: 'Erro ao editar usuário: ${error}',
editUserSuccess: 'Usuário editado com sucesso: ${data}',
encryptPwdError: 'A senha não pôde ser criptografada.',
encryptionDisabled: 'Desativado',
encryptionEnabled: 'Ativado',
encryptionError: 'Erro de criptografia.',
errorHandlingRequest: 'Erro ao processar a solicitação: ${error}',
errorProcessingMsg: 'Erro ao processar a mensagem: ${error}',
fetchChatInfoError: 'Erro ao buscar informações do chat: ${error}',
fetchGroupsError: 'Erro ao buscar grupos: ${error}',
fetchGroupsErrorBackup: 'Erro ao buscar grupos.',
fetchGroupsErrorPrefix: 'Erro ao buscar grupos:',
fetchSourcesError: 'Erro ao buscar fontes.',
fetchingSources: 'Buscando fontes para o grupo: ${groupName}',
fileReadErrorTitle: 'Erro ao ler o arquivo.',
functionDisabled: 'desativado',
genericServerErrorPrefix: 'Erro:',
gotGetSourceResponse: 'Resposta para get_source recebida: ${data}',
gotListGroupsResponse: 'Resposta para list_groups recebida: ${response}',
gotListSourcesResponse: 'Resposta para list_sources recebida: ${data}',
groupFetchError: 'Erro ao buscar grupos: Por favor, tente novamente mais tarde.',
groupNameRequired: 'Nome do grupo é necessário para esta solicitação.',
groupValidationError: 'Erro ao validar o grupo: ${error}',
groupValidationErrorPrefix: 'Erro: ${error}',
handlingToolRequest: 'Processando solicitação da ferramenta: ${tool}',
headers: 'Headers: ${headers}',
incomingMessage: 'Mensagem recebida: ${MESSAGE}',
invalidArgumentsError: 'Erro: Nenhum argumento válido encontrado na entrada: ${input}',
invalidGroups: 'Grupos inválidos: ${groups}',
invalidGroupsError: 'Grupos inválidos: ${invalidGroups}',
invalidGroupsLog: 'Inválido: ${groups}',
invalidMessage: 'Mensagem inválida',
invalidOrEmptyRequest: 'Mensagem inválida ou solicitação vazia.',
keygenDisabled: 'Desativado',
keygenEnabled: 'Ativado',
keygenErrorPrefix: 'Erro na solicitação de keygen:',
keygenSuccess: 'Keygen concluído com sucesso.',
langNotSupported: 'Idioma \"${lang}\" não é suportado. Usando inglês como padrão.',
loginEmailPasswordRequired: 'Falha no login: E-mail e senha são necessários.',
loginError: 'Erro no login: ${error}',
loginErrorPrefix: 'Erro: ${error}',
loginMissingCredentials: 'Falha no login: E-mail e senha são necessários.',
loginMissingCredentialsAlternative: 'Falha no login: E-mail e senha são necessários.',
loginResponse: 'Resposta de login',
loginSuccess: 'Login bem-sucedido: ${data}',
loginTokenReceived: 'Token recebido: ${token}',
LogIpsSuccess: 'LOG_IPs está habilitado: ${status}',
logChangeError: 'Erro ao processar alterações no arquivo de log: ${error}',
logReadError: 'Erro ao ler o arquivo de log: ${error}',
logViewerRunning: 'Visualizador de log está rodando em http://localhost:${port}',
logoutError: 'Erro ao sair: ${error}',
logoutFailedTryAgain: 'Logout falhou. Por favor, tente novamente mais tarde.',
logoutSuccess: 'Logout bem-sucedido: ${data}',
makingGetSourceRequest: 'Criando solicitação get_source: ${args}',
makingListGroupsRequest: 'Criando solicitação list_groups',
makingListSourcesRequest: 'Criando solicitação list_sources: ${args}',
mcpVersion: 'Versão:',
mcpPort: 'Porta:',
mcpStartTime: 'Hora de início:',
mcpLicense: 'Licença:',
method: 'Método: ${method}',
missingArgumentsError: 'Faltam argumentos: ${args}',
missingChatParams: 'Faltam parâmetros obrigatórios: chatId e/ou question.',
missingCommandParameter: 'Parâmetro de comando faltando na mensagem.',
missingConfigError: 'Variável de configuração .json faltando: ${key}',
missingGroupNameAndDesc: 'Faltam parâmetros obrigatórios: groupName e descrição.',
missingGroupNameParam: 'Parâmetro obrigatório faltando: groupName.',
missingGroupParameterDelete: 'Excluir: Parâmetro obrigatório faltando: groupName.',
missingGroupParameterStore: 'Armazenar: Parâmetro obrigatório faltando: groupName.',
missingNameAndContent: 'Faltam parâmetros obrigatórios: nome e conteúdo.',
missingNameEmailPwd: 'Faltam parâmetros obrigatórios: nome, e-mail ou senha.',
missingParametersError: 'Faltam parâmetros: ${parameters}',
missingParameterError: 'Parâmetro obrigatório faltando: ${parameter}.',
missingTokenAuth: 'Token ausente',
missingTokenError: 'Token ausente. Por favor, faça login e tente novamente.',
missingTokenGroups: 'Token ausente. Grupos não podem ser validados.',
missingToolName: 'Nome da ferramenta faltando',
missingUriParameter: 'Parâmetro URI faltando.',
noChatData: 'Nenhum dado encontrado para o chat especificado.',
noDescriptionProvided: 'Nenhuma descrição fornecida',
noErrorMessage: 'Nenhuma mensagem de erro.',
noServerResponse: 'Nenhuma resposta recebida do servidor.',
passwordEncEnabled: 'Criptografia de senha está habilitada.',
passwordIsRequired: 'Senha é necessária.',
payload: 'Payload: ${payload}',
portInUse: 'Erro de porta: Porta ${PORT} já está em uso.',
portInvalid: 'Erro de porta: PORT deve ser um número entre 1 e 65535.',
portValidated: 'PORT validado com sucesso: ${port}',
proxyAuthMissing: 'Dados de autenticação de proxy ausentes.',
proxyUseProxy: 'USE_PROXY: ${val}',
publicGroupsConflictWarning: 'Conflito: usePublic foi definido como false porque grupos foram especificados.',
requestError: 'Erro na solicitação: ${error}',
requestSent: 'Solicitação enviada',
restrictedGroupsError: "Erro: Configuração RESTRICTED_GROUPS inválida. Deve ser 'true' ou 'false'. Valor atual: ${value}",
restrictedGroupsSuccess: 'RESTRICTED_GROUPS está habilitado: ${status}',
restrictedGroupsWarning: 'RESTRICTED_GROUPS habilitado. Grupos disponíveis estão restritos.',
responseError: 'Erro na resposta: ${error}',
responseSentSuccess: 'Status: Sucesso',
serverError: 'Servidor não pôde ser iniciado: ${error}',
serverListeningOnPort: 'Servidor ouvindo na porta ${port}',
serverRunning: 'Servidor está rodando na porta ${port}',
serverShutdownLog: 'Servidor desligado',
serverStartedLog: 'Servidor iniciado.',
serverStoppedLog: 'Servidor parado',
sendingChatRequest: 'Enviando solicitação de chat para API',
sourcesRetrieved: 'Fontes recuperadas: ${data}',
startingServerWithConfig: 'Iniciando servidor com a seguinte configuração:',
sslValidationSet: '${symbol} Validação SSL está definida para: ${value}',
socketErrorPrefix: 'Erro:',
storeGroupLog: 'Armazenando novo grupo com nome: ${groupName} e descrição: ${description}',
storeGroupSuccess: 'Grupo armazenado com sucesso: ${data}',
storegroupError: 'Erro ao criar grupo: ${error}',
storeGroupText: 'Grupo \"${groupName}\" armazenado com sucesso com ID: ${id}.',
unknownAddress: 'IP desconhecido',
unknownCommandError: 'Comando desconhecido: ${cmd}',
unknownError: 'Erro desconhecido',
unknownPort: 'Porta desconhecida',
unknownTool: 'Ferramenta desconhecida: ${toolName}',
tokenMissing: 'Token ausente.'
},
// Spanish (es)
es: {
ErrorConnReset: 'Conexión terminada prematuramente por el cliente (ECONNRESET).',
NoTLSCertFound: 'No se encontró ningún certificado o clave SSL. Por favor, cree un certificado. Por ejemplo, puede crear un certificado autofirmado con OpenSSL:',
deleteChatsSuccess: "Todo el historial de chat se ha eliminado correctamente.",
deleteChatsError: "Ocurrió un error al eliminar el historial de chat: ${error}.",
missingAuthToken: "El token de autorización falta o no es válido.",
deleteChatsUnauthorized: "No está autorizado para eliminar el historial de chat.",
deleteChatsServerIssue: "Se produjo un error en el servidor al procesar la solicitud.",
deleteChatsNotAllowed: "No está permitido eliminar el historial de chat para este usuario.",
missingChatId: "Falta el ID del chat. Por favor, proporcione un ID de chat válido.",
chatDeleted: "El chat con ID ${chatId} se ha eliminado correctamente.",
deleteChatError: "Ocurrió un error al eliminar el chat con ID ${chatId}: ${error}.",
missingAuthToken: "El token de autorización falta o no es válido.",
deleteChatUnauthorized: "No está autorizado para eliminar este chat.",
deleteChatServerIssue: "Se produjo un error en el servidor al procesar la solicitud.",
deleteChatNotAllowed: "No está permitido eliminar este chat.",
toolDisabledLog: formatMessage(templates.error, { action: 'Llamada a función deshabilitada en el servidor:', details: '${toolName}' }),
toolDisabledError: formatMessage(templates.error, { action: 'Llamada a función deshabilitada en el servidor:', details: '${toolName}' }),
emailRequiredForReactivate: "Se requiere una dirección de correo electrónico para reactivar un usuario.",
reactivateUserLog: "Iniciando el proceso de reactivación para el usuario: ${UserName}.",
reactivateUserSuccess: "Usuario reactivado con éxito: ${data}.",
reactivateUserError: "Error al reactivar el usuario: ${error}. Por favor, inténtelo de nuevo más tarde.",
createSourceError: 'Error al crear la fuente: ${error}',
create_sourceUnknownError: 'Error desconocido al crear la fuente: ${error}',
returnStatus: 'Estado: ${Status}',
extractedToken: 'Token extraído: ${token}',
missingChatId: 'Se requiere chatId para recuperar la información del chat.',
missingQuestion: 'Falta la pregunta en los argumentos.',
ChatInfoRetrieved: 'Información del chat recuperada: ${chatData}',
InvalidGroups: 'Grupos inválidos: ${GROUPS}',
sourceIdRequiredEditSource: 'Se requiere sourceId para editar una fuente.',
sourceIdRequiredRetrieveSource: 'Se requiere sourceId para recuperar una fuente.',
ConnectionEstablished: 'Conexión establecida',
ResponseSuccessfullySent: 'Respuesta enviada con éxito',
ConnectionClosed: 'Conexión cerrada',
ServerStopped: 'El servidor ha sido detenido',
responseReceived: 'Respuesta recibida con estado: ${status}',
internalServerError: 'Error interno del servidor',
tcpServerError: 'Ocurrió un error en el servidor TCP:',
unknownErrorOccured: 'Ocurrió un error desconocido.',
KeygenRequired: 'Se requiere generación de clave',
unknownCommand: 'Comando desconocido',
socketEmitLogNotActivated: 'El archivo de registro no está activado.',
socketEmitLogReadError: 'Error al leer el archivo de registro.',
deletesourceLog: formatMessage(templates.info, { action: 'Eliminar Fuente', details: 'con nombre: ${SourceName}' }),
sourceIdRequiredDeleteSource: 'Se requiere sourceId para eliminar la fuente.',
listGroupsSuccess: 'Lista de grupos recuperada: ${GROUPS}',
toolNotDefinedInConfig: formatMessage(templates.error, { action: 'Llamada a función inválida', details: '${warn}' }),
toolDisabledLog: formatMessage(templates.error, { action: 'Llamada a función deshabilitada en el servidor:', details: '${warn}' }),
toolDisabledError: formatMessage(templates.error, { action: 'Llamada a función deshabilitada en el servidor:', details: '${warn}' }),
accessRestrictedGroups: formatMessage(templates.info, { action: 'Valor de RESTRICTED_GROUPS', details: '${val}' }),
allFunctionsEnabled: formatMessage(templates.success, { action: 'Todas las funciones están habilitadas', details: '' }),
allGroupsValid: formatMessage(templates.success, { action: 'Todos los grupos son válidos', details: '' }),
AllowLoggingSuccess: formatMessage(templates.success, { action: 'ALLOW_LOGGING', details: 'está habilitado: ${status}' }),
anonymousModeSuccess: formatMessage(templates.success, { action: 'ANONYMOUS_MODE', details: 'está habilitado: ${status}' }),
apiErrorDetails: formatMessage(templates.error, { action: 'Error de API', details: 'Estado: ${status}, Datos: ${data}' }),
apiRequestError: formatMessage(templates.error, { action: 'Error en la solicitud de API', details: '${error}' }),
apiUrlInvalid: formatMessage(templates.error, { action: 'API_URL inválido', details: '' }),
apiUrlValidated: formatMessage(templates.success, { action: 'API_URL validado con éxito', details: '${url}' }),
apiUrlWarning: formatMessage(templates.warning, { action: 'Advertencia', details: 'API_URL no comienza con "https://". La URL está siendo ajustada.' }),
apiUrlWarningV1: formatMessage(templates.warning, { action: 'Advertencia', details: 'API_URL no termina con "/api/v1". La URL está siendo ajustada.' }),
authFailed: 'Autenticación fallida.',
authStarted: 'Autenticación iniciada.',
availableGroups: formatMessage(templates.success, { action: 'Grupos disponibles', details: '${availableGroups}' }),
chatApiErrorDefault: 'Error durante la solicitud de chat.',
chatApiError: formatMessage(templates.error, { action: 'Error en la solicitud de Chat API', details: '${error}' }),
chatResponseSuccess: formatMessage(templates.success, { action: 'Respuesta de chat recibida', details: '${data}' }),
checkingGroups: formatMessage(templates.info, { action: 'Verificando grupos', details: '${groups}' }),
clientConnected: formatMessage(templates.info, { action: 'Cliente WebSocket conectado', details: '' }),
clientDisconnected: formatMessage(templates.info, { action: 'Cliente WebSocket desconectado', details: '' }),
connection: {
new: formatMessage(templates.info, { action: 'Nueva conexión aceptada', details: 'de ${ip}:${port}' }),
established: formatMessage(templates.success, { action: 'Conexión establecida', details: '' }),
closed: formatMessage(templates.info, { action: 'Conexión cerrada', details: '${ip}:${port}' }),
dataReceived: formatMessage(templates.info, { action: 'Datos recibidos', details: 'de ${ip}:${port}: ${data}' }),
},
errors: {
processMessage: formatMessage(templates.error, { action: 'Error al procesar el mensaje', details: '${error}' }),
invalidMessage: formatMessage(templates.error, { action: 'Formato de mensaje inválido', details: '' }),
socketError: formatMessage(templates.error, { action: 'Error de socket', details: 'en ${ip}:${port}: ${error}' }),
serverError: formatMessage(templates.error, { action: 'Error del servidor', details: '${error}' }),
},
server: {
running: formatMessage(templates.success, { action: 'El servidor está en funcionamiento', details: 'en el puerto ${port}' }),
stopped: formatMessage(templates.info, { action: 'El servidor ha sido detenido', details: '' }),
},
continueConversationError: formatMessage(templates.error, { action: 'Error al continuar la conversación', details: '' }),
conversationContinuation: formatMessage(templates.success, { action: 'La conversación continúa', details: 'ID: ${chatId}' }),
conversationSuccess: formatMessage(templates.success, { action: 'La conversación se ha continuado con éxito', details: '${data}' }),
createGroupSuccess: formatMessage(templates.success, { action: 'Grupo creado con éxito', details: '${data}' }),
createSourceLog: 'Editando fuente con ID: ${sourceId}, Título: ${title}',
createSourceSuccess: 'Fuente creada con éxito: ${data}',
createUserError: 'Error al crear el usuario: ${error}',
createUserLog: 'Creando nuevo usuario: ${payload}',
createUserSuccess: 'Usuario creado con éxito: ${data}',
deactivatedFunctions: 'Funciones desactivadas:',
deleteGroupInternalError: 'Error interno al eliminar el grupo.',
deleteGroupLog: formatMessage(templates.info, { action: 'Eliminando grupo', details: 'con nombre: ${groupName}' }),
deleteGroupSuccessLog: formatMessage(templates.success, { action: 'Grupo eliminado con éxito', details: '${data}' }),
deleteGroupText: 'El grupo "${groupName}" ha sido eliminado con éxito.',
deleteSourceError: 'Error al eliminar la fuente: ${error}',
deleteSourceFailedTryAgain: 'La eliminación de la fuente falló. Por favor, inténtelo de nuevo más tarde.',
deleteUserError: 'Error al eliminar el usuario: ${error}',
deleteUserLog: formatMessage(templates.info, { action: 'Eliminando usuario', details: 'con nombre: ${UserName}' }),
deleteUserSuccess: 'Usuario eliminado con éxito: ${data}',
decryptPwdError: 'No se pudo descifrar la contraseña.',
decryptionError: 'Error de descifrado.',
dataReceivedMsg: 'Datos recibidos: ${data}',
emailRequiredForDelete: 'Se requiere correo electrónico para eliminar un usuario.',
emailRequiredForEdit: 'Se requiere correo electrónico del usuario para editar el registro.',
editSourceError: 'Error al editar la fuente: ${error}',
editSourceLog: 'Editando fuente con ID: ${sourceId}, Título: ${title}',
editSourceSuccess: 'Fuente editada con éxito: ${data}',
editUserError: 'Error al editar el usuario: ${error}',
editUserSuccess: 'Usuario editado con éxito: ${data}',
encryptPwdError: 'No se pudo cifrar la contraseña.',
encryptionDisabled: 'Deshabilitado',
encryptionEnabled: 'Habilitado',
encryptionError: 'Error de cifrado.',
errorHandlingRequest: formatMessage(templates.error, { action: 'Error al manejar la solicitud', details: '${error}' }),
errorProcessingMsg: formatMessage(templates.error, { action: 'Error al procesar el mensaje:', details: '${error}' }),
fetchChatInfoError: 'Error al obtener la información del chat: ${error}',
fetchGroupsError: formatMessage(templates.error, { action: 'Error al obtener los grupos', details: '${error}' }),
fetchGroupsErrorBackup: 'Error al obtener los grupos.',
fetchGroupsErrorPrefix: 'Error al obtener los grupos:',
fetchSourcesError: formatMessage(templates.error, { action: 'Error al obtener las fuentes', details: '' }),
fetchingSources: formatMessage(templates.info, { action: 'Obteniendo fuentes para el grupo: ${groupName}', details: '' }),
fileReadErrorTitle: 'Error al leer el archivo.',
functionDisabled: 'deshabilitado',
genericServerErrorPrefix: 'Error:',
gotGetSourceResponse: formatMessage(templates.success, { action: 'Respuesta de get_source recibida', details: '${data}' }),
gotListGroupsResponse: formatMessage(templates.success, { action: 'Respuesta de list_groups recibida', details: '${response}' }),
gotListSourcesResponse: formatMessage(templates.success, { action: 'Respuesta de list_sources recibida', details: '${data}' }),
groupFetchError: 'Error al obtener los grupos: Por favor, inténtelo de nuevo más tarde.',
groupNameRequired: 'Se requiere el nombre del grupo para esta solicitud.',
groupValidationError: 'Error al validar el grupo: ${error}',
groupValidationErrorPrefix: 'Error: ${error}',
handlingToolRequest: 'Manejando solicitud de herramienta: ${tool}',
headers: 'Encabezados: ${headers}',
incomingMessage: 'Mensaje entrante: ${MESSAGE}',
invalidArgumentsError: 'Error: No se encontraron argumentos válidos en la entrada: ${input}',
invalidGroups: 'Grupos inválidos: ${groups}',
invalidGroupsError: 'Grupos inválidos: ${invalidGroups}',
invalidGroupsLog: 'Inválidos: ${groups}',
invalidMessage: 'Mensaje inválido',
invalidOrEmptyRequest: 'Mensaje inválido o solicitud vacía.',
keygenDisabled: 'Deshabilitado',
keygenEnabled: 'Habilitado',
keygenErrorPrefix: 'Error con la solicitud de generación de clave:',
keygenSuccess: 'Generación de clave completada con éxito.',
langNotSupported: 'El idioma "${lang}" no es compatible. Volviendo a inglés.',
loginEmailPasswordRequired: 'Inicio de sesión fallido: Se requieren correo electrónico y contraseña.',
loginError: formatMessage(templates.error, { action: 'Error de inicio de sesión', details: '${error}' }),
loginErrorPrefix: 'Error: ${error}',
loginMissingCredentials: 'Inicio de sesión fallido: Se requieren correo electrónico y contraseña.',
loginMissingCredentialsAlternative: 'Inicio de sesión fallido: Se requieren correo electrónico y contraseña.',
loginResponse: 'Respuesta de inicio de sesión',
loginSuccess: formatMessage(templates.success, { action: 'Inicio de sesión exitoso', details: '${data}' }),
loginTokenReceived: 'Token recibido: ${token}',
LogIpsSuccess: formatMessage(templates.success, { action: 'LOG_IPs', details: 'está habilitado: ${status}' }),
logChangeError: 'Error al procesar cambios en el archivo de registro: ${error}',
logReadError: 'Error al leer el archivo de registro: ${error}',
logViewerRunning: 'El visor de registros está funcionando en http://localhost:${port}',
logoutError: 'Error al cerrar sesión: ${error}',
logoutFailedTryAgain: 'El cierre de sesión falló. Por favor, inténtelo de nuevo más tarde.',
logoutSuccess: 'Cierre de sesión exitoso: ${data}',
makingGetSourceRequest: 'Creando solicitud get_source: ${args}',
makingListGroupsRequest: 'Creando solicitud list_groups',
makingListSourcesRequest: 'Creando solicitud list_sources: ${args}',
mcpVersion: 'Versión:',
mcpPort: 'Puerto:',
mcpStartTime: 'Hora de inicio:',
mcpLicense: 'Licencia:',
method: 'Método: ${method}',
missingArgumentsError: 'Faltan argumentos: ${args}',
missingChatParams: 'Faltan parámetros requeridos: chatId y/o pregunta.',
missingCommandParameter: 'Falta el parámetro de comando en el mensaje.',
missingConfigError: 'Falta la variable de configuración .json: ${key}',
missingGroupNameAndDesc: 'Faltan parámetros requeridos: nombre del grupo y descripción.',
missingGroupNameParam: 'Falta el parámetro requerido: nombre del grupo.',
missingGroupParameterDelete: 'Eliminar: Falta el parámetro requerido: nombre del grupo.',
missingGroupParameterStore: 'Almacenar: Falta el parámetro requerido: nombre del grupo.',
missingNameAndContent: 'Faltan parámetros requeridos: nombre y contenido.',
missingNameEmailPwd: 'Faltan parámetros requeridos: nombre, correo electrónico o contraseña.',
missingParametersError: formatMessage(templates.error, { action: 'Parámetros faltantes', details: '${parameters}' }),
missingParameterError: 'Falta el parámetro requerido: ${parameter}.',
missingTokenAuth: 'Falta el token',
missingTokenError: 'Token faltante. Por favor, inicie sesión e inténtelo de nuevo.',
missingTokenGroups: 'Token faltante. No se pueden validar los grupos.',
missingToolName: 'Falta el nombre de la herramienta',
missingUriParameter: 'Falta el parámetro URI.',
noChatData: 'No se encontraron datos para el chat especificado.',
noDescriptionProvided: 'No se proporcionó descripción',
noErrorMessage: 'No hay mensaje de error.',
noServerResponse: 'No se recibió respuesta del servidor.',
passwordEncEnabled: 'El cifrado de la contraseña está habilitado.',
passwordIsRequired: 'Se requiere contraseña.',
payload: 'Carga útil: ${payload}',
portInUse: 'Error de puerto: El puerto ${PORT} ya está en uso.',
portInvalid: 'Error de puerto: PORT debe ser un número entre 1 y 65535.',
portValidated: 'PORT validado con éxito: ${port}',
proxyAuthMissing: 'Faltan datos de autenticación del proxy.',
proxyUseProxy: 'USE_PROXY: ${val}',
publicGroupsConflictWarning: 'Conflicto: usePublic se ha establecido en falso porque se especificaron grupos.',
requestError: 'Error de solicitud: ${error}',
requestSent: 'Solicitud enviada',
restrictedGroupsError: 'Error: Configuración de RESTRICTED_GROUPS inválida. Debe ser \'true\' o \'false\'. Valor actual: ${value}',
restrictedGroupsSuccess: 'RESTRICTED_GROUPS está habilitado: ${status}',
restrictedGroupsWarning: 'RESTRICTED_GROUPS está habilitado. Los grupos disponibles están restringidos.',
responseError: 'Error en la respuesta: ${error}',
responseSentSuccess: formatMessage(templates.success, { action: 'Estado', details: 'Éxito' }),
serverError: formatMessage(templates.error, { action: 'No se pudo iniciar el servidor', details: '${error}' }),
serverListeningOnPort: 'Servidor escuchando en el puerto ${port}',
serverRunning: 'El servidor está funcionando en el puerto ${port}',
serverShutdownLog: 'Servidor apagado',
serverStartedLog: 'Servidor iniciado.',
serverStoppedLog: 'Servidor detenido',
sendingChatRequest: 'Enviando solicitud de chat a API',
sourcesRetrieved: formatMessage(templates.success, { action: 'Fuentes recuperadas', details: '${data}' }),
startingServerWithConfig: 'Iniciando el servidor con la siguiente configuración:',
sslValidationSet: '${symbol} La validación SSL está establecida en: ${value}',
socketErrorPrefix: 'Error:',
storeGroupLog: 'Almacenando un nuevo grupo con nombre: ${groupName} y descripción: ${description}',
storeGroupSuccess: 'Grupo almacenado con éxito: ${data}',
storegroupError: 'Error al crear el grupo: ${error}',
storeGroupText: 'El grupo "${groupName}" ha sido almacenado con éxito con ID: ${id}.',
unknownAddress: 'IP desconocida',
unknownCommandError: formatMessage(templates.error, { action: 'Comando desconocido', details: '${cmd}' }),
unknownError: formatMessage(templates.error, { action: 'Error desconocido', details: '' }),
unknownPort: 'Puerto desconocido',
unknownTool: 'Herramienta desconocida: ${toolName}',
tokenMissing: 'Token faltante.',
},
nl: {
ErrorConnReset: 'Verbinding voortijdig beëindigd door de client (ECONNRESET).',
NoTLSCertFound: 'Geen SSL-certificaat of sleutel gevonden. Maak alstublieft een certificaat aan. U kunt bijvoorbeeld een zelfondertekend certificaat maken met OpenSSL:',
deleteChatsSuccess: "De volledige chatgeschiedenis is succesvol verwijderd.",
deleteChatsError: "Er is een fout opgetreden bij het verwijderen van de chatgeschiedenis: ${error}.",
missingAuthToken: "Het autorisatietoken ontbreekt of is ongeldig.",
deleteChatsUnauthorized: "U bent niet gemachtigd om de chatgeschiedenis te verwijderen.",
deleteChatsServerIssue: "Er is een serverfout opgetreden bij het verwerken van het verzoek.",
deleteChatsNotAllowed: "Het verwijderen van de chatgeschiedenis is niet toegestaan voor deze gebruiker.",
missingChatId: "Chat-ID ontbreekt. Geef een geldige chat-ID op.",
chatDeleted: "De chat met ID ${chatId} is succesvol verwijderd.",
deleteChatError: "Er is een fout opgetreden bij het verwijderen van de chat met ID ${chatId}: ${error}.",
missingAuthToken: "Het autorisatietoken ontbreekt of is ongeldig.",
deleteChatUnauthorized: "U bent niet gemachtigd om deze chat te verwijderen.",
deleteChatServerIssue: "Er is een serverfout opgetreden bij het verwerken van het verzoek.",
deleteChatNotAllowed: "Het verwijderen van deze chat is niet toegestaan.",
toolDisabledLog: formatMessage(templates.error, { action: 'Functieaanroep uitgeschakeld aan serverzijde:', details: '${toolName}' }),
toolDisabledError: formatMessage(templates.error, { action: 'Functieaanroep uitgeschakeld aan serverzijde:', details: '${toolName}' }),
emailRequiredForReactivate: "Een e-mailadres is vereist om een gebruiker te reactiveren.",
reactivateUserLog: "Reactiveringsproces gestart voor gebruiker: ${UserName}.",
reactivateUserSuccess: "Gebruiker succesvol geheractiveerd: ${data}.",
reactivateUserError: "Fout bij het heractiveren van de gebruiker: ${error}. Probeer het later opnieuw.",
createSourceError: 'Fout bij het aanmaken van bron: ${error}',
create_sourceUnknownError: 'Onbekende fout bij het aanmaken van bron: ${error}',
returnStatus: 'Status: ${Status}',
extractedToken: 'Extracted Token: ${token}',
missingChatId: 'chatId is vereist om chatinformatie op te halen.',
missingQuestion: 'Vraag ontbreekt in de argumenten.',
ChatInfoRetrieved: 'Chatinformatie opgehaald: ${chatData}',
InvalidGroups: 'Ongeldige groepen: ${GROUPS}',
sourceIdRequiredEditSource: 'sourceId is vereist om een bron te bewerken.',
sourceIdRequiredRetrieveSource: 'sourceId is vereist om een bron op te halen.',
ConnectionEstablished: 'Verbinding tot stand gebracht',
ResponseSuccessfullySent: 'Antwoord succesvol verzonden',
ConnectionClosed: 'Verbinding gesloten',
ServerStopped: 'Server is gestopt',
responseReceived: 'Antwoord ontvangen met status: ${status}',
internalServerError: 'Interne serverfout',
tcpServerError: 'Er is een fout opgetreden in de TCP-server:',
unknownErrorOccured: 'Er is een onbekende fout opgetreden.',
KeygenRequired: 'Keygen vereist',
unknownCommand: 'Onbekend commando',
socketEmitLogNotActivated: 'Logbestand is niet geactiveerd.',
socketEmitLogReadError: 'Fout bij het lezen van logbestand.',
deletesourceLog: 'Bron verwijderen: met naam: ${SourceName}',
sourceIdRequiredDeleteSource: 'sourceId is vereist om bron te verwijderen.',
listGroupsSuccess: 'Groepenlijst opgehaald: ${GROUPS}',
// Existing ones
toolNotDefinedInConfig: 'Ongeldige functiebaanroep: ${warn}',
toolDisabledLog: 'Functieaanroep uitgeschakeld aan serverzijde: ${warn}',
toolDisabledError: 'Functieaanroep uitgeschakeld aan serverzijde: ${warn}',
accessRestrictedGroups: 'RESTRICTED_GROUPS Waarde: ${val}',
allFunctionsEnabled: 'Alle functies zijn ingeschakeld',
allGroupsValid: 'Alle groepen zijn geldig',
AllowLoggingSuccess: 'ALLOW_LOGGING is ingeschakeld: ${status}',
anonymousModeSuccess: 'ANONYMOUS_MODE is ingeschakeld: ${status}',
apiErrorDetails: 'API-fout: Status: ${status}, Data: ${data}',
apiRequestError: 'API-aanvraagfout: ${error}',
apiUrlInvalid: 'Ongeldige API_URL',
apiUrlValidated: 'API_URL succesvol gevalideerd: ${url}',
apiUrlWarning: 'Waarschuwing: API_URL begint niet met "https://". De URL wordt aangepast.',
apiUrlWarningV1: 'Waarschuwing: API_URL eindigt niet met "/api/v1". De URL wordt aangepast.',
authFailed: 'Authenticatie mislukt.',
authStarted: 'Authenticatie gestart.',
availableGroups: 'Beschikbare groepen: ${availableGroups}',
chatApiErrorDefault: 'Fout tijdens chatverzoek.',
chatApiError: 'Fout in Chat API-aanvraag: ${error}',
chatResponseSuccess: 'Chatantwoord ontvangen: ${data}',
checkingGroups: 'Groepen controleren: ${groups}',
clientConnected: 'WebSocket-client verbonden',
clientDisconnected: 'WebSocket-client verbroken',
connection: {
new: 'Nieuwe verbinding geaccepteerd van ${ip}:${port}',
established: 'Verbinding tot stand gebracht',
closed: 'Verbinding gesloten ${ip}:${port}',
dataReceived: 'Gegevens ontvangen van ${ip}:${port}: ${data}',
},
errors: {
processMessage: 'Fout bij verwerken van bericht: ${error}',
invalidMessage: 'Ongeldig berichtformaat',
socketError: 'Socketfout bij ${ip}:${port}: ${error}',
serverError: 'Serverfout: ${error}',
},
server: {
running: 'Server draait op poort ${port}',
stopped: 'Server is gestopt',
},
continueConversationError: 'Fout bij het voortzetten van gesprek',
conversationContinuation: 'Gesprek wordt voortgezet ID: ${chatId}',
conversationSuccess: 'Gesprek succesvol voortgezet: ${data}',
createGroupSuccess: 'Groep succesvol aangemaakt: ${data}',
createSourceLog: 'Bron bewerken met ID: ${sourceId}, Titel: ${title}',
createSourceSuccess: 'Bron succesvol aangemaakt: ${data}',
createUserError: 'Fout bij aanmaken gebruiker: ${error}',
createUserLog: 'Nieuwe gebruiker aanmaken: ${payload}',
createUserSuccess: 'Gebruiker succesvol aangemaakt: ${data}',
deactivatedFunctions: 'Gedeactiveerde functies:',
deleteGroupInternalError: 'Interne fout bij het verwijderen van groep.',
deleteGroupLog: 'Groep verwijderen met naam: ${groupName}',
deleteGroupSuccessLog: 'Groep succesvol verwijderd: ${data}',
deleteGroupText: 'Groep "${groupName}" is succesvol verwijderd.',
deleteSourceError: 'Fout bij verwijderen van bron: ${error}',
deleteSourceFailedTryAgain: 'Verwijderen van bron mislukt. Probeer het later opnieuw.',
deleteUserError: 'Fout bij verwijderen van gebruiker: ${error}',
deleteUserLog: 'Gebruiker verwijderen met naam: ${UserName}',
deleteUserSuccess: 'Gebruiker succesvol verwijderd: ${data}',
decryptPwdError: 'Het wachtwoord kon niet worden gedecrypteerd.',
decryptionError: 'Decryptiefout.',
dataReceivedMsg: 'Gegevens ontvangen: ${data}',
emailRequiredForDelete: 'E-mail is vereist om een gebruiker te verwijderen.',
emailRequiredForEdit: 'Gebruikers-e-mail is vereist om het record te bewerken.',
editSourceError: 'Fout bij bewerken van bron: ${error}',
editSourceLog: 'Bron bewerken met ID: ${sourceId}, Titel: ${title}',
editSourceSuccess: 'Bron succesvol bewerkt: ${data}',
editUserError: 'Fout bij bewerken van gebruiker: ${error}',
editUserSuccess: 'Gebruiker succesvol bewerkt: ${data}',
encryptPwdError: 'Het wachtwoord kon niet worden versleuteld.',
encryptionDisabled: 'Uitgeschakeld',
encryptionEnabled: 'Ingeschakeld',
encryptionError: 'Encryptiefout.',
errorHandlingRequest: 'Fout bij afhandelen van verzoek: ${error}',
errorProcessingMsg: 'Fout bij verwerken van bericht: ${error}',
fetchChatInfoError: 'Fout bij ophalen van chatinformatie: ${error}',
fetchGroupsError: 'Fout bij ophalen van groepen: ${error}',
fetchGroupsErrorBackup: 'Fout bij ophalen van groepen.',
fetchGroupsErrorPrefix: 'Fout bij ophalen van groepen:',
fetchSourcesError: 'Fout bij ophalen van bronnen:',
fetchingSources: 'Bronnen ophalen voor groep: ${groupName}',
fileReadErrorTitle: 'Fout bij lezen van bestand.',
functionDisabled: 'uitgeschakeld',
genericServerErrorPrefix: 'Fout:',
gotGetSourceResponse: 'Antwoord ontvangen voor get_source: ${data}',
gotListGroupsResponse: 'Antwoord ontvangen voor list_groups: ${response}',
gotListSourcesResponse: 'Antwoord ontvangen voor list_sources: ${data}',
groupFetchError: 'Fout bij ophalen van groepen: Probeer het later opnieuw.',
groupNameRequired: 'Groepsnaam is vereist voor dit verzoek.',
groupValidationError: 'Fout bij valideren van groep: ${error}',
groupValidationErrorPrefix: 'Fout: ${error}',
handlingToolRequest: 'Toolverzoek afhandelen: ${tool}',
headers: 'Headers: ${headers}',
incomingMessage: 'Binnenkomend bericht: ${MESSAGE}',
invalidArgumentsError: 'Fout: Geen geldige argumenten gevonden in invoer: ${input}',
invalidGroups: 'Ongeldige groepen: ${groups}',
invalidGroupsError: 'Ongeldige groepen: ${invalidGroups}',
invalidGroupsLog: 'Ongeldig: ${groups}',
invalidMessage: 'Ongeldig bericht',
invalidOrEmptyRequest: 'Ongeldig bericht of leeg verzoek.',
keygenDisabled: 'Uitgeschakeld',
keygenEnabled: 'Ingeschakeld',
keygenErrorPrefix: 'Fout met keygen-aanvraag:',
keygenSuccess: 'Keygen succesvol voltooid.',
langNotSupported: 'Taal "${lang}" wordt niet ondersteund. Terugval naar Engels.',
loginEmailPasswordRequired: 'Inloggen mislukt: E-mail en wachtwoord zijn vereist.',
loginError: 'Loginfout: ${error}',
loginErrorPrefix: 'Fout: ${error}',
loginMissingCredentials: 'Inloggen mislukt: E-mail en wachtwoord zijn vereist.',
loginMissingCredentialsAlternative: 'Inloggen mislukt: E-mail en wachtwoord zijn vereist.',
loginResponse: 'Loginrespons',
loginSuccess: 'Inloggen succesvol: ${data}',
loginTokenReceived: 'Token ontvangen: ${token}',
LogIpsSuccess: 'LOG_IPs is ingeschakeld: ${status}',
logChangeError: 'Fout bij verwerken van logbestandwijzigingen: ${error}',
logReadError: 'Fout bij lezen van logbestand: ${error}',
logViewerRunning: 'Logviewer draait op http://localhost:${port}',
logoutError: 'Fout tijdens uitloggen: ${error}',
logoutFailedTryAgain: 'Uitloggen mislukt. Probeer het later opnieuw.',
logoutSuccess: 'Uitloggen succesvol: ${data}',
makingGetSourceRequest: 'get_source-aanvraag aanmaken: ${args}',
makingListGroupsRequest: 'list_groups-aanvraag aanmaken',
makingListSourcesRequest: 'list_sources-aanvraag aanmaken: ${args}',
mcpVersion: 'Versie:',
mcpPort: 'Poort:',
mcpStartTime: 'Starttijd:',
mcpLicense: 'Licentie:',
method: 'Methode: ${method}',
missingArgumentsError: 'Ontbrekende argumenten: ${args}',
missingChatParams: 'Ontbrekende vereiste parameters: chatId en/of vraag.',
missingCommandParameter: 'Ontbrekende commando-parameter in het bericht.',
missingConfigError: 'Ontbrekende .json-configuratievariabele: ${key}',
missingGroupNameAndDesc: 'Ontbrekende vereiste parameters: groupName en beschrijving.',
missingGroupNameParam: 'Ontbrekende vereiste parameter: groupName.',
missingGroupParameterDelete: 'Verwijderen: Ontbrekende vereiste parameter: groupName.',
missingGroupParameterStore: 'Opslaan: Ontbrekende vereiste parameter: groupName.',
missingNameAndContent: 'Ontbrekende vereiste parameters: naam en inhoud.',
missingNameEmailPwd: 'Ontbrekende vereiste parameters: naam, e-mail of wachtwoord.',
missingParametersError: 'Ontbrekende parameters: ${parameters}',
missingParameterError: 'Ontbrekende vereiste parameter: ${parameter}.',
missingTokenAuth: 'Token ontbreekt',
missingTokenError: 'Token ontbreekt. Log in en probeer het opnieuw.',
missingTokenGroups: 'Token ontbreekt. Groepen kunnen niet worden gevalideerd.',
missingToolName: 'Functienaam ontbreekt',
missingUriParameter: 'URI-parameter ontbreekt.',
noChatData: 'Geen gegevens gevonden voor de opgegeven chat.',
noDescriptionProvided: 'Geen beschrijving opgegeven',
noErrorMessage: 'Geen foutmelding.',
noServerResponse: 'Geen antwoord ontvangen van server.',
passwordEncEnabled: 'Wachtwoordversleuteling is ingeschakeld.',
passwordIsRequired: 'Wachtwoord is vereist.',
payload: 'Payload: ${payload}',
portInUse: 'Poortfout: Poort ${PORT} is al in gebruik.',
portInvalid: 'Poortfout: PORT moet een nummer zijn tussen 1 en 65535.',
portValidated: 'PORT succesvol gevalideerd: ${port}',
proxyAuthMissing: 'Proxy-authenticatiegegevens ontbreken.',
proxyUseProxy: 'USE_PROXY: ${val}',
publicGroupsConflictWarning: 'Conflict: usePublic is ingesteld op false omdat groepen zijn opgegeven.',
requestError: 'Verzoekfout: ${error}',
requestSent: 'Verzoek verzonden',
restrictedGroupsError: 'Fout: Ongeldige RESTRICTED_GROUPS-configuratie. Moet \'true\' of \'false\' zijn. Huidige waarde: ${value}',
restrictedGroupsSuccess: 'RESTRICTED_GROUPS is ingeschakeld: ${status}',
restrictedGroupsWarning: 'RESTRICTED_GROUPS ingeschakeld. Beschikbare groepen zijn beperkt.',
responseError: 'Antwoordfout: ${error}',
responseSentSuccess: 'Status: Succes',
serverError: 'Server kon niet worden gestart: ${error}',
serverListeningOnPort: 'Server luistert op poort ${port}',
serverRunning: 'Server draait op poort ${port}',
serverShutdownLog: 'Server uitgeschakeld',
serverStartedLog: 'Server gestart.',
serverStoppedLog: 'Server gestopt',
sendingChatRequest: 'Chatverzoek verzenden naar API',
sourcesRetrieved: 'Bronnen opgehaald: ${data}',
startingServerWithConfig: 'Server starten met de volgende configuratie:',
sslValidationSet: '${symbol} SSL-validatie is ingesteld op: ${value}',
socketErrorPrefix: 'Fout:',
storeGroupLog: 'Nieuwe groep opslaan met naam: ${groupName} en beschrijving: ${description}',
storeGroupSuccess: 'Groep succesvol opgeslagen: ${data}',
storegroupError: 'Fout bij aanmaken van groep: ${error}',
storeGroupText: 'Groep "${groupName}" succesvol opgeslagen met ID: ${id}.',
unknownAddress: 'Onbekend IP',
unknownCommandError: 'Onbekend commando: ${cmd}',
unknownError: 'Onbekende fout',
unknownPort: 'Onbekende poort',
unknownTool: 'Onbekend hulpmiddel: ${toolName}',
tokenMissing: 'Token ontbreekt.',
},
fi: {
ErrorConnReset: 'Yhteys katkaistiin ennenaikaisesti asiakkaan toimesta (ECONNRESET).',
NoTLSCertFound: 'SSL-varmennetta tai avainta ei löytynyt. Luo varmenne. Voit esimerkiksi luoda itseallekirjoitetun varmenteen OpenSSL:llä:',
deleteChatsSuccess: "Kaikki keskusteluhistoria on poistettu onnistuneesti.",
deleteChatsError: "Tapahtui virhe keskusteluhistorian poistamisessa: ${error}.",
missingAuthToken: "Autentikointitunnus puuttuu tai on virheellinen.",
deleteChatsUnauthorized: "Sinulla ei ole oikeuksia poistaa keskusteluhistoriaa.",
deleteChatsServerIssue: "Palvelinvirhe tapahtui pyyntöä käsiteltäessä.",
deleteChatsNotAllowed: "Tämän käyttäjän ei ole sallittua poistaa keskusteluhistoriaa.",
missingChatId: "Keskustelun tunnus puuttuu. Anna kelvollinen keskustelutunnus.",
chatDeleted: "Keskustelu tunnuksella ${chatId} on poistettu onnistuneesti.",
deleteChatError: "Tapahtui virhe keskustelun poistamisessa tunnuksella ${chatId}: ${error}.",
missingAuthToken: "Autentikointitunnus puuttuu tai on virheellinen.",
deleteChatUnauthorized: "Sinulla ei ole oikeuksia poistaa tätä keskustelua.",
deleteChatServerIssue: "Palvelinvirhe tapahtui pyyntöä käsiteltäessä.",
deleteChatNotAllowed: "Tämän keskustelun poistaminen ei ole sallittua.",
toolDisabledLog: formatMessage(templates.error, { action: 'Toimintokutsu poistettu käytöstä palvelinpuolella:', details: '${toolName}' }),
toolDisabledError: formatMessage(templates.error, { action: 'Toimintokutsu poistettu käytöstä palvelinpuolella:', details: '${toolName}' }),
emailRequiredForReactivate: "Käyttäjän uudelleenaktivointiin vaaditaan sähköpostiosoite.",
reactivateUserLog: "Aloitetaan käyttäjän uudelleenaktivointiprosessi: ${UserName}.",
reactivateUserSuccess: "Käyttäjä aktivoitu uudelleen onnistuneesti: ${data}.",
reactivateUserError: "Virhe käyttäjän uudelleenaktivoinnissa: ${error}. Yritä uudelleen myöhemmin.",
createSourceError: 'Virhe lähteen luomisessa: ${error}',
create_sourceUnknownError: 'Tuntematon virhe lähteen luomisessa: ${error}',
returnStatus: 'Tila: ${Status}',
extractedToken: 'Poistettu tunnus: ${token}',
missingChatId: 'chatId tarvitaan keskustelutietojen hakemiseen.',
missingQuestion: 'Kysymys puuttuu argumenteista.',
ChatInfoRetrieved: 'Keskustelutiedot haettu: ${chatData}',
InvalidGroups: 'Virheelliset ryhmät: ${GROUPS}',
sourceIdRequiredEditSource: 'sourceId tarvitaan lähteen muokkaamiseen.',
sourceIdRequiredRetrieveSource: 'sourceId tarvitaan lähteen hakemiseen.',
ConnectionEstablished: 'Yhteys muodostettu',
ResponseSuccessfullySent: 'Vastaus lähetetty onnistuneesti',
ConnectionClosed: 'Yhteys suljettu',
ServerStopped: 'Palvelin on pysäytetty',
responseReceived: 'Vastaus vastaanotettu tilalla: ${status}',
internalServerError: 'Sisäinen palvelinvirhe',
tcpServerError: 'TCP-palvelimessa tapahtui virhe:',
unknownErrorOccured: 'Tuntematon virhe tapahtui.',
KeygenRequired: 'Avaingeneraattori vaaditaan',
unknownCommand: 'Tuntematon komento',
socketEmitLogNotActivated: 'Lokitiedosto ei ole aktivoitu.',
socketEmitLogReadError: 'Virhe luettaessa lokitiedostoa.',
deletesourceLog: 'Lähteen poisto: nimi: ${SourceName}',
sourceIdRequiredDeleteSource: 'sourceId tarvitaan lähteen poistamiseen.',
listGroupsSuccess: 'Ryhmälista haettu: ${GROUPS}',
// Existing ones
toolNotDefinedInConfig: 'Virheellinen toiminnon kutsu: ${warn}',
toolDisabledLog: 'Toiminnon kutsu estetty palvelimen puolella: ${warn}',
toolDisabledError: 'Toiminnon kutsu estetty palvelimen puolella: ${warn}',
accessRestrictedGroups: 'RESTRICTED_GROUPS arvo: ${val}',
allFunctionsEnabled: 'Kaikki toiminnot ovat käytössä',
allGroupsValid: 'Kaikki ryhmät ovat kelvollisia',
AllowLoggingSuccess: 'ALLOW_LOGGING on käytössä: ${status}',
anonymousModeSuccess: 'ANONYMOUS_MODE on käytössä: ${status}',
apiErrorDetails: 'API-virhe: Tila: ${status}, Tiedot: ${data}',
apiRequestError: 'API-pyynnön virhe: ${error}',
apiUrlInvalid: 'Virheellinen API_URL',
apiUrlValidated: 'API_URL validoitu onnistuneesti: ${url}',
apiUrlWarning: 'Varoitus: API_URL ei ala "https://". URL mukautetaan.',
apiUrlWarningV1: 'Varoitus: API_URL ei pääty "/api/v1". URL mukautetaan.',
authFailed: 'Autentikointi epäonnistui.',
authStarted: 'Autentikointi aloitettu.',
availableGroups: 'Saatavilla olevat ryhmät: ${availableGroups}',
chatApiErrorDefault: 'Virhe keskustelupyynnössä.',
chatApiError: 'Virhe Chat API -pyynnössä: ${error}',
chatResponseSuccess: 'Keskusteluvastaus vastaanotettu: ${data}',
checkingGroups: 'Ryhmien tarkistus: ${groups}',
clientConnected: 'WebSocket-asiakas yhdistetty',
clientDisconnected: 'WebSocket-asiakas katkaistu',
connection: {
new: 'Uusi yhteys hyväksytty: ${ip}:${port}',
established: 'Yhteys muodostettu',
closed: 'Yhteys suljettu ${ip}:${port}',
dataReceived: 'Data vastaanotettu ${ip}:${port}: ${data}',
},
errors: {
processMessage: 'Virhe viestin käsittelyssä: ${error}',
invalidMessage: 'Virheellinen viestimuoto',
socketError: 'Socket-virhe osoitteessa ${ip}:${port}: ${error}',
serverError: 'Palvelinvirhe: ${error}',
},
server: {
running: 'Palvelin toimii portissa ${port}',
stopped: 'Palvelin on pysäytetty',
},
continueConversationError: 'Virhe keskustelun jatkamisessa',
conversationContinuation: 'Keskustelu jatkuu ID: ${chatId}',
conversationSuccess: 'Keskustelu jatkettu onnistuneesti: ${data}',
createGroupSuccess: 'Ryhmä luotu onnistuneesti: ${data}',
createSourceLog: 'Lähteen muokkaus ID: ${sourceId}, Otsikko: ${title}',
createSourceSuccess: 'Lähde luotu onnistuneesti: ${data}',
createUserError: 'Virhe käyttäjän luomisessa: ${error}',
createUserLog: 'Uuden käyttäjän luominen: ${payload}',
createUserSuccess: 'Käyttäjä luotu onnistuneesti: ${data}',
deactivatedFunctions: 'Pois käytöstä olevat toiminnot:',
deleteGroupInternalError: 'Sisäinen virhe ryhmän poistossa.',
deleteGroupLog: 'Ryhmän poistaminen nimellä: ${groupName}',
deleteGroupSuccessLog: 'Ryhmän poistaminen onnistui: ${data}',
deleteGroupText: 'Ryhmä "${groupName}" poistettu onnistuneesti.',
deleteSourceError: 'Virhe lähteen poistossa: ${error}',
deleteSourceFailedTryAgain: 'Lähteen poistaminen epäonnistui. Yritä uudelleen myöhemmin.',
deleteUserError: 'Virhe käyttäjän poistossa: ${error}',
deleteUserLog: 'Käyttäjän poistaminen nimellä: ${UserName}',
deleteUserSuccess: 'Käyttäjä poistettu onnistuneesti: ${data}',
decryptPwdError: 'Salasana ei voitu purkaa.',
decryptionError: 'Purkamisvirhe.',
dataReceivedMsg: 'Data vastaanotettu: ${data}',
emailRequiredForDelete: 'Sähköposti tarvitaan käyttäjän poistamiseen.',
emailRequiredForEdit: 'Käyttäjän sähköposti tarvitaan tietueen muokkaamiseen.',
editSourceError: 'Virhe lähteen muokkauksessa: ${error}',
editSourceLog: 'Lähteen muokkaus ID: ${sourceId}, Otsikko: ${title}',
editSourceSuccess: 'Lähde muokattu onnistuneesti: ${data}',
editUserError: 'Virhe käyttäjän muokkauksessa: ${error}',
editUserSuccess: 'Käyttäjä muokattu onnistuneesti: ${data}',
encryptPwdError: 'Salasanaa ei voitu salata.',
encryptionDisabled: 'Pois käytöstä',
encryptionEnabled: 'Käytössä',
encryptionError: 'Salauksen virhe.',
errorHandlingRequest: 'Virhe pyynnön käsittelyssä: ${error}',
errorProcessingMsg: 'Virhe viestin käsittelyssä: ${error}',
fetchChatInfoError: 'Virhe keskustelutietojen hakemisessa: ${error}',
fetchGroupsError: 'Virhe ryhmien hakemisessa: ${error}',
fetchGroupsErrorBackup: 'Virhe ryhmien hakemisessa.',
fetchGroupsErrorPrefix: 'Virhe ryhmien hakemisessa:',
fetchSourcesError: 'Virhe lähteiden hakemisessa:',
fetchingSources: 'Haetaan lähteitä ryhmälle: ${groupName}',
fileReadErrorTitle: 'Virhe tiedoston lukemisessa.',
functionDisabled: 'pois käytöstä',
genericServerErrorPrefix: 'Virhe:',
gotGetSourceResponse: 'Vastaus vastaanotettu get_source: ${data}',
gotListGroupsResponse: 'Vastaus vastaanotettu list_groups: ${response}',
gotListSourcesResponse: 'Vastaus vastaanotettu list_sources: ${data}',
groupFetchError: 'Virhe ryhmien hakemisessa: Yritä uudelleen myöhemmin.',
groupNameRequired: 'Ryhmänimi vaaditaan tätä pyyntöä varten.',
groupValidationError: 'Virhe ryhmän validoinnissa: ${error}',
groupValidationErrorPrefix: 'Virhe: ${error}',
handlingToolRequest: 'Käsitellään työkalupyyntöä: ${tool}',
headers: 'Otsikot: ${headers}',
incomingMessage: 'Saapuva viesti: ${MESSAGE}',
invalidArgumentsError: 'Virhe: Ei kelvollisia argumentteja syötteessä: ${input}',
invalidGroups: 'Virheelliset ryhmät: ${groups}',
invalidGroupsError: 'Virheelliset ryhmät: ${invalidGroups}',
invalidGroupsLog: 'Virheellinen: ${groups}',
invalidMessage: 'Virheellinen viesti',
invalidOrEmptyRequest: 'Virheellinen viesti tai tyhjä pyyntö.',
keygenDisabled: 'Pois käytöstä',
keygenEnabled: 'Käytössä',
keygenErrorPrefix: 'Virhe keygen-pyynnössä:',
keygenSuccess: 'Keygen suoritettu onnistuneesti.',
langNotSupported: 'Kieltä "${lang}" ei tueta. Palataan englantiin.',
loginEmailPasswordRequired: 'Kirjautuminen epäonnistui: Sähköposti ja salasana vaaditaan.',
loginError: 'Kirjautumisvirhe: ${error}',
loginErrorPrefix: 'Virhe: ${error}',
loginMissingCredentials: 'Kirjautuminen epäonnistui: Sähköposti ja salasana vaaditaan.',
loginMissingCredentialsAlternative: 'Kirjautuminen epäonnistui: Sähköposti ja salasana vaaditaan.',
loginResponse: 'Kirjautumisvastaus',
loginSuccess: 'Kirjautuminen onnistui: ${data}',
loginTokenReceived: 'Tunnus vastaanotettu: ${token}',
LogIpsSuccess: 'LOG_IPs on käytössä: ${status}',
logChangeError: 'Virhe lokitiedoston muutosten käsittelyssä: ${error}',
logReadError: 'Virhe lokitiedoston lukemisessa: ${error}',
logViewerRunning: 'Lokien katseluohjelma on käynnissä osoitteessa http://localhost:${port}',
logoutError: 'Virhe uloskirjautumisessa: ${error}',
logoutFailedTryAgain: 'Uloskirjautuminen epäonnistui. Yritä myöhemmin uudelleen.',
logoutSuccess: 'Uloskirjautuminen onnistui: ${data}',
makingGetSourceRequest: 'Luodaan get_source-pyyntöä: ${args}',
makingListGroupsRequest: 'Luodaan list_groups-pyyntöä',
makingListSourcesRequest: 'Luodaan list_sources-pyyntöä: ${args}',
mcpVersion: 'Versio:',
mcpPort: 'Portti:',
mcpStartTime: 'Käynnistysaika:',
mcpLicense: 'Lisenssi:',
method: 'Menetelmä: ${method}',
missingArgumentsError: 'Puuttuvat argumentit: ${args}',
missingChatParams: 'Pakolliset parametrit puuttuvat: chatId ja/tai kysymys.',
missingCommandParameter: 'Komentoparametri puuttuu viestissä.',
missingConfigError: 'Puuttuva .json-konfiguraatiomuuttuja: ${key}',
missingGroupNameAndDesc: 'Pakolliset parametrit puuttuvat: groupName ja kuvaus.',
missingGroupNameParam: 'Pakollinen parametri puuttuu: groupName.',
missingGroupParameterDelete: 'Poista: Pakollinen parametri puuttuu: groupName.',
missingGroupParameterStore: 'Tallenna: Pakollinen parametri puuttuu: groupName.',
missingNameAndContent: 'Pakolliset parametrit puuttuvat: nimi ja sisältö.',
missingNameEmailPwd: 'Pakolliset parametrit puuttuvat: nimi, sähköposti tai salasana.',
missingParametersError: 'Puuttuvat parametrit: ${parameters}',
missingParameterError: 'Pakollinen parametri puuttuu: ${parameter}.',
missingTokenAuth: 'Token puuttuu',
missingTokenError: 'Token puuttuu. Kirjaudu sisään ja yritä uudelleen.',
missingTokenGroups: 'Token puuttuu. Ryhmiä ei voida validoida.',
missingToolName: 'Työkalun nimi puuttuu',
missingUriParameter: 'URI-parametri puuttuu.',
noChatData: 'Ei löytynyt tietoja määritetystä keskustelusta.',
noDescriptionProvided: 'Kuvausta ei annettu',
noErrorMessage: 'Virheviestiä ei ole.',
noServerResponse: 'Palvelimelta ei ole vastaanotettu vastausta.',
passwordEncEnabled: 'Salasanan salaus on käytössä.',
passwordIsRequired: 'Salasana on pakollinen.',
payload: 'Payload: ${payload}',
portInUse: 'Porttivirhe: Portti ${PORT} on jo käytössä.',
portInvalid: 'Porttivirhe: PORTin tulee olla numero välillä 1 ja 65535.',
portValidated: 'PORT validoitu onnistuneesti: ${port}',
proxyAuthMissing: 'Proxy-todennustiedot puuttuvat.',
proxyUseProxy: 'USE_PROXY: ${val}',
publicGroupsConflictWarning: 'Konflikti: usePublic on asetettu epätodeksi, koska ryhmiä on määritelty.',
requestError: 'Pyyntövirhe: ${error}',
requestSent: 'Pyyntö lähetetty',
restrictedGroupsError: 'Virhe: RESTRICTED_GROUPS -konfiguraatio on virheellinen. Sen tulee olla \'true\' tai \'false\'. Nykyinen arvo: ${value}',
restrictedGroupsSuccess: 'RESTRICTED_GROUPS on käytössä: ${status}',
restrictedGroupsWarning: 'RESTRICTED_GROUPS on käytössä. Saatavilla olevat ryhmät ovat rajoitettuja.',
responseError: 'Vastausvirhe: ${error}',
responseSentSuccess: 'Tila: Onnistunut',
serverError: 'Palvelinta ei voitu käynnistää: ${error}',
serverListeningOnPort: 'Palvelin kuuntelee portissa ${port}',
serverRunning: 'Palvelin toimii portissa ${port}',
serverShutdownLog: 'Palvelin sammutettu',
serverStartedLog: 'Palvelin käynnistetty.',
serverStoppedLog: 'Palvelin pysäytetty',
sendingChatRequest: 'Lähetetään keskustelupyyntöä API:lle',
sourcesRetrieved: 'Lähteet haettu: ${data}',
startingServerWithConfig: 'Käynnistetään palvelin seuraavalla konfiguraatiolla:',
sslValidationSet: '${symbol} SSL-validointi on asetettu: ${value}',
socketErrorPrefix: 'Virhe:',
storeGroupLog: 'Tallennetaan uusi ryhmä nimellä: ${groupName} ja kuvauksella: ${description}',
storeGroupSuccess: 'Ryhmä tallennettu onnistuneesti: ${data}',
storegroupError: 'Virhe ryhmän luomisessa: ${error}',
storeGroupText: 'Ryhmä "${groupName}" tallennettu onnistuneesti ID:llä: ${id}.',
unknownAddress: 'Tuntematon IP',
unknownCommandError: 'Tuntematon komento: ${cmd}',
unknownError: 'Tuntematon virhe',
unknownPort: 'Tuntematon portti',
unknownTool: 'Tuntematon työkalu: ${toolName}',
tokenMissing: 'Token puuttuu.',
},
fr: {
ErrorConnReset: 'Connexion interrompue prématurément par le client (ECONNRESET).',
NoTLSCertFound: 'Aucun certificat ou clé SSL trouvé. Veuillez créer un certificat. Par exemple, vous pouvez créer un certificat auto-signé avec OpenSSL :',
deleteChatsSuccess: "L'historique des discussions a été supprimé avec succès.",
deleteChatsError: "Une erreur est survenue lors de la suppression de l'historique des discussions : ${error}.",
missingAuthToken: "Le jeton d'autorisation est manquant ou invalide.",
deleteChatsUnauthorized: "Vous n'êtes pas autorisé à supprimer l'historique des discussions.",
deleteChatsServerIssue: "Une erreur de serveur est survenue lors du traitement de la requête.",
deleteChatsNotAllowed: "La suppression de l'historique des discussions n'est pas autorisée pour cet utilisateur.",
missingChatId: "L'ID de la discussion est manquant. Veuillez fournir un ID de discussion valide.",
chatDeleted: "La discussion avec l'ID ${chatId} a été supprimée avec succès.",
deleteChatError: "Une erreur est survenue lors de la suppression de la discussion avec l'ID ${chatId} : ${error}.",
missingAuthToken: "Le jeton d'autorisation est manquant ou invalide.",
deleteChatUnauthorized: "Vous n'êtes pas autorisé à supprimer cette discussion.",
deleteChatServerIssue: "Une erreur de serveur est survenue lors du traitement de la requête.",
deleteChatNotAllowed: "La suppression de cette discussion n'est pas autorisée.",
toolDisabledLog: formatMessage(templates.error, { action: 'Appel de fonction désactivé côté serveur :', details: '${toolName}' }),
toolDisabledError: formatMessage(templates.error, { action: 'Appel de fonction désactivé côté serveur :', details: '${toolName}' }),
emailRequiredForReactivate: "Une adresse e-mail est requise pour réactiver un utilisateur.",
reactivateUserLog: "Début du processus de réactivation pour l'utilisateur : ${UserName}.",
reactivateUserSuccess: "Utilisateur réactivé avec succès : ${data}.",
reactivateUserError: "Erreur lors de la réactivation de l'utilisateur : ${error}. Veuillez réessayer plus tard.",
createSourceError: 'Erreur lors de la création de la source : ${error}',
create_sourceUnknownError: 'Erreur inconnue lors de la création de la source : ${error}',
returnStatus: 'Statut : ${Status}',
extractedToken: 'Jeton extrait : ${token}',
missingChatId: 'chatId est requis pour récupérer les informations du chat.',
missingQuestion: 'Question manquante dans les arguments.',
ChatInfoRetrieved: 'Informations du chat récupérées : ${chatData}',
InvalidGroups: 'Groupes invalides : ${GROUPS}',
sourceIdRequiredEditSource: 'sourceId est requis pour modifier une source.',
sourceIdRequiredRetrieveSource: 'sourceId est requis pour récupérer une source.',
ConnectionEstablished: 'Connexion établie',
ResponseSuccessfullySent: 'Réponse envoyée avec succès',
ConnectionClosed: 'Connexion fermée',
ServerStopped: 'Le serveur a été arrêté',
responseReceived: 'Réponse reçue avec le statut : ${status}',
internalServerError: 'Erreur interne du serveur',
tcpServerError: 'Une erreur est survenue dans le serveur TCP :',
unknownErrorOccured: 'Une erreur inconnue est survenue.',
KeygenRequired: 'Génération de clé requise',
unknownCommand: 'Commande inconnue',
socketEmitLogNotActivated: 'Le fichier de journal n\'est pas activé.',
socketEmitLogReadError: 'Erreur de lecture du fichier de journal.',
deletesourceLog: 'Supprimer la source avec le nom : ${SourceName}',
sourceIdRequiredDeleteSource: 'sourceId est requis pour supprimer la source.',
listGroupsSuccess: 'Liste des groupes récupérée : ${GROUPS}',
// Existing ones
toolNotDefinedInConfig: 'Appel de fonction invalide : ${warn}',
toolDisabledLog: 'Appel de fonction désactivé côté serveur : ${warn}',
toolDisabledError: 'Appel de fonction désactivé côté serveur : ${warn}',
accessRestrictedGroups: 'Valeur RESTRICTED_GROUPS : ${val}',
allFunctionsEnabled: 'Toutes les fonctions sont activées',
allGroupsValid: 'Tous les groupes sont valides',
AllowLoggingSuccess: 'ALLOW_LOGGING est activé : ${status}',
anonymousModeSuccess: 'ANONYMOUS_MODE est activé : ${status}',
apiErrorDetails: 'Erreur API : Statut : ${status}, Données : ${data}',
apiRequestError: 'Erreur de requête API : ${error}',
apiUrlInvalid: 'API_URL invalide',
apiUrlValidated: 'API_URL validé avec succès : ${url}',
apiUrlWarning: 'Attention : API_URL ne commence pas par "https://". L\'URL est en cours d\'ajustement.',
apiUrlWarningV1: 'Attention : API_URL ne se termine pas par "/api/v1". L\'URL est en cours d\'ajustement.',
authFailed: 'Authentification échouée.',
authStarted: 'Authentification démarrée.',
availableGroups: 'Groupes disponibles : ${availableGroups}',
chatApiErrorDefault: 'Erreur lors de la requête de chat.',
chatApiError: 'Erreur dans la requête Chat API : ${error}',
chatResponseSuccess: 'Réponse du chat reçue : ${data}',
checkingGroups: 'Vérification des groupes : ${groups}',
clientConnected: 'Client WebSocket connecté',
clientDisconnected: 'Client WebSocket déconnecté',
connection: {
new: 'Nouvelle connexion acceptée de ${ip}:${port}',
established: 'Connexion établie',
closed: 'Connexion fermée ${ip}:${port}',
dataReceived: 'Données reçues de ${ip}:${port} : ${data}',
},
errors: {
processMessage: 'Erreur lors du traitement du message : ${error}',
invalidMessage: 'Format de message invalide',
socketError: 'Erreur de socket chez ${ip}:${port} : ${error}',
serverError: 'Erreur du serveur : ${error}',
},
server: {
running: 'Le serveur est en cours d\'exécution sur le port ${port}',
stopped: 'Le serveur a été arrêté',
},
continueConversationError: 'Erreur lors de la poursuite de la conversation',
conversationContinuation: 'Conversation en cours de poursuite ID : ${chatId}',
conversationSuccess: 'Conversation poursuivie avec succès : ${data}',
createGroupSuccess: 'Groupe créé avec succès : ${data}',
createSourceLog: 'Modification de la source avec ID : ${sourceId}, Titre : ${title}',
createSourceSuccess: 'Source créée avec succès : ${data}',
createUserError: 'Erreur lors de la création de l\'utilisateur : ${error}',
createUserLog: 'Création d\'un nouvel utilisateur : ${payload}',
createUserSuccess: 'Utilisateur créé avec succès : ${data}',
deactivatedFunctions: 'Fonctions désactivées :',
deleteGroupInternalError: 'Erreur interne lors de la suppression du groupe.',
deleteGroupLog: 'Suppression du groupe avec le nom : ${groupName}',
deleteGroupSuccessLog: 'Groupe supprimé avec succès : ${data}',
deleteGroupText: 'Le groupe "${groupName}" a été supprimé avec succès.',
deleteSourceError: 'Erreur lors de la suppression de la source : ${error}',
deleteSourceFailedTryAgain: 'La suppression de la source a échoué. Veuillez réessayer plus tard.',
deleteUserError: 'Erreur lors de la suppression de l\'utilisateur : ${error}',
deleteUserLog: 'Suppression de l\'utilisateur avec le nom : ${UserName}',
deleteUserSuccess: 'Utilisateur supprimé avec succès : ${data}',
decryptPwdError: 'Le mot de passe n\'a pas pu être décrypté.',
decryptionError: 'Erreur de décryptage.',
dataReceivedMsg: 'Données reçues : ${data}',
emailRequiredForDelete: 'L\'e-mail est requis pour supprimer un utilisateur.',
emailRequiredForEdit: 'L\'e-mail de l\'utilisateur est requis pour modifier l\'enregistrement.',
editSourceError: 'Erreur lors de la modification de la source : ${error}',
editSourceLog: 'Modification de la source avec ID : ${sourceId}, Titre : ${title}',
editSourceSuccess: 'Source modifiée avec succès : ${data}',
editUserError: 'Erreur lors de la modification de l\'utilisateur : ${error}',
editUserSuccess: 'Utilisateur modifié avec succès : ${data}',
encryptPwdError: 'Le mot de passe n\'a pas pu être crypté.',
encryptionDisabled: 'Désactivé',
encryptionEnabled: 'Activé',
encryptionError: 'Erreur de cryptage.',
errorHandlingRequest: 'Erreur lors du traitement de la requête : ${error}',
errorProcessingMsg: 'Erreur lors du traitement du message : ${error}',
fetchChatInfoError: 'Erreur lors de la récupération des informations du chat : ${error}',
fetchGroupsError: 'Erreur lors de la récupération des groupes : ${error}',
fetchGroupsErrorBackup: 'Erreur lors de la récupération des groupes.',
fetchGroupsErrorPrefix: 'Erreur lors de la récupération des groupes :',
fetchSourcesError: 'Erreur lors de la récupération des sources :',
fetchingSources: 'Récupération des sources pour le groupe : ${groupName}',
fileReadErrorTitle: 'Erreur lors de la lecture du fichier.',
functionDisabled: 'désactivé',
genericServerErrorPrefix: 'Erreur :',
gotGetSourceResponse: 'Réponse reçue pour get_source : ${data}',
gotListGroupsResponse: 'Réponse reçue pour list_groups : ${response}',
gotListSourcesResponse: 'Réponse reçue pour list_sources : ${data}',
groupFetchError: 'Erreur lors de la récupération des groupes : Veuillez réessayer plus tard.',
groupNameRequired: 'Le nom du groupe est requis pour cette requête.',
groupValidationError: 'Erreur lors de la validation du groupe : ${error}',
groupValidationErrorPrefix: 'Erreur : ${error}',
handlingToolRequest: 'Traitement de la requête de l\'outil : ${tool}',
headers: 'En-têtes : ${headers}',
incomingMessage: 'Message entrant : ${MESSAGE}',
invalidArgumentsError: 'Erreur : Aucun argument valide trouvé dans l\'entrée : ${input}',
invalidGroups: 'Groupes invalides : ${groups}',
invalidGroupsError: 'Groupes invalides : ${invalidGroups}',
invalidGroupsLog: 'Invalide : ${groups}',
invalidMessage: 'Message invalide',
invalidOrEmptyRequest: 'Message invalide ou requête vide.',
keygenDisabled: 'Désactivé',
keygenEnabled: 'Activé',
keygenErrorPrefix: 'Erreur lors de la demande de keygen :',
keygenSuccess: 'Keygen terminé avec succès.',
langNotSupported: 'La langue "${lang}" n\'est pas prise en charge. Passage à l\'anglais.',
loginEmailPasswordRequired: 'Échec de la connexion : E-mail et mot de passe requis.',
loginError: 'Erreur de connexion : ${error}',
loginErrorPrefix: 'Erreur : ${error}',
loginMissingCredentials: 'Échec de la connexion : E-mail et mot de passe requis.',
loginMissingCredentialsAlternative: 'Échec de la connexion : E-mail et mot de passe requis.',
loginResponse: 'Réponse de connexion',
loginSuccess: 'Connexion réussie : ${data}',
loginTokenReceived: 'Jeton reçu : ${token}',
LogIpsSuccess: 'LOG_IPs est activé : ${status}',
logChangeError: 'Erreur lors du traitement des modifications du fichier journal : ${error}',
logReadError: 'Erreur lors de la lecture du fichier journal : ${error}',
logViewerRunning: 'Le visualiseur de journal est en cours d\'exécution sur http://localhost:${port}',
logoutError: 'Erreur lors de la déconnexion : ${error}',
logoutFailedTryAgain: 'Déconnexion échouée. Veuillez réessayer plus tard.',
logoutSuccess: 'Déconnexion réussie : ${data}',
makingGetSourceRequest: 'Création de la demande get_source : ${args}',
makingListGroupsRequest: 'Création de la demande list_groups',
makingListSourcesRequest: 'Création de la demande list_sources : ${args}',
mcpVersion: 'Version :',
mcpPort: 'Port :',
mcpStartTime: 'Heure de démarrage :',
mcpLicense: 'Licence :',
method: 'Méthode : ${method}',
missingArgumentsError: 'Arguments manquants : ${args}',
missingChatParams: 'Paramètres requis manquants : chatId et/ou question.',
missingCommandParameter: 'Paramètre de commande manquant dans le message.',
missingConfigError: 'Variable de configuration .json manquante : ${key}',
missingGroupNameAndDesc: 'Paramètres requis manquants : groupName et description.',
missingGroupNameParam: 'Paramètre requis manquant : groupName.',
missingGroupParameterDelete: 'Supprimer : Paramètre requis manquant : groupName.',
missingGroupParameterStore: 'Enregistrer : Paramètre requis manquant : groupName.',
missingNameAndContent: 'Paramètres requis manquants : nom et contenu.',
missingNameEmailPwd: 'Paramètres requis manquants : nom, e-mail ou mot de passe.',
missingParametersError: 'Paramètres manquants : ${parameters}',
missingParameterError: 'Paramètre requis manquant : ${parameter}.',
missingTokenAuth: 'Token manquant',
missingTokenError: 'Token manquant. Veuillez vous connecter et réessayer.',
missingTokenGroups: 'Token manquant. Les groupes ne peuvent pas être validés.',
missingToolName: 'Nom de l\'outil manquant',
missingUriParameter: 'Paramètre URI manquant.',
noChatData: 'Aucune donnée trouvée pour le chat spécifié.',
noDescriptionProvided: 'Aucune description fournie',
noErrorMessage: 'Aucun message d\'erreur.',
noServerResponse: 'Aucune réponse reçue du serveur.',
passwordEncEnabled: 'Le chiffrement des mots de passe est activé.',
passwordIsRequired: 'Le mot de passe est requis.',
payload: 'Charge utile : ${payload}',
portInUse: 'Erreur de port : le port ${PORT} est déjà utilisé.',
portInvalid: 'Erreur de port : PORT doit être un nombre entre 1 et 65535.',
portValidated: 'PORT validé avec succès : ${port}',
proxyAuthMissing: 'Données d\'authentification proxy manquantes.',
proxyUseProxy: 'USE_PROXY : ${val}',
publicGroupsConflictWarning: 'Conflit : usePublic a été défini sur false car des groupes sont spécifiés.',
requestError: 'Erreur de requête : ${error}',
requestSent: 'Requête envoyée',
restrictedGroupsError: 'Erreur : Configuration RESTRICTED_GROUPS invalide. Doit être \'true\' ou \'false\'. Valeur actuelle : ${value}',
restrictedGroupsSuccess: 'RESTRICTED_GROUPS est activé : ${status}',
restrictedGroupsWarning: 'RESTRICTED_GROUPS activé. Les groupes disponibles sont restreints.',
responseError: 'Erreur de réponse : ${error}',
responseSentSuccess: 'Statut : Succès',
serverError: 'Le serveur n\'a pas pu être démarré : ${error}',
serverListeningOnPort: 'Le serveur écoute sur le port ${port}',
serverRunning: 'Le serveur fonctionne sur le port ${port}',
serverShutdownLog: 'Arrêt du serveur',
serverStartedLog: 'Serveur démarré.',
serverStoppedLog: 'Serveur arrêté',
sendingChatRequest: 'Envoi de la requête de chat à l\'API',
sourcesRetrieved: 'Sources récupérées : ${data}',
startingServerWithConfig: 'Démarrage du serveur avec la configuration suivante :',
sslValidationSet: '${symbol} La validation SSL est définie sur : ${value}',
socketErrorPrefix: 'Erreur :',
storeGroupLog: 'Enregistrement d\'un nouveau groupe avec le nom : ${groupName} et la description : ${description}',
storeGroupSuccess: 'Groupe enregistré avec succès : ${data}',
storegroupError: 'Erreur lors de la création du groupe : ${error}',
storeGroupText: 'Groupe "${groupName}" enregistré avec succès avec l\'ID : ${id}.',
unknownAddress: 'IP inconnue',
unknownCommandError: 'Commande inconnue : ${cmd}',
unknownError: 'Erreur inconnue',
unknownPort: 'Port inconnu',
unknownTool: 'Outil inconnu : ${toolName}',
tokenMissing: 'Token manquant.',
},
sv: {
ErrorConnReset: 'Anslutningen avslutades i förtid av klienten (ECONNRESET).',
NoTLSCertFound: 'Inget SSL-certifikat eller nyckel hittades. Vänligen skapa ett certifikat. Du kan till exempel skapa ett självsignerat certifikat med OpenSSL:',
deleteChatsSuccess: "All chathistorik har raderats framgångsrikt.",
deleteChatsError: "Ett fel uppstod vid radering av chathistoriken: ${error}.",
missingAuthToken: "Auktoriseringstoken saknas eller är ogiltig.",
deleteChatsUnauthorized: "Du har inte behörighet att radera chathistorik.",
deleteChatsServerIssue: "Ett serverfel uppstod vid bearbetning av begäran.",
deleteChatsNotAllowed: "Det är inte tillåtet att radera chathistorik för denna användare.",
missingChatId: "Chatt-ID saknas. Vänligen ange ett giltigt chatt-ID.",
chatDeleted: "Chatten med ID ${chatId} har raderats framgångsrikt.",
deleteChatError: "Ett fel uppstod vid radering av chatten med ID ${chatId}: ${error}.",
missingAuthToken: "Auktoriseringstoken saknas eller är ogiltig.",
deleteChatUnauthorized: "Du har inte behörighet att radera denna chatt.",
deleteChatServerIssue: "Ett serverfel uppstod vid bearbetning av begäran.",
deleteChatNotAllowed: "Det är inte tillåtet att radera denna chatt.",
toolDisabledLog: formatMessage(templates.error, { action: 'Funktionsanrop inaktiverat på serversidan:', details: '${toolName}' }),
toolDisabledError: formatMessage(templates.error, { action: 'Funktionsanrop inaktiverat på serversidan:', details: '${toolName}' }),
emailRequiredForReactivate: "En e-postadress krävs för att återaktivera en användare.",
reactivateUserLog: "Startar återaktiveringsprocessen för användare: ${UserName}.",
reactivateUserSuccess: "Användaren har återaktiverats framgångsrikt: ${data}.",
reactivateUserError: "Fel vid återaktivering av användaren: ${error}. Vänligen försök igen senare.",
createSourceError: 'Fel vid skapande av källa: ${error}',
create_sourceUnknownError: 'Okänt fel vid skapande av källa: ${error}',
returnStatus: 'Status: ${Status}',
extractedToken: 'Extraherad token: ${token}',
missingChatId: 'chatId krävs för att hämta chattinformation.',
missingQuestion: 'Fråga saknas i argumenten.',
ChatInfoRetrieved: 'Chattinformation hämtad: ${chatData}',
InvalidGroups: 'Ogiltiga grupper: ${GROUPS}',
sourceIdRequiredEditSource: 'sourceId krävs för att redigera en källa.',
sourceIdRequiredRetrieveSource: 'sourceId krävs för att hämta en källa.',
ConnectionEstablished: 'Anslutning etablerad',
ResponseSuccessfullySent: 'Svar skickat framgångsrikt',
ConnectionClosed: 'Anslutning stängd',
ServerStopped: 'Servern har stoppats',
responseReceived: 'Svar mottaget med status: ${status}',
internalServerError: 'Internt serverfel',
tcpServerError: 'Ett fel uppstod i TCP-servern:',
unknownErrorOccured: 'Ett okänt fel uppstod.',
KeygenRequired: 'Keygen krävs',
unknownCommand: 'Okänt kommando',
socketEmitLogNotActivated: 'Loggfil är inte aktiverad.',
socketEmitLogReadError: 'Fel vid läsning av loggfil.',
deletesourceLog: formatMessage(templates.info, { action: 'Ta bort källa', details: 'med namn: ${SourceName}' }),
sourceIdRequiredDeleteSource: 'sourceId krävs för att ta bort källa.',
listGroupsSuccess: 'Grupplista hämtad: ${GROUPS}',
// Existing ones
toolNotDefinedInConfig: formatMessage(templates.error, { action: 'Ogiltigt funktionsanrop', details: '${warn}' }),
toolDisabledLog: formatMessage(templates.error, { action: 'Funktionsanrop inaktiverat på serversidan:', details: '${warn}' }),
toolDisabledError: formatMessage(templates.error, { action: 'Funktionsanrop inaktiverat på serversidan:', details: '${warn}' }),
accessRestrictedGroups: formatMessage(templates.info, { action: 'RESTRICTED_GROUPS Värde', details: '${val}' }),
allFunctionsEnabled: formatMessage(templates.success, { action: 'Alla funktioner är aktiverade', details: '' }),
allGroupsValid: formatMessage(templates.success, { action: 'Alla grupper är giltiga', details: '' }),
AllowLoggingSuccess: formatMessage(templates.success, { action: 'ALLOW_LOGGING', details: 'är aktiverat: ${status}' }),
anonymousModeSuccess: formatMessage(templates.success, { action: 'ANONYMOUS_MODE', details: 'är aktiverat: ${status}' }),
apiErrorDetails: formatMessage(templates.error, { action: 'API-fel', details: 'Status: ${status}, Data: ${data}' }),
apiRequestError: formatMessage(templates.error, { action: 'API-förfrågningsfel', details: '${error}' }),
apiUrlInvalid: formatMessage(templates.error, { action: 'Ogiltig API_URL', details: '' }),
apiUrlValidated: formatMessage(templates.success, { action: 'API_URL validerad framgångsrikt', details: '${url}' }),
apiUrlWarning: formatMessage(templates.warning, { action: 'Varning', details: 'API_URL börjar inte med "https://". URL:en justeras.' }),
apiUrlWarningV1: formatMessage(templates.warning, { action: 'Varning', details: 'API_URL slutar inte med "/api/v1". URL:en justeras.' }),
authFailed: 'Autentisering misslyckades.',
authStarted: 'Autentisering påbörjad.',
availableGroups: formatMessage(templates.success, { action: 'Tillgängliga grupper', details: '${availableGroups}' }),
chatApiErrorDefault: 'Fel under chattförfrågan.',
chatApiError: formatMessage(templates.error, { action: 'Fel i Chat API-förfrågan', details: '${error}' }),
chatResponseSuccess: formatMessage(templates.success, { action: 'Chatt svar mottaget', details: '${data}' }),
checkingGroups: formatMessage(templates.info, { action: 'Kontrollerar grupper', details: '${groups}' }),
clientConnected: formatMessage(templates.info, { action: 'WebSocket-klient ansluten', details: '' }),
clientDisconnected: formatMessage(templates.info, { action: 'WebSocket-klient frånkopplad', details: '' }),
connection: {
new: formatMessage(templates.info, { action: 'Ny anslutning accepterad', details: 'från ${ip}:${port}' }),
established: formatMessage(templates.success, { action: 'Anslutning etablerad', details: '' }),
closed: formatMessage(templates.info, { action: 'Anslutning stängd', details: '${ip}:${port}' }),
dataReceived: formatMessage(templates.info, { action: 'Data mottagen', details: 'från ${ip}:${port}: ${data}' }),
},
errors: {
processMessage: formatMessage(templates.error, { action: 'Fel vid bearbetning av meddelande', details: '${error}' }),
invalidMessage: formatMessage(templates.error, { action: 'Ogiltigt meddelandeformat', details: '' }),
socketError: formatMessage(templates.error, { action: 'Socketfel', details: 'vid ${ip}:${port}: ${error}' }),
serverError: formatMessage(templates.error, { action: 'Serverfel', details: '${error}' }),
},
server: {
running: formatMessage(templates.success, { action: 'Servern körs', details: 'på port ${port}' }),
stopped: formatMessage(templates.info, { action: 'Servern har stoppats', details: '' }),
},
continueConversationError: formatMessage(templates.error, { action: 'Fel vid fortsättning av konversation', details: '' }),
conversationContinuation: formatMessage(templates.success, { action: 'Konversation fortsätter', details: 'ID: ${chatId}' }),
conversationSuccess: formatMessage(templates.success, { action: 'Konversation framgångsrikt fortsatt', details: '${data}' }),
createGroupSuccess: formatMessage(templates.success, { action: 'Grupp skapad framgångsrikt', details: '${data}' }),
createSourceLog: 'Redigerar källa med ID: ${sourceId}, Titel: ${title}',
createSourceSuccess: 'Källa skapad framgångsrikt: ${data}',
createUserError: 'Fel vid skapande av användare: ${error}',
createUserLog: 'Skapar ny användare: ${payload}',
createUserSuccess: 'Användare skapad framgångsrikt: ${data}',
deactivatedFunctions: 'Inaktiverade funktioner:',
deleteGroupInternalError: 'Internt fel vid borttagning av grupp.',
deleteGroupLog: formatMessage(templates.info, { action: 'Tar bort grupp', details: 'med namn: ${groupName}' }),
deleteGroupSuccessLog: formatMessage(templates.success, { action: 'Grupp borttagen framgångsrikt', details: '${data}' }),
deleteGroupText: 'Grupp "${groupName}" har tagits bort framgångsrikt.',
deleteSourceError: 'Fel vid borttagning av källa: ${error}',
deleteSourceFailedTryAgain: 'Borttagning av källan misslyckades. Försök igen senare.',
deleteUserError: 'Fel vid borttagning av användare: ${error}',
deleteUserLog: formatMessage(templates.info, { action: 'Tar bort användare', details: 'med namn: ${UserName}' }),
deleteUserSuccess: 'Användare borttagen framgångsrikt: ${data}',
decryptPwdError: 'Lösenordet kunde inte avkrypteras.',
decryptionError: 'Avkrypteringsfel.',
dataReceivedMsg: 'Data mottagen: ${data}',
emailRequiredForDelete: 'E-post krävs för att ta bort en användare.',
emailRequiredForEdit: 'Användarens e-post krävs för att redigera posten.',
editSourceError: 'Fel vid redigering av källa: ${error}',
editSourceLog: 'Redigerar källa med ID: ${sourceId}, Titel: ${title}',
editSourceSuccess: 'Källa redigerad framgångsrikt: ${data}',
editUserError: 'Fel vid redigering av användare: ${error}',
editUserSuccess: 'Användare redigerad framgångsrikt: ${data}',
encryptPwdError: 'Lösenordet kunde inte krypteras.',
encryptionDisabled: 'Inaktiverat',
encryptionEnabled: 'Aktiverat',
encryptionError: 'Krypteringsfel.',
errorHandlingRequest: formatMessage(templates.error, { action: 'Fel vid hantering av förfrågan', details: '${error}' }),
errorProcessingMsg: formatMessage(templates.error, { action: 'Fel vid bearbetning av meddelande:', details: '${error}' }),
fetchChatInfoError: 'Fel vid hämtning av chattinformation: ${error}',
fetchGroupsError: formatMessage(templates.error, { action: 'Fel vid hämtning av grupper', details: '${error}' }),
fetchGroupsErrorBackup: 'Fel vid hämtning av grupper.',
fetchGroupsErrorPrefix: 'Fel vid hämtning av grupper:',
fetchSourcesError: formatMessage(templates.error, { action: 'Fel vid hämtning av källor', details: '' }),
fetchingSources: formatMessage(templates.info, { action: 'Hämtar källor för grupp: ${groupName}', details: '' }),
fileReadErrorTitle: 'Fel vid läsning av fil.',
functionDisabled: 'inaktiverad',
genericServerErrorPrefix: 'Fel:',
gotGetSourceResponse: formatMessage(templates.success, { action: 'Mottog svar för get_source', details: '${data}' }),
gotListGroupsResponse: formatMessage(templates.success, { action: 'Mottog svar för list_groups', details: '${response}' }),
gotListSourcesResponse: formatMessage(templates.success, { action: 'Mottog svar för list_sources', details: '${data}' }),
groupFetchError: 'Fel vid hämtning av grupper: Försök igen senare.',
groupNameRequired: 'Gruppnamn krävs för denna förfrågan.',
groupValidationError: 'Fel vid validering av grupp: ${error}',
groupValidationErrorPrefix: 'Fel: ${error}',
handlingToolRequest: 'Hantera verktygsförfrågan: ${tool}',
headers: 'Headers: ${headers}',
incomingMessage: 'Inkommande meddelande: ${MESSAGE}',
invalidArgumentsError: 'Fel: Inga giltiga argument hittades i inmatningen: ${input}',
invalidGroups: 'Ogiltiga grupper: ${groups}',
invalidGroupsError: 'Ogiltiga grupper: ${invalidGroups}',
invalidGroupsLog: 'Ogiltiga: ${groups}',
invalidMessage: 'Ogiltigt meddelande',
invalidOrEmptyRequest: 'Ogiltigt meddelande eller tom förfrågan.',
keygenDisabled: 'Inaktiverat',
keygenEnabled: 'Aktiverat',
keygenErrorPrefix: 'Fel med keygen-förfrågan:',
keygenSuccess: 'Keygen slutförd framgångsrikt.',
langNotSupported: 'Språket "${lang}" stöds inte. Återgår till engelska.',
loginEmailPasswordRequired: 'Inloggning misslyckades: E-post och lösenord krävs.',
loginError: formatMessage(templates.error, { action: 'Inloggningsfel', details: '${error}' }),
loginErrorPrefix: 'Fel: ${error}',
loginMissingCredentials: 'Inloggning misslyckades: E-post och lösenord krävs.',
loginMissingCredentialsAlternative: 'Inloggning misslyckades: E-post och lösenord krävs.',
loginResponse: 'Inloggningssvar',
loginSuccess: formatMessage(templates.success, { action: 'Inloggning lyckades', details: '${data}' }),
loginTokenReceived: 'Token mottagen: ${token}',
LogIpsSuccess: formatMessage(templates.success, { action: 'LOG_IPs', details: 'är aktiverat: ${status}' }),
logChangeError: 'Fel vid bearbetning av loggfiländringar: ${error}',
logReadError: 'Fel vid läsning av loggfil: ${error}',
logViewerRunning: 'Loggvärmare körs på http://localhost:${port}',
logoutError: 'Fel vid utloggning: ${error}',
logoutFailedTryAgain: 'Utloggning misslyckades. Försök igen senare.',
logoutSuccess: 'Utloggning lyckades: ${data}',
makingGetSourceRequest: 'Skapar get_source-förfrågan: ${args}',
makingListGroupsRequest: 'Skapar list_groups-förfrågan',
makingListSourcesRequest: 'Skapar list_sources-förfrågan: ${args}',
mcpVersion: 'Version:',
mcpPort: 'Port:',
mcpStartTime: 'Starttid:',
mcpLicense: 'Licens:',
method: 'Metod: ${method}',
missingArgumentsError: 'Saknade argument: ${args}',
missingChatParams: 'Saknade nödvändiga parametrar: chatId och/eller fråga.',
missingCommandParameter: 'Saknas kommandoparameter i meddelandet.',
missingConfigError: 'Saknas .json-konfigurationsvariabel: ${key}',
missingGroupNameAndDesc: 'Saknade nödvändiga parametrar: groupName och beskrivning.',
missingGroupNameParam: 'Saknad nödvändig parameter: groupName.',
missingGroupParameterDelete: 'Ta bort: Saknad nödvändig parameter: groupName.',
missingGroupParameterStore: 'Spara: Saknad nödvändig parameter: groupName.',
missingNameAndContent: 'Saknade nödvändiga parametrar: namn och innehåll.',
missingNameEmailPwd: 'Saknade nödvändiga parametrar: namn, e-post eller lösenord.',
missingParametersError: formatMessage(templates.error, { action: 'Saknade parametrar', details: '${parameters}' }),
missingParameterError: 'Saknad nödvändig parameter: ${parameter}.',
missingTokenAuth: 'Token saknas',
missingTokenError: 'Token saknas. Vänligen logga in och försök igen.',
missingTokenGroups: 'Token saknas. Grupper kan inte valideras.',
missingToolName: 'Verktygsnamn saknas',
missingUriParameter: 'Saknad URI-parameter.',
noChatData: 'Ingen data hittades för den angivna chatten.',
noDescriptionProvided: 'Ingen beskrivning angiven',
noErrorMessage: 'Inget felmeddelande.',
noServerResponse: 'Ingen respons mottagen från servern.',
passwordEncEnabled: 'Lösenordskryptering är aktiverad.',
passwordIsRequired: 'Lösenord krävs.',
payload: 'Payload: ${payload}',
portInUse: 'Portfel: Port ${PORT} används redan.',
portInvalid: 'Portfel: PORT måste vara ett nummer mellan 1 och 65535.',
portValidated: 'PORT validerad framgångsrikt: ${port}',
proxyAuthMissing: 'Proxyautentiseringsdata saknas.',
proxyUseProxy: 'USE_PROXY: ${val}',
publicGroupsConflictWarning: 'Konflikt: usePublic har ställts in på falskt eftersom grupper specificeras.',
requestError: 'Förfrågningsfel: ${error}',
requestSent: 'Förfrågan skickad',
restrictedGroupsError: 'Fel: Ogiltig RESTRICTED_GROUPS-konfiguration. Måste vara \'true\' eller \'false\'. Nuvarande värde: ${value}',
restrictedGroupsSuccess: 'RESTRICTED_GROUPS är aktiverat: ${status}',
restrictedGroupsWarning: 'RESTRICTED_GROUPS aktiverat. Tillgängliga grupper är begränsade.',
responseError: 'Svarsfel: ${error}',
// responseReceived: formatMessage(templates.success, { action: 'Response received', details: '${response}' }),
responseSentSuccess: formatMessage(templates.success, { action: 'Status', details: 'Framgång' }),
serverError: formatMessage(templates.error, { action: 'Servern kunde inte startas', details: '${error}' }),
serverListeningOnPort: 'Servern lyssnar på port ${port}',
serverRunning: 'Servern körs på port ${port}',
serverShutdownLog: 'Serverstängning',
serverStartedLog: 'Servern startad.',
serverStoppedLog: 'Servern stoppad',
sendingChatRequest: 'Skickar chattförfrågan till API',
sourcesRetrieved: formatMessage(templates.success, { action: 'Källor hämtade', details: '${data}' }),
startingServerWithConfig: 'Startar server med följande konfiguration:',
sslValidationSet: '${symbol} SSL-validering är inställd på: ${value}',
socketErrorPrefix: 'Fel:',
storeGroupLog: 'Lagrar en ny grupp med namn: ${groupName} och beskrivning: ${description}',
storeGroupSuccess: 'Grupp lagrad framgångsrikt: ${data}',
storegroupError: 'Fel vid skapande av grupp: ${error}',
storeGroupText: 'Grupp "${groupName}" lagrad framgångsrikt med ID: ${id}.',
unknownAddress: 'Okänd IP',
unknownCommandError: formatMessage(templates.error, { action: 'Okänt kommando', details: '${cmd}' }),
unknownError: formatMessage(templates.error, { action: 'Okänt fel', details: '' }),
unknownPort: 'Okänd port',
unknownTool: 'Okänt verktyg: ${toolName}',
tokenMissing: 'Token saknas.',
},
// Bulgarian (bg)
bg: {
ErrorConnReset: 'Връзката беше прекратена преждевременно от клиента (ECONNRESET).',
NoTLSCertFound: 'Не е намерен SSL сертификат или ключ. Моля, създайте сертификат. Например, можете да създадете самоподписан сертификат с OpenSSL:',
deleteChatsSuccess: "Цялата хронология на чатовете беше успешно изтрита.",
deleteChatsError: "Възникна грешка при изтриването на хронологията на чатовете: ${error}.",
missingAuthToken: "Липсва или е невалиден токен за удостоверяване.",
deleteChatsUnauthorized: "Нямате разрешение да изтриете хронологията на чатовете.",
deleteChatsServerIssue: "Възникна грешка на сървъра при обработката на заявката.",
deleteChatsNotAllowed: "Изтриването на хронологията на чатовете не е разрешено за този потребител.",
missingChatId: "Липсва идентификатор на чата. Моля, предоставете валиден идентификатор на чат.",
chatDeleted: "Чатът с ID ${chatId} беше успешно изтрит.",
deleteChatError: "Възникна грешка при изтриването на чата с ID ${chatId}: ${error}.",
missingAuthToken: "Липсва или е невалиден токен за удостоверяване.",
deleteChatUnauthorized: "Нямате разрешение да изтриете този чат.",
deleteChatServerIssue: "Възникна грешка на сървъра при обработката на заявката.",
deleteChatNotAllowed: "Изтриването на този чат не е разрешено.",
toolDisabledLog: formatMessage(templates.error, { action: 'Извикването на функция е деактивирано от сървъра:', details: '${toolName}' }),
toolDisabledError: formatMessage(templates.error, { action: 'Извикването на функция е деактивирано от сървъра:', details: '${toolName}' }),
emailRequiredForReactivate: "Необходим е имейл адрес за реактивиране на потребителя.",
reactivateUserLog: "Стартиране на процеса по реактивиране на потребител: ${UserName}.",
reactivateUserSuccess: "Потребителят беше успешно реактивиран: ${data}.",
reactivateUserError: "Грешка при реактивирането на потребителя: ${error}. Моля, опитайте отново по-късно.",
createSourceError: 'Грешка при създаване на източника: ${error}',
create_sourceUnknownError: 'Неизвестна грешка при създаване на източника: ${error}',
returnStatus: 'Статус: ${Status}',
extractedToken: 'Извлечен токен: ${token}',
missingChatId: 'chatId е необходим за извличане на информация за чата.',
missingQuestion: 'Липсва въпрос в аргументите.',
ChatInfoRetrieved: 'Информация за чата е извлечена: ${chatData}',
InvalidGroups: 'Невалидни групи: ${GROUPS}',
sourceIdRequiredEditSource: 'sourceId е необходим за редактиране на източник.',
sourceIdRequiredRetrieveSource: 'sourceId е необходим за извличане на източник.',
ConnectionEstablished: 'Връзката е установена',
ResponseSuccessfullySent: 'Отговорът е изпратен успешно',
ConnectionClosed: 'Връзката е затворена',
ServerStopped: 'Сървърът е спрян',
responseReceived: 'Отговорът е получен със статус: ${status}',
internalServerError: 'Вътрешна сървърна грешка',
tcpServerError: 'Възникна грешка в TCP сървъра:',
unknownErrorOccured: 'Възникна неизвестна грешка.',
KeygenRequired: 'Изисква се генериране на ключ',
unknownCommand: 'Неизвестна команда',
socketEmitLogNotActivated: 'Файлът с логове не е активиран.',
socketEmitLogReadError: 'Грешка при четене на файл с логове.',
deletesourceLog: formatMessage(templates.info, { action: 'Изтриване на източник', details: 'с име: ${SourceName}' }),
sourceIdRequiredDeleteSource: 'sourceId е необходим за изтриване на източник.',
listGroupsSuccess: 'Списъкът с групи е извлечен: ${GROUPS}',
toolNotDefinedInConfig: formatMessage(templates.error, { action: 'Невалиден повик за функция', details: '${warn}' }),
toolDisabledLog: formatMessage(templates.error, { action: 'Повик за функцията е деактивиран от страна на сървъра:', details: '${warn}' }),
toolDisabledError: formatMessage(templates.error, { action: 'Повик за функцията е деактивиран от страна на сървъра:', details: '${warn}' }),
accessRestrictedGroups: formatMessage(templates.info, { action: 'Стойност на RESTRICTED_GROUPS', details: '${val}' }),
allFunctionsEnabled: formatMessage(templates.success, { action: 'Всички функции са активирани', details: '' }),
allGroupsValid: formatMessage(templates.success, { action: 'Всички групи са валидни', details: '' }),
AllowLoggingSuccess: formatMessage(templates.success, { action: 'ALLOW_LOGGING', details: 'е активиран: ${status}' }),
anonymousModeSuccess: formatMessage(templates.success, { action: 'ANONYMOUS_MODE', details: 'е активиран: ${status}' }),
apiErrorDetails: formatMessage(templates.error, { action: 'API грешка', details: 'Статус: ${status}, Данни: ${data}' }),
apiRequestError: formatMessage(templates.error, { action: 'Грешка при API заявка', details: '${error}' }),
apiUrlInvalid: formatMessage(templates.error, { action: 'Невалиден API_URL', details: '' }),
apiUrlValidated: formatMessage(templates.success, { action: 'API_URL е валидиран успешно', details: '${url}' }),
apiUrlWarning: formatMessage(templates.warning, { action: 'Предупреждение', details: 'API_URL не започва с "https://". URL адресът се коригира.' }),
apiUrlWarningV1: formatMessage(templates.warning, { action: 'Предупреждение', details: 'API_URL не завършва с "/api/v1". URL адресът се коригира.' }),
authFailed: 'Автентикацията е неуспешна.',
authStarted: 'Автентикацията е започнала.',
availableGroups: formatMessage(templates.success, { action: 'Налични групи', details: '${availableGroups}' }),
chatApiErrorDefault: 'Грешка по време на чат заявка.',
chatApiError: formatMessage(templates.error, { action: 'Грешка при чат API заявка', details: '${error}' }),
chatResponseSuccess: formatMessage(templates.success, { action: 'Чат отговор получен', details: '${data}' }),
checkingGroups: formatMessage(templates.info, { action: 'Проверка на групите', details: '${groups}' }),
clientConnected: formatMessage(templates.info, { action: 'WebSocket клиент е свързан', details: '' }),
clientDisconnected: formatMessage(templates.info, { action: 'WebSocket клиент е прекъснал връзката', details: '' }),
connection: {
new: formatMessage(templates.info, { action: 'Нова връзка е приета', details: 'от ${ip}:${port}' }),
established: formatMessage(templates.success, { action: 'Връзката е установена', details: '' }),
closed: formatMessage(templates.info, { action: 'Връзката е затворена', details: '${ip}:${port}' }),
dataReceived: formatMessage(templates.info, { action: 'Данни получени', details: 'от ${ip}:${port}: ${data}' }),
},
errors: {
processMessage: formatMessage(templates.error, { action: 'Грешка при обработка на съобщението', details: '${error}' }),
invalidMessage: formatMessage(templates.error, { action: 'Невалиден формат на съобщението', details: '' }),
socketError: formatMessage(templates.error, { action: 'Грешка в сокета', details: 'на ${ip}:${port}: ${error}' }),
serverError: formatMessage(templates.error, { action: 'Сървърна грешка', details: '${error}' }),
},
server: {
running: formatMessage(templates.success, { action: 'Сървърът работи', details: 'на порт ${port}' }),
stopped: formatMessage(templates.info, { action: 'Сървърът е спрян', details: '' }),
},
continueConversationError: formatMessage(templates.error, { action: 'Грешка при продължаване на разговора', details: '' }),
conversationContinuation: formatMessage(templates.success, { action: 'Разговорът продължава', details: 'ID: ${chatId}' }),
conversationSuccess: formatMessage(templates.success, { action: 'Разговорът е успешно продължен', details: '${data}' }),
createGroupSuccess: formatMessage(templates.success, { action: 'Групата е успешно създадена', details: '${data}' }),
createSourceLog: 'Редактиране на източник с ID: ${sourceId}, Заглавие: ${title}',
createSourceSuccess: 'Източникът е успешно създаден: ${data}',
createUserError: 'Грешка при създаване на потребител: ${error}',
createUserLog: 'Създаване на нов потребител: ${payload}',
createUserSuccess: 'Потребителят е успешно създаден: ${data}',
deactivatedFunctions: 'Деактивирани функции:',
deleteGroupInternalError: 'Вътрешна грешка при изтриване на група.',
deleteGroupLog: formatMessage(templates.info, { action: 'Изтриване на група', details: 'с име: ${groupName}' }),
deleteGroupSuccessLog: formatMessage(templates.success, { action: 'Групата е успешно изтрита', details: '${data}' }),
deleteGroupText: 'Групата "${groupName}" е успешно изтрита.',
deleteSourceError: 'Грешка при изтриване на източник: ${error}',
deleteSourceFailedTryAgain: 'Изтриването на източника се провали. Моля, опитайте отново по-късно.',
deleteUserError: 'Грешка при изтриване на потребител: ${error}',
deleteUserLog: formatMessage(templates.info, { action: 'Изтриване на потребител', details: 'с име: ${UserName}' }),
deleteUserSuccess: 'Потребителят е успешно изтрит: ${data}',
decryptPwdError: 'Паролата не може да бъде декриптирана.',
decryptionError: 'Грешка при декрипция.',
dataReceivedMsg: 'Данни получени: ${data}',
emailRequiredForDelete: 'Имейл е необходим за изтриване на потребител.',
emailRequiredForEdit: 'Имейл на потребителя е необходим за редактиране на записа.',
editSourceError: 'Грешка при редактиране на източник: ${error}',
editSourceLog: 'Редактиране на източник с ID: ${sourceId}, Заглавие: ${title}',
editSourceSuccess: 'Източникът е успешно редактиран: ${data}',
editUserError: 'Грешка при редактиране на потребител: ${error}',
editUserSuccess: 'Потребителят е успешно редактиран: ${data}',
encryptPwdError: 'Паролата не може да бъде криптирана.',
encryptionDisabled: 'Деактивирано',
encryptionEnabled: 'Активирано',
encryptionError: 'Грешка при криптиране.',
errorHandlingRequest: formatMessage(templates.error, { action: 'Грешка при обработка на заявката', details: '${error}' }),
errorProcessingMsg: formatMessage(templates.error, { action: 'Грешка при обработка на съобщението:', details: '${error}' }),
fetchChatInfoError: 'Грешка при извличане на информация за чата: ${error}',
fetchGroupsError: formatMessage(templates.error, { action: 'Грешка при извличане на групи', details: '${error}' }),
fetchGroupsErrorBackup: 'Грешка при извличане на групи.',
fetchGroupsErrorPrefix: 'Грешка при извличане на групи:',
fetchSourcesError: formatMessage(templates.error, { action: 'Грешка при извличане на източници', details: '' }),
fetchingSources: formatMessage(templates.info, { action: 'Извличане на източници за група: ${groupName}', details: '' }),
fileReadErrorTitle: 'Грешка при четене на файл.',
functionDisabled: 'деактивирано',
genericServerErrorPrefix: 'Грешка:',
gotGetSourceResponse: formatMessage(templates.success, { action: 'Получен отговор за get_source', details: '${data}' }),
gotListGroupsResponse: formatMessage(templates.success, { action: 'Получен отговор за list_groups', details: '${response}' }),
gotListSourcesResponse: formatMessage(templates.success, { action: 'Получен отговор за list_sources', details: '${data}' }),
groupFetchError: 'Грешка при извличане на групи: Моля, опитайте отново по-късно.',
groupNameRequired: 'Име на група е необходимо за тази заявка.',
groupValidationError: 'Грешка при валидация на група: ${error}',
groupValidationErrorPrefix: 'Грешка: ${error}',
handlingToolRequest: 'Обработка на заявка за инструмент: ${tool}',
headers: 'Заглавки: ${headers}',
incomingMessage: 'Входящо съобщение: ${MESSAGE}',
invalidArgumentsError: 'Грешка: Не са намерени валидни аргументи в входа: ${input}',
invalidGroups: 'Невалидни групи: ${groups}',
invalidGroupsError: 'Невалидни групи: ${invalidGroups}',
invalidGroupsLog: 'Невалидни: ${groups}',
invalidMessage: 'Невалидно съобщение',
invalidOrEmptyRequest: 'Невалидно съобщение или празна заявка.',
keygenDisabled: 'Деактивирано',
keygenEnabled: 'Активирано',
keygenErrorPrefix: 'Грешка при заявка за генериране на ключ:',
keygenSuccess: 'Генериране на ключ е успешно завършено.',
langNotSupported: 'Език "${lang}" не е поддържан. Връщане към английски.',
loginEmailPasswordRequired: 'Влизането е неуспешно: Имейл и парола са необходими.',
loginError: formatMessage(templates.error, { action: 'Грешка при влизане', details: '${error}' }),
loginErrorPrefix: 'Грешка: ${error}',
loginMissingCredentials: 'Влизането е неуспешно: Имейл и парола са необходими.',
loginMissingCredentialsAlternative: 'Влизането е неуспешно: Имейл и парола са необходими.',
loginResponse: 'Отговор при влизане',
loginSuccess: formatMessage(templates.success, { action: 'Влизането е успешно', details: '${data}' }),
loginTokenReceived: 'Токен получен: ${token}',
LogIpsSuccess: formatMessage(templates.success, { action: 'LOG_IPs', details: 'е активиран: ${status}' }),
logChangeError: 'Грешка при обработка на промени във файла с логове: ${error}',
logReadError: 'Грешка при четене на файл с логове: ${error}',
logViewerRunning: 'Прегледачът на логове работи на http://localhost:${port}',
logoutError: 'Грешка при излизане: ${error}',
logoutFailedTryAgain: 'Излизането е неуспешно. Моля, опитайте отново по-късно.',
logoutSuccess: 'Излизането е успешно: ${data}',
makingGetSourceRequest: 'Създаване на get_source заявка: ${args}',
makingListGroupsRequest: 'Създаване на list_groups заявка',
makingListSourcesRequest: 'Създаване на list_sources заявка: ${args}',
mcpVersion: 'Версия:',
mcpPort: 'Порт:',
mcpStartTime: 'Време на стартиране:',
mcpLicense: 'Лиценз:',
method: 'Метод: ${method}',
missingArgumentsError: 'Липсват аргументи: ${args}',
missingChatParams: 'Липсват задължителни параметри: chatId и/или въпрос.',
missingCommandParameter: 'Липсва команден параметър в съобщението.',
missingConfigError: 'Липсва .json конфигурационна променлива: ${key}',
missingGroupNameAndDesc: 'Липсват задължителни параметри: име на група и описание.',
missingGroupNameParam: 'Липсва задължителен параметър: име на група.',
missingGroupParameterDelete: 'Изтриване: Липсва задължителен параметър: име на група.',
missingGroupParameterStore: 'Съхраняване: Липсва задължителен параметър: име на група.',
missingNameAndContent: 'Липсват задължителни параметри: име и съдържание.',
missingNameEmailPwd: 'Липсват задължителни параметри: име, имейл или парола.',
missingParametersError: formatMessage(templates.error, { action: 'Липсващи параметри', details: '${parameters}' }),
missingParameterError: 'Липсва задължителен параметър: ${parameter}.',
missingTokenAuth: 'Липсва токен',
missingTokenError: 'Токенът липсва. Моля, влезте и опитайте отново.',
missingTokenGroups: 'Токенът липсва. Групите не могат да бъдат валидирани.',
missingToolName: 'Липсва име на инструмент',
missingUriParameter: 'Липсва URI параметър.',
noChatData: 'Няма намерени данни за посочения чат.',
noDescriptionProvided: 'Не е предоставено описание',
noErrorMessage: 'Няма съобщение за грешка.',
noServerResponse: 'Не е получен отговор от сървъра.',
passwordEncEnabled: 'Паролното криптиране е активирано.',
passwordIsRequired: 'Паролата е необходима.',
payload: 'Носител: ${payload}',
portInUse: 'Порт грешка: Порт ${PORT} вече се използва.',
portInvalid: 'Порт грешка: PORT трябва да е число между 1 и 65535.',
portValidated: 'PORT е валидиран успешно: ${port}',
proxyAuthMissing: 'Липсват данни за прокси автентикация.',
proxyUseProxy: 'USE_PROXY: ${val}',
publicGroupsConflictWarning: 'Конфликт: usePublic е зададено на false, тъй като са посочени групи.',
requestError: 'Грешка при заявка: ${error}',
requestSent: 'Заявката е изпратена',
restrictedGroupsError: 'Грешка: Невалидна конфигурация на RESTRICTED_GROUPS. Трябва да е \'true\' или \'false\'. Текуща стойност: ${value}',
restrictedGroupsSuccess: 'RESTRICTED_GROUPS е активиран: ${status}',
restrictedGroupsWarning: 'RESTRICTED_GROUPS е активиран. Наличните групи са ограничени.',
responseError: 'Грешка при отговор: ${error}',
responseSentSuccess: formatMessage(templates.success, { action: 'Статус', details: 'Успех' }),
serverError: formatMessage(templates.error, { action: 'Сървърът не можа да бъде стартиран', details: '${error}' }),
serverListeningOnPort: 'Сървърът слуша на порт ${port}',
serverRunning: 'Сървърът работи на порт ${port}',
serverShutdownLog: 'Сървърът е спрян',
serverStartedLog: 'Сървърът е стартиран.',
serverStoppedLog: 'Сървърът е спрян',
sendingChatRequest: 'Изпращане на чат заявка към API',
sourcesRetrieved: formatMessage(templates.success, { action: 'Източниците са извлечени', details: '${data}' }),
startingServerWithConfig: 'Стартиране на сървър с следната конфигурация:',
sslValidationSet: '${symbol} SSL валидацията е зададена на: ${value}',
socketErrorPrefix: 'Грешка:',
storeGroupLog: 'Съхраняване на нова група с име: ${groupName} и описание: ${description}',
storeGroupSuccess: 'Групата е успешно съхранена: ${data}',
storegroupError: 'Грешка при създаване на група: ${error}',
storeGroupText: 'Групата "${groupName}" е успешно съхранена с ID: ${id}.',
unknownAddress: 'Неизвестен IP',
unknownCommandError: formatMessage(templates.error, { action: 'Неизвестна команда', details: '${cmd}' }),
unknownError: formatMessage(templates.error, { action: 'Неизвестна грешка', details: '' }),
unknownPort: 'Неизвестен порт',
unknownTool: 'Неизвестен инструмент: ${toolName}',
tokenMissing: 'Токенът липсва.',
},
he: {
ErrorConnReset: 'החיבור נותק בטרם עת על ידי הלקוח (ECONNRESET).',
NoTLSCertFound: 'לא נמצא אישור או מפתח SSL. אנא צור אישור. לדוגמה, ניתן ליצור אישור חתום עצמית באמצעות OpenSSL:',
deleteChatsSuccess: "כל היסטוריית הצ'אטים נמחקה בהצלחה.",
deleteChatsError: "אירעה שגיאה בעת מחיקת היסטוריית הצ'אטים: ${error}.",
missingAuthToken: "אסימון ההרשאה חסר או לא תקף.",
deleteChatsUnauthorized: "אין לך הרשאה למחוק את היסטוריית הצ'אטים.",
deleteChatsServerIssue: "אירעה שגיאת שרת בעת עיבוד הבקשה.",
deleteChatsNotAllowed: "מחיקת היסטוריית הצ'אטים אינה מותרת עבור משתמש זה.",
missingChatId: "מזהה הצ'אט חסר. אנא ספק מזהה צ'אט חוקי.",
chatDeleted: "הצ'אט עם המזהה ${chatId} נמחק בהצלחה.",
deleteChatError: "אירעה שגיאה בעת מחיקת הצ'אט עם המזהה ${chatId}: ${error}.",
missingAuthToken: "אסימון ההרשאה חסר או לא תקף.",
deleteChatUnauthorized: "אין לך הרשאה למחוק צ'אט זה.",
deleteChatServerIssue: "אירעה שגיאת שרת בעת עיבוד הבקשה.",
deleteChatNotAllowed: "מחיקת צ'אט זה אינה מותרת.",
toolDisabledLog: formatMessage(templates.error, { action: 'קריאת הפונקציה הושבתה בצד השרת:', details: '${toolName}' }),
toolDisabledError: formatMessage(templates.error, { action: 'קריאת הפונקציה הושבתה בצד השרת:', details: '${toolName}' }),
emailRequiredForReactivate: "נדרש כתובת אימייל כדי להפעיל מחדש משתמש.",
reactivateUserLog: "מתחיל תהליך הפעלה מחדש של המשתמש: ${UserName}.",
reactivateUserSuccess: "המשתמש הופעל מחדש בהצלחה: ${data}.",
reactivateUserError: "שגיאה בהפעלת המשתמש מחדש: ${error}. אנא נסה שוב מאוחר יותר.",
createSourceError: 'שגיאה ביצירת המקור: ${error}',
create_sourceUnknownError: 'שגיאה לא ידועה ביצירת המקור: ${error}',
returnStatus: 'סטטוס: ${Status}',
extractedToken: 'טוקן שהופק: ${token}',
missingChatId: 'chatId נדרש כדי לאחזר מידע צ\'אט.',
missingQuestion: 'השאלה חסרה בארגומנטים.',
ChatInfoRetrieved: 'מידע צ\'אט נשלף: ${chatData}',
InvalidGroups: 'קבוצות לא חוקיות: ${GROUPS}',
sourceIdRequiredEditSource: 'sourceId נדרש לעריכת מקור.',
sourceIdRequiredRetrieveSource: 'sourceId נדרש לאחזור מקור.',
ConnectionEstablished: 'החיבור נקבע',
ResponseSuccessfullySent: 'התגובה נשלחה בהצלחה',
ConnectionClosed: 'החיבור נסגר',
ServerStopped: 'השרת נעצר',
responseReceived: 'תגובה התקבלה עם סטטוס: ${status}',
internalServerError: 'שגיאת שרת פנימית',
tcpServerError: 'אירעה שגיאה בשרת ה-TCP:',
unknownErrorOccured: 'אירעה שגיאה לא ידועה.',
KeygenRequired: 'נדרש Keygen',
unknownCommand: 'פקודה לא ידועה',
socketEmitLogNotActivated: 'קובץ הלוג אינו מופעל.',
socketEmitLogReadError: 'שגיאה בקריאת קובץ הלוג.',
deletesourceLog: formatMessage(templates.info, { action: 'מחיקת מקור', details: 'עם שם: ${SourceName}' }),
sourceIdRequiredDeleteSource: 'sourceId נדרש למחיקת מקור.',
listGroupsSuccess: 'רשימת קבוצות נשלפה: ${GROUPS}',
// Existing ones
toolNotDefinedInConfig: formatMessage(templates.error, { action: 'קריאת פונקציה לא חוקית', details: '${warn}' }),
toolDisabledLog: formatMessage(templates.error, { action: 'קריאת פונקציה מושבתת מצד השרת:', details: '${warn}' }),
toolDisabledError: formatMessage(templates.error, { action: 'קריאת פונקציה מושבתת מצד השרת:', details: '${warn}' }),
accessRestrictedGroups: formatMessage(templates.info, { action: 'ערך RESTRICTED_GROUPS', details: '${val}' }),
allFunctionsEnabled: formatMessage(templates.success, { action: 'כל הפונקציות מופעלות', details: '' }),
allGroupsValid: formatMessage(templates.success, { action: 'כל הקבוצות תקינות', details: '' }),
AllowLoggingSuccess: formatMessage(templates.success, { action: 'ALLOW_LOGGING', details: 'מופעל: ${status}' }),
anonymousModeSuccess: formatMessage(templates.success, { action: 'ANONYMOUS_MODE', details: 'מופעל: ${status}' }),
apiErrorDetails: formatMessage(templates.error, { action: 'שגיאת API', details: 'סטטוס: ${status}, נתונים: ${data}' }),
apiRequestError: formatMessage(templates.error, { action: 'שגיאת בקשת API', details: '${error}' }),
apiUrlInvalid: formatMessage(templates.error, { action: 'API_URL לא חוקי', details: '' }),
apiUrlValidated: formatMessage(templates.success, { action: 'API_URL אומתה בהצלחה', details: '${url}' }),
apiUrlWarning: formatMessage(templates.warning, { action: 'אזהרה', details: 'API_URL אינו מתחיל ב-"https://". ה-URL מתוקן.' }),
apiUrlWarningV1: formatMessage(templates.warning, { action: 'אזהרה', details: 'API_URL אינו מסתיים ב-"/api/v1". ה-URL מתוקן.' }),
authFailed: 'האימות נכשל.',
authStarted: 'האימות התחיל.',
availableGroups: formatMessage(templates.success, { action: 'קבוצות זמינות', details: '${availableGroups}' }),
chatApiErrorDefault: 'שגיאה במהלך בקשת הצ\'אט.',
chatApiError: formatMessage(templates.error, { action: 'שגיאה בבקשת Chat API', details: '${error}' }),
chatResponseSuccess: formatMessage(templates.success, { action: 'תגובה לצ\'אט התקבלה', details: '${data}' }),
checkingGroups: formatMessage(templates.info, { action: 'בודק קבוצות', details: '${groups}' }),
clientConnected: formatMessage(templates.info, { action: 'לקוח WebSocket התחבר', details: '' }),
clientDisconnected: formatMessage(templates.info, { action: 'לקוח WebSocket נותק', details: '' }),
connection: {
new: formatMessage(templates.info, { action: 'חיבור חדש התקבל', details: 'מ-${ip}:${port}' }),
established: formatMessage(templates.success, { action: 'החיבור נקבע', details: '' }),
closed: formatMessage(templates.info, { action: 'החיבור נסגר', details: '${ip}:${port}' }),
dataReceived: formatMessage(templates.info, { action: 'נתונים התקבלו', details: 'מ-${ip}:${port}: ${data}' }),
},
errors: {
processMessage: formatMessage(templates.error, { action: 'שגיאה בעיבוד הודעה', details: '${error}' }),
invalidMessage: formatMessage(templates.error, { action: 'פורמט הודעה לא חוקי', details: '' }),
socketError: formatMessage(templates.error, { action: 'שגיאת Socket', details: 'ב-${ip}:${port}: ${error}' }),
serverError: formatMessage(templates.error, { action: 'שגיאת שרת', details: '${error}' }),
},
server: {
running: formatMessage(templates.success, { action: 'השרת פועל', details: 'על פורט ${port}' }),
stopped: formatMessage(templates.info, { action: 'השרת נעצר', details: '' }),
},
continueConversationError: formatMessage(templates.error, { action: 'שגיאה בהמשך השיחה', details: '' }),
conversationContinuation: formatMessage(templates.success, { action: 'השיחה ממשיכה', details: 'ID: ${chatId}' }),
conversationSuccess: formatMessage(templates.success, { action: 'השיחה הושלמה בהצלחה', details: '${data}' }),
createGroupSuccess: formatMessage(templates.success, { action: 'הקבוצה נוצרה בהצלחה', details: '${data}' }),
createSourceLog: 'עורך מקור עם ID: ${sourceId}, כותרת: ${title}',
createSourceSuccess: 'מקור נוצר בהצלחה: ${data}',
createUserError: 'שגיאה ביצירת משתמש: ${error}',
createUserLog: 'יוצר משתמש חדש: ${payload}',
createUserSuccess: 'משתמש נוצר בהצלחה: ${data}',
deactivatedFunctions: 'פונקציות מושבתות:',
deleteGroupInternalError: 'שגיאה פנימית במחיקת קבוצה.',
deleteGroupLog: formatMessage(templates.info, { action: 'מוחק קבוצה', details: 'עם שם: ${groupName}' }),
deleteGroupSuccessLog: formatMessage(templates.success, { action: 'הקבוצה נמחקה בהצלחה', details: '${data}' }),
deleteGroupText: 'הקבוצה "${groupName}" נמחקה בהצלחה.',
deleteSourceError: 'שגיאה במחיקת המקור: ${error}',
deleteSourceFailedTryAgain: 'מחיקת המקור נכשלה. אנא נסה שוב מאוחר יותר.',
deleteUserError: 'שגיאה במחיקת המשתמש: ${error}',
deleteUserLog: formatMessage(templates.info, { action: 'מוחק משתמש', details: 'עם שם: ${UserName}' }),
deleteUserSuccess: 'משתמש נמחק בהצלחה: ${data}',
decryptPwdError: 'לא ניתן לפענח את הסיסמה.',
decryptionError: 'שגיאת פענוח.',
dataReceivedMsg: 'נתונים התקבלו: ${data}',
emailRequiredForDelete: 'נדרש אימייל למחיקת משתמש.',
emailRequiredForEdit: 'נדרש אימייל של משתמש לעריכת הרשומה.',
editSourceError: 'שגיאה בעריכת המקור: ${error}',
editSourceLog: 'עורך מקור עם ID: ${sourceId}, כותרת: ${title}',
editSourceSuccess: 'המקור נערך בהצלחה: ${data}',
editUserError: 'שגיאה בעריכת המשתמש: ${error}',
editUserSuccess: 'המשתמש נערך בהצלחה: ${data}',
encryptPwdError: 'לא ניתן להצפין את הסיסמה.',
encryptionDisabled: 'מושבת',
encryptionEnabled: 'מופעל',
encryptionError: 'שגיאת הצפנה.',
errorHandlingRequest: formatMessage(templates.error, { action: 'שגיאה בטיפול בבקשה', details: '${error}' }),
errorProcessingMsg: formatMessage(templates.error, { action: 'שגיאה בעיבוד הודעה:', details: '${error}' }),
fetchChatInfoError: 'שגיאה באחזור מידע הצ\'אט: ${error}',
fetchGroupsError: formatMessage(templates.error, { action: 'שגיאה באחזור קבוצות', details: '${error}' }),
fetchGroupsErrorBackup: 'שגיאה באחזור קבוצות.',
fetchGroupsErrorPrefix: 'שגיאה באחזור קבוצות:',
fetchSourcesError: formatMessage(templates.error, { action: 'שגיאה באחזור מקורות', details: '' }),
fetchingSources: formatMessage(templates.info, { action: 'מאחזר מקורות עבור קבוצה: ${groupName}', details: '' }),
fileReadErrorTitle: 'שגיאה בקריאת קובץ.',
functionDisabled: 'מושבת',
genericServerErrorPrefix: 'שגיאה:',
gotGetSourceResponse: formatMessage(templates.success, { action: 'קיבלתי תגובה עבור get_source', details: '${data}' }),
gotListGroupsResponse: formatMessage(templates.success, { action: 'קיבלתי תגובה עבור list_groups', details: '${response}' }),
gotListSourcesResponse: formatMessage(templates.success, { action: 'קיבלתי תגובה עבור list_sources', details: '${data}' }),
groupFetchError: 'שגיאה באחזור קבוצות: אנא נסה שוב מאוחר יותר.',
groupNameRequired: 'נדרש שם קבוצה לבקשה זו.',
groupValidationError: 'שגיאה באימות קבוצה: ${error}',
groupValidationErrorPrefix: 'שגיאה: ${error}',
handlingToolRequest: 'מטפל בבקשת כלי: ${tool}',
headers: 'Headers: ${headers}',
incomingMessage: 'הודעה נכנסת: ${MESSAGE}',
invalidArgumentsError: 'שגיאה: לא נמצאו ארגומנטים חוקיים בקלט: ${input}',
invalidGroups: 'קבוצות לא חוקיות: ${groups}',
invalidGroupsError: 'קבוצות לא חוקיות: ${invalidGroups}',
invalidGroupsLog: 'לא חוקי: ${groups}',
invalidMessage: 'הודעה לא חוקית',
invalidOrEmptyRequest: 'הודעה לא חוקית או בקשה ריקה.',
keygenDisabled: 'מושבת',
keygenEnabled: 'מופעל',
keygenErrorPrefix: 'שגיאה בבקשת keygen:',
keygenSuccess: 'Keygen הושלם בהצלחה.',
langNotSupported: 'השפה "${lang}" אינה נתמכת. חוזר לאנגלית.',
loginEmailPasswordRequired: 'ההתחברות נכשלה: נדרשים אימייל וסיסמה.',
loginError: formatMessage(templates.error, { action: 'שגיאת התחברות', details: '${error}' }),
loginErrorPrefix: 'שגיאה: ${error}',
loginMissingCredentials: 'ההתחברות נכשלה: נדרשים אימייל וסיסמה.',
loginMissingCredentialsAlternative: 'ההתחברות נכשלה: נדרשים אימייל וסיסמה.',
loginResponse: 'תגובה להתחברות',
loginSuccess: formatMessage(templates.success, { action: 'ההתחברות הצליחה', details: '${data}' }),
loginTokenReceived: 'טוקן התקבל: ${token}',
LogIpsSuccess: formatMessage(templates.success, { action: 'LOG_IPs', details: 'מופעל: ${status}' }),
logChangeError: 'שגיאה בעיבוד שינויים בקובץ הלוג: ${error}',
logReadError: 'שגיאה בקריאת קובץ הלוג: ${error}',
logViewerRunning: 'מציג הלוגים פועל ב-http://localhost:${port}',
logoutError: 'שגיאה בייציאה: ${error}',
logoutFailedTryAgain: 'היציאה נכשלה. אנא נסה שוב מאוחר יותר.',
logoutSuccess: 'יציאה הצליחה: ${data}',
makingGetSourceRequest: 'יוצר בקשת get_source: ${args}',
makingListGroupsRequest: 'יוצר בקשת list_groups',
makingListSourcesRequest: 'יוצר בקשת list_sources: ${args}',
mcpVersion: 'גרסה:',
mcpPort: 'פורט:',
mcpStartTime: 'שעת התחלה:',
mcpLicense: 'רישיון:',
method: 'שיטה: ${method}',
missingArgumentsError: 'ארגומנטים חסרים: ${args}',
missingChatParams: 'פרמטרים נדרשים חסרים: chatId ו/או שאלה.',
missingCommandParameter: 'פרמטר פקודה חסר בהודעה.',
missingConfigError: 'חסרה משתנה קונפיגורציה .json: ${key}',
missingGroupNameAndDesc: 'פרמטרים נדרשים חסרים: groupName ותיאור.',
missingGroupNameParam: 'פרמטר נדרש חסר: groupName.',
missingGroupParameterDelete: 'מחיקה: פרמטר נדרש חסר: groupName.',
missingGroupParameterStore: 'אחסון: פרמטר נדרש חסר: groupName.',
missingNameAndContent: 'פרמטרים נדרשים חסרים: שם ותוכן.',
missingNameEmailPwd: 'פרמטרים נדרשים חסרים: שם, אימייל או סיסמה.',
missingParametersError: formatMessage(templates.error, { action: 'פרמטרים חסרים', details: '${parameters}' }),
missingParameterError: 'פרמטר נדרש חסר: ${parameter}.',
missingTokenAuth: 'טוקן חסר',
missingTokenError: 'טוקן חסר. אנא התחבר ונסה שוב.',
missingTokenGroups: 'טוקן חסר. לא ניתן לאמת קבוצות.',
missingToolName: 'שם כלי חסר',
missingUriParameter: 'פרמטר URI חסר.',
noChatData: 'לא נמצאו נתונים לצ\'אט הספציפי.',
noDescriptionProvided: 'לא סופקה תיאור',
noErrorMessage: 'אין הודעת שגיאה.',
noServerResponse: 'לא התקבלה תגובה מהשרת.',
passwordEncEnabled: 'הצפנת סיסמה מופעלת.',
passwordIsRequired: 'נדרשת סיסמה.',
payload: 'Payload: ${payload}',
portInUse: 'שגיאת פורט: הפורט ${PORT} כבר בשימוש.',
portInvalid: 'שגיאת פורט: PORT חייב להיות מספר בין 1 ל-65535.',
portValidated: 'PORT אומתה בהצלחה: ${port}',
proxyAuthMissing: 'נתוני אימות Proxy חסרים.',
proxyUseProxy: 'USE_PROXY: ${val}',
publicGroupsConflictWarning: 'סכסוך: usePublic הוגדר על false מכיוון שקבוצות מצוינות.',
requestError: 'שגיאת בקשה: ${error}',
requestSent: 'בקשה נשלחה',
restrictedGroupsError: 'שגיאה: קונפיגורציית RESTRICTED_GROUPS לא חוקית. חייב להיות \'true\' או \'false\'. ערך נוכחי: ${value}',
restrictedGroupsSuccess: 'RESTRICTED_GROUPS מופעל: ${status}',
restrictedGroupsWarning: 'RESTRICTED_GROUPS מופעל. הקבוצות הזמינות מוגבלות.',
responseError: 'שגיאת תגובה: ${error}',
// responseReceived: formatMessage(templates.success, { action: 'Response received', details: '${response}' }),
responseSentSuccess: formatMessage(templates.success, { action: 'סטטוס', details: 'הצלחה' }),
serverError: formatMessage(templates.error, { action: 'השרת לא הצליח להתחיל', details: '${error}' }),
serverListeningOnPort: 'השרת מאזין על פורט ${port}',
serverRunning: 'השרת פועל על פורט ${port}',
serverShutdownLog: 'כיבוי השרת',
serverStartedLog: 'השרת התחיל.',
serverStoppedLog: 'השרת נעצר',
sendingChatRequest: 'שולח בקשת צ\'אט ל-API',
sourcesRetrieved: formatMessage(templates.success, { action: 'מקורות נשלפו', details: '${data}' }),
startingServerWithConfig: 'מפעיל שרת עם הקונפיגורציה הבאה:',
sslValidationSet: '${symbol} אימות SSL מוגדר ל: ${value}',
socketErrorPrefix: 'שגיאה:',
storeGroupLog: 'מאחסן קבוצה חדשה עם שם: ${groupName} ותיאור: ${description}',
storeGroupSuccess: 'הקבוצה נשמרה בהצלחה: ${data}',
storegroupError: 'שגיאה ביצירת קבוצה: ${error}',
storeGroupText: 'הקבוצה "${groupName}" נשמרה בהצלחה עם ID: ${id}.',
unknownAddress: 'כתובת IP לא ידועה',
unknownCommandError: formatMessage(templates.error, { action: 'פקודה לא ידועה', details: '${cmd}' }),
unknownError: formatMessage(templates.error, { action: 'שגיאה לא ידועה', details: '' }),
unknownPort: 'פורט לא ידוע',
unknownTool: 'כלי לא ידוע: ${toolName}',
tokenMissing: 'טוקן חסר.',
},
ar: {
ErrorConnReset: 'تم إنهاء الاتصال بشكل غير متوقع من قبل العميل (ECONNRESET).',
NoTLSCertFound: 'لم يتم العثور على شهادة أو مفتاح SSL. يرجى إنشاء شهادة. على سبيل المثال، يمكنك إنشاء شهادة موقعة ذاتيًا باستخدام OpenSSL:',
deleteChatsSuccess: "تم حذف سجل الدردشة بالكامل بنجاح.",
deleteChatsError: "حدث خطأ أثناء حذف سجل الدردشة: ${error}.",
missingAuthToken: "رمز المصادقة مفقود أو غير صالح.",
deleteChatsUnauthorized: "ليس لديك إذن لحذف سجل الدردشة.",
deleteChatsServerIssue: "حدث خطأ في الخادم أثناء معالجة الطلب.",
deleteChatsNotAllowed: "حذف سجل الدردشة غير مسموح به لهذا المستخدم.",
missingChatId: "معرّف الدردشة مفقود. يرجى تقديم معرّف دردشة صالح.",
chatDeleted: "تم حذف الدردشة بالمعرّف ${chatId} بنجاح.",
deleteChatError: "حدث خطأ أثناء حذف الدردشة بالمعرّف ${chatId}: ${error}.",
missingAuthToken: "رمز المصادقة مفقود أو غير صالح.",
deleteChatUnauthorized: "ليس لديك إذن لحذف هذه الدردشة.",
deleteChatServerIssue: "حدث خطأ في الخادم أثناء معالجة الطلب.",
deleteChatNotAllowed: "غير مسموح بحذف هذه الدردشة.",
toolDisabledLog: formatMessage(templates.error, { action: 'تم تعطيل استدعاء الوظيفة من جانب الخادم:', details: '${toolName}' }),
toolDisabledError: formatMessage(templates.error, { action: 'تم تعطيل استدعاء الوظيفة من جانب الخادم:', details: '${toolName}' }),
emailRequiredForReactivate: "مطلوب عنوان بريد إلكتروني لإعادة تنشيط المستخدم.",
reactivateUserLog: "بدء عملية إعادة تنشيط المستخدم: ${UserName}.",
reactivateUserSuccess: "تمت إعادة تنشيط المستخدم بنجاح: ${data}.",
reactivateUserError: "خطأ في إعادة تنشيط المستخدم: ${error}. يرجى المحاولة مرة أخرى لاحقًا.",
createSourceError: 'خطأ في إنشاء المصدر: ${error}',
create_sourceUnknownError: 'خطأ غير معروف في إنشاء المصدر: ${error}',
returnStatus: 'الحالة: ${Status}',
extractedToken: 'التوكن المستخرج: ${token}',
missingChatId: 'مطلوب chatId لاسترجاع معلومات الدردشة.',
missingQuestion: 'السؤال مفقود في الوسائط.',
ChatInfoRetrieved: 'تم استرجاع معلومات الدردشة: ${chatData}',
InvalidGroups: 'مجموعات غير صالحة: ${GROUPS}',
sourceIdRequiredEditSource: 'مطلوب sourceId لتحرير مصدر.',
sourceIdRequiredRetrieveSource: 'مطلوب sourceId لاسترجاع مصدر.',
ConnectionEstablished: 'تم إنشاء الاتصال',
ResponseSuccessfullySent: 'تم إرسال الرد بنجاح',
ConnectionClosed: 'تم إغلاق الاتصال',
ServerStopped: 'تم إيقاف الخادم',
responseReceived: 'تم استلام الرد بالحالة: ${status}',
internalServerError: 'خطأ داخلي في الخادم',
tcpServerError: 'حدث خطأ في خادم TCP:',
unknownErrorOccured: 'حدث خطأ غير معروف.',
KeygenRequired: 'مطلوب Keygen',
unknownCommand: 'أمر غير معروف',
socketEmitLogNotActivated: 'ملف السجل غير مفعل.',
socketEmitLogReadError: 'خطأ في قراءة ملف السجل.',
deletesourceLog: formatMessage(templates.info, { action: 'حذف المصدر', details: 'بالاسم: ${SourceName}' }),
sourceIdRequiredDeleteSource: 'مطلوب sourceId لحذف المصدر.',
listGroupsSuccess: 'تم استرجاع قائمة المجموعات: ${GROUPS}',
// Existing ones
toolNotDefinedInConfig: formatMessage(templates.error, { action: 'نداء دالة غير صالح', details: '${warn}' }),
toolDisabledLog: formatMessage(templates.error, { action: 'نداء دالة معطل من جانب الخادم:', details: '${warn}' }),
toolDisabledError: formatMessage(templates.error, { action: 'نداء دالة معطل من جانب الخادم:', details: '${warn}' }),
accessRestrictedGroups: formatMessage(templates.info, { action: 'قيمة RESTRICTED_GROUPS', details: '${val}' }),
allFunctionsEnabled: formatMessage(templates.success, { action: 'تم تفعيل جميع الدوال', details: '' }),
allGroupsValid: formatMessage(templates.success, { action: 'جميع المجموعات صالحة', details: '' }),
AllowLoggingSuccess: formatMessage(templates.success, { action: 'ALLOW_LOGGING', details: 'مفعل: ${status}' }),
anonymousModeSuccess: formatMessage(templates.success, { action: 'ANONYMOUS_MODE', details: 'مفعل: ${status}' }),
apiErrorDetails: formatMessage(templates.error, { action: 'خطأ في API', details: 'الحالة: ${status}, البيانات: ${data}' }),
apiRequestError: formatMessage(templates.error, { action: 'خطأ في طلب API', details: '${error}' }),
apiUrlInvalid: formatMessage(templates.error, { action: 'API_URL غير صالح', details: '' }),
apiUrlValidated: formatMessage(templates.success, { action: 'تم التحقق من API_URL بنجاح', details: '${url}' }),
apiUrlWarning: formatMessage(templates.warning, { action: 'تحذير', details: 'API_URL لا يبدأ بـ "https://". يتم تعديل URL.' }),
apiUrlWarningV1: formatMessage(templates.warning, { action: 'تحذير', details: 'API_URL لا ينتهي بـ "/api/v1". يتم تعديل URL.' }),
authFailed: 'فشل المصادقة.',
authStarted: 'بدأت المصادقة.',
availableGroups: formatMessage(templates.success, { action: 'المجموعات المتاحة', details: '${availableGroups}' }),
chatApiErrorDefault: 'خطأ أثناء طلب الدردشة.',
chatApiError: formatMessage(templates.error, { action: 'خطأ في طلب Chat API', details: '${error}' }),
chatResponseSuccess: formatMessage(templates.success, { action: 'تم استلام رد الدردشة', details: '${data}' }),
checkingGroups: formatMessage(templates.info, { action: 'جارٍ فحص المجموعات', details: '${groups}' }),
clientConnected: formatMessage(templates.info, { action: 'تم الاتصال بعميل WebSocket', details: '' }),
clientDisconnected: formatMessage(templates.info, { action: 'تم فصل عميل WebSocket', details: '' }),
connection: {
new: formatMessage(templates.info, { action: 'تم قبول اتصال جديد', details: 'من ${ip}:${port}' }),
established: formatMessage(templates.success, { action: 'تم إنشاء الاتصال', details: '' }),
closed: formatMessage(templates.info, { action: 'تم إغلاق الاتصال', details: '${ip}:${port}' }),
dataReceived: formatMessage(templates.info, { action: 'تم استلام البيانات', details: 'من ${ip}:${port}: ${data}' }),
},
errors: {
processMessage: formatMessage(templates.error, { action: 'خطأ في معالجة الرسالة', details: '${error}' }),
invalidMessage: formatMessage(templates.error, { action: 'تنسيق رسالة غير صالح', details: '' }),
socketError: formatMessage(templates.error, { action: 'خطأ في Socket', details: 'في ${ip}:${port}: ${error}' }),
serverError: formatMessage(templates.error, { action: 'خطأ في الخادم', details: '${error}' }),
},
server: {
running: formatMessage(templates.success, { action: 'الخادم يعمل', details: 'على المنفذ ${port}' }),
stopped: formatMessage(templates.info, { action: 'تم إيقاف الخادم', details: '' }),
},
continueConversationError: formatMessage(templates.error, { action: 'خطأ في متابعة المحادثة', details: '' }),
conversationContinuation: formatMessage(templates.success, { action: 'المحادثة مستمرة', details: 'ID: ${chatId}' }),
conversationSuccess: formatMessage(templates.success, { action: 'تمت متابعة المحادثة بنجاح', details: '${data}' }),
createGroupSuccess: formatMessage(templates.success, { action: 'تم إنشاء المجموعة بنجاح', details: '${data}' }),
createSourceLog: 'تحرير المصدر بالمعرف: ${sourceId}, العنوان: ${title}',
createSourceSuccess: 'تم إنشاء المصدر بنجاح: ${data}',
createUserError: 'خطأ في إنشاء المستخدم: ${error}',
createUserLog: 'إنشاء مستخدم جديد: ${payload}',
createUserSuccess: 'تم إنشاء المستخدم بنجاح: ${data}',
deactivatedFunctions: 'الدوال المعطلة:',
deleteGroupInternalError: 'خطأ داخلي في حذف المجموعة.',
deleteGroupLog: formatMessage(templates.info, { action: 'حذف المجموعة', details: 'بالاسم: ${groupName}' }),
deleteGroupSuccessLog: formatMessage(templates.success, { action: 'تم حذف المجموعة بنجاح', details: '${data}' }),
deleteGroupText: 'تم حذف المجموعة "${groupName}" بنجاح.',
deleteSourceError: 'خطأ في حذف المصدر: ${error}',
deleteSourceFailedTryAgain: 'فشل حذف المصدر. يرجى المحاولة مرة أخرى لاحقًا.',
deleteUserError: 'خطأ في حذف المستخدم: ${error}',
deleteUserLog: formatMessage(templates.info, { action: 'حذف المستخدم', details: 'بالاسم: ${UserName}' }),
deleteUserSuccess: 'تم حذف المستخدم بنجاح: ${data}',
decryptPwdError: 'لا يمكن فك تشفير كلمة المرور.',
decryptionError: 'خطأ في فك التشفير.',
dataReceivedMsg: 'تم استلام البيانات: ${data}',
emailRequiredForDelete: 'مطلوب بريد إلكتروني لحذف مستخدم.',
emailRequiredForEdit: 'مطلوب بريد إلكتروني للمستخدم لتحرير السجل.',
editSourceError: 'خطأ في تحرير المصدر: ${error}',
editSourceLog: 'تحرير المصدر بالمعرف: ${sourceId}, العنوان: ${title}',
editSourceSuccess: 'تم تحرير المصدر بنجاح: ${data}',
editUserError: 'خطأ في تحرير المستخدم: ${error}',
editUserSuccess: 'تم تحرير المستخدم بنجاح: ${data}',
encryptPwdError: 'لا يمكن تشفير كلمة المرور.',
encryptionDisabled: 'معطل',
encryptionEnabled: 'مفعل',
encryptionError: 'خطأ في التشفير.',
errorHandlingRequest: formatMessage(templates.error, { action: 'خطأ في معالجة الطلب', details: '${error}' }),
errorProcessingMsg: formatMessage(templates.error, { action: 'خطأ في معالجة الرسالة:', details: '${error}' }),
fetchChatInfoError: 'خطأ في جلب معلومات الدردشة: ${error}',
fetchGroupsError: formatMessage(templates.error, { action: 'خطأ في جلب المجموعات', details: '${error}' }),
fetchGroupsErrorBackup: 'خطأ في جلب المجموعات.',
fetchGroupsErrorPrefix: 'خطأ في جلب المجموعات:',
fetchSourcesError: formatMessage(templates.error, { action: 'خطأ في جلب المصادر', details: '' }),
fetchingSources: formatMessage(templates.info, { action: 'يجلب المصادر للمجموعة: ${groupName}', details: '' }),
fileReadErrorTitle: 'خطأ في قراءة الملف.',
functionDisabled: 'معطل',
genericServerErrorPrefix: 'خطأ:',
gotGetSourceResponse: formatMessage(templates.success, { action: 'تم استلام الرد لـ get_source', details: '${data}' }),
gotListGroupsResponse: formatMessage(templates.success, { action: 'تم استلام الرد لـ list_groups', details: '${response}' }),
gotListSourcesResponse: formatMessage(templates.success, { action: 'تم استلام الرد لـ list_sources', details: '${data}' }),
groupFetchError: 'خطأ في جلب المجموعات: يرجى المحاولة مرة أخرى لاحقًا.',
groupNameRequired: 'اسم المجموعة مطلوب لهذا الطلب.',
groupValidationError: 'خطأ في التحقق من المجموعة: ${error}',
groupValidationErrorPrefix: 'خطأ: ${error}',
handlingToolRequest: 'تعامل مع طلب الأداة: ${tool}',
headers: 'الرؤوس: ${headers}',
incomingMessage: 'رسالة واردة: ${MESSAGE}',
invalidArgumentsError: 'خطأ: لم يتم العثور على وسائط صالحة في الإدخال: ${input}',
invalidGroups: 'مجموعات غير صالحة: ${groups}',
invalidGroupsError: 'مجموعات غير صالحة: ${invalidGroups}',
invalidGroupsLog: 'غير صالح: ${groups}',
invalidMessage: 'رسالة غير صالحة',
invalidOrEmptyRequest: 'رسالة غير صالحة أو طلب فارغ.',
keygenDisabled: 'معطل',
keygenEnabled: 'مفعل',
keygenErrorPrefix: 'خطأ في طلب keygen:',
keygenSuccess: 'تم إكمال keygen بنجاح.',
langNotSupported: 'اللغة "${lang}" غير مدعومة. يتم العودة إلى الإنجليزية.',
loginEmailPasswordRequired: 'فشل تسجيل الدخول: مطلوب البريد الإلكتروني وكلمة المرور.',
loginError: formatMessage(templates.error, { action: 'خطأ في تسجيل الدخول', details: '${error}' }),
loginErrorPrefix: 'خطأ: ${error}',
loginMissingCredentials: 'فشل تسجيل الدخول: مطلوب البريد الإلكتروني وكلمة المرور.',
loginMissingCredentialsAlternative: 'فشل تسجيل الدخول: مطلوب البريد الإلكتروني وكلمة المرور.',
loginResponse: 'استجابة تسجيل الدخول',
loginSuccess: formatMessage(templates.success, { action: 'تم تسجيل الدخول بنجاح', details: '${data}' }),
loginTokenReceived: 'تم استلام التوكن: ${token}',
LogIpsSuccess: formatMessage(templates.success, { action: 'LOG_IPs', details: 'مفعل: ${status}' }),
logChangeError: 'خطأ في معالجة تغييرات ملف السجل: ${error}',
logReadError: 'خطأ في قراءة ملف السجل: ${error}',
logViewerRunning: 'عارض السجلات يعمل على http://localhost:${port}',
logoutError: 'خطأ أثناء تسجيل الخروج: ${error}',
logoutFailedTryAgain: 'فشل تسجيل الخروج. يرجى المحاولة مرة أخرى لاحقًا.',
logoutSuccess: 'تم تسجيل الخروج بنجاح: ${data}',
makingGetSourceRequest: 'إنشاء طلب get_source: ${args}',
makingListGroupsRequest: 'إنشاء طلب list_groups',
makingListSourcesRequest: 'إنشاء طلب list_sources: ${args}',
mcpVersion: 'الإصدار:',
mcpPort: 'المنفذ:',
mcpStartTime: 'وقت البدء:',
mcpLicense: 'الرخصة:',
method: 'الطريقة: ${method}',
missingArgumentsError: 'حجج مفقودة: ${args}',
missingChatParams: 'الوسائط المطلوبة مفقودة: chatId و/أو سؤال.',
missingCommandParameter: 'معامل الأمر مفقود في الرسالة.',
missingConfigError: 'متغير التكوين .json مفقود: ${key}',
missingGroupNameAndDesc: 'الوسائط المطلوبة مفقودة: groupName والوصف.',
missingGroupNameParam: 'معامل groupName المطلوب مفقود.',
missingGroupParameterDelete: 'حذف: معامل groupName المطلوب مفقود.',
missingGroupParameterStore: 'تخزين: معامل groupName المطلوب مفقود.',
missingNameAndContent: 'الوسائط المطلوبة مفقودة: الاسم والمحتوى.',
missingNameEmailPwd: 'الوسائط المطلوبة مفقودة: الاسم، البريد الإلكتروني أو كلمة المرور.',
missingParametersError: formatMessage(templates.error, { action: 'الوسائط المفقودة', details: '${parameters}' }),
missingParameterError: 'المعامل المطلوب مفقود: ${parameter}.',
missingTokenAuth: 'التوكن مفقود',
missingTokenError: 'التوكن مفقود. يرجى تسجيل الدخول والمحاولة مرة أخرى.',
missingTokenGroups: 'التوكن مفقود. لا يمكن التحقق من المجموعات.',
missingToolName: 'اسم الأداة مفقود',
missingUriParameter: 'معامل URI مفقود.',
noChatData: 'لم يتم العثور على بيانات للدردشة المحددة.',
noDescriptionProvided: 'لم يتم توفير وصف',
noErrorMessage: 'لا توجد رسالة خطأ.',
noServerResponse: 'لم يتم استلام رد من الخادم.',
passwordEncEnabled: 'تشفير كلمة المرور مفعل.',
passwordIsRequired: 'كلمة المرور مطلوبة.',
payload: 'Payload: ${payload}',
portInUse: 'خطأ في المنفذ: المنفذ ${PORT} قيد الاستخدام بالفعل.',
portInvalid: 'خطأ في المنفذ: PORT يجب أن يكون رقمًا بين 1 و 65535.',
portValidated: 'تم التحقق من PORT بنجاح: ${port}',
proxyAuthMissing: 'بيانات مصادقة البروكسي مفقودة.',
proxyUseProxy: 'USE_PROXY: ${val}',
publicGroupsConflictWarning: 'تعارض: تم تعيين usePublic إلى false لأن المجموعات محددة.',
requestError: 'خطأ في الطلب: ${error}',
requestSent: 'تم إرسال الطلب',
restrictedGroupsError: 'خطأ: تكوين RESTRICTED_GROUPS غير صالح. يجب أن يكون \'true\' أو \'false\'. القيمة الحالية: ${value}',
restrictedGroupsSuccess: 'تم تفعيل RESTRICTED_GROUPS: ${status}',
restrictedGroupsWarning: 'تم تفعيل RESTRICTED_GROUPS. المجموعات المتاحة محدودة.',
responseError: 'خطأ في الاستجابة: ${error}',
// responseReceived: formatMessage(templates.success, { action: 'Response received', details: '${response}' }),
responseSentSuccess: formatMessage(templates.success, { action: 'الحالة', details: 'نجاح' }),
serverError: formatMessage(templates.error, { action: 'تعذر بدء الخادم', details: '${error}' }),
serverListeningOnPort: 'الخادم يستمع على المنفذ ${port}',
serverRunning: 'الخادم يعمل على المنفذ ${port}',
serverShutdownLog: 'إيقاف الخادم',
serverStartedLog: 'تم بدء الخادم.',
serverStoppedLog: 'تم إيقاف الخادم',
sendingChatRequest: 'يتم إرسال طلب الدردشة إلى API',
sourcesRetrieved: formatMessage(templates.success, { action: 'تم استرجاع المصادر', details: '${data}' }),
startingServerWithConfig: 'بدء الخادم بالتكوين التالي:',
sslValidationSet: '${symbol} تم تعيين التحقق من SSL على: ${value}',
socketErrorPrefix: 'خطأ:',
storeGroupLog: 'تخزين مجموعة جديدة بالاسم: ${groupName} والوصف: ${description}',
storeGroupSuccess: 'تم تخزين المجموعة بنجاح: ${data}',
storegroupError: 'خطأ في إنشاء المجموعة: ${error}',
storeGroupText: 'تم تخزين المجموعة "${groupName}" بنجاح بالمعرف: ${id}.',
unknownAddress: 'عنوان IP غير معروف',
unknownCommandError: formatMessage(templates.error, { action: 'أمر غير معروف', details: '${cmd}' }),
unknownError: formatMessage(templates.error, { action: 'خطأ غير معروف', details: '' }),
unknownPort: 'منفذ غير معروف',
unknownTool: 'أداة غير معروفة: ${toolName}',
tokenMissing: 'التوكن مفقود.'
},
// Estonian (et)
et: {
ErrorConnReset: 'Ühendus katkestati enneaegselt kliendi poolt (ECONNRESET).',
NoTLSCertFound: 'SSL-sertifikaati või võtit ei leitud. Palun looge sertifikaat. Näiteks saate luua iseallkirjastatud sertifikaadi OpenSSL-iga:',
deleteChatsSuccess: "Kõik vestluste ajaloos on edukalt kustutatud.",
deleteChatsError: "Tekkis viga vestluste ajaloo kustutamisel: ${error}.",
missingAuthToken: "Autentimistunnus puudub või on kehtetu.",
deleteChatsUnauthorized: "Teil ei ole õigust vestluste ajalugu kustutada.",
deleteChatsServerIssue: "Päringu töötlemisel ilmnes serveri viga.",
deleteChatsNotAllowed: "Selle kasutaja jaoks pole vestluste ajaloo kustutamine lubatud.",
missingChatId: "Vestluse ID puudub. Palun esitage kehtiv vestluse ID.",
chatDeleted: "Vestlus ID-ga ${chatId} kustutati edukalt.",
deleteChatError: "Tekkis viga vestluse kustutamisel ID-ga ${chatId}: ${error}.",
missingAuthToken: "Autentimistunnus puudub või on kehtetu.",
deleteChatUnauthorized: "Teil ei ole õigust seda vestlust kustutada.",
deleteChatServerIssue: "Päringu töötlemisel ilmnes serveri viga.",
deleteChatNotAllowed: "Selle vestluse kustutamine ei ole lubatud.",
toolDisabledLog: formatMessage(templates.error, { action: 'Funktsiooni kutse on serveri poolel keelatud:', details: '${toolName}' }),
toolDisabledError: formatMessage(templates.error, { action: 'Funktsiooni kutse on serveri poolel keelatud:', details: '${toolName}' }),
emailRequiredForReactivate: "Kasutaja taasaktiveerimiseks on vaja e-posti aadressi.",
reactivateUserLog: "Kasutaja taasaktiveerimisprotsessi alustamine: ${UserName}.",
reactivateUserSuccess: "Kasutaja taasaktiveeriti edukalt: ${data}.",
reactivateUserError: "Viga kasutaja taasaktiveerimisel: ${error}. Palun proovige hiljem uuesti.",
createSourceError: 'Allika loomisel tekkis viga: ${error}',
create_sourceUnknownError: 'Allika loomisel tekkis tundmatu viga: ${error}',
returnStatus: 'Staatus: ${Status}',
extractedToken: 'Ekstraheeritud token: ${token}',
missingChatId: 'chatId on vajalik vestlusinfo hankimiseks.',
missingQuestion: 'Argumendidelt puudub küsimus.',
ChatInfoRetrieved: 'Vestluse teave on hankitud: ${chatData}',
InvalidGroups: 'Vigased grupid: ${GROUPS}',
sourceIdRequiredEditSource: 'allika ID on vajalik allika muutmiseks.',
sourceIdRequiredRetrieveSource: 'allika ID on vajalik allika hankimiseks.',
ConnectionEstablished: 'Ühendus on loodud',
ResponseSuccessfullySent: 'Vastus on edukalt saadetud',
ConnectionClosed: 'Ühendus on suletud',
ServerStopped: 'Server on peatatud',
responseReceived: 'Vastus saadud staatusega: ${status}',
internalServerError: 'Sisemine serveri viga',
tcpServerError: 'TCP serveris tekkis viga:',
unknownErrorOccured: 'Tekkis tundmatu viga.',
KeygenRequired: 'Vajalik võtme genereerimine',
unknownCommand: 'Tundmatu käsk',
socketEmitLogNotActivated: 'Logifail ei ole aktiveeritud.',
socketEmitLogReadError: 'Logifaili lugemisel tekkis viga.',
deletesourceLog: formatMessage(templates.info, { action: 'Allika kustutamine', details: 'nimega: ${SourceName}' }),
sourceIdRequiredDeleteSource: 'allika ID on vajalik allika kustutamiseks.',
listGroupsSuccess: 'Gruppide nimekiri on hankitud: ${GROUPS}',
toolNotDefinedInConfig: formatMessage(templates.error, { action: 'Vigane funktsiooni kutse', details: '${warn}' }),
toolDisabledLog: formatMessage(templates.error, { action: 'Funktsiooni kutse on serveripoolselt keelatud:', details: '${warn}' }),
toolDisabledError: formatMessage(templates.error, { action: 'Funktsiooni kutse on serveripoolselt keelatud:', details: '${warn}' }),
accessRestrictedGroups: formatMessage(templates.info, { action: 'RESTRICTED_GROUPS väärtus', details: '${val}' }),
allFunctionsEnabled: formatMessage(templates.success, { action: 'Kõik funktsioonid on lubatud', details: '' }),
allGroupsValid: formatMessage(templates.success, { action: 'Kõik grupid on kehtivad', details: '' }),
AllowLoggingSuccess: formatMessage(templates.success, { action: 'ALLOW_LOGGING', details: 'on lubatud: ${status}' }),
anonymousModeSuccess: formatMessage(templates.success, { action: 'ANONYMOUS_MODE', details: 'on lubatud: ${status}' }),
apiErrorDetails: formatMessage(templates.error, { action: 'API viga', details: 'Staatus: ${status}, Andmed: ${data}' }),
apiRequestError: formatMessage(templates.error, { action: 'API päringu viga', details: '${error}' }),
apiUrlInvalid: formatMessage(templates.error, { action: 'Vigane API_URL', details: '' }),
apiUrlValidated: formatMessage(templates.success, { action: 'API_URL on edukalt valideeritud', details: '${url}' }),
apiUrlWarning: formatMessage(templates.warning, { action: 'Hoiatus', details: 'API_URL ei alga "https://". URL-i kohandatakse.' }),
apiUrlWarningV1: formatMessage(templates.warning, { action: 'Hoiatus', details: 'API_URL ei lõpe "/api/v1". URL-i kohandatakse.' }),
authFailed: 'Autentimine ebaõnnestus.',
authStarted: 'Autentimine alustati.',
availableGroups: formatMessage(templates.success, { action: 'Saadaval olevad grupid', details: '${availableGroups}' }),
chatApiErrorDefault: 'Viga vestluspäringus.',
chatApiError: formatMessage(templates.error, { action: 'Viga Chat API päringus', details: '${error}' }),
chatResponseSuccess: formatMessage(templates.success, { action: 'Vestlusvastus on saadud', details: '${data}' }),
checkingGroups: formatMessage(templates.info, { action: 'Grupide kontrollimine', details: '${groups}' }),
clientConnected: formatMessage(templates.info, { action: 'WebSocket klient ühendatud', details: '' }),
clientDisconnected: formatMessage(templates.info, { action: 'WebSocket klienti ühendus katkestatud', details: '' }),
connection: {
new: formatMessage(templates.info, { action: 'Uus ühendus aktsepteeritud', details: 'kohalt ${ip}:${port}' }),
established: formatMessage(templates.success, { action: 'Ühendus on loodud', details: '' }),
closed: formatMessage(templates.info, { action: 'Ühendus on suletud', details: '${ip}:${port}' }),
dataReceived: formatMessage(templates.info, { action: 'Andmed saadud', details: 'kohalt ${ip}:${port}: ${data}' }),
},
errors: {
processMessage: formatMessage(templates.error, { action: 'Sõnumi töötlemise viga', details: '${error}' }),
invalidMessage: formatMessage(templates.error, { action: 'Sõnumi vorming on vigane', details: '' }),
socketError: formatMessage(templates.error, { action: 'Socketi viga', details: 'kohalt ${ip}:${port}: ${error}' }),
serverError: formatMessage(templates.error, { action: 'Serveri viga', details: '${error}' }),
},
server: {
running: formatMessage(templates.success, { action: 'Server töötab', details: 'pordil ${port}' }),
stopped: formatMessage(templates.info, { action: 'Server on peatatud', details: '' }),
},
continueConversationError: formatMessage(templates.error, { action: 'Viga vestluse jätkamisel', details: '' }),
conversationContinuation: formatMessage(templates.success, { action: 'Vestlus jätkub', details: 'ID: ${chatId}' }),
conversationSuccess: formatMessage(templates.success, { action: 'Vestlus on edukalt jätkustatud', details: '${data}' }),
createGroupSuccess: formatMessage(templates.success, { action: 'Grupp on edukalt loodud', details: '${data}' }),
createSourceLog: 'Allika muutmine ID-ga: ${sourceId}, Pealkirjaga: ${title}',
createSourceSuccess: 'Allikas on edukalt loodud: ${data}',
createUserError: 'Kasutaja loomisel tekkis viga: ${error}',
createUserLog: 'Uue kasutaja loomine: ${payload}',
createUserSuccess: 'Kasutaja on edukalt loodud: ${data}',
deactivatedFunctions: 'Deaktiveeritud funktsioonid:',
deleteGroupInternalError: 'Gruppi kustutamisel tekkis sisemine viga.',
deleteGroupLog: formatMessage(templates.info, { action: 'Gruppi kustutamine', details: 'nimega: ${groupName}' }),
deleteGroupSuccessLog: formatMessage(templates.success, { action: 'Grupp on edukalt kustutatud', details: '${data}' }),
deleteGroupText: 'Grupp "${groupName}" on edukalt kustutatud.',
deleteSourceError: 'Allika kustutamisel tekkis viga: ${error}',
deleteSourceFailedTryAgain: 'Allika kustutamine ebaõnnestus. Palun proovi hiljem uuesti.',
deleteUserError: 'Kasutaja kustutamisel tekkis viga: ${error}',
deleteUserLog: formatMessage(templates.info, { action: 'Kasutaja kustutamine', details: 'nimega: ${UserName}' }),
deleteUserSuccess: 'Kasutaja on edukalt kustutatud: ${data}',
decryptPwdError: 'Parooli ei saanud dekrüpteerida.',
decryptionError: 'Dekrüpteerimisviga.',
dataReceivedMsg: 'Andmed saadud: ${data}',
emailRequiredForDelete: 'Imeyli on vajalik kasutaja kustutamiseks.',
emailRequiredForEdit: 'Kasutaja email on vajalik kirje muutmiseks.',
editSourceError: 'Allika muutmisel tekkis viga: ${error}',
editSourceLog: 'Allika muutmine ID-ga: ${sourceId}, Pealkirjaga: ${title}',
editSourceSuccess: 'Allikas on edukalt muudetud: ${data}',
editUserError: 'Kasutaja muutmisel tekkis viga: ${error}',
editUserSuccess: 'Kasutaja on edukalt muudetud: ${data}',
encryptPwdError: 'Parooli ei saanud krüpteerida.',
encryptionDisabled: 'Keelatud',
encryptionEnabled: 'Lubatud',
encryptionError: 'Krüpteerimisviga.',
errorHandlingRequest: formatMessage(templates.error, { action: 'Päringu töötlemise viga', details: '${error}' }),
errorProcessingMsg: formatMessage(templates.error, { action: 'Sõnumi töötlemise viga:', details: '${error}' }),
fetchChatInfoError: 'Vestluse info hankimisel tekkis viga: ${error}',
fetchGroupsError: formatMessage(templates.error, { action: 'Gruppide hankimise viga', details: '${error}' }),
fetchGroupsErrorBackup: 'Gruppide hankimisel tekkis viga.',
fetchGroupsErrorPrefix: 'Gruppide hankimise viga:',
fetchSourcesError: formatMessage(templates.error, { action: 'Allikate hankimise viga', details: '' }),
fetchingSources: formatMessage(templates.info, { action: 'Allikate hankimine grupile: ${groupName}', details: '' }),
fileReadErrorTitle: 'Faili lugemisel tekkis viga.',
functionDisabled: 'keelatud',
genericServerErrorPrefix: 'Viga:',
gotGetSourceResponse: formatMessage(templates.success, { action: 'Get_source vastus saadud', details: '${data}' }),
gotListGroupsResponse: formatMessage(templates.success, { action: 'List_groups vastus saadud', details: '${response}' }),
gotListSourcesResponse: formatMessage(templates.success, { action: 'List_sources vastus saadud', details: '${data}' }),
groupFetchError: 'Gruppide hankimisel tekkis viga: Palun proovi hiljem uuesti.',
groupNameRequired: 'Gruppi nimi on selle päringu jaoks vajalik.',
groupValidationError: 'Gruppi valideerimisel tekkis viga: ${error}',
groupValidationErrorPrefix: 'Viga: ${error}',
handlingToolRequest: 'Tööriista päringu töötlemine: ${tool}',
headers: 'Päised: ${headers}',
incomingMessage: 'Sisenev sõnum: ${MESSAGE}',
invalidArgumentsError: 'Viga: sisendis pole leitud kehtivaid argumente: ${input}',
invalidGroups: 'Vigased grupid: ${groups}',
invalidGroupsError: 'Vigased grupid: ${invalidGroups}',
invalidGroupsLog: 'Vigased: ${groups}',
invalidMessage: 'Vigane sõnum',
invalidOrEmptyRequest: 'Vigane sõnum või tühi päring.',
keygenDisabled: 'Keelatud',
keygenEnabled: 'Lubatud',
keygenErrorPrefix: 'Viga võtme genereerimise päringuga:',
keygenSuccess: 'Võtme genereerimine on edukalt lõpetatud.',
langNotSupported: 'Keel "${lang}" ei ole toetatud. Tagasiingutamine inglise keelde.',
loginEmailPasswordRequired: 'Sisselogimine ebaõnnestus: e-post ja parool on vajalikud.',
loginError: formatMessage(templates.error, { action: 'Sisselogimise viga', details: '${error}' }),
loginErrorPrefix: 'Viga: ${error}',
loginMissingCredentials: 'Sisselogimine ebaõnnestus: e-post ja parool on vajalikud.',
loginMissingCredentialsAlternative: 'Sisselogimine ebaõnnestus: e-post ja parool on vajalikud.',
loginResponse: 'Sisselogimise vastus',
loginSuccess: formatMessage(templates.success, { action: 'Sisselogimine õnnestus', details: '${data}' }),
loginTokenReceived: 'Token on saadud: ${token}',
LogIpsSuccess: formatMessage(templates.success, { action: 'LOG_IPs', details: 'on lubatud: ${status}' }),
logChangeError: 'Logifaili muudatuste töötlemisel tekkis viga: ${error}',
logReadError: 'Logifaili lugemisel tekkis viga: ${error}',
logViewerRunning: 'Logivaatur töötab aadressil http://localhost:${port}',
logoutError: 'Viga väljalogimisel: ${error}',
logoutFailedTryAgain: 'Väljalogimine ebaõnnestus. Palun proovi uuesti hiljem.',
logoutSuccess: 'Väljalogimine õnnestus: ${data}',
makingGetSourceRequest: 'Get_source päringu loomine: ${args}',
makingListGroupsRequest: 'List_groups päringu loomine',
makingListSourcesRequest: 'List_sources päringu loomine: ${args}',
mcpVersion: 'Versioon:',
mcpPort: 'Port:',
mcpStartTime: 'Algusaeg:',
mcpLicense: 'Litsents:',
method: 'Meetod: ${method}',
missingArgumentsError: 'Puuduvad argumendid: ${args}',
missingChatParams: 'Puuduvad vajalikud parameetrid: chatId ja/või küsimus.',
missingCommandParameter: 'Sõnumis puudub käskparameeter.',
missingConfigError: 'Puudub .json konfiguratsioonimuutuja: ${key}',
missingGroupNameAndDesc: 'Puuduvad vajalikud parameetrid: gruppi nimi ja kirjeldus.',
missingGroupNameParam: 'Puudub vajalik parameeter: gruppi nimi.',
missingGroupParameterDelete: 'Kustutamine: Puudub vajalik parameeter: gruppi nimi.',
missingGroupParameterStore: 'Salvestamine: Puudub vajalik parameeter: gruppi nimi.',
missingNameAndContent: 'Puuduvad vajalikud parameetrid: nimi ja sisu.',
missingNameEmailPwd: 'Puuduvad vajalikud parameetrid: nimi, e-post või parool.',
missingParametersError: formatMessage(templates.error, { action: 'Puuduvad parameetrid', details: '${parameters}' }),
missingParameterError: 'Puudub vajalik parameeter: ${parameter}.',
missingTokenAuth: 'Puudub token',
missingTokenError: 'Token puudub. Palun logi sisse ja proovi uuesti.',
missingTokenGroups: 'Token puudub. Gruppide valideerimine ei ole võimalik.',
missingToolName: 'Puudub tööriista nimi',
missingUriParameter: 'Puudub URI parameeter.',
noChatData: 'Määratud vestluse andmed puuduvad.',
noDescriptionProvided: 'Kirjeldus puudub',
noErrorMessage: 'Vea sõnum puudub.',
noServerResponse: 'Serverilt ei ole vastust saadud.',
passwordEncEnabled: 'Parooli krüpteerimine on lubatud.',
passwordIsRequired: 'Parool on vajalik.',
payload: 'Nositiiler: ${payload}',
portInUse: 'Pordi viga: Port ${PORT} on juba kasutusel.',
portInvalid: 'Pordi viga: PORT peab olema number vahemikus 1 kuni 65535.',
portValidated: 'PORT on edukalt valideeritud: ${port}',
proxyAuthMissing: 'Proxy autentimisandmed puuduvad.',
proxyUseProxy: 'USE_PROXY: ${val}',
publicGroupsConflictWarning: 'Konflikt: usePublic on seatud vääraks, kuna on määratud grupid.',
requestError: 'Päringu viga: ${error}',
requestSent: 'Päring on saadetud',
restrictedGroupsError: 'Viga: Vigane RESTRICTED_GROUPS konfiguratsioon. Peab olema \'true\' või \'false\'. Praegune väärtus: ${value}',
restrictedGroupsSuccess: 'RESTRICTED_GROUPS on lubatud: ${status}',
restrictedGroupsWarning: 'RESTRICTED_GROUPS on lubatud. Saadaval olevad grupid on piiratud.',
responseError: 'Vastusviga: ${error}',
responseSentSuccess: formatMessage(templates.success, { action: 'Staatus', details: 'Edu' }),
serverError: formatMessage(templates.error, { action: 'Serverit ei saanud käivitada', details: '${error}' }),
serverListeningOnPort: 'Server kuulab pordil ${port}',
serverRunning: 'Server töötab pordil ${port}',
serverShutdownLog: 'Server on suletud',
serverStartedLog: 'Server on käivitunud.',
serverStoppedLog: 'Server on peatatud',
sendingChatRequest: 'Chat päringu saatmine API-le',
sourcesRetrieved: formatMessage(templates.success, { action: 'Allikad on hankitud', details: '${data}' }),
startingServerWithConfig: 'Serveri käivitamine järgmise konfiguratsiooniga:',
sslValidationSet: '${symbol} SSL valideerimine on seatud: ${value}',
socketErrorPrefix: 'Viga:',
storeGroupLog: 'Uue grupi salvestamine nimega: ${groupName} ja kirjeldusega: ${description}',
storeGroupSuccess: 'Grupp on edukalt salvestatud: ${data}',
storegroupError: 'Gruppi loomisel tekkis viga: ${error}',
storeGroupText: 'Grupp "${groupName}" on edukalt salvestatud ID-ga: ${id}.',
unknownAddress: 'Tundmatu IP',
unknownCommandError: formatMessage(templates.error, { action: 'Tundmatu käsk', details: '${cmd}' }),
unknownError: formatMessage(templates.error, { action: 'Tundmatu viga', details: '' }),
unknownPort: 'Tundmatu port',
unknownTool: 'Tundmatu tööriist: ${toolName}',
tokenMissing: 'Token puudub.'
},
ja: {
ErrorConnReset: 'クライアントによって接続が予期せず終了されました (ECONNRESET)。',
NoTLSCertFound: 'SSL証明書または鍵が見つかりませんでした。証明書を作成してください。例えば、OpenSSL を使用して自己署名証明書を作成できます:',
deleteChatsSuccess: "すべてのチャット履歴が正常に削除されました。",
deleteChatsError: "チャット履歴の削除中にエラーが発生しました: ${error}。",
missingAuthToken: "認証トークンが見つからないか、無効です。",
deleteChatsUnauthorized: "チャット履歴を削除する権限がありません。",
deleteChatsServerIssue: "リクエストの処理中にサーバーエラーが発生しました。",
deleteChatsNotAllowed: "このユーザーはチャット履歴を削除できません。",
missingChatId: "チャット ID が見つかりません。有効なチャット ID を入力してください。",
chatDeleted: "チャット ID ${chatId} が正常に削除されました。",
deleteChatError: "チャット ID ${chatId} の削除中にエラーが発生しました: ${error}。",
missingAuthToken: "認証トークンが見つからないか、無効です。",
deleteChatUnauthorized: "このチャットを削除する権限がありません。",
deleteChatServerIssue: "リクエストの処理中にサーバーエラーが発生しました。",
deleteChatNotAllowed: "このチャットの削除は許可されていません。",
toolDisabledLog: formatMessage(templates.error, { action: 'サーバー側で機能の呼び出しが無効化されています:', details: '${toolName}' }),
toolDisabledError: formatMessage(templates.error, { action: 'サーバー側で機能の呼び出しが無効化されています:', details: '${toolName}' }),
emailRequiredForReactivate: "ユーザーを再有効化するにはメールアドレスが必要です。",
reactivateUserLog: "ユーザーの再有効化プロセスを開始: ${UserName}。",
reactivateUserSuccess: "ユーザーが正常に再有効化されました: ${data}。",
reactivateUserError: "ユーザーの再有効化中にエラーが発生しました: ${error}。後でもう一度お試しください。",
toolNotDefinedInConfig: formatMessage(templates.error, { action: '無効な関数呼び出し', details: '${warn}' }),
toolDisabledLog: formatMessage(templates.error, { action: '関数呼び出しがサーバー側で無効化されています:', details: '${warn}' }),
toolDisabledError: formatMessage(templates.error, { action: '関数呼び出しがサーバー側で無効化されています:', details: '${warn}' }),
accessRestrictedGroups: formatMessage(templates.info, { action: 'RESTRICTED_GROUPS の値', details: '${val}' }),
allFunctionsEnabled: formatMessage(templates.success, { action: 'すべての機能が有効です', details: '' }),
allGroupsValid: formatMessage(templates.success, { action: 'すべてのグループが有効です', details: '' }),
AllowLoggingSuccess: formatMessage(templates.success, { action: 'ALLOW_LOGGING', details: 'が有効になっています: ${status}' }),
anonymousModeSuccess: formatMessage(templates.success, { action: 'ANONYMOUS_MODE', details: 'が有効になっています: ${status}' }),
apiErrorDetails: formatMessage(templates.error, { action: 'API エラー', details: 'ステータス: ${status}, データ: ${data}' }),
apiRequestError: formatMessage(templates.error, { action: 'API リクエスト エラー', details: '${error}' }),
apiUrlInvalid: formatMessage(templates.error, { action: '無効な API_URL', details: '' }),
apiUrlValidated: formatMessage(templates.success, { action: 'API_URL が正常に検証されました', details: '${url}' }),
apiUrlWarning: formatMessage(templates.warning, { action: '警告', details: 'API_URL が "https://" で始まっていません。URL が調整されています。' }),
apiUrlWarningV1: formatMessage(templates.warning, { action: '警告', details: 'API_URL が "/api/v1" で終わっていません。URL が調整されています。' }),
authFailed: '認証に失敗しました。',
authStarted: '認証が開始されました。',
availableGroups: formatMessage(templates.success, { action: '利用可能なグループ', details: '${availableGroups}' }),
chatApiErrorDefault: 'チャットリクエスト中にエラーが発生しました。',
chatApiError: formatMessage(templates.error, { action: 'チャット API リクエスト エラー', details: '${error}' }),
chatResponseSuccess: formatMessage(templates.success, { action: 'チャットの応答が受信されました', details: '${data}' }),
checkingGroups: formatMessage(templates.info, { action: 'グループを確認中', details: '${groups}' }),
clientConnected: formatMessage(templates.info, { action: 'WebSocket クライアントが接続しました', details: '' }),
clientDisconnected: formatMessage(templates.info, { action: 'WebSocket クライアントが切断されました', details: '' }),
connection: {
new: formatMessage(templates.info, { action: '新しい接続が受け入れられました', details: 'from ${ip}:${port}' }),
established: formatMessage(templates.success, { action: '接続が確立されました', details: '' }),
closed: formatMessage(templates.info, { action: '接続が閉じられました', details: '${ip}:${port}' }),
dataReceived: formatMessage(templates.info, { action: 'データを受信しました', details: 'from ${ip}:${port}: ${data}' }),
},
errors: {
processMessage: formatMessage(templates.error, { action: 'メッセージの処理中にエラーが発生しました', details: '${error}' }),
invalidMessage: formatMessage(templates.error, { action: '無効なメッセージ形式', details: '' }),
socketError: formatMessage(templates.error, { action: 'ソケットエラー', details: 'at ${ip}:${port}: ${error}' }),
serverError: formatMessage(templates.error, { action: 'サーバーエラー', details: '${error}' }),
},
server: {
running: formatMessage(templates.success, { action: 'サーバーが実行中です', details: 'on port ${port}' }),
stopped: formatMessage(templates.info, { action: 'サーバーが停止されました', details: '' }),
},
continueConversationError: formatMessage(templates.error, { action: '会話の継続中にエラーが発生しました', details: '' }),
conversationContinuation: formatMessage(templates.success, { action: '会話が継続されています', details: 'ID: ${chatId}' }),
conversationSuccess: formatMessage(templates.success, { action: '会話が正常に継続されました', details: '${data}' }),
createGroupSuccess: formatMessage(templates.success, { action: 'グループが正常に作成されました', details: '${data}' }),
createSourceLog: 'Editing source with ID: ${sourceId}, Title: ${title}',
createSourceSuccess: 'ソースが正常に作成されました: ${data}',
createUserError: 'ユーザーの作成中にエラーが発生しました: ${error}',
createUserLog: '新しいユーザーを作成しています: ${payload}',
createUserSuccess: 'ユーザーが正常に作成されました: ${data}',
deactivatedFunctions: '無効化された機能:',
deleteGroupInternalError: 'グループの削除中に内部エラーが発生しました。',
deleteGroupLog: formatMessage(templates.info, { action: 'グループを削除中', details: 'with name: ${groupName}' }),
deleteGroupSuccessLog: formatMessage(templates.success, { action: 'グループが正常に削除されました', details: '${data}' }),
deleteGroupText: 'グループ "${groupName}" が正常に削除されました。',
deleteSourceError: 'ソースの削除中にエラーが発生しました: ${error}',
deleteSourceFailedTryAgain: 'ソースの削除に失敗しました。後でもう一度やり直してください。',
deleteUserError: 'ユーザーの削除中にエラーが発生しました: ${error}',
deleteUserLog: formatMessage(templates.info, { action: 'ユーザーを削除中', details: 'with name: ${UserName}' }),
deleteUserSuccess: 'ユーザーが正常に削除されました: ${data}',
decryptPwdError: 'パスワードを復号できませんでした。',
decryptionError: '復号エラー。',
dataReceivedMsg: 'データを受信しました: ${data}',
emailRequiredForDelete: 'ユーザーを削除するにはメールが必要です。',
emailRequiredForEdit: 'レコードを編集するにはユーザーのメールが必要です。',
editSourceError: 'ソースの編集中にエラーが発生しました: ${error}',
editSourceLog: 'Editing source with ID: ${sourceId}, Title: ${title}',
editSourceSuccess: 'ソースが正常に編集されました: ${data}',
editUserError: 'ユーザーの編集中にエラーが発生しました: ${error}',
editUserSuccess: 'ユーザーが正常に編集されました: ${data}',
encryptPwdError: 'パスワードを暗号化できませんでした。',
encryptionDisabled: '無効',
encryptionEnabled: '有効',
encryptionError: '暗号化エラー。',
errorHandlingRequest: formatMessage(templates.error, { action: 'リクエストの処理中にエラーが発生しました', details: '${error}' }),
errorProcessingMsg: formatMessage(templates.error, { action: 'メッセージの処理中にエラーが発生しました:', details: '${error}' }),
fetchChatInfoError: 'チャット情報の取得中にエラーが発生しました: ${error}',
fetchGroupsError: formatMessage(templates.error, { action: 'グループの取得中にエラーが発生しました', details: '${error}' }),
fetchGroupsErrorBackup: 'グループの取得中にエラーが発生しました。',
fetchGroupsErrorPrefix: 'グループの取得中にエラーが発生しました:',
fetchSourcesError: formatMessage(templates.error, { action: 'ソースの取得中にエラーが発生しました', details: '' }),
fetchingSources: formatMessage(templates.info, { action: 'グループ: ${groupName} のソースを取得中', details: '' }),
fileReadErrorTitle: 'ファイルの読み取り中にエラーが発生しました。',
functionDisabled: '無効',
genericServerErrorPrefix: 'エラー:',
gotGetSourceResponse: formatMessage(templates.success, { action: 'get_source の応答を受信しました', details: '${data}' }),
gotListGroupsResponse: formatMessage(templates.success, { action: 'list_groups の応答を受信しました', details: '${response}' }),
gotListSourcesResponse: formatMessage(templates.success, { action: 'list_sources の応答を受信しました', details: '${data}' }),
groupFetchError: 'グループの取得中にエラーが発生しました: 後でもう一度やり直してください。',
groupNameRequired: 'このリクエストにはグループ名が必要です。',
groupValidationError: 'グループの検証中にエラーが発生しました: ${error}',
groupValidationErrorPrefix: 'エラー: ${error}',
handlingToolRequest: 'ツールリクエストを処理中: ${tool}',
headers: 'ヘッダー: ${headers}',
incomingMessage: '受信メッセージ: ${MESSAGE}',
invalidArgumentsError: 'エラー: 入力に有効な引数が見つかりませんでした: ${input}',
invalidGroups: '無効なグループ: ${groups}',
invalidGroupsError: '無効なグループ: ${invalidGroups}',
invalidGroupsLog: '無効: ${groups}',
invalidMessage: '無効なメッセージ',
invalidOrEmptyRequest: '無効なメッセージまたは空のリクエストです。',
keygenDisabled: '無効',
keygenEnabled: '有効',
keygenErrorPrefix: 'keygen リクエストのエラー:',
keygenSuccess: 'keygen が正常に完了しました。',
langNotSupported: '言語 "${lang}" はサポートされていません。英語に戻します。',
loginEmailPasswordRequired: 'ログインに失敗しました: メールとパスワードが必要です。',
loginError: formatMessage(templates.error, { action: 'ログインエラー', details: '${error}' }),
loginErrorPrefix: 'エラー: ${error}',
loginMissingCredentials: 'ログインに失敗しました: メールとパスワードが必要です。',
loginMissingCredentialsAlternative: 'ログインに失敗しました: メールとパスワードが必要です。',
loginResponse: 'ログインの応答',
loginSuccess: formatMessage(templates.success, { action: 'ログインに成功しました', details: '${data}' }),
loginTokenReceived: 'トークンを受信しました: ${token}',
LogIpsSuccess: formatMessage(templates.success, { action: 'LOG_IPs', details: 'が有効になっています: ${status}' }),
logChangeError: 'ログファイルの変更を処理中にエラーが発生しました: ${error}',
logReadError: 'ログファイルの読み取り中にエラーが発生しました: ${error}',
logViewerRunning: 'ログビューアが http://localhost:${port} で実行中です',
logoutError: 'ログアウト中にエラーが発生しました: ${error}',
logoutFailedTryAgain: 'ログアウトに失敗しました。後でもう一度やり直してください。',
logoutSuccess: 'ログアウトに成功しました: ${data}',
makingGetSourceRequest: 'get_source リクエストを作成中: ${args}',
makingListGroupsRequest: 'list_groups リクエストを作成中',
makingListSourcesRequest: 'list_sources リクエストを作成中: ${args}',
mcpVersion: 'バージョン:',
mcpPort: 'ポート:',
mcpStartTime: '開始時間:',
mcpLicense: 'ライセンス:',
method: 'メソッド: ${method}',
missingArgumentsError: 'エラー: 入力に必要な引数が不足しています: ${args}',
missingChatParams: '必要なパラメータが不足しています: chatId および/または question.',
missingCommandParameter: 'メッセージにコマンドパラメータが不足しています。',
missingConfigError: '設定変数 .json が不足しています: ${key}',
missingGroupNameAndDesc: '必要なパラメータが不足しています: groupName および description.',
missingGroupNameParam: '必要なパラメータが不足しています: groupName.',
missingGroupParameterDelete: '削除: 必要なパラメータが不足しています: groupName.',
missingGroupParameterStore: '保存: 必要なパラメータが不足しています: groupName.',
missingNameAndContent: '必要なパラメータが不足しています: name および content.',
missingNameEmailPwd: '必要なパラメータが不足しています: name, email, または password.',
missingParametersError: formatMessage(templates.error, { action: 'パラメータが不足しています', details: '${parameters}' }),
missingParameterError: '必要なパラメータが不足しています: ${parameter}.',
missingTokenAuth: 'トークンが不足しています',
missingTokenError: 'トークンが不足しています。ログインして再試行してください。',
missingTokenGroups: 'トークンが不足しています。グループを検証できません。',
missingToolName: 'ツール名が不足しています',
missingUriParameter: 'URI パラメータが不足しています。',
noChatData: '指定されたチャットにデータが見つかりません。',
noDescriptionProvided: '説明が提供されていません',
noErrorMessage: 'エラーメッセージがありません。',
noServerResponse: 'サーバーからの応答がありません。',
passwordEncEnabled: 'パスワードの暗号化が有効です。',
passwordIsRequired: 'パスワードが必要です。',
payload: 'ペイロード: ${payload}',
portInUse: 'ポートエラー: ポート ${PORT} は既に使用中です。',
portInvalid: 'ポートエラー: PORT は 1 から 65535 までの数字である必要があります。',
portValidated: 'PORT が正常に検証されました: ${port}',
proxyAuthMissing: 'プロキシ認証データが不足しています。',
proxyUseProxy: 'USE_PROXY: ${val}',
publicGroupsConflictWarning: '競合: グループが指定されているため usePublic が false に設定されました。',
requestError: 'リクエストエラー: ${error}',
requestSent: 'リクエストが送信されました',
restrictedGroupsError: 'エラー: 無効な RESTRICTED_GROUPS 設定です。\'true\' または \'false\' である必要があります。現在の値: ${value}',
restrictedGroupsSuccess: 'RESTRICTED_GROUPS が有効です: ${status}',
restrictedGroupsWarning: 'RESTRICTED_GROUPS が有効です。利用可能なグループが制限されています。',
responseError: '応答エラー: ${error}',
responseReceived: formatMessage(templates.success, { action: '応答が受信されました', details: '${response}' }),
responseSentSuccess: formatMessage(templates.success, { action: 'ステータス', details: '成功' }),
serverError: formatMessage(templates.error, { action: 'サーバーを起動できませんでした', details: '${error}' }),
serverListeningOnPort: 'サーバーがポート ${port} でリスニングしています',
serverRunning: 'サーバーがポート ${port} で実行中です',
serverShutdownLog: 'サーバーがシャットダウンしました',
serverStartedLog: 'サーバーが開始されました。',
serverStoppedLog: 'サーバーが停止されました',
sendingChatRequest: 'チャットリクエストを API に送信しています',
sourcesRetrieved: formatMessage(templates.success, { action: 'ソースが取得されました', details: '${data}' }),
startingServerWithConfig: '次の設定でサーバーを起動しています:',
sslValidationSet: '${symbol} SSL 検証が設定されています: ${value}',
socketErrorPrefix: 'エラー:',
storeGroupLog: '名前: ${groupName} および説明: ${description} の新しいグループを保存しています',
storeGroupSuccess: 'グループが正常に保存されました: ${data}',
storegroupError: 'グループの作成中にエラーが発生しました: ${error}',
storeGroupText: 'グループ "${groupName}" が ID: ${id} で正常に保存されました。',
unknownAddress: '不明なIP',
unknownCommandError: formatMessage(templates.error, { action: '不明なコマンド', details: '${cmd}' }),
unknownError: formatMessage(templates.error, { action: '不明なエラー', details: '' }),
unknownPort: '不明なポート',
unknownTool: '不明なツール: ${toolName}',
tokenMissing: 'トークンが不足しています。'
}
};
```