feat(model/omni): name change input video representation_compact parameter

Author: agentscope-ai-java

dashscope/audio/qwen_omni/omni_realtime.py

@@ -414,7 +414,7 @@ def update_session(
         transcription_params: TranscriptionParams = None,
         input_audio_config: AudioFormatConfig = None,
         output_audio_config: AudioFormatConfig = None,
-        input_video_representation_compactness: int = None,
+        input_video_representation_compact: str = None,
         **kwargs,
     ) -> None:
         """
@@ -461,11 +461,10 @@ def update_session(
             type (pcm/wav) and sample rate (8000/16000/24000/48000), as well
             as free extension parameters via ``extra_params``. When provided,
             the request emits the ``session.audio.output.format`` structure.
-        input_video_representation_compactness: int
-            input video representation compactness. When provided, the request
-            emits ``session.video.input.representation_compactness``. No strict
-            client-side validation is performed so newly supported values can
-            be used without upgrading the SDK.
+        input_video_representation_compact: str
+            input video representation compact setting. When provided, the
+            request emits ``session.video.input.representation_compact`` and
+            passes the string value through without client-side validation.
 
         Notes
         -----
@@ -516,12 +515,10 @@ def update_session(
                     }
         if transcription_params is not None:
             self._apply_transcription_params(transcription_params)
-        if input_video_representation_compactness is not None:
+        if input_video_representation_compact is not None:
             self.config["video"] = {
                 "input": {
-                    "representation_compactness": (
-                        input_video_representation_compactness
-                    ),
+                    "representation_compact": input_video_representation_compact,
                 },
             }
         self.config.update(kwargs)

dashscope/cli/agentic_rl.py

@@ -460,14 +460,6 @@ def run(
         "--config",
         help="Path to YAML configuration file",
     ),
-    teacher_model: Optional[str] = typer.Option(
-        None,
-        "--teacher-model",
-        help=(
-            "Enable OPD with this teacher model (overrides YAML); "
-            "Rollout and Reward are optional"
-        ),
-    ),
     job_name: Optional[str] = typer.Option(
         None,
         help="Custom name for the tuning job",
@@ -499,8 +491,10 @@ def run(
     1. Configuration-driven: Use -c/--config to specify a YAML file
     2. Direct parameter: Provide all required arguments via CLI options
 
-    Rollout and Reward are required for regular reinforcement learning, but
-    optional for OPD.
+    Required parameters:
+    - rollout_classpath
+    - reward_classpaths (at least one)
+    - training_files (at least one)
     """
     output_format = validate_output_format(output_format)
     _apply_verbose(verbose)
