dashscope 1.27.6__tar.gz → 1.27.7__tar.gz

{dashscope-1.27.6 → dashscope-1.27.7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dashscope
-Version: 1.27.6
+Version: 1.27.7
 Summary: dashscope client sdk library
 Home-page: https://dashscope.aliyun.com/
 Author: Alibaba Cloud
@@ -88,7 +88,7 @@ The DashScope Python SDK provides a comprehensive interface to [Alibaba Cloud Mo
 
 ## What is New
 
-**v1.27.0 ships an interactive AI assistant — [DashScope SDK Expert](#ai-assistant-dashscope-sdk-expert).** Run `dashscope` with no arguments (or ask directly, e.g. `dashscope "how do I stream Generation output"`) to get SDK/API answers, runnable examples, CLI usage, and error diagnosis right in your terminal. Guidance is drawn from per-domain quick-reference skills (text, multimodal, speech, retrieval, fine-tuning, agent, cli) built on the SDK's public interfaces — parameters, outputs, and error codes — so you can ask instead of reading the docs. Type `/help` inside the assistant to view available commands.
+**v1.27.0 ships an interactive AI assistant — [DashScope SDK Expert](#ai-assistant-dashscope-sdk-expert).** Run `dashscope` with no arguments (or ask directly with `dashscope expert "how do I stream Generation output"`) to get SDK/API answers, runnable examples, CLI usage, and error diagnosis right in your terminal. Guidance is drawn from per-domain quick-reference skills (text, multimodal, speech, retrieval, fine-tuning, agent, cli) built on the SDK's public interfaces — parameters, outputs, and error codes — so you can ask instead of reading the docs. Type `/help` inside the assistant to view available commands.
 
 ## Installation
 To install the DashScope Python SDK, simply run:
@@ -257,7 +257,7 @@ A complete runnable example is available in [`samples/set_region_example.py`](sa
 The SDK ships with an interactive AI assistant, **DashScope SDK Expert**, built on the bundled Agentic CLI (`dashscope/acli`) framework. For DashScope SDK/CLI users it is the recommended way to get development consultation and AI coding help — answering SDK/API questions, generating runnable examples, showing CLI usage, and diagnosing errors, right in your terminal.
 
 - Run `dashscope` with no arguments to start the assistant. On first run it offers to install the SDK Expert knowledge pack (per-domain quick-reference skills: text, multimodal, speech, retrieval, fine-tuning, agent, cli), so guidance comes from the SDK's public interfaces — parameters, outputs, error codes — without reading the source
-- Ask it instead of reading docs — e.g. `dashscope "how do I stream Generation output"` or `dashscope "CLI command to cancel a fine-tuning job"`. Type `/help` inside the assistant to list available commands (`/setup`, `/skill`, `/stats`, ...); classic SDK subcommands still work, and unrecognized commands are routed to the assistant
+- Ask it instead of reading docs — e.g. `dashscope expert "how do I stream Generation output"` or `dashscope expert "CLI command to cancel a fine-tuning job"`, each of which asks once and exits. Type `/help` inside the assistant to list available commands (`/setup`, `/skill`, `/stats`, ...); classic SDK subcommands still work, plain `dashscope expert` enters the assistant interactively, and `dashscope expert --help` shows all the forms
 - Full walkthrough: [DashScope SDK Expert guide](https://help.aliyun.com/en/model-studio/dashscope-sdk-expert)
 
 ## Supported Models

{dashscope-1.27.6 → dashscope-1.27.7}/README.md

@@ -6,7 +6,7 @@ The DashScope Python SDK provides a comprehensive interface to [Alibaba Cloud Mo
 
 ## What is New
 
-**v1.27.0 ships an interactive AI assistant — [DashScope SDK Expert](#ai-assistant-dashscope-sdk-expert).** Run `dashscope` with no arguments (or ask directly, e.g. `dashscope "how do I stream Generation output"`) to get SDK/API answers, runnable examples, CLI usage, and error diagnosis right in your terminal. Guidance is drawn from per-domain quick-reference skills (text, multimodal, speech, retrieval, fine-tuning, agent, cli) built on the SDK's public interfaces — parameters, outputs, and error codes — so you can ask instead of reading the docs. Type `/help` inside the assistant to view available commands.
+**v1.27.0 ships an interactive AI assistant — [DashScope SDK Expert](#ai-assistant-dashscope-sdk-expert).** Run `dashscope` with no arguments (or ask directly with `dashscope expert "how do I stream Generation output"`) to get SDK/API answers, runnable examples, CLI usage, and error diagnosis right in your terminal. Guidance is drawn from per-domain quick-reference skills (text, multimodal, speech, retrieval, fine-tuning, agent, cli) built on the SDK's public interfaces — parameters, outputs, and error codes — so you can ask instead of reading the docs. Type `/help` inside the assistant to view available commands.
 
 ## Installation
 To install the DashScope Python SDK, simply run:
@@ -175,7 +175,7 @@ A complete runnable example is available in [`samples/set_region_example.py`](sa
 The SDK ships with an interactive AI assistant, **DashScope SDK Expert**, built on the bundled Agentic CLI (`dashscope/acli`) framework. For DashScope SDK/CLI users it is the recommended way to get development consultation and AI coding help — answering SDK/API questions, generating runnable examples, showing CLI usage, and diagnosing errors, right in your terminal.
 
 - Run `dashscope` with no arguments to start the assistant. On first run it offers to install the SDK Expert knowledge pack (per-domain quick-reference skills: text, multimodal, speech, retrieval, fine-tuning, agent, cli), so guidance comes from the SDK's public interfaces — parameters, outputs, error codes — without reading the source
-- Ask it instead of reading docs — e.g. `dashscope "how do I stream Generation output"` or `dashscope "CLI command to cancel a fine-tuning job"`. Type `/help` inside the assistant to list available commands (`/setup`, `/skill`, `/stats`, ...); classic SDK subcommands still work, and unrecognized commands are routed to the assistant
+- Ask it instead of reading docs — e.g. `dashscope expert "how do I stream Generation output"` or `dashscope expert "CLI command to cancel a fine-tuning job"`, each of which asks once and exits. Type `/help` inside the assistant to list available commands (`/setup`, `/skill`, `/stats`, ...); classic SDK subcommands still work, plain `dashscope expert` enters the assistant interactively, and `dashscope expert --help` shows all the forms
 - Full walkthrough: [DashScope SDK Expert guide](https://help.aliyun.com/en/model-studio/dashscope-sdk-expert)
 
 ## Supported Models

{dashscope-1.27.6 → dashscope-1.27.7}/dashscope/acli/__init__.py

@@ -3,7 +3,7 @@ from __future__ import annotations
 
 import uuid
 
-__version__ = "0.6.6"
+__version__ = "0.6.7"
 
 # Per-process identifier sent as x-dashscope-sdk-session-id so the
 # backend can group multi-turn requests from one CLI run.

{dashscope-1.27.6 → dashscope-1.27.7}/dashscope/acli/agent.py

@@ -42,6 +42,7 @@ from dashscope.acli.utils import (
     UserSupplement,
     normalize_for_model,
     sanitize,
+    sanitize_text,
     text_of,
     tool_result_for_display,
     tool_result_for_history,
@@ -66,14 +67,22 @@ def _classify_outcome(successes: int, failures: int) -> str:
 def _tool_message(tool_call: ToolCall, result: str) -> dict:
     """Build the history entry answering ``tool_call``.
 
-    The restore note must be attached here, at truncation time: later
+    Redaction happens here, ahead of truncation. ``save_session`` already ran
+    ``sanitize`` over the on-disk copy, so before this a key read out of the
+    environment was scrubbed from the session file and still handed to the
+    model in full — the persistence path was protecting the wrong reader.
+    Scrubbing after truncation would not work either: ``truncate_head_tail``
+    cuts on a character budget and can split a token in half, leaving a
+    fragment that matches no pattern.
+
+    The restore note must be attached here for the same reason: later
     shrinking skips a result that already carries an omission marker, so the
     largest results would end up with no way to be read back.
     """
     return {
         "role": "tool",
         "content": tool_result_for_history(
-            result,
+            sanitize_text(result),
             note=restore_note(tool_call.name, tool_call.arguments),
         ),
         "name": tool_call.name,
@@ -154,7 +163,10 @@ Rules:
 18. **Verify code changes before reporting done.** Run the tests that cover
     what you touched; if nothing covers it, add a focused test for the new
     behaviour and run that. Report the command and its pass/fail result —
-    never claim a change works without having executed it
+    never claim a change works without having executed it. When the output
+    transforms or joins data (ETL, CSV/JSON, migrations), also assert every
+    cross-reference resolves — schema-valid output with dangling IDs still
+    fails
 
 Reply style:
 - **Concise**. No filler like "let me see / let me help you / I'll analyze
@@ -245,6 +257,20 @@ class Agent:
             )
         except ValueError:
             self.converge_hard_ratio = 0.85
+        # Silence nudge: one reminder per turn after N tool calls have gone by
+        # without any prose reaching the user. Mode-independent on purpose —
+        # the shape this exists for is an interactive turn of *distinct*
+        # run_command calls, which every existing backstop misses:
+        # StagnationTracker's read-only classifier counts run_command as
+        # mutating and so resets its streak, its repeat counters need
+        # byte-identical calls, and _convergence_section is oneshot-only.
+        # Env: ACLI_SILENT_TOOL_NUDGE (0 disables).
+        try:
+            self.silent_tool_nudge = int(
+                os.environ.get("ACLI_SILENT_TOOL_NUDGE", "6"),
+            )
+        except ValueError:
+            self.silent_tool_nudge = 6
         # Hard acceptance gate (oneshot only): run the project's test command
         # before accepting a final answer, and send the raw output back when
         # it fails. Built here, ahead of the policy text below, so the prompt
@@ -354,6 +380,10 @@ class Agent:
         self.turn_subagents = 0
         self.turn_mcp_calls = 0
         self.turn_skills = 0
+        # Consecutive tool calls that streamed no prose, and whether the
+        # silence nudge has already been spent this turn.
+        self._silent_tool_calls = 0
+        self._silent_nudge_injected = False
         # Explicit /skill invocations to count on the next turn
         self._pending_skill_names: list[str] = []
 
@@ -567,6 +597,33 @@ class Agent:
             self.converge_hard_ratio,
         )
 
+    def _silence_section(self) -> str:
+        """Inject one reminder when tool calls stop producing prose.
+
+        Spent at most once per turn. Repeating it every iteration teaches the
+        model to skim past it, which is the failure mode prose instructions
+        already have — the point of a structural backstop is that it fires on
+        a count rather than on the model's willingness to re-read advice.
+
+        Deliberately not gated on ``oneshot``: the user watching a spinner for
+        five minutes with no text is the interactive case, and the oneshot
+        runs already have the convergence and read-only-cap sections.
+        """
+        if self._silent_nudge_injected or not self.silent_tool_nudge:
+            return ""
+        if self._silent_tool_calls < self.silent_tool_nudge:
+            return ""
+        self._silent_nudge_injected = True
+        return (
+            "\n## ⏸ You have gone quiet\n"
+            f"{self._silent_tool_calls} tool calls in a row and not one word "
+            "of it reached the user.\n"
+            "Before the next call, say in one or two sentences what you are "
+            "doing and what you have found so far. If the calls were "
+            "collecting information to answer a question you can already "
+            "answer, answer it instead of calling again.\n"
+        )
+
     async def _recall_memory(self, user_input) -> str:
         """Search for relevant profile info and format as context.
 
@@ -649,6 +706,8 @@ class Agent:
         self.turn_tool_calls = 0
         self.turn_subagents = 0
         self.turn_mcp_calls = 0
+        self._silent_tool_calls = 0
+        self._silent_nudge_injected = False
         try:
             active = get_skill_manager().active_packages(user_input_text)
             names = [p.name for p in active] + self._pending_skill_names
@@ -725,26 +784,28 @@ class Agent:
                         f"messages → {len(self.messages)}[/dim]",
                     )
 
-            # Reflection / stagnation / convergence hints are volatile, so
-            # they ride at the tail of the request instead of being folded
-            # into the system message. Rewriting messages_with_system[0] on
-            # every iteration changed the whole prompt prefix byte-for-byte and
-            # defeated provider-side prompt caching, where cached input costs
-            # roughly a tenth of uncached. The system message and the
-            # accumulated history below it stay append-only and byte-stable.
+            # Reflection / stagnation / convergence / silence hints are
+            # volatile, so they ride at the tail of the request instead of
+            # being folded into the system message. Rewriting
+            # messages_with_system[0] on every iteration changed the whole
+            # prompt prefix byte-for-byte and defeated provider-side prompt
+            # caching, where cached input costs roughly a tenth of uncached.
+            # The system message and the accumulated history below it stay
+            # append-only and byte-stable.
             #
             # The hint has to be a user message, not a second system message:
             # the Anthropic converter keeps only the last system message, so a
             # second one would replace the real prompt outright, and the Tongyi
             # converter only reads messages[0] as system.
             #
-            # All three sections are rebuilt every iteration because tracker
+            # All four sections are rebuilt every iteration because tracker
             # state changes as tools run; each returns "" when its condition
             # is not met, so an empty hint costs no message at all.
             hint = (
                 self._reflection_section()
                 + self._stagnation_section()
                 + self._convergence_section(_loop_i)
+                + self._silence_section()
             ).strip()
             request_messages = (
                 [*messages_with_system, {"role": "user", "content": hint}]
@@ -901,6 +962,13 @@ class Agent:
             tool_calls = [tc for tc in tool_calls if tc.name]
 
             self.turn_tool_calls += len(tool_calls)
+            # Silence is per-iteration, not cumulative over the turn: an
+            # iteration that streamed prose did talk to the user, so the run
+            # of unheard calls starts over from the next one.
+            if full_content.strip():
+                self._silent_tool_calls = 0
+            else:
+                self._silent_tool_calls += len(tool_calls)
             for tc in tool_calls:
                 if tc.name in ("delegate", "subagent_invoke"):
                     self.turn_subagents += 1

{dashscope-1.27.6 → dashscope-1.27.7}/dashscope/acli/cli/__init__.py

@@ -219,6 +219,16 @@ def main():
 
             _mcp_server_main()
             return
+        else:
+            # Only a bare `acli` and the explicit -c/--command one-shot enter
+            # the agent — the same contract the dashscope CLI enforces. An
+            # unrecognized token used to fall through and start a chat, which
+            # discarded the whole command line: `acli auth whoami` opened the
+            # agent instead of reporting that no such command exists. Exit 2
+            # matches the usage-error code typer/click use for the same case.
+            print(f"Error: No such command '{arg}'.")
+            print("Try 'acli --help' for help.")
+            sys.exit(2)
     config = Config.load()
     _apply_cli_overrides(config, protocol_override, max_turns_override)
 

{dashscope-1.27.6 → dashscope-1.27.7}/dashscope/acli/examples/dashscope-sdk-expert/.acli/skills/agent.md

@@ -67,16 +67,21 @@ with client.sessions.events.stream(session.id) as stream:
 | Error code/exception | HTTP status | Meaning | Handling |
 | --- | --- | --- | --- |
 | `InputRequired` / `ModelRequired` / `InvalidInput` | raised locally | missing required params such as app_id/prompt/model | add params per the exception message; Application failures do not raise — check status_code |
-| `invalid_request_error` (InvalidRequestError) | 400 | invalid agentstudio request parameters | check parameter names/types, e.g. empty events raises a local ValueError |
+| `invalid_request_error` / `request_too_large` (InvalidRequestError) | 400/413 | invalid agentstudio request parameters, or payload too large | check parameter names/types, e.g. empty events raises a local ValueError |
 | `authentication_error` (AuthenticationError) | 401 | api_key missing or invalid | check api_key or DASHSCOPE_API_KEY |
-| `permission_denied_error` (PermissionDeniedError) | 403 | no access to the resource | check workspace/uid and resource ownership |
+| `permission_denied_error` / `permission_error` (PermissionDeniedError) | 403 | no access to the resource | check workspace/uid and resource ownership |
 | `not_found_error` (NotFoundError) | 404 | agent/session and other resources do not exist | verify the id and region/workspace are correct |
 | `conflict_error` (ConflictError) | 409 | version in agents.update does not match the server | retrieve the latest version first, then update |
-| `rate_limit_error` (RateLimitError) | 429 | rate limited | retry with backoff (client default max_retries=2) |
-| `api_error` (InternalServerError) / `overloaded_error` (OverloadedError) | 500/502/504 / 503 | server error/overloaded | troubleshoot with `request_id` or retry |
+| `rate_limit_error` / `billing_error` (RateLimitError) | 429 | rate limited or out of quota | retry with backoff (client default max_retries=2) |
+| `api_error` / `timeout_error` (InternalServerError), `overloaded_error` (OverloadedError) | 500/502/504 / 503 | server error/overloaded | troubleshoot with `request_id` or retry |
 | `APITimeoutError` / `APIConnectionError` | no response | connection/read/write timeout | increase timeout, check network, then retry |
 | `StreamError` / `StreamClosedError` | mid-stream | SSE protocol error/stream closed | call `events.stream` again to reopen the stream |
 
+Match on the exception class, not on `.code`: `.code` echoes the server's raw
+string, so a 403 may arrive as either `permission_denied_error` or
+`permission_error`, and it is normalised to `api_error` when the server omits
+it. The class is always the one listed above.
+
 ## Java SDK
 
 Java SDK v2.22.23 entry points:

{dashscope-1.27.6 → dashscope-1.27.7}/dashscope/acli/examples/dashscope-sdk-expert/.acli/skills/cli.md

@@ -11,6 +11,7 @@ This file is authoritative for answering `dashscope` CLI usage questions (based
 
 | Command group | Subcommands | Purpose | Corresponding SDK class |
 | --- | --- | --- | --- |
+| auth | whoami/login/logout | Verify the active API key and persist one to ~/.dashscope/api_key | dashscope.common.api_key (get_default_api_key/save_api_key) |
 | generation | create | Text generation (including streaming and multi-turn messages) | dashscope.Generation |
 | ft (hidden alias fine-tunes) | create/get/list/stream/cancel/delete | Fine-tuning job management | dashscope.FineTunes |
 | files | upload/get/list/delete | Training file upload and management | dashscope.Files |
@@ -34,9 +35,12 @@ Note: code-generation and understanding still exist in the source but are deprec
 
 ## Common usage
 
-Prerequisite: `export DASHSCOPE_API_KEY=sk-xxx` (or pass the global `-k/--api-key`).
+Prerequisite: `export DASHSCOPE_API_KEY=sk-xxx` (or pass the global `-k/--api-key`, or persist one with `dashscope auth login`).
 
 ```bash
+dashscope auth whoami                 # verify the active key against the API and show its source
+dashscope auth login --key sk-xxx     # save a key to ~/.dashscope/api_key
+dashscope auth logout                 # remove the saved key file
 dashscope generation create -m qwen-plus -p "Hello" -s --temperature 0.7
 dashscope ft create -m qwen-turbo -t file-xxx -v file-yyy -e 2 -b 16 -l 1e-5
 dashscope files upload -f train.jsonl -p fine-tune -d "training set"
@@ -59,6 +63,9 @@ dashscope rl run -c rl_config.yaml -o json -v
 ```
 
 Key option notes:
+- auth whoami: takes no options; validates the resolved key with a lightweight `dashscope.Models.list(page=1, page_size=1)` call and prints `Authenticated  key=sk-xxx...yyyy  source=...`. The key is always masked (first 6 + last 4), never printed in full. `source` reports where it came from: `environment / --api-key flag`, `file (<path>)`, or `unknown`. Exit codes: 0 = present and accepted, 1 = no key configured, 2 = configured but rejected (401/403) or an unexpected response.
+- auth login: `-k/--key` saves to `~/.dashscope/api_key`. Omitted, it prompts interactively with hidden input — that prompt blocks forever in a non-TTY (piped stdin, or a shell tool driven by an agent), so pass `--key` explicitly there. An empty/whitespace key exits 1. Note that `--key sk-xxx` lands in shell history and the process arg list; prefer the interactive prompt when a human is at a terminal.
+- auth logout: takes no options; removes `~/.dashscope/api_key` if present, otherwise prints "nothing to remove" and exits 0. It does not unset `DASHSCOPE_API_KEY`, so a key exported in the environment still authenticates afterwards.
 - generation create: `-p/--prompt`, `--messages` (JSON string), `-s/--stream`, `--temperature/--top-p/--top-k/--max-tokens/--seed/--stop/--repetition-penalty/--presence-penalty/--enable-search/--n/--result-format`
 - ft create: `-t/--training-file-ids` (repeatable), `-v/--validation-file-ids`, `--mode`, `-e/--n-epochs`, `-b/--batch-size`, `-l/--learning-rate`, `-p/--prompt-loss`; get/stream/cancel/delete all take job_id as a positional argument; list uses `-p/--page`, `-s/--size`
 - files: upload `-f/--file`, `-p/--purpose` (default fine-tune), `-d/--description`; all commands support `-u/--base-url`
@@ -75,13 +82,17 @@ Key option notes:
 - `-k/--api-key`: global API Key; can be placed before or after the command group name. The oss and rl/agentic-rl groups have their own local `--api-key` (with envvar DASHSCOPE_API_KEY), which is parsed locally once the command name appears.
 - `-h` is automatically converted to `--help`; use `dashscope --help` or `dashscope <group> --help` for the authoritative option list.
 - Legacy syntax compatibility: `dashscope fine_tunes.call` -> `fine-tunes create`, `generation.call` -> `generation create`, etc.; underscore options like `--training_file_ids` and `--api_key` are automatically mapped to hyphenated forms.
-- Bare `dashscope` (no subcommand; a change in this repo): enters the built-in agent "DashScope SDK Expert" interactive mode, TUI by default; `--cli` switches to a plain REPL, `--tui` forces TUI; requires `pip install dashscope[acli]`. When stdin is not a TTY, piped text is treated as a one-shot question. Unrecognized commands do not error; the whole line is forwarded to the agent as a question. On the first interactive run, if there is no ./.acli, it asks whether to download the dashscope-sdk-expert example configuration.
+- Bare `dashscope` (no arguments; a change in this repo): enters the built-in agent "DashScope SDK Expert" interactive mode, TUI by default; `--cli` switches to a plain REPL, `--tui` forces TUI; requires `pip install dashscope[acli]`. When stdin is not a TTY, piped text is treated as a one-shot question. On the first interactive run, if there is no ./.acli, it asks whether to download the dashscope-sdk-expert example configuration.
+- Entering the agent explicitly: `dashscope expert` (interactive), `dashscope expert --cli|--tui`, `dashscope expert --help` (prints usage), `dashscope expert "question"` (one-shot). The `expert` keyword is the only way to pass a question on the command line.
+- Anything else that is not a known command group is a **typer error, not a question**: `dashscope generaton create` reports `No such command`, and so does a quoted question like `dashscope "how do I stream Generation output"`, so a typo surfaces instead of silently opening a chat. Only `-k/--api-key`, `--cli` and `--tui` may precede the command; group-level options must follow it (`dashscope generation create -w wsid`, not `dashscope -w wsid generation create`).
 
 ## Common errors and troubleshooting
 
-- `Error: ... AuthenticationError` (exit code 1): no Key configured; set DASHSCOPE_API_KEY or add `-k`.
+- `Error: ... AuthenticationError` (exit code 1): no Key configured; set DASHSCOPE_API_KEY, add `-k`, or persist one with `dashscope auth login`. Diagnose with `dashscope auth whoami` — it reports both validity and which source the key came from.
+- `dashscope auth whoami` opens the SDK Expert agent instead of printing key info: `auth` was missing from the CLI's top-level routing table, so the line was treated as an unknown command and forwarded to the agent as a question. Fixed in this repo; if a user hits it, they are on an older install and should upgrade rather than keep retrying.
 - `Option '--api-key' requires an argument.` (exit code 2): `-k/--api-key` is missing a value or the value starts with `-`.
 - `--messages must be a valid JSON string`: generation's --messages must be a JSON array string; watch shell quoting/escaping.
 - `File ... does not exist`: local paths (-f, --image, --audio, etc.) are validated locally first; `~` expansion is supported; URLs must include a scheme.
 - `Failed request_id: ..., status_code: ..., code: ..., message: ...` (exit code 1): rejected by the server; troubleshoot by code (InvalidParameter usually means a wrong model name or parameter value); HTTP 200 with a non-empty business code is also treated as a failure.
-- Bare dashscope shows `Install dashscope[acli] to enable the agent`: install `dashscope[acli]`; if it reports `Interactive mode requires a terminal.`, use `dashscope "your question"` for a one-shot question instead.
+- Bare dashscope shows `Install dashscope[acli] to enable the agent`: install `dashscope[acli]`; if it reports `Interactive mode requires a terminal.`, use `dashscope expert "your question"` for a one-shot question instead.
+- `No such command 'how do I ...'`: a question was passed without the `expert` keyword. `dashscope "question"` is no longer a short form — tell the user to write `dashscope expert "question"`.

{dashscope-1.27.6 → dashscope-1.27.7}/dashscope/acli/examples/dashscope-sdk-expert/.acli/system-prompt.md

@@ -3,7 +3,10 @@ You are DashScope SDK Expert, an intelligent assistant for the DashScope Python
 Your knowledge base:
 - Python SDK: https://github.com/dashscope/dashscope-sdk-python
 - Java SDK: https://github.com/dashscope/dashscope-sdk-java
-- Alibaba Cloud Model Studio (Bailian) Product Overview: https://help.aliyun.com/zh/model-studio/what-is-model-studio
+- Alibaba Cloud Model Studio (Bailian) Product Overview: https://docs.modelstudio.console.alibabacloud.com/zh/model-studio/what-is-model-studio
+- Get and Configure an API Key: https://docs.modelstudio.console.alibabacloud.com/zh/model-studio/get-api-key
+- Get the App ID and Workspace ID: https://docs.modelstudio.console.alibabacloud.com/zh/model-studio/obtain-the-app-id-and-workspace-id
+- Build a Knowledge-Base Q&A Application with No Code: https://docs.modelstudio.console.alibabacloud.com/zh/model-studio/build-knowledge-base-qa-assistant-without-coding
 - Model Studio User Guide: https://help.aliyun.com/zh/model-studio/get-started-with-models
 - Application User Guide: https://help.aliyun.com/zh/model-studio/start-using
 - Model API Reference: https://help.aliyun.com/zh/model-studio/preparations
@@ -32,6 +35,7 @@ Match your approach to the question type:
 - **Issue / bug analysis**: Analyze directly from the user's description first. Only inspect SDK source when you need to verify a specific behavior. Go straight to the root cause.
 - **API questions** (signature, parameters, usage): Load the matching skill under `.acli/skills/` (covers Python and Java interfaces). If the user mentions a specific SDK version, verify the signatures against the installed package.
 - **Example generation**: Cross-check against the installed version, then write runnable code.
+- **Questions about you** (what model you are, what you can do, what a skill or slash command means): Answer from this prompt, with **zero tool calls**. Your model name is on the `Current model:` line, your domains and skill list are above, and your capabilities are in this section. Nothing about yourself is discoverable by running a command — probing the environment to answer "what can you do" only makes the user wait for an answer you already had.
 
 ### Version Check
 
@@ -61,10 +65,11 @@ When verification is needed, use `run_command` to inspect the installed `dashsco
 
 ### Workflow
 
-1. Identify the question type (issue analysis / API question / example).
-2. If issue analysis — answer directly, only verify if something is unclear.
-3. If API question — run one targeted `inspect.signature` or `help()` call.
-4. Compose a concise, actionable answer.
+1. Identify the question type (question about you / issue analysis / API question / example).
+2. If it is about you — answer straight from this prompt and stop. No tool call.
+3. If issue analysis — answer directly, only verify if something is unclear.
+4. If API question — run one targeted `inspect.signature` or `help()` call.
+5. Compose a concise, actionable answer.
 
 ### SDK Reference
 

{dashscope-1.27.6 → dashscope-1.27.7}/dashscope/acli/prompt_pipeline.py

@@ -200,7 +200,17 @@ class EnvironmentSection:
     name = "environment"
 
     def render(self, ctx: PromptContext) -> str:
-        env_info: list[str] = []
+        import platform
+
+        from dashscope.acli.tools.shell import shell_label
+
+        # The platform is stated because run_command's syntax depends on it and
+        # a wrong guess costs a whole turn: on Windows the model wrote
+        # `2>/dev/null || find /` and got back a PowerShell ParserError.
+        env_info: list[str] = [
+            f"Current OS: {platform.system()} {platform.machine()}",
+            f"run_command executes via: {shell_label()}",
+        ]
         if ctx.user_name:
             env_info.append(f"Current user: {ctx.user_name}")
         if ctx.provider_name or ctx.model_name:
@@ -210,8 +220,6 @@ class EnvironmentSection:
                 "mentioned in history or summaries may be outdated — "
                 "always defer to this line for model questions)",
             )
-        if not env_info:
-            return ""
         env_info.append(
             "Rule: when mentioning this CLI's commands, only cite real "
             "commands that definitely exist; when unsure, point the user "

{dashscope-1.27.6 → dashscope-1.27.7}/dashscope/acli/providers/tongyi.py

@@ -4,7 +4,7 @@ from __future__ import annotations
 
 import json
 import os
-from typing import AsyncIterator
+from typing import AsyncIterator, ClassVar
 
 import httpx
 
@@ -15,14 +15,21 @@ from dashscope.acli.providers.base import LLMChunk, LLMResponse, ToolCall
 # the DashScope native route (NOT the OpenAI-compatible one) so requests
 # land in the native SLS logstore.
 DASHSCOPE_BASE_URL = "https://dashscope.aliyuncs.com"
-# The gateway binds each model to exactly one aigc service path (newer
-# models like qwen3.8-max live on multimodal-generation, classic text
-# models on text-generation). The provider tries them in order and
-# remembers the one that answers 200 — see _is_url_error.
+# The gateway binds each model to exactly one aigc service path and answers
+# the other with a 400 "url error" (see _is_url_error), so probing an
+# unlearned model always costs one failed request — one that lands in the
+# prod gateway log as InvalidParameter. multimodal-generation is probed
+# first because acli's default model (qwen3.8-max) and the vl/omni family
+# live there; classic text models are the minority and learn their binding
+# on the first call.
 _GENERATION_PATHS = (
-    "/api/v1/services/aigc/text-generation/generation",
     "/api/v1/services/aigc/multimodal-generation/generation",
+    "/api/v1/services/aigc/text-generation/generation",
 )
+# Learned model → path bindings, shared across processes so a fresh CLI
+# start does not re-probe. Global rather than per-workspace: the binding is
+# a property of the gateway, and bench/CI runs execute in a throwaway cwd.
+_PATH_CACHE_NAME = "generation-paths.json"
 # Historical/standard prefixes a persisted config may carry; the provider
 # normalizes them back to the service root.
 _LEGACY_PREFIXES = ("/compatible-mode/v1", "/api/v1")
@@ -59,6 +66,45 @@ def _is_url_error_message(message: str) -> bool:
     return "url error" in (message or "")
 
 
+def _load_path_cache() -> dict[str, str]:
+    """Read the model → generation-path bindings learned by earlier runs.
+
+    Entries that are unreadable or name an unknown path are dropped rather
+    than repaired: a dropped binding costs one probe, which the fallback
+    already survives.
+    """
+    from dashscope.acli.config import CONFIG_DIR
+
+    try:
+        raw = json.loads(
+            (CONFIG_DIR / _PATH_CACHE_NAME).read_text(encoding="utf-8"),
+        )
+    except (OSError, ValueError):
+        return {}
+    if not isinstance(raw, dict):
+        return {}
+    return {
+        str(model): str(path)
+        for model, path in raw.items()
+        if str(path) in _GENERATION_PATHS
+    }
+
+
+def _save_path_cache(paths: dict[str, str]) -> None:
+    """Persist learned bindings. An unwritable home must not fail a call."""
+    from dashscope.acli.config import CONFIG_DIR
+    from dashscope.acli.utils.paths import atomic_write_text
+
+    try:
+        CONFIG_DIR.mkdir(parents=True, exist_ok=True)
+        atomic_write_text(
+            CONFIG_DIR / _PATH_CACHE_NAME,
+            json.dumps(paths, indent=2, sort_keys=True),
+        )
+    except OSError:
+        pass
+
+
 def _to_native_content(content):
     """Convert OpenAI message content parts to the native shape.
 
@@ -185,6 +231,30 @@ def _native_chunk_to_openai(chunk) -> dict:
 
 
 class TongyiProvider:
+    # model → generation path, shared by every instance in this process and
+    # mirrored to disk by _remember_path. A provider is constructed per
+    # session start, per model switch and per vision call, so without this
+    # each of those re-probes and re-logs the same 400.
+    _path_cache: ClassVar[dict[str, str] | None] = None
+
+    @classmethod
+    def _learned_paths(cls) -> dict[str, str]:
+        # Bound to a local so the Optional class attribute narrows to a dict
+        # for both the caller and the type checker.
+        cache = cls._path_cache
+        if cache is None:
+            cache = _load_path_cache()
+            cls._path_cache = cache
+        return cache
+
+    @classmethod
+    def _remember_path(cls, model: str, path: str) -> None:
+        learned = cls._learned_paths()
+        if learned.get(model) == path:
+            return
+        learned[model] = path
+        _save_path_cache(learned)
+
     def __init__(
         self,
         model: str = "qwen3.8-max",
@@ -205,7 +275,16 @@ class TongyiProvider:
                 break
         self.base_url = base
         self.module = module
-        self._generation_path = _GENERATION_PATHS[0]
+        self._generation_path = self._learned_paths().get(
+            model,
+            _GENERATION_PATHS[0],
+        )
+
+    def _commit_path(self, path: str) -> None:
+        """Record the path that answered 200, for this instance and every
+        later one."""
+        self._generation_path = path
+        self._remember_path(self.model, path)
 
     def _candidate_paths(self) -> list[str]:
         others = [p for p in _GENERATION_PATHS if p != self._generation_path]
@@ -348,7 +427,7 @@ class TongyiProvider:
                         headers=headers,
                     )
                     if response.status_code == 200:
-                        self._generation_path = path
+                        self._commit_path(path)
                         break
                     if i + 1 < len(paths) and _is_url_error(
                         response.status_code,
@@ -487,7 +566,7 @@ class TongyiProvider:
                         try:
                             first = await stream.__anext__()
                         except StopAsyncIteration:
-                            self._generation_path = path
+                            self._commit_path(path)
                             return
                         except _StreamAPIError as e:
                             if i + 1 < len(paths) and _is_url_error_message(
@@ -495,7 +574,7 @@ class TongyiProvider:
                             ):
                                 continue
                             raise
-                        self._generation_path = path
+                        self._commit_path(path)
                         yield first
                         async for chunk in stream:
                             yield chunk

{dashscope-1.27.6 → dashscope-1.27.7}/dashscope/acli/scheduler.py

@@ -591,7 +591,9 @@ class Scheduler:
                     continue
 
             rendered = render_skill(skill, inv.args)
-            if not rendered:
+            # `is None`, not falsy: None is the missing-arguments signal, so
+            # arg_hint is never empty here.
+            if rendered is None:
                 arg_hint = " ".join(f"<{a}>" for a in skill.arguments)
                 results.append(
                     f"missing args: /skill {inv.name} {arg_hint}",

{dashscope-1.27.6 → dashscope-1.27.7}/dashscope/acli/skills/base.py

@@ -200,13 +200,18 @@ def render_skill(skill: Skill, args: list[str]) -> str | None:
     don't match."""
     if len(args) < len(skill.arguments):
         return None
-    kwargs = {}
+    template = skill.prompt_template
+    # A skill body is Markdown, not a format string: it is full of literal
+    # braces from the JSON and Python it documents. Running str.format() over
+    # the whole body raised KeyError on `{"role": ...}`, which the old
+    # `except KeyError` turned into a bogus "missing args" report for every
+    # no-argument skill that showed a payload, and let the IndexError from
+    # `{}` escape entirely. Substitute only the declared arguments and leave
+    # every other brace exactly as the author wrote it.
     for i, arg_name in enumerate(skill.arguments):
         if i == len(skill.arguments) - 1:
-            kwargs[arg_name] = " ".join(args[i:])
+            value = " ".join(args[i:])
         else:
-            kwargs[arg_name] = args[i]
-    try:
-        return skill.prompt_template.format(**kwargs)
-    except KeyError:
-        return None
+            value = args[i]
+        template = template.replace("{" + arg_name + "}", value)
+    return template