dashscope 2.0.1__tar.gz → 2.0.2__tar.gz

{dashscope-2.0.1 → dashscope-2.0.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dashscope
-Version: 2.0.1
+Version: 2.0.2
 Summary: dashscope client sdk library
 Home-page: https://dashscope.aliyun.com/
 Author: Alibaba Cloud

{dashscope-2.0.1 → dashscope-2.0.2}/dashscope/acli/examples/dashscope-sdk-expert/.acli/skills/agent.md

@@ -13,7 +13,7 @@ description: Quick reference for Agent APIs (agentstudio-hosted Agent/Applicatio
 ### agentstudio (`from dashscope.agentstudio import Client, AsyncClient`)
 - `Client(api_key=, workspace=, region=None, base_url=None, uid=None, timeout=None, max_retries=2)`; if base_url is not given, `workspace` (or env var `DASHSCOPE_WORKSPACE`) is required; base_url can also be set via `DASHSCOPE_AGENTSTUDIO_URL`/`AGENTSTUDIO_URL`; default region `cn-beijing`, timeout 600s.
 - Resource entry points: `client.agents / .sessions / .environments / .files / .skills / .vaults / .deployments / .deployment_runs`.
-- `agents.create(*, name, model, description=None, system_prompt=None, tools=None, mcp_servers=None, skills=None, metadata=None)` → `Agent`; `retrieve(agent_id, *, version=None)` (alias `get`); `update(agent_id, *, version, ...)` (version must equal the server's current version, otherwise HTTP 409); `archive(agent_id)`; `list(*, limit, page, include_archived)` → `CursorPage`; `list_versions(agent_id)`.
+- `agents.create(*, name, model, description=None, system_prompt=None, tools=None, mcp_servers=None, skills=None, multiagent=None, metadata=None)` → `Agent`; `model` is a `ModelConfig(id=…, temperature=…, max_tokens=…, enable_thinking=…, thinking_budget=…)` (bare id string = `ModelConfig(id=…)`); `retrieve(agent_id, *, version=None)` (alias `get`); `update(agent_id, *, version, name, model=None, ...)` — version must equal the current version (HTTP 409), `name` is required (`AGENT_005`), and a sent `model` replaces the whole config (keep the rest via `agent.model.copy_with(...)`); `archive(agent_id)`; `list(*, limit, page, include_archived)` → `CursorPage`; `list_versions(agent_id)`.
 - `sessions.create(*, agent, environment_id=None, title=None, resources=None, metadata=None)` → `Session`; also `retrieve/update(title, metadata)/list(*, limit, page, agent_id, statuses, created_at_gt/gte/lt/lte)/archive/delete`.
 - `environments.create(*, name, config, description=None, scope="organization", metadata=None)`; `files.upload(file, *, mime_type=None, progress=None)` (file accepts a path/binary stream/(name, fileobj)); `skills.create(*, file_id=None, file=None, mime_type=None)`, `skills.versions.create(skill_id, ...)`.
 

{dashscope-2.0.1 → dashscope-2.0.2}/dashscope/agentstudio/__init__.py

@@ -55,6 +55,7 @@ from .types import (
     MemoryStore,
     MemoryVersion,
     Message,
+    ModelConfig,
     PermissionPolicy,
     SecurityAlert,
     SecurityAlertList,
@@ -124,6 +125,7 @@ __all__ = [
     "MemoryStore",
     "MemoryVersion",
     "Message",
+    "ModelConfig",
     "PermissionPolicy",
     "SecurityAlert",
     "SecurityAlertList",

{dashscope-2.0.1 → dashscope-2.0.2}/dashscope/agentstudio/client.py

@@ -100,10 +100,18 @@ class Client:
 
     Usage::
 
-        from dashscope.agentstudio import Client
+        from dashscope.agentstudio import Client, ModelConfig
 
         client = Client(api_key="sk-xxx", workspace="my-ws")
-        agent = client.agents.create(name="demo", model="qwen-max")
+        agent = client.agents.create(
+            name="demo",
+            model=ModelConfig(
+                id="qwen-max",
+                temperature=0.7,
+                enable_thinking=True,
+                thinking_budget=2048,
+            ),
+        )
         session = client.sessions.create(agent=agent.id)
         with client.sessions.events.stream(session.id) as stream:
             for event in stream:
@@ -173,11 +181,12 @@ class AsyncClient:
 
     Usage::
 
-        from dashscope.agentstudio import AsyncClient
+        from dashscope.agentstudio import AsyncClient, ModelConfig
 
         client = AsyncClient(api_key="sk-xxx", workspace="my-ws")
         agent = await client.agents.create(
-            name="demo", model="qwen-max",
+            name="demo",
+            model=ModelConfig(id="qwen-max", max_tokens=4096),
         )
         session = await client.sessions.create(agent=agent.id)
         async with client.sessions.events.stream(session.id) as stream:

{dashscope-2.0.1 → dashscope-2.0.2}/dashscope/agentstudio/resources/agents.py

@@ -4,7 +4,7 @@
 
 from __future__ import annotations
 
-from typing import Any, Mapping, Optional, Sequence
+from typing import Any, Mapping, Optional, Sequence, Union
 
 from dashscope.agentstudio.pagination import (
     AsyncCursorPage,
@@ -15,7 +15,7 @@ from dashscope.agentstudio.resources._helpers import (
     _coerce_agent,
     _coerce_agent_version,
 )
-from dashscope.agentstudio.types import Agent, AgentVersion
+from dashscope.agentstudio.types import Agent, AgentVersion, ModelConfig
 from dashscope.agentstudio.types.params import (
     AgentCreateParams,
     AgentListParams,
@@ -36,7 +36,7 @@ class Agents:
         self,
         *,
         name: str,
-        model: str,
+        model: Union[str, ModelConfig],
         description: Optional[str] = None,
         system_prompt: Optional[str] = None,
         tools: Optional[Sequence[Mapping[str, Any]]] = None,
@@ -85,8 +85,8 @@ class Agents:
         *,
         version: int,
         name: Optional[str] = None,
+        model: Optional[Union[str, ModelConfig]] = None,
         description: Optional[str] = None,
-        model: Optional[str] = None,
         system_prompt: Optional[str] = None,
         tools: Optional[Sequence[Mapping[str, Any]]] = None,
         mcp_servers: Optional[Sequence[Mapping[str, Any]]] = None,
@@ -99,12 +99,13 @@ class Agents:
         ``version`` must equal the server's current version;
         the server rejects mismatches with HTTP 409.
         Retrieve the agent first to obtain the current version.
+        ``name`` is required too (``AGENT_005`` without it).
         """
         body = AgentUpdateParams(
             version=version,
             name=name,
-            description=description,
             model=model,
+            description=description,
             system_prompt=system_prompt,
             tools=tools,
             mcp_servers=mcp_servers,
@@ -189,7 +190,7 @@ class AsyncAgents:
         self,
         *,
         name: str,
-        model: str,
+        model: Union[str, ModelConfig],
         description: Optional[str] = None,
         system_prompt: Optional[str] = None,
         tools: Optional[Sequence[Mapping[str, Any]]] = None,
@@ -242,8 +243,8 @@ class AsyncAgents:
         *,
         version: int,
         name: Optional[str] = None,
+        model: Optional[Union[str, ModelConfig]] = None,
         description: Optional[str] = None,
-        model: Optional[str] = None,
         system_prompt: Optional[str] = None,
         tools: Optional[Sequence[Mapping[str, Any]]] = None,
         mcp_servers: Optional[Sequence[Mapping[str, Any]]] = None,
@@ -256,12 +257,13 @@ class AsyncAgents:
         ``version`` must equal the server's current version;
         the server rejects mismatches with HTTP 409.
         Retrieve the agent first to obtain the current version.
+        ``name`` is required too (``AGENT_005`` without it).
         """
         body = AgentUpdateParams(
             version=version,
             name=name,
-            description=description,
             model=model,
+            description=description,
             system_prompt=system_prompt,
             tools=tools,
             mcp_servers=mcp_servers,

{dashscope-2.0.1 → dashscope-2.0.2}/dashscope/agentstudio/resources/session_events.py

@@ -45,6 +45,15 @@ _TERMINAL_STATUSES = (
 )
 
 
+def _terminal_status(event: Any) -> bool:
+    """True when a ``session_status`` event reports that the run is over."""
+    if getattr(event, "type", None) != SSEEventType.SESSION_STATUS:
+        return False
+    block = event.content[0] if event.content else None
+    data = getattr(block, "data", None) or {}
+    return data.get("session_status") in _TERMINAL_STATUSES
+
+
 class SessionEvents:
     """Session event send / list / stream."""
 
@@ -125,9 +134,13 @@ class SessionEvents:
     ) -> "_TypedEventStream":
         """Open the SSE stream and return an iterator of typed events.
 
-        ``event_deltas`` opts into incremental text streaming for the given
-        event types (``"message"`` and/or ``"reasoning"``; aliases
-        ``"agent.message"`` / ``"agent.thinking"``).
+        ``event_deltas`` opts into incremental streaming for the given event
+        types (``"message"`` and/or ``"reasoning"``; aliases ``"agent.message"``
+        / ``"agent.thinking"``); anything else the server rejects. The stream is
+        read once, so ``text_deltas`` can be taken from it only; a second pass
+        raises rather than returning nothing. A chunk stream is not a reliable
+        source for final text: a reconnect replays only persisted events, so use
+        ``text_stream``.
         """
         params: Optional[Dict[str, Any]] = None
         if event_deltas:
@@ -146,7 +159,13 @@ class SessionEvents:
 
 
 class _TypedEventStream:
-    """Wrap :class:`EventStream` so iterating yields :class:`ServerEvent`."""
+    """Wrap :class:`EventStream` so iterating yields :class:`ServerEvent`.
+
+    A stream is read once: a second pass would silently yield nothing, so it
+    raises instead. Call ``sessions.events.stream()`` again to read the events.
+    """
+
+    _passed = False
 
     def __init__(self, stream: EventStream) -> None:
         self._stream = stream
@@ -179,6 +198,15 @@ class _TypedEventStream:
         self.close()
 
     def __iter__(self) -> Iterator[ServerEvent]:
+        if self._passed:
+            raise RuntimeError(
+                "this stream is single-pass and was already consumed; call "
+                "sessions.events.stream() again to read it again",
+            )
+        self._passed = True
+        return self._iter()
+
+    def _iter(self) -> Iterator[ServerEvent]:
         for payload in self._stream:
             yield _coerce_event(payload)
 
@@ -196,30 +224,27 @@ class _TypedEventStream:
                         text = getattr(block, "text", "")
                         if text:
                             yield text
-            elif getattr(event, "type", None) == SSEEventType.SESSION_STATUS:
-                block = event.content[0] if event.content else None
-                d = getattr(block, "data", None) or {}
-                if d.get("session_status") in _TERMINAL_STATUSES:
-                    return
+            elif _terminal_status(event):
+                return
 
     @property
     def text_deltas(self):
         """Iterate over incremental text chunks from ``event_delta`` frames.
 
         Requires the stream to be opened with ``event_deltas``; otherwise
-        yields nothing (use :attr:`text_stream` for terminal full text).
+        yields nothing (use :attr:`text_stream` for terminal full text, which is
+        also what a reconnect can rebuild — chunks are not replayed).
         """
+        return self._text_deltas()
+
+    def _text_deltas(self):
         for event in self:
-            etype = getattr(event, "type", None)
-            if etype == "event_delta":
+            if getattr(event, "type", None) == "event_delta":
                 text = event.delta_text
                 if text:
                     yield text
-            elif etype == SSEEventType.SESSION_STATUS:
-                block = event.content[0] if event.content else None
-                d = getattr(block, "data", None) or {}
-                if d.get("session_status") in _TERMINAL_STATUSES:
-                    return
+            elif _terminal_status(event):
+                return
 
     def close(self) -> None:
         self._stream.close()
@@ -331,7 +356,15 @@ class _AioTypedEventStream:
     async def __aexit__(self, *exc: Any) -> None:
         await self.aclose()
 
+    _passed = False
+
     def __aiter__(self) -> AsyncIterator[ServerEvent]:
+        if self._passed:
+            raise RuntimeError(
+                "this stream is single-pass and was already consumed; call "
+                "sessions.events.stream() again to read it again",
+            )
+        self._passed = True
         return self._aiter()
 
     async def _aiter(self) -> AsyncIterator[ServerEvent]:
@@ -358,20 +391,17 @@ class _AioTypedEventStream:
 
     @property
     def text_deltas(self):
+        """Async incremental text chunks from ``event_delta`` frames."""
         return self._text_deltas()
 
     async def _text_deltas(self):
         async for event in self:
-            etype = getattr(event, "type", None)
-            if etype == "event_delta":
+            if getattr(event, "type", None) == "event_delta":
                 text = event.delta_text
                 if text:
                     yield text
-            elif etype == SSEEventType.SESSION_STATUS:
-                block = event.content[0] if event.content else None
-                d = getattr(block, "data", None) or {}
-                if d.get("session_status") in _TERMINAL_STATUSES:
-                    return
+            elif _terminal_status(event):
+                return
 
     async def aclose(self) -> None:
         await self._stream.aclose()

{dashscope-2.0.1 → dashscope-2.0.2}/dashscope/agentstudio/types/__init__.py

@@ -30,6 +30,7 @@ from dashscope.agentstudio.types.models import (  # noqa: F401
     AgentVersion,
     MultiAgentConfig,
     MultiAgentRosterEntry,
+    ModelConfig,
     Credential,
     CredentialAuth,
     Memory,

{dashscope-2.0.1 → dashscope-2.0.2}/dashscope/agentstudio/types/models.py

@@ -446,6 +446,44 @@ class MultiAgentConfig(BaseModel):
         super().__init__(**kwargs)
 
 
+class ModelConfig(BaseModel):
+    """Model configuration of an agent (the ``model`` field).
+
+    Wire names as-is: ``id`` required, inference params optional (unset ones
+    are omitted so the server default applies), ranges validated server-side.
+    ``name`` is console-only: the public API neither accepts nor returns it.
+    Read or write the wire dict with :meth:`to_dict`.
+    """
+
+    _fields = (
+        "id",
+        "name",
+        "temperature",
+        "max_tokens",
+        "enable_thinking",
+        "thinking_budget",
+    )
+
+    def copy_with(self, **changes: Any) -> "ModelConfig":
+        """Copy with ``changes`` applied (``None`` drops a field).
+
+        Update replaces the whole config, so this changes one knob without
+        clearing the rest.  A name outside :attr:`_fields` has to be carried
+        by this config already, so a forward-compat field can be retuned and
+        a typo still cannot.
+        """
+        unknown = set(changes) - set(self._fields) - set(self.to_dict())
+        if unknown:
+            raise ValueError(
+                "unknown model config field(s): " + ", ".join(sorted(unknown)),
+            )
+        payload = self.to_dict()
+        payload.update(changes)
+        return ModelConfig(
+            **{k: v for k, v in payload.items() if v is not None},
+        )
+
+
 class Agent(BaseModel):
     _fields = (
         "id",
@@ -468,6 +506,9 @@ class Agent(BaseModel):
     )
 
     def __init__(self, **kwargs: Any) -> None:
+        model = kwargs.get("model")
+        if isinstance(model, Mapping):
+            kwargs["model"] = ModelConfig(**dict(model))
         multiagent = kwargs.get("multiagent")
         if isinstance(multiagent, Mapping):
             kwargs["multiagent"] = MultiAgentConfig(**dict(multiagent))
@@ -478,6 +519,16 @@ class Agent(BaseModel):
         """Alias: server field is ``system``, kept for SDK user convenience."""
         return self.system
 
+    @property
+    def model_id(self) -> Optional[str]:
+        """Convenience: the model id carried by ``model`` (None if unset)."""
+        model = self.model
+        if isinstance(model, ModelConfig):
+            return model.id
+        if isinstance(model, Mapping):
+            return model.get("id")
+        return model if isinstance(model, str) else None
+
 
 class AgentVersion(BaseModel):
     _fields = (

{dashscope-2.0.1 → dashscope-2.0.2}/dashscope/agentstudio/types/params.py

@@ -16,9 +16,9 @@ Python 3.8+ compatible.
 
 from __future__ import annotations
 
-from typing import Any, Mapping, Optional, Sequence
+from typing import Any, Dict, Mapping, Optional, Sequence, Union
 
-from dashscope.agentstudio.types.models import BaseModel
+from dashscope.agentstudio.types.models import BaseModel, ModelConfig
 
 _NOT_GIVEN = object()
 
@@ -31,6 +31,24 @@ def _to_mapping(value: Any) -> Any:
     return value
 
 
+def _resolve_model(
+    model: Optional[Union[str, ModelConfig]],
+) -> Dict[str, Any]:
+    """Wire ``model`` from a ModelConfig or a bare model id; id required."""
+    if model is None:
+        raise ValueError("model is required")
+    if isinstance(model, str):
+        model = ModelConfig(id=model)
+    if not isinstance(model, ModelConfig):
+        raise TypeError(
+            f"model must be a ModelConfig, got {type(model).__name__} "
+            "(use ModelConfig(**raw))",
+        )
+    if not model.id:
+        raise ValueError("model.id is required")
+    return model.to_dict()
+
+
 # ===========================================================================
 # Agents
 # ===========================================================================
@@ -39,9 +57,10 @@ def _to_mapping(value: Any) -> Any:
 class AgentCreateParams(BaseModel):
     """Request body for ``POST /agents``.
 
-    Maps to :meth:`Agents.create`.  The SDK method exposes
-    ``model`` as a plain string and ``system_prompt`` as a keyword arg,
-    but the wire format uses ``model: {"id": "…"}`` and ``system``.
+    Maps to :meth:`Agents.create`.  The SDK method exposes ``model`` as a
+    :class:`ModelConfig` or a bare model id, and ``system_prompt`` as a
+    keyword arg; the wire format uses ``model: {"id": "…", …}`` and
+    ``system``.
     """
 
     _fields = (
@@ -60,7 +79,7 @@ class AgentCreateParams(BaseModel):
         self,
         *,
         name: str,
-        model: str,
+        model: Union[str, ModelConfig],
         description: Optional[str] = None,
         system_prompt: Optional[str] = None,
         tools: Optional[Sequence[Mapping[str, Any]]] = None,
@@ -71,7 +90,7 @@ class AgentCreateParams(BaseModel):
     ) -> None:
         super().__init__(
             name=name,
-            model={"id": model},
+            model=_resolve_model(model),
             description=description,
             system=system_prompt,
             tools=([dict(t) for t in tools] if tools is not None else None),
@@ -109,7 +128,7 @@ class AgentUpdateParams(BaseModel):
         *,
         version: int,
         name: Optional[str] = None,
-        model: Optional[str] = None,
+        model: Optional[Union[str, ModelConfig]] = None,
         description: Optional[str] = None,
         system_prompt: Optional[str] = None,
         tools: Optional[Sequence[Mapping[str, Any]]] = None,
@@ -121,7 +140,7 @@ class AgentUpdateParams(BaseModel):
         super().__init__(
             version=version,
             name=name,
-            model=({"id": model} if model is not None else None),
+            model=(_resolve_model(model) if model is not None else None),
             description=description,
             system=system_prompt,
             tools=([dict(t) for t in tools] if tools is not None else None),

{dashscope-2.0.1 → dashscope-2.0.2}/dashscope/finetune/reinforcement/component/observability/genai/_core.py

@@ -59,12 +59,19 @@ try:
         ToolCall,
     )
 
+    try:  # Reasoning part exists in loongsuite-util-genai >= 0.4.0.
+        from opentelemetry.util.genai import types as _genai_types
+
+        Reasoning = getattr(_genai_types, "Reasoning", None)
+    except ImportError:  # pragma: no cover - older genai util
+        Reasoning = None  # type: ignore[assignment,misc]
+
     GENAI_AVAILABLE = True
 except ImportError:  # pragma: no cover
     get_extended_telemetry_handler = None  # type: ignore[assignment]
     ExecuteToolInvocation = None  # type: ignore[assignment]
     # type: ignore[assignment]
-    InputMessage = OutputMessage = Text = ToolCall = None
+    InputMessage = OutputMessage = Reasoning = Text = ToolCall = None
     GENAI_AVAILABLE = False
 
 _logger = logging.getLogger(__name__)

{dashscope-2.0.1 → dashscope-2.0.2}/dashscope/finetune/reinforcement/component/observability/genai/messages.py

@@ -454,6 +454,23 @@ def openai_chat_messages_to_input_messages(
     return out
 
 
+def _reasoning_part(msg: Any) -> Any:
+    """Return a ``Reasoning`` part when the message carries thinking content.
+
+    ``None`` when the GenAI util is unavailable or the field is absent, so
+    callers keep their existing part ordering logic.
+    """
+    if _core.Reasoning is None or msg is None:
+        return None
+    if isinstance(msg, Dict):
+        reasoning = msg.get("reasoning_content")
+    else:
+        reasoning = getattr(msg, "reasoning_content", None)
+    if not isinstance(reasoning, str) or not reasoning:
+        return None
+    return _core.Reasoning(content=reasoning)
+
+
 def openai_completion_to_output_messages(  # pylint: disable=too-many-branches
     completion: Any,
 ) -> List[Any]:
@@ -513,6 +530,9 @@ def openai_completion_to_output_messages(  # pylint: disable=too-many-branches
                 tool_calls = getattr(msg, "tool_calls", None)
             if tool_calls:
                 parts.extend(tool_calls_to_parts(tool_calls))
+            reasoning_part = _reasoning_part(msg)
+            if reasoning_part is not None:
+                parts.insert(0, reasoning_part)
         if not parts:
             parts.append(_core.Text(content=""))
         result.append(
@@ -561,6 +581,9 @@ def dashscope_response_to_output_messages(response: Any) -> List[Any]:
                     )
                 if tool_calls:
                     parts.extend(tool_calls_to_parts(tool_calls))
+                reasoning_part = _reasoning_part(msg)
+                if reasoning_part is not None:
+                    parts.insert(0, reasoning_part)
             if not parts:
                 parts.append(_core.Text(content=""))
             result.append(

{dashscope-2.0.1 → dashscope-2.0.2}/dashscope/finetune/reinforcement/component/observability/genai/tools.py

@@ -535,7 +535,7 @@ def _bind_tool_arguments(
         bound = sig.bind_partial(*args, **kwargs)
         bound.apply_defaults()
         param_names = list(sig.parameters.keys())
-        raw = Dict(bound.arguments)
+        raw = dict(bound.arguments)
         if param_names and param_names[0] in ("self", "cls"):
             raw = {k: v for k, v in raw.items() if k not in ("self", "cls")}
         return _json_serializable(raw)

{dashscope-2.0.1 → dashscope-2.0.2}/dashscope/version.py

@@ -1,4 +1,4 @@
 # -*- coding: utf-8 -*-
 # Copyright (c) Alibaba, Inc. and its affiliates.
 
-__version__ = "2.0.1"
+__version__ = "2.0.2"

{dashscope-2.0.1 → dashscope-2.0.2}/dashscope.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dashscope
-Version: 2.0.1
+Version: 2.0.2
 Summary: dashscope client sdk library
 Home-page: https://dashscope.aliyun.com/
 Author: Alibaba Cloud

{dashscope-2.0.1 → dashscope-2.0.2}/examples/03_agent_recipes/agentstudio.py

@@ -22,7 +22,7 @@ AgentStudio workspace (defaults to trial).
 import os
 
 import dashscope
-from dashscope.agentstudio import user_message
+from dashscope.agentstudio import ModelConfig, user_message
 
 
 def make_client():
@@ -48,10 +48,16 @@ def main() -> None:
     print(f"   environment_id={env.id}")
 
     print("==> creating agent")
+    # model is a ModelConfig (a bare id string is the ModelConfig(id=...)
+    # shorthand); unset params keep the server defaults.
     agent = studio.agents.create(
         name="quickstart-agent",
         system_prompt="You are a friendly demo agent. Reply briefly.",
-        model="qwen3.8-max",
+        model=ModelConfig(
+            id="qwen3.8-max",
+            temperature=0.7,
+            max_tokens=4096,
+        ),
         tools=[
             {
                 "type": "builtin_toolkit",
@@ -60,7 +66,7 @@ def main() -> None:
             },
         ],
     )
-    print(f"   agent_id={agent.id}")
+    print(f"   agent_id={agent.id} model={agent.model_id}")
 
     print("==> creating session")
     session = studio.sessions.create(