agentscope-runtime 0.1.5b2__py3-none-any.whl → 0.2.0b2__py3-none-any.whl

agentscope_runtime/engine/deployers/utils/service_utils/standalone_main.py.j2

@@ -0,0 +1,211 @@
+import os
+import sys
+
+# Add current directory and handler directories to Python path for local module imports
+current_dir = os.path.dirname(os.path.abspath(__file__))
+if current_dir not in sys.path:
+    sys.path.insert(0, current_dir)
+
+{% if handler_dirs %}
+# Add copied handler directories to sys.path
+{% for handler_dir in handler_dirs %}
+handler_dir_path = os.path.join(current_dir, "{{handler_dir}}")
+if os.path.isdir(handler_dir_path) and handler_dir_path not in sys.path:
+    sys.path.insert(0, handler_dir_path)
+{% endfor %}
+{% endif %}
+
+import uvicorn
+from agentscope_runtime.engine.deployers.utils.deployment_modes import DeploymentMode
+from agentscope_runtime.engine.deployers.utils.service_utils import (
+    FastAPIAppFactory,
+    ServicesConfig,
+    ServiceConfig,
+)
+from agentscope_runtime.engine.schemas.agent_schemas import AgentRequest
+from typing import Callable, Optional, Dict, List, Any, Union
+
+from agent_file import {{agent_name}} as agent
+{% if protocol_adapters %}{{protocol_adapters}}{% endif %}
+
+{% if custom_endpoints %}
+# Custom endpoint imports
+{% for endpoint in custom_endpoints %}
+{% if endpoint.handler_module and endpoint.function_name %}
+from {{endpoint.handler_module}} import {{endpoint.function_name}}
+{% elif endpoint.module and endpoint.function_name %}
+from agent_file import {{endpoint.function_name}}
+{% endif %}
+{% endfor %}
+{% endif %}
+
+
+
+def load_services_config() -> ServicesConfig:
+    """Load services configuration from environment variables or config file."""
+    config_file = os.getenv('AGENTSCOPE_SERVICES_CONFIG')
+
+    if config_file and os.path.exists(config_file):
+        # Load from JSON config file
+        import json
+        with open(config_file, 'r', encoding='utf-8') as f:
+            config_data = json.load(f)
+            return ServicesConfig.model_validate(config_data)
+    else:
+        # Load from environment variables
+        memory_provider = os.getenv('MEMORY_PROVIDER', 'in_memory')
+        session_provider = os.getenv('SESSION_HISTORY_PROVIDER', 'in_memory')
+
+        memory_config = {}
+        session_config = {}
+
+        # Add Redis configuration if using Redis
+        if memory_provider == 'redis':
+            memory_config = {
+                'host': os.getenv('REDIS_HOST', 'localhost'),
+                'port': int(os.getenv('REDIS_PORT', 6379)),
+                'db': int(os.getenv('REDIS_MEMORY_DB', 0))
+            }
+
+        if session_provider == 'redis':
+            session_config = {
+                'host': os.getenv('REDIS_HOST', 'localhost'),
+                'port': int(os.getenv('REDIS_PORT', 6379)),
+                'db': int(os.getenv('REDIS_SESSION_DB', 1))
+            }
+
+        return ServicesConfig(
+            memory=ServiceConfig(provider=memory_provider, config=memory_config),
+            session_history=ServiceConfig(provider=session_provider, config=session_config)
+        )
+
+
+def load_celery_config():
+    """Load Celery configuration from environment variables or infer from existing config."""
+    celery_config = {
+        'broker_url': None,
+        'backend_url': None,
+        'enable_embedded_worker': False,
+        'redis_available': False
+    }
+
+    {% if celery_config %}
+    # Apply inline Celery configuration
+    {{celery_config}}
+    {% endif %}
+
+    if not celery_config.get('broker_url') or not celery_config.get('backend_url'):
+        redis_host = os.getenv('REDIS_HOST', 'localhost')
+        redis_port = os.getenv('REDIS_PORT', '6379')
+
+        # Use different databases for different purposes
+        broker_db = os.getenv('CELERY_BROKER_DB', '2')  # Default DB 2 for Celery broker
+        backend_db = os.getenv('CELERY_BACKEND_DB', '3')  # Default DB 3 for Celery backend
+
+        # Auto-generate URLs if Redis is available
+        if not celery_config.get('broker_url'):
+            celery_config['broker_url'] = f"redis://{redis_host}:{redis_port}/{broker_db}"
+        if not celery_config.get('backend_url'):
+            celery_config['backend_url'] = f"redis://{redis_host}:{redis_port}/{backend_db}"
+
+    return celery_config
+
+
+def _check_redis_availability(redis_url: str) -> bool:
+    """Check if Redis is available at the given URL."""
+    try:
+        import redis
+        from urllib.parse import urlparse
+
+        parsed = urlparse(redis_url)
+        host = parsed.hostname or 'localhost'
+        port = parsed.port or 6379
+
+        r = redis.Redis(host=host, port=port, socket_connect_timeout=2)
+        r.ping()
+        return True
+    except Exception:
+        return False
+
+
+{% if custom_endpoints %}
+def setup_custom_endpoints():
+    """Setup custom endpoints configuration."""
+    custom_endpoints = [
+        {% for endpoint in custom_endpoints %}
+        {
+            "path": "{{endpoint.path}}",
+            "handler": {% if endpoint.handler_module or endpoint.module %}{{endpoint.function_name}}{% else %}{{endpoint.inline_code|default('lambda request: {"error": "Handler not available"}')}}{% endif %},
+            "methods": {{endpoint.methods}}
+        },
+        {% endfor %}
+    ]
+    return custom_endpoints
+{% endif %}
+
+
+async def setup_runner_with_agent(app):
+    """Setup runner with the agent instance."""
+    if hasattr(app.state, 'runner') and app.state.runner:
+        # Set the agent on the runner
+        app.state.runner._agent = agent
+
+
+async def before_start(app, **kwargs):
+    """Application startup callback."""
+    await setup_runner_with_agent(app)
+
+
+async def after_finish(app, **kwargs):
+    """Application shutdown callback."""
+    # Runner cleanup is handled by the factory
+    pass
+
+
+# Load services configuration
+services_config = load_services_config()
+
+# Load Celery configuration
+celery_config = load_celery_config()
+
+# Determine deployment mode from environment or use default
+deployment_mode_str = os.getenv('DEPLOYMENT_MODE', '{{deployment_mode|default("standalone")}}')
+if deployment_mode_str == 'detached_process':
+    deployment_mode = DeploymentMode.DETACHED_PROCESS
+elif deployment_mode_str == 'standalone':
+    deployment_mode = DeploymentMode.STANDALONE
+else:
+    deployment_mode = DeploymentMode.STANDALONE  # fallback
+
+# Create FastAPI application using the factory
+app = FastAPIAppFactory.create_app(
+    endpoint_path="{{endpoint_path}}",
+    mode=deployment_mode,
+    services_config=services_config,
+    before_start=before_start,
+    after_finish=after_finish,
+    stream=True,
+    broker_url=celery_config['broker_url'],
+    backend_url=celery_config['backend_url'],
+    enable_embedded_worker=celery_config['enable_embedded_worker']{% if protocol_adapters %},
+    protocol_adapters=protocol_adapters{% endif %}{% if custom_endpoints %},
+    custom_endpoints=setup_custom_endpoints(){% endif %}
+)
+
+
+if __name__ == "__main__":
+    import argparse
+
+    parser = argparse.ArgumentParser(description="AgentScope Runtime Standalone Service")
+    parser.add_argument("--host", default="0.0.0.0", help="Host to bind to")
+    parser.add_argument("--port", type=int, default=8080, help="Port to bind to")
+    parser.add_argument("--workers", type=int, default=1, help="Number of worker processes")
+
+    args = parser.parse_args()
+
+    uvicorn.run(
+        app,
+        host=args.host,
+        port=args.port,
+        workers=args.workers if args.workers > 1 else None
+    )

