agentscope-runtime 0.1.6__py3-none-any.whl → 0.2.0__py3-none-any.whl

agentscope_runtime/engine/runner.py

@@ -1,27 +1,33 @@
 # -*- coding: utf-8 -*-
 import uuid
-from typing import Optional, List, AsyncGenerator, Any
 from contextlib import AsyncExitStack
+from typing import Optional, List, AsyncGenerator, Any, Union, Dict
 
-from openai.types.chat import ChatCompletion
-
-from .deployers.adapter.protocol_adapter import ProtocolAdapter
+from agentscope_runtime.engine.deployers.utils.service_utils import (
+    ServicesConfig,
+)
 from .agents import Agent
-from .schemas.context import Context
 from .deployers import (
     DeployManager,
     LocalDeployManager,
 )
+from .deployers.adapter.protocol_adapter import ProtocolAdapter
 from .schemas.agent_schemas import (
     Event,
     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:
@@ -40,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()
 
@@ -77,37 +85,62 @@ class Runner:
         endpoint_path: str = "/process",
         stream: bool = True,
         protocol_adapters: Optional[list[ProtocolAdapter]] = None,
+        requirements: Optional[Union[str, List[str]]] = None,
+        extra_packages: Optional[List[str]] = None,
+        base_image: str = "python:3.9-slim",
+        environment: Optional[Dict[str, str]] = None,
+        runtime_config: Optional[Dict] = None,
+        services_config: Optional[Union[ServicesConfig, dict]] = None,
+        **kwargs,
     ):
         """
         Deploys the agent as a service.
 
         Args:
-            protocol_adapters: protocol adapters
             deploy_manager: Deployment manager to handle service deployment
             endpoint_path: API endpoint path for the processing function
             stream: If start a streaming service
+            protocol_adapters: protocol adapters
+            requirements: PyPI dependencies
+            extra_packages: User code directory/file path
+            base_image: Docker base image (for containerized deployment)
+            environment: Environment variables dict
+            runtime_config: Runtime configuration dict
+            services_config: Services configuration dict
+            **kwargs: Additional arguments passed to deployment manager
         Returns:
             URL of the deployed service
 
         Raises:
             RuntimeError: If deployment fails
         """
-        if stream:
-            deploy_func = self.stream_query
-        else:
-            deploy_func = self.query
         deploy_result = await deploy_manager.deploy(
-            deploy_func,
+            runner=self,
             endpoint_path=endpoint_path,
+            stream=stream,
             protocol_adapters=protocol_adapters,
+            requirements=requirements,
+            extra_packages=extra_packages,
+            base_image=base_image,
+            environment=environment,
+            runtime_config=runtime_config,
+            services_config=services_config,
+            **kwargs,
         )
+
+        # TODO: add redis or other persistant method
         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: AgentRequest,
+        request: Union[AgentRequest, dict],
         user_id: Optional[str] = None,
         tools: Optional[List] = None,
         **kwargs: Any,
@@ -115,13 +148,25 @@ class Runner:
         """
         Streams the agent.
         """
+        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)
+
+        if user_id is None:
+            if getattr(request, "user_id", None):
+                user_id = request.user_id
+            else:
+                user_id = ""  # Default user id
 