@@ -511,7 +505,6 @@ def run(
 
     # Prepare workflow parameters
     run_kwargs = {
-        "teacher_model": teacher_model,
         "job_name": job_name,
     }
 

dashscope/cli/deployments.py

@@ -85,11 +85,9 @@ def _wait_for_deployment(
     except Exception as exc:
         logger.debug("wait_for_deployment error", exc_info=exc)
         err_console.print(
-            f"[red]Error:[/red] Failed to check deployment status: {exc}. "
             f"You can get deployment status via: "
             f"[cyan]dashscope deployments get {deployed_model}[/cyan]",
         )
-        raise typer.Exit(1)
 
 
 def _print_deployments(output):

dashscope/finetune/agentic_rl.py

@@ -3,7 +3,6 @@
 
 # Copyright (c) Alibaba, Inc. and its affiliates.
 
-import time
 from typing import Union, List, Optional, ClassVar, Dict, Any
 from typing_extensions import Self
 
@@ -28,7 +27,6 @@
 from dashscope.finetune.reinforcement import (
     FunctionType,
     DatasetsType,
-    TrainingType,
 )
 from dashscope.finetune.reinforcement import (
     RewardInput,
@@ -45,7 +43,6 @@
 from dashscope.finetune.reinforcement.common.errors import (
     RegistrationError,
     ValidationError,
-    InstanceQueryError,
     RuntimeErrorWithCode,
     ValueErrorWithCode,
     DatasetsError,
@@ -172,14 +169,11 @@ def submit_job(
         hyper_parameters: Optional[Dict[str, str]] = None,
         resources: Optional[Dict[str, str]] = None,
         job_name: Optional[str] = None,
-        teacher_model: Optional[str] = None,
         **kwargs,
     ) -> FineTune:
         """
         Submit RL tuning job to the platform.
         """
-        teacher_model = teacher_model or self.tuning.teacher_model
-
         # Resolve job name (fallback to class default)
         if job_name:
             self.tuning.name = job_name
@@ -234,15 +228,6 @@ def submit_job(
         if resources:
             self.tuning.training.resources = resources
 
-        training_type = self.tuning.training.type
-        if teacher_model:
-            training_type = TrainingType.PG_OPD
-        elif training_type == TrainingType.PG_OPD:
-            raise ValueErrorWithCode(
-                f"teacher_model is required when training.type is {training_type}",
-                error_code=3006,
-            )
-
         request = {
             "model": self.tuning.model.name,
             "training_datasets": [ds.model_dump() for ds in training_datasets],
@@ -253,8 +238,7 @@ def submit_job(
             "rewards": rewards,
             "hyper_parameters": self.tuning.training.hyper_parameters,
             "resource_config": self.tuning.training.resources,
-            "training_type": str(training_type),
-            "teacher_model": teacher_model,
+            "training_type": str(self.tuning.training.type),
             "job_name": job_name_with_suffix,
         }
         request = deep_remove_none(request)
@@ -301,7 +285,6 @@ async def run(
         hyper_parameters: Optional[Dict[str, str]] = None,
         resources: Optional[Dict[str, str]] = None,
         job_name: Optional[str] = None,
-        teacher_model: Optional[str] = None,
         **kwargs,
     ) -> FineTune:
         """
@@ -330,7 +313,6 @@ async def run(
                 hyper_parameters=hyper_parameters,
                 resources=resources,
                 job_name=job_name,
-                teacher_model=teacher_model,
                 **kwargs,
             )
         except Exception as e:
@@ -444,28 +426,7 @@ async def test_functions(
         functype: FunctionType,
         input_data: Dict[str, Any],
         api_key: str = None,
-        pull_logs: bool = False,
-        log_page_size: int = 100,
-        start_time: Optional[int] = None,
-        end_time: Optional[int] = None,
     ):
-        """Test a deployed function instance with custom input data.
-
-        Args:
-            instance_id: Target function instance ID.
-            functype: Function type (ROLLOUT/REWARD/GROUP_REWARD).
-            input_data: Test input payload.
-            api_key: DashScope API key (uses DASHSCOPE_API_KEY env var
-                if omitted).
-            pull_logs: If True, pull all logs of the function instance
-                (with pagination) after verification and print them
-                between separator markers.
-            log_page_size: Page size used when pulling logs.
-            start_time: Optional start time filter (in seconds) for log
-                pulling. Defaults to 24 hours before ``end_time``.
-            end_time: Optional end time filter (in seconds) for log
-                pulling. Defaults to the current time (now).
-        """
         try:
             set_api_key(api_key)
 
@@ -489,197 +450,13 @@ async def test_functions(
                 },
             )
 
-            result = await AgenticRLFunctionComponent.verify_function(
+            return await AgenticRLFunctionComponent.verify_function(
                 value,
                 instance_id,
             )
 
-            if pull_logs:
-                await cls._pull_function_instance_logs(
-                    function_instance_id=instance_id,
-                    page_size=log_page_size,
-                    start_time=start_time,
-                    end_time=end_time,
-                )
-
-            return result
-
         except Exception as e:
             raise ValidationError(
                 "Function test failed",
                 error_code=3008,
             ) from e
-
-    @classmethod
-    async def query_function_instance_logs(
-        cls,
-        function_instance_id: str,
-        page_number: int = 1,
-        page_size: int = 100,
-        start_time: Optional[int] = None,
-        end_time: Optional[int] = None,
-        keywords: Optional[List[str]] = None,
-        api_key: str = None,
-    ) -> Dict[str, Any]:
-        """Query one page of logs for a function (faas) instance.
-
-        Args:
-            function_instance_id: Target function instance ID.
-            page_number: Page number, starting from 1.
-            page_size: Number of log entries per page.
-            start_time: Optional start time filter (in seconds).
-            end_time: Optional end time filter (in seconds).
-            keywords: Optional keyword filters for log messages.
-            api_key: DashScope API key (uses DASHSCOPE_API_KEY env var
-                if omitted).
-
-        Returns:
-            Raw response dict of the log query API.
-        """
-        try:
-            set_api_key(api_key)
-
-            fc_component = AgenticRLFunctionComponent
-            return await fc_component.query_function_instance_logs(
-                function_instance_id=function_instance_id,
-                page_number=page_number,
-                page_size=page_size,
-                start_time=start_time,
-                end_time=end_time,
-                keywords=keywords,
-            )
-
-        except Exception as e:
-            if hasattr(e, "error_code"):
-                raise
-            raise InstanceQueryError(
-                "Function instance log query failed",
-                error_code=3009,
-            ) from e
-
-    @classmethod
-    async def query_all_function_instance_logs(
-        cls,
-        function_instance_id: str,
-        page_size: int = 100,
-        start_time: Optional[int] = None,
-        end_time: Optional[int] = None,
-        keywords: Optional[List[str]] = None,
-        api_key: str = None,
-    ) -> List[str]:
-        """Fetch all logs of a function (faas) instance.
-
-        Pages are fetched one by one via the paginated log query until
-        all entries are collected.
-
-        Args:
-            function_instance_id: Target function instance ID.
-            page_size: Number of log entries per page.
-            start_time: Optional start time filter (in seconds).
-            end_time: Optional end time filter (in seconds).
-            keywords: Optional keyword filters for log messages.
-            api_key: DashScope API key (uses DASHSCOPE_API_KEY env var
-                if omitted).
-
-        Returns:
-            Aggregated list of log messages across all pages.
-        """
-        try:
-            set_api_key(api_key)
-
-            fc_component = AgenticRLFunctionComponent
-            return await fc_component.query_all_function_instance_logs(
-                function_instance_id=function_instance_id,
-                page_size=page_size,
-                start_time=start_time,
-                end_time=end_time,
-                keywords=keywords,
-            )
-
-        except Exception as e:
-            if hasattr(e, "error_code"):
-                raise
-            raise InstanceQueryError(
-                "Function instance log query failed",
-                error_code=3010,
-            ) from e
-
-    @classmethod
-    async def delete_function_instance(
-        cls,
-        function_instance_id: str,
-        api_key: str = None,
-    ) -> Dict[str, Any]:
-        """Delete a function (faas) runtime instance.
-
-        Args:
-            function_instance_id: Target function instance ID.
-            api_key: DashScope API key (uses DASHSCOPE_API_KEY env var
-                if omitted).
-
-        Returns:
-            Raw response dict of the delete API, containing
-            ``data.status`` (e.g. "deleted") and
-            ``data.sandbox_code``.
-
-        Raises:
-            InstanceQueryError: If the deletion fails.
-        """
-        try:
-            set_api_key(api_key)
-
-            fc_component = AgenticRLFunctionComponent
-            return await fc_component.delete_function_instance(
-                function_instance_id=function_instance_id,
-            )
-
-        except Exception as e:
-            if hasattr(e, "error_code"):
-                raise
-            raise InstanceQueryError(
-                "Function instance deletion failed",
-                error_code=3011,
-            ) from e
-
-    @classmethod
-    async def _pull_function_instance_logs(
-        cls,
-        function_instance_id: str,
-        page_size: int = 100,
-        start_time: Optional[int] = None,
-        end_time: Optional[int] = None,
-    ) -> None:
-        """Pull all logs of a function instance and print them between
-        separator markers (best effort, never raises).
-
-        When ``start_time``/``end_time`` are not provided, defaults to
-        pulling logs from 24 hours ago until now.
-        """
-        if end_time is None:
-            end_time = int(time.time())
-        if start_time is None:
-            start_time = end_time - 24 * 60 * 60
-        logger.info(
-            "************start query log "
-            f"(function_instance_id={function_instance_id})*******",
-        )
-        try:
-            logs = await cls.query_all_function_instance_logs(
-                function_instance_id=function_instance_id,
-                page_size=page_size,
-                start_time=start_time,
-                end_time=end_time,
-            )
-            for entry in logs:
-                logger.info(f"[function instance log] {entry}")
-            logger.info(
-                f"Pulled {len(logs)} log entries for function instance "
-                f"{function_instance_id}",
-            )
-        except Exception as e:
-            logger.warning(
-                f"Failed to pull logs for function instance "
-                f"{function_instance_id}: {e}",
-            )
-        finally:
-            logger.info("************end query log *******")