agentscope_runtime/engine/deployers/utils/wheel_packager.py

@@ -26,7 +26,7 @@ from typing import List, Tuple
 
 try:
     import tomllib  # Python 3.11+
-except Exception:  # pragma: no cover - fallback on older Pythons
+except ImportError:  # pragma: no cover - fallback on older Pythons
     tomllib = None  # type: ignore
 
 

agentscope_runtime/engine/helpers/helper.py

@@ -1,4 +1,5 @@
 # -*- coding: utf-8 -*-
+import logging
 
 from agentscope_runtime.engine import Runner
 from agentscope_runtime.engine.schemas.agent_schemas import (
@@ -13,22 +14,28 @@ from agentscope_runtime.engine.services.environment_manager import (
     create_environment_manager,
 )
 
+logger = logging.getLogger(__name__)
+
 
 async def simple_call_agent(query, runner, user_id=None, session_id=None):
-    request = AgentRequest(
-        input=[
-            {
-                "role": "user",
-                "content": [
-                    {
-                        "type": "text",
-                        "text": query,
-                    },
-                ],
-            },
-        ],
-        session_id=session_id,
-    )
+    if isinstance(query, str):
+        request = AgentRequest(
+            input=[
+                {
+                    "role": "user",
+                    "content": [
+                        {
+                            "type": "text",
+                            "text": query,
+                        },
+                    ],
+                },
+            ],
+            session_id=session_id,
+        )
+    else:
+        request = query
+
     all_result = ""
     async for message in runner.stream_query(
         user_id=user_id,
@@ -58,6 +65,23 @@ async def simple_call_agent_direct(agent, query):
 
 
 async def simple_call_agent_tool(agent, query):
+    if isinstance(query, str):
+        request = AgentRequest(
+            input=[
+                {
+                    "role": "user",
+                    "content": [
+                        {
+                            "type": "text",
+                            "text": query,
+                        },
+                    ],
+                },
+            ],
+        )
+    else:
+        request = query
+
     all_result = ""
     async with create_context_manager() as context_manager:
         async with create_environment_manager() as environment_manager:
@@ -67,20 +91,6 @@ async def simple_call_agent_tool(agent, query):
                 environment_manager=environment_manager,
             )
 
-            request = AgentRequest(
-                input=[
-                    {
-                        "role": "user",
-                        "content": [
-                            {
-                                "type": "text",
-                                "text": query,
-                            },
-                        ],
-                    },
-                ],
-            )
-
             async for message in runner.stream_query(
                 request=request,
             ):
@@ -94,12 +104,7 @@ async def simple_call_agent_tool(agent, query):
 
 
 async def simple_call_agent_tool_auto_lifecycle(agent, query):
-    all_result = ""
-    async with Runner(
-        agent=agent,
-        context_manager=create_context_manager(),
-        environment_manager=create_environment_manager(),
-    ) as runner:
+    if isinstance(query, str):
         request = AgentRequest(
             input=[
                 {
@@ -113,7 +118,15 @@ async def simple_call_agent_tool_auto_lifecycle(agent, query):
                 },
             ],
         )
+    else:
+        request = query
 
+    all_result = ""
+    async with Runner(
+        agent=agent,
+        context_manager=create_context_manager(),
+        environment_manager=create_environment_manager(),
+    ) as runner:
         async for message in runner.stream_query(
             request=request,
         ):
@@ -127,13 +140,7 @@ async def simple_call_agent_tool_auto_lifecycle(agent, query):
 
 
 async def simple_call_agent_tool_wo_env(agent, query):
-    all_result = ""
-    async with create_context_manager() as context_manager:
-        runner = Runner(
-            agent=agent,
-            context_manager=context_manager,
-        )
-
+    if isinstance(query, str):
         request = AgentRequest(
             input=[
                 {
@@ -147,6 +154,15 @@ async def simple_call_agent_tool_wo_env(agent, query):
                 },
             ],
         )
+    else:
+        request = query
+
+    all_result = ""
+    async with create_context_manager() as context_manager:
+        runner = Runner(
+            agent=agent,
+            context_manager=context_manager,
+        )
 
         async for message in runner.stream_query(
             request=request,
@@ -157,4 +173,7 @@ async def simple_call_agent_tool_wo_env(agent, query):
                 and RunStatus.Completed == message.status
             ):
                 all_result = message.content[0].text
+
+            logger.debug(message.model_dump())
+
     return all_result

agentscope_runtime/engine/runner.py

@@ -3,8 +3,6 @@ import uuid
 from contextlib import AsyncExitStack
 from typing import Optional, List, AsyncGenerator, Any, Union, Dict
 
-from openai.types.chat import ChatCompletion
-
 from agentscope_runtime.engine.deployers.utils.service_utils import (
     ServicesConfig,
 )
@@ -19,12 +17,17 @@ from .schemas.agent_schemas import (
     AgentRequest,
     RunStatus,
     AgentResponse,
+    SequenceNumberGenerator,
 )
 from .schemas.context import Context
 from .services.context_manager import ContextManager
 from .services.environment_manager import EnvironmentManager
 from .tracing import TraceType
 from .tracing.wrapper import trace
+from .tracing.message_util import (
+    merge_agent_response,
+    get_agent_response_finish_reason,
+)
 
 
 class Runner:
@@ -43,7 +46,9 @@ class Runner:
         """
         self._agent = agent
         self._environment_manager = environment_manager
-        self._context_manager = context_manager
+        self._context_manager = (
+            context_manager or ContextManager()
+        )  # Add default context manager
         self._deploy_managers = {}
         self._exit_stack = AsyncExitStack()
 
@@ -127,7 +132,12 @@ class Runner:
         self._deploy_managers[deploy_manager.deploy_id] = deploy_result
         return deploy_result
 
-    @trace(TraceType.AGENT_STEP)
+    @trace(
+        TraceType.AGENT_STEP,
+        trace_name="agent_step",
+        merge_output_func=merge_agent_response,
+        get_finish_reason_func=get_agent_response_finish_reason,
+    )
     async def stream_query(  # pylint:disable=unused-argument
         self,
         request: Union[AgentRequest, dict],
@@ -141,11 +151,15 @@ class Runner:
         if isinstance(request, dict):
             request = AgentRequest(**request)
 
+        seq_gen = SequenceNumberGenerator()
+
+        # Initial response
         response = AgentResponse()
-        yield response
+        yield seq_gen.yield_with_sequence(response)
 
+        # Set to in-progress status
         response.in_progress()
-        yield response
+        yield seq_gen.yield_with_sequence(response)
 
         user_id = user_id or str(uuid.uuid4())
         session_id = request.session_id or str(uuid.uuid4())
@@ -193,35 +207,32 @@ class Runner:
             request_input=request_input,
         )
 
-        sequence_number = 0
         async for event in context.agent.run_async(context):
             if (
                 event.status == RunStatus.Completed
                 and event.object == "message"
             ):
                 response.add_new_message(event)
-            event.sequence_number = sequence_number
-            yield event
-            sequence_number += 1
+            yield seq_gen.yield_with_sequence(event)
 
         await context.context_manager.append(
             session=context.session,
             event_output=response.output,
         )
-        response.sequence_number = sequence_number
-        yield response.completed()
-
-    @trace(TraceType.AGENT_STEP)
-    async def query(  # pylint:disable=unused-argument
-        self,
-        message: List[dict],
-        session_id: Optional[str] = None,
-        **kwargs: Any,
-    ) -> ChatCompletion:
-        """
-        Streams the agent.
-        """
-        return self._agent.query(message, session_id)
+        yield seq_gen.yield_with_sequence(response.completed())
+
+    #  TODO: will be added before 2025/11/30
+    # @trace(TraceType.AGENT_STEP)
+    # async def query(  # pylint:disable=unused-argument
+    #     self,
+    #     message: List[dict],
+    #     session_id: Optional[str] = None,
+    #     **kwargs: Any,
+    # ) -> ChatCompletion:
+    #     """
+    #     Streams the agent.
+    #     """
+    #     return self._agent.query(message, session_id)
 
     # TODO: should be sync method?
     async def stop(

agentscope_runtime/engine/schemas/agent_schemas.py

@@ -752,6 +752,48 @@ class AgentResponse(BaseResponse):
     """conversation id for dialog"""
 
 
+class SequenceNumberGenerator:
+    """
+    A simple sequence number generator for streaming events.
+
+    This class encapsulates the logic for generating sequential numbers,
+    making the code more maintainable and less error-prone.
+    """
+
+    def __init__(self, start: int = 0):
+        """
+        Initialize the generator with a starting number.
+
+        Args:
+            start: The starting sequence number (default: 0)
+        """
+        self._current = start
+
+    def next(self) -> int:
+        """
+        Get the next sequence number and increment the counter.
+
+        Returns:
+            The current sequence number before incrementing
+        """
+        current = self._current
+        self._current += 1
+        return current
+
+    def yield_with_sequence(self, event: Event) -> Event:
+        """
+        Set the sequence number on an event and increment the counter.
+
+        Args:
+            event: The event to set the sequence number on
+
+        Returns:
+            The same event with sequence number set
+        """
+        event.sequence_number = self.next()
+        return event
+
+
 def convert_to_openai_tool_call(function: FunctionCall):
     return {
         "id": function.get("call_id", None),

agentscope_runtime/engine/schemas/modelstudio_llm.py

@@ -32,7 +32,7 @@ class IntentionOptions(BaseModel):
     """A list of blocked intentions that should not be processed."""
 
     search_model: str = "search_v6"
-    """The searches model version to use for intentions recognition."""
+    """The search model version to use for intentions recognition."""
 
     intensity: Optional[int] = None
     """The intensity level for intentions matching and processing."""
@@ -44,11 +44,11 @@ class IntentionOptions(BaseModel):
 class SearchOptions(BaseModel):
     """
     Search Options on Modelstudio platform for knowledge retrieval and web
-    searches.
+    search.
     """
 
     enable_source: bool = False
-    """Whether to include source information in searches results."""
+    """Whether to include source information in search results."""
 
     enable_citation: bool = False
     """Whether to include citation information for retrieved content."""
@@ -72,26 +72,26 @@ class SearchOptions(BaseModel):
         "turbo",
         "max",
     ] = "turbo"
-    """The searches strategy to use ('standard', 'pro_ultra',
+    """The search strategy to use ('standard', 'pro_ultra',
     'pro', 'lite','pro_max', 'image','turbo','max'). """
 
     forced_search: bool = False
-    """Whether to force searches even when cached results are available."""
+    """Whether to force search even when cached results are available."""
 
     prepend_search_result: bool = False
-    """Whether to prepend searches results to the response."""
+    """Whether to prepend search results to the response."""
 
     enable_search_extension: bool = False
-    """Whether to enable extended searches capabilities."""
+    """Whether to enable extended search capabilities."""
 
     item_cnt: int = 20000
-    """The maximum number of items to retrieve in searches results."""
+    """The maximum number of items to retrieve in search results."""
 
     top_n: int = 0
     """The number of top results to return (0 means return all)."""
 
     intention_options: Union[IntentionOptions, None] = IntentionOptions()
-    """Options for intentions recognition and processing during searches."""
+    """Options for intentions recognition and processing during search."""
 
 
 # maximum chunk size from knowledge base [1, 20]
@@ -148,7 +148,7 @@ class RagOptions(BaseModel):
         default_factory=list,
         alias="file_id_list",
     )
-    """List of specific file IDs to searches within."""
+    """List of specific file IDs to search within."""
 
     prompt_strategy: Optional[str] = Field(
         default="topK",
@@ -173,7 +173,7 @@ class RagOptions(BaseModel):
     """Options for handling cases when RAG retrieval fails."""
 
     enable_web_search: bool = False
-    """Whether to enable web searches as part of the RAG pipeline."""
+    """Whether to enable web search as part of the RAG pipeline."""
 
     session_file_ids: Optional[List[str]] = Field(default_factory=list)
     """List of file IDs that are specific to the current session."""
@@ -214,7 +214,7 @@ class RagOptions(BaseModel):
     """The prompt to use for content rejection filtering."""
 
     enable_agg_search: Optional[bool] = None
-    """Whether to enable aggregation searches."""
+    """Whether to enable aggregation search."""
 
     enable_hybrid_gen: Optional[bool] = None
     """Whether to enable hybrid generations."""
@@ -269,10 +269,10 @@ class ModelstudioParameters(Parameters):
 
     # Search
     enable_search: bool = False
-    """Whether to enable searches capabilities for knowledge retrieval."""
+    """Whether to enable search capabilities for knowledge retrieval."""
 
     search_options: Optional[SearchOptions] = SearchOptions()
-    """Configuration options for searches functionality."""
+    """Configuration options for search functionality."""
 
     # RAG
     enable_rag: bool = False  # RAGs of modelstudio assistant service