-        user_id = user_id or str(uuid.uuid4())
         session_id = request.session_id or str(uuid.uuid4())
         request_input = request.input
         session = await self._context_manager.compose_session(
@@ -167,36 +212,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()
+        yield seq_gen.yield_with_sequence(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.
-        """
-        # TODO: fix this @zhicheng
-        return self._agent.query(message, session_id)
+    #  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

@@ -27,6 +27,7 @@ class MessageType:
     MCP_APPROVAL_REQUEST = "mcp_approval_request"
     MCP_TOOL_CALL = "mcp_call"
     MCP_APPROVAL_RESPONSE = "mcp_approval_response"
+    REASONING = "reasoning"
     HEARTBEAT = "heartbeat"
     ERROR = "error"
 
@@ -45,6 +46,8 @@ class ContentType:
     DATA = "data"
     IMAGE = "image"
     AUDIO = "audio"
+    FILE = "file"
+    REFUSAL = "refusal"
 
 
 class Role:
@@ -66,6 +69,8 @@ class RunStatus:
     Failed = "failed"
     Rejected = "rejected"
     Unknown = "unknown"
+    Queued = "queued"
+    Incomplete = "incomplete"
 
 
 class FunctionParameters(BaseModel):
@@ -282,6 +287,63 @@ class DataContent(Content):
     """The data content."""
 
 
+class AudioContent(Content):
+    type: Literal[ContentType.AUDIO] = ContentType.AUDIO
+    """The type of the content part."""
+
+    data: Optional[str] = None
+    """The audio data details."""
+
+    format: Optional[str] = None
+    """
+    The format of the audio data.
+    """
+
+
+class FileContent(Content):
+    type: Literal[ContentType.FILE] = ContentType.FILE
+    """The type of the content part."""
+
+    file_url: Optional[str] = None
+    """The file URL details."""
+
+    file_id: Optional[str] = None
+    """The file ID details."""
+
+    filename: Optional[str] = None
+    """The file name details."""
+
+    file_data: Optional[str] = None
+    """The file data details."""
+
+
+class RefusalContent(Content):
+    type: Literal[ContentType.REFUSAL] = ContentType.REFUSAL
+    """The type of the content part."""
+
+    refusal: Optional[str] = None
+    """The refusal content."""
+
+
+class ToolCall(BaseModel):
+    arguments: str
+    """A JSON string of the arguments to pass to the function."""
+
+    call_id: str
+    """The unique ID of the function tool call generated by the model."""
+
+    name: str
+    """The name of the function to run."""
+
+
+class ToolCallOutput(BaseModel):
+    call_id: str
+    """The unique ID of the function tool call generated by the model."""
+
+    output: str
+    """A JSON string of the output of the function tool call."""
+
+
 AgentRole: TypeAlias = Literal[
     Role.ASSISTANT,
     Role.SYSTEM,
@@ -289,9 +351,15 @@ AgentRole: TypeAlias = Literal[
     Role.TOOL,
 ]
 
-
 AgentContent = Annotated[
-    Union[TextContent, ImageContent, DataContent],
+    Union[
+        TextContent,
+        ImageContent,
+        DataContent,
+        AudioContent,
+        FileContent,
+        RefusalContent,
+    ],
     Field(discriminator="type"),
 ]
 
@@ -684,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/embedding.py

@@ -0,0 +1,37 @@
+# -*- coding: utf-8 -*-
+from typing import List, Optional, Literal
+
+from openai.types import Embedding
+from pydantic import BaseModel
+
+
+class Usage(BaseModel):
+    prompt_tokens: Optional[int] = None
+    """The number of tokens used by the prompt."""
+
+    total_tokens: Optional[int] = None
+    """The total number of tokens used by the request."""
+
+    input_tokens: Optional[int] = None
+
+    text_count: Optional[int] = None
+
+    image_count: Optional[int] = None
+
+    video_count: Optional[int] = None
+
+    duration: Optional[float] = None
+
+
+class EmbeddingResponse(BaseModel):
+    data: List[Embedding]
+    """The list of embeddings generated by the model."""
+
+    model: str
+    """The name of the model used to generate the embedding."""
+
+    object: Literal["list"]
+    """The object type, which is always "list"."""
+
+    usage: Usage
+    """The usage information for the request."""

agentscope_runtime/engine/schemas/modelstudio_llm.py

@@ -0,0 +1,310 @@
+# -*- coding: utf-8 -*-
+import os
+from typing import List, Literal, Optional, Union
+
+from openai.types.chat import ChatCompletion, ChatCompletionChunk
+from pydantic import (
+    BaseModel,
+    StrictInt,
+    field_validator,
+    Field,
+)
+
+from .oai_llm import (
+    Parameters,
+    OpenAIMessage,
+)
+
+
+class KnowledgeHolder(BaseModel):
+    source: str
+    """The source identifier or URL where the knowledge was retrieved from."""
+
+    content: str
+    """The actual content or knowledge text retrieved from the source."""
+
+
+class IntentionOptions(BaseModel):
+    white_list: List[str] = Field(default_factory=list)
+    """A list of allowed intentions that can be processed."""
+
+    black_list: List[str] = Field(default_factory=list)
+    """A list of blocked intentions that should not be processed."""
+
+    search_model: str = "search_v6"
+    """The search model version to use for intentions recognition."""
+
+    intensity: Optional[int] = None
+    """The intensity level for intentions matching and processing."""
+
+    scene_id: Optional[str] = None
+    """The scene identifier for context-aware intentions processing."""
+
+
+class SearchOptions(BaseModel):
+    """
+    Search Options on Modelstudio platform for knowledge retrieval and web
+    search.
+    """
+
+    enable_source: bool = False
+    """Whether to include source information in search results."""
+
+    enable_citation: bool = False
+    """Whether to include citation information for retrieved content."""
+
+    enable_readpage: bool = False
+    """Whether to enable full page reading for web content."""
+
+    enable_online_read: bool = False
+    """Whether to enable online reading capabilities for real-time content."""
+
+    citation_format: str = "[<number>]"
+    """The format string for citations in the response."""
+
+    search_strategy: Literal[
+        "standard",
+        "pro_ultra",
+        "pro",
+        "lite",
+        "pro_max",
+        "image",
+        "turbo",
+        "max",
+    ] = "turbo"
+    """The search strategy to use ('standard', 'pro_ultra',
+    'pro', 'lite','pro_max', 'image','turbo','max'). """
+
+    forced_search: bool = False
+    """Whether to force search even when cached results are available."""
+
+    prepend_search_result: bool = False
+    """Whether to prepend search results to the response."""
+
+    enable_search_extension: bool = False
+    """Whether to enable extended search capabilities."""
+
+    item_cnt: int = 20000
+    """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 search."""
+
+
+# maximum chunk size from knowledge base [1, 20]
+PARAM_MAXIMUM_ALLOWED_CHUNK_NUM_MIN = int(
+    os.getenv(
+        "PARAM_MAXIMUM_ALLOWED_CHUNK_NUM_MIN",
+        "1",
+    ),
+)
+PARAM_MAXIMUM_ALLOWED_CHUNK_NUM_MAX = int(
+    os.getenv(
+        "PARAM_MAXIMUM_ALLOWED_CHUNK_NUM_MAX",
+        "20",
+    ),
+)
+
+
+class RagOptions(BaseModel):
+    model_config = {"populate_by_name": True}
+
+    class FallbackOptions(BaseModel):
+        default_response_type: Optional[str] = "llm"
+        """The type of default response when RAG fails ('llm', 'template',
+        'none'). """
+
+        default_response: Optional[str] = ""
+        """The default response text to use when RAG fails."""
+
+    class RewriteOptions(BaseModel):
+        model_name: Optional[str] = None
+        """The model name to use for rewriting."""
+
+        class_name: Optional[str] = None
+        """The class name to use for rewriting."""
+
+    class RerankOptions(BaseModel):
+        model_name: Optional[str] = None
+        """The model name to use for reranking."""
+
+    workspace_id: Optional[str] = ""
+    """The modelstudio workspace id"""
+
+    replaced_word: str = "${documents}"
+    """The placeholder word in prompts that will be replaced with retrieved
+    documents. """
+
+    index_names: Optional[List[str]] = Field(default_factory=list)
+    """List of index names to use for document processing and retrieval."""
+
+    pipeline_ids: Optional[List[str]] = Field(default_factory=list)
+    """List of pipeline IDs to use for document processing and retrieval."""
+
+    file_ids: Optional[List[str]] = Field(
+        default_factory=list,
+        alias="file_id_list",
+    )
+    """List of specific file IDs to search within."""
+
+    prompt_strategy: Optional[str] = Field(
+        default="topK",
+        alias="prompt_strategy_name",
+    )
+    """The strategy for selecting and organizing retrieved content in
+    prompts. """
+
+    maximum_allowed_chunk_num: Optional[int] = 5
+    """The maximum number of document chunks to include in the context."""
+
+    maximum_allowed_length: Optional[int] = 2000
+    """The maximum total length of retrieved content in characters."""
+
+    enable_citation: bool = Field(
+        default=False,
+        alias="prompt_enable_citation",
+    )
+    """Whether to include citation information for retrieved documents."""
+
+    fallback_options: Optional[FallbackOptions] = None
+    """Options for handling cases when RAG retrieval fails."""
+
+    enable_web_search: bool = False
+    """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."""
+
+    dense_similarity_top_k: Optional[int] = 100
+    """The number of most similar dense vectors to retrieve."""
+
+    sparse_similarity_top_k: Optional[int] = 100
+    """The number of most similar sparse vectors to retrieve."""
+
+    enable_rewrite: Optional[bool] = None
+    """Whether to enable content rewrite during RAG."""
+
+    rewrite: Optional[List[RewriteOptions]] = None
+    """Options for content rewrite."""
+
+    enable_reranking: Optional[bool] = None
+    """Whether to enable content reranking."""
+
+    rerank_min_score: Optional[float] = None
+    """The minimum score threshold for content reranking."""
+
+    rerank_top_n: Optional[int] = None
+    """The number of top results to return for content reranking."""
+
+    rerank: Optional[List[RerankOptions]] = None
+
+    enable_reject_filter: Optional[bool] = None
+    """Whether to enable content rejection filtering."""
+
+    reject_filter_type: Optional[str] = None
+    """The type of content rejection filter to use."""
+
+    reject_filter_model_name: Optional[str] = None
+    """The name of the model to use for content rejection filtering."""
+
+    reject_filter_prompt: Optional[str] = None
+    """The prompt to use for content rejection filtering."""
+
+    enable_agg_search: Optional[bool] = None
+    """Whether to enable aggregation search."""
+
+    enable_hybrid_gen: Optional[bool] = None
+    """Whether to enable hybrid generations."""
+
+    @field_validator("prompt_strategy")
+    def prompt_strategy_check(self, value: str) -> str:
+        if value:
+            value = value.lower()
+            if value in ["topk", "top_k"]:
+                return "topK"
+        return value
+
+    @field_validator("maximum_allowed_chunk_num")
+    def maximum_allowed_chunk_num_check(self, value: int) -> int:
+        if value < int(PARAM_MAXIMUM_ALLOWED_CHUNK_NUM_MIN) or value > int(
+            PARAM_MAXIMUM_ALLOWED_CHUNK_NUM_MAX,
+        ):
+            raise KeyError(
+                f"Range of maximum_allowed_chunk_num should be "
+                f"[{PARAM_MAXIMUM_ALLOWED_CHUNK_NUM_MIN}, "
+                f"{PARAM_MAXIMUM_ALLOWED_CHUNK_NUM_MAX}]",
+            )
+        return value
+
+
+class ModelstudioParameters(Parameters):
+    """
+    Parameters for Modelstudio platform, extending the base Parameters with
+    Modelstudio-specific options.
+    """
+
+    repetition_penalty: Union[float, None] = None
+    """Penalty for repeating tokens. Higher values reduce repetition."""
+
+    length_penalty: Union[float, None] = None
+    """Penalty applied to longer sequences. Affects the length of generated
+    text. """
+
+    top_k: Union[StrictInt, None] = None
+    """The number of highest probability vocabulary tokens to keep for top-k
+    filtering."""
+
+    min_tokens: Optional[int] = None
+    """The minimum number of tokens to generate before stopping."""
+
+    result_format: Literal["text", "message"] = "message"
+    """The format of the response ('text' for plain text, 'message' for
+    structured message) """
+
+    incremental_output: bool = False
+    """Whether to return incremental output during generations."""
+
+    # Search
+    enable_search: bool = False
+    """Whether to enable search capabilities for knowledge retrieval."""
+
+    search_options: Optional[SearchOptions] = SearchOptions()
+    """Configuration options for search functionality."""
+
+    # RAG
+    enable_rag: bool = False  # RAGs of modelstudio assistant service
+    """Whether to enable Retrieval-Augmented Generation (RAG) for the
+    Modelstudio assistant service. """
+
+    rag_options: Union[RagOptions, None] = None
+    """Configuration options for RAG functionality."""
+
+    selected_model: Optional[str] = "qwen-max"
+    """The selected model name to use for generations."""
+
+    # Intention
+    intention_options: Optional[IntentionOptions] = None
+    """Options for intentions recognition and processing."""
+
+    # MCP Servers
+    mcp_config_file: Optional[str] = None
+    """Path to the MCP (Model Context Protocol) configuration file."""
+
+
+class ModelstudioChatRequest(ModelstudioParameters):
+    messages: List[OpenAIMessage]
+    """A list of messages comprising the conversation so far."""
+
+    model: str
+    """ID of the model to use for the chat completion."""
+
+
+class ModelstudioChatResponse(ChatCompletion):
+    pass
+
+
+class ModelstudioChatCompletionChunk(ChatCompletionChunk):
+    pass