auto-coder 3.0.48__tar.gz → 3.0.50__tar.gz

{auto_coder-3.0.48/src/auto_coder.egg-info → auto_coder-3.0.50}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: auto-coder
-Version: 3.0.48
+Version: 3.0.50
 Summary: AutoCoder: AutoCoder
 Author: allwefantasy
 Author-email: allwefantasy <allwefantasy@gmail.com>
@@ -189,7 +189,7 @@ Requires-Dist: prompt-toolkit
 Requires-Dist: tokenizers
 Requires-Dist: aiofiles
 Requires-Dist: readerwriterlock
-Requires-Dist: byzerllm[saas]>=0.1.207
+Requires-Dist: byzerllm[saas]>=0.1.208
 Requires-Dist: patch
 Requires-Dist: diff_match_patch
 Requires-Dist: GitPython

{auto_coder-3.0.48 → auto_coder-3.0.50}/pyproject.toml

@@ -5,7 +5,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "auto-coder"
-version = "3.0.48"
+version = "3.0.50"
 description = "AutoCoder: AutoCoder"
 authors = [
     {name = "allwefantasy", email = "allwefantasy@gmail.com"}
@@ -39,7 +39,7 @@ dependencies = [
     "tokenizers",
     "aiofiles",
     "readerwriterlock",
-    "byzerllm[saas]>=0.1.207",
+    "byzerllm[saas]>=0.1.208",
     "patch",
     "diff_match_patch",
     "GitPython",

{auto_coder-3.0.48 → auto_coder-3.0.50}/requirements.txt

@@ -46,7 +46,7 @@ readerwriterlock
 
 # camelot-py
 # llama_index
-byzerllm[saas]>=0.1.207
+byzerllm[saas]>=0.1.208
 patch
 diff_match_patch
 GitPython

{auto_coder-3.0.48 → auto_coder-3.0.50/src/auto_coder.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: auto-coder
-Version: 3.0.48
+Version: 3.0.50
 Summary: AutoCoder: AutoCoder
 Author: allwefantasy
 Author-email: allwefantasy <allwefantasy@gmail.com>
@@ -189,7 +189,7 @@ Requires-Dist: prompt-toolkit
 Requires-Dist: tokenizers
 Requires-Dist: aiofiles
 Requires-Dist: readerwriterlock
-Requires-Dist: byzerllm[saas]>=0.1.207
+Requires-Dist: byzerllm[saas]>=0.1.208
 Requires-Dist: patch
 Requires-Dist: diff_match_patch
 Requires-Dist: GitPython

{auto_coder-3.0.48 → auto_coder-3.0.50}/src/auto_coder.egg-info/SOURCES.txt

@@ -820,12 +820,21 @@ src/autocoder/terminal_core/task_runtime.py
 src/autocoder/terminal_core/tunnel_worker.py
 src/autocoder/terminal_v3/__init__.py
 src/autocoder/terminal_v3/app.py
+src/autocoder/terminal_v3/async_runner/__init__.py
+src/autocoder/terminal_v3/async_runner/async_executor.py
+src/autocoder/terminal_v3/async_runner/async_service.py
+src/autocoder/terminal_v3/async_runner/markdown_processor.py
+src/autocoder/terminal_v3/async_runner/stop_signals.py
+src/autocoder/terminal_v3/async_runner/task_metadata.py
+src/autocoder/terminal_v3/async_runner/worktree_manager.py
 src/autocoder/terminal_v3/handlers/__init__.py
 src/autocoder/terminal_v3/handlers/command_handler.py
 src/autocoder/terminal_v3/models/__init__.py
 src/autocoder/terminal_v3/models/conversation_buffer.py
 src/autocoder/terminal_v3/models/markdown_render.py
 src/autocoder/terminal_v3/models/message.py
+src/autocoder/terminal_v3/models/session_registry.py
+src/autocoder/terminal_v3/models/session_slot.py
 src/autocoder/terminal_v3/models/tool_display.py
 src/autocoder/terminal_v3/ui/__init__.py
 src/autocoder/terminal_v3/ui/keybindings.py
@@ -872,4 +881,12 @@ tests/test_args_parser.py
 tests/test_command_consistency.py
 tests/test_conf_completions.py
 tests/test_conf_global_shorthand.py
-tests/test_plugin_manager.py
+tests/test_deepseek_cache_billing.py
+tests/test_deepseek_cache_billing_real.py
+tests/test_llm_pricing_detailed.py
+tests/test_llm_usage_side_paths.py
+tests/test_model_pricing.py
+tests/test_plugin_manager.py
+tests/test_stream_chat_with_continue.py
+tests/test_terminal_usage_display.py
+tests/test_tiered_pricing.py

{auto_coder-3.0.48 → auto_coder-3.0.50}/src/auto_coder.egg-info/requires.txt

@@ -16,7 +16,7 @@ prompt-toolkit
 tokenizers
 aiofiles
 readerwriterlock
-byzerllm[saas]>=0.1.207
+byzerllm[saas]>=0.1.208
 patch
 diff_match_patch
 GitPython

{auto_coder-3.0.48 → auto_coder-3.0.50}/src/autocoder/agent/base_agentic/base_agent.py

@@ -10,6 +10,7 @@ from typing import List, Dict, Any, Union, Optional, Tuple, Type, Generator, Ite
 from rich.console import Console
 from rich.panel import Panel
 from loguru import logger
+from autocoder.common.llms.pricing import lookup_usage_field
 import byzerllm
 from pydantic import BaseModel
 
@@ -1409,26 +1410,120 @@ class BaseAgent(ABC):
                 elif isinstance(agent_event, TokenUsageEvent):
                     # 缓存模型价格信息
                     if not hasattr(self, "_cached_model_info"):
-                        model_name = ",".join(llms_utils.get_llm_names(self.llm))
-                        self._cached_model_info = (
-                            llms_utils.get_model_info(
-                                model_name, self.args.product_mode
+                        model_names = [
+                            name.strip()
+                            for raw_name in llms_utils.get_llm_names(self.llm)
+                            for name in raw_name.split(",")
+                            if name.strip()
+                        ]
+                        self._cached_model_name = ",".join(model_names)
+                        self._cached_model_info = {}
+                        for candidate_name in model_names or [self._cached_model_name]:
+                            model_info = (
+                                llms_utils.get_model_info(
+                                    candidate_name, self.args.product_mode
+                                )
+                                or {}
                             )
-                            or {}
-                        )
-                        self._cached_model_name = model_name
-
-                    # 获取价格
-                    input_price = self._cached_model_info.get("input_price", 0.0)
-                    output_price = self._cached_model_info.get("output_price", 0.0)
+                            if model_info:
+                                self._cached_model_name = candidate_name
+                                self._cached_model_info = model_info
+                                break
 
                     # 计算成本
                     last_meta = agent_event.usage
-                    input_tokens = max(last_meta.input_tokens_count, 0)
-                    output_tokens = max(last_meta.generated_tokens_count, 0)
+                    def _usage_int(*keys: str, default: int = 0) -> int:
+                        for key in keys:
+                            value = lookup_usage_field(last_meta, key)
+                            if value is None:
+                                continue
+                            try:
+                                return max(int(value), 0)
+                            except (TypeError, ValueError):
+                                continue
+                        return default
+
+                    def _usage_float(*keys: str, default: float = 0.0) -> float:
+                        for key in keys:
+                            value = lookup_usage_field(last_meta, key)
+                            if value is None:
+                                continue
+                            try:
+                                return float(value)
+                            except (TypeError, ValueError):
+                                continue
+                        return default
+
+                    input_tokens = _usage_int(
+                        "input_tokens_count",
+                        "input_tokens",
+                        "prompt_tokens",
+                    )
+                    output_tokens = _usage_int(
+                        "generated_tokens_count",
+                        "output_tokens",
+                        "completion_tokens",
+                    )
+                    cache_creation_input_tokens = _usage_int(
+                        "cache_creation_input_tokens",
+                        "cache_creation_tokens",
+                    )
+                    cache_read_input_tokens = _usage_int(
+                        "cache_read_input_tokens",
+                        "cache_read_tokens",
+                        "prompt_cached_tokens",
+                        "cached_tokens",
+                    )
+                    reasoning_tokens = _usage_int("reasoning_tokens")
+                    billable_output_tokens = max(output_tokens - reasoning_tokens, 0)
 
-                    input_cost = (input_tokens * input_price) / 1000000  # 转换为百万
-                    output_cost = (output_tokens * output_price) / 1000000
+                    input_cost = 0.0
+                    output_cost = 0.0
+                    cache_read_cost = 0.0
+                    cache_creation_cost = 0.0
+                    reasoning_cost = 0.0
+                    total_cost = 0.0
+
+                    if self._cached_model_info:
+                        from autocoder.common.llms.manager import LLMManager
+
+                        cost_detail = LLMManager().calculate_detailed_cost(
+                            self._cached_model_name, last_meta
+                        )
+                        if cost_detail:
+                            input_cost = cost_detail.input_cost
+                            output_cost = cost_detail.output_cost
+                            cache_read_cost = cost_detail.cache_read_cost
+                            cache_creation_cost = cost_detail.cache_creation_cost
+                            reasoning_cost = cost_detail.reasoning_cost
+                            total_cost = cost_detail.total_cost
+                        else:
+                            input_price = self._cached_model_info.get("input_price", 0.0)
+                            output_price = self._cached_model_info.get("output_price", 0.0)
+                            input_cost = (input_tokens * input_price) / 1000000
+                            output_cost = (billable_output_tokens * output_price) / 1000000
+                            reasoning_price = self._cached_model_info.get(
+                                "reasoning_price", output_price
+                            )
+                            reasoning_cost = (
+                                reasoning_tokens * reasoning_price
+                            ) / 1000000
+                            total_cost = input_cost + output_cost + reasoning_cost
+                    else:
+                        input_cost = _usage_float("input_cost", "prompt_cost")
+                        output_cost = _usage_float("output_cost", "completion_cost")
+                        cache_read_cost = _usage_float("cache_read_cost")
+                        cache_creation_cost = _usage_float("cache_creation_cost")
+                        reasoning_cost = _usage_float("reasoning_cost")
+                        total_cost = _usage_float("total_cost")
+                        if total_cost == 0.0:
+                            total_cost = (
+                                input_cost
+                                + output_cost
+                                + cache_read_cost
+                                + cache_creation_cost
+                                + reasoning_cost
+                            )
 
                     # 预测总成本
                     if not hasattr(self, "_total_input_tokens"):
@@ -1436,22 +1531,37 @@ class BaseAgent(ABC):
                         self._total_output_tokens = 0
                         self._total_input_cost = 0.0
                         self._total_output_cost = 0.0
+                        self._total_cache_read_cost = 0.0
+                        self._total_cache_creation_cost = 0.0
+                        self._total_reasoning_cost = 0.0
+                        self._total_total_cost = 0.0
 
                     self._total_input_tokens += input_tokens
                     self._total_output_tokens += output_tokens
                     self._total_input_cost += input_cost
                     self._total_output_cost += output_cost
+                    self._total_cache_read_cost += cache_read_cost
+                    self._total_cache_creation_cost += cache_creation_cost
+                    self._total_reasoning_cost += reasoning_cost
+                    self._total_total_cost += total_cost
 
                     # 记录详细Token使用情况
                     logger.info(
                         f"Token Usage Details:\n"
                         f"- Model: {self._cached_model_name}\n"
-                        f"- Input: {input_tokens} tokens (${input_cost:.6f})\n"
-                        f"- Output: {output_tokens} tokens (${output_cost:.6f})\n"
+                        f"- Input: {input_tokens} tokens (¥{input_cost:.6f})\n"
+                        f"- Cache Read: {cache_read_input_tokens} tokens (¥{cache_read_cost:.6f})\n"
+                        f"- Cache Creation: {cache_creation_input_tokens} tokens (¥{cache_creation_cost:.6f})\n"
+                        f"- Output: {billable_output_tokens} tokens (¥{output_cost:.6f})\n"
+                        f"- Reasoning: {reasoning_tokens} tokens (¥{reasoning_cost:.6f})\n"
                         f"- Running Totals:\n"
-                        f"  - Input: {self._total_input_tokens} tokens (${self._total_input_cost:.6f})\n"
-                        f"  - Output: {self._total_output_tokens} tokens (${self._total_output_cost:.6f})\n"
-                        f"- Estimated Final Cost: ${(self._total_input_cost + self._total_output_cost) * 1.2:.6f} (with 20% buffer)"
+                        f"  - Input: {self._total_input_tokens} tokens (¥{self._total_input_cost:.6f})\n"
+                        f"  - Output: {self._total_output_tokens} tokens (¥{self._total_output_cost:.6f})\n"
+                        f"  - Cache Read: ¥{self._total_cache_read_cost:.6f}\n"
+                        f"  - Cache Creation: ¥{self._total_cache_creation_cost:.6f}\n"
+                        f"  - Reasoning: ¥{self._total_reasoning_cost:.6f}\n"
+                        f"  - Total: ¥{self._total_total_cost:.6f}\n"
+                        f"- Estimated Final Cost: ¥{self._total_total_cost * 1.2:.6f} (with 20% buffer)"
                     )
 
                     # 写入Token统计事件
@@ -1460,11 +1570,18 @@ class BaseAgent(ABC):
                             content=EventContentCreator.ResultTokenStatContent(
                                 model_name=model_name,
                                 elapsed_time=0.0,
-                                first_token_time=last_meta.first_token_time,
-                                input_tokens=last_meta.input_tokens_count,
-                                output_tokens=last_meta.generated_tokens_count,
+                                first_token_time=_usage_float("first_token_time"),
+                                input_tokens=input_tokens,
+                                output_tokens=output_tokens,
+                                cache_creation_input_tokens=cache_creation_input_tokens,
+                                cache_read_input_tokens=cache_read_input_tokens,
+                                reasoning_tokens=reasoning_tokens,
                                 input_cost=input_cost,
                                 output_cost=output_cost,
+                                cache_read_cost=cache_read_cost,
+                                cache_creation_cost=cache_creation_cost,
+                                reasoning_cost=reasoning_cost,
+                                total_cost=total_cost,
                             ).to_dict()
                         ),
                         metadata=metadata.to_dict(),

{auto_coder-3.0.48 → auto_coder-3.0.50}/src/autocoder/auto_coder_terminal_v3.py

@@ -38,17 +38,21 @@ from autocoder.auto_coder_runner import (
 V3_COMMANDS = [
     "/async",
     "/auto",
+    "/bg",
     "/clear",
     "/commit",
     "/conf",
     "/connect",
     "/exit",
     "/fast",
+    "/fork",
     "/help",
     "/memory",
     "/models",
     "/new",
+    "/refresh",
     "/rules",
+    "/sessions",
     "/status",
     "/tunnel",
     "/workflow",
@@ -92,6 +96,17 @@ def parse_arguments():
     )
     parser.add_argument("--lite", action="store_true", help="Lite mode")
     parser.add_argument("--pro", action="store_true", help="Pro mode")
+    parser.add_argument(
+        "--display-session-cost",
+        type=str,
+        default=None,
+        choices=["CNY", "USD", "NONE", "HIDE"],
+        help=(
+            "Whether to display the session cost in the status bar, and which "
+            "currency to use. CNY shows ¥, USD shows $, NONE/HIDE hides the cost. "
+            "If not provided, the cost is hidden by default."
+        ),
+    )
 
     from autocoder.terminal_core.cloud_config import (
         DEFAULT_BASE_URL,
@@ -298,6 +313,7 @@ async def async_main():
         startup_logs=startup_logs,
         debug=args.debug,
         cloud_bridge=cloud_bridge,
+        display_session_cost=args.display_session_cost,
     )
     try:
         await chat_app.run()

{auto_coder-3.0.48 → auto_coder-3.0.50}/src/autocoder/chat/models_command.py

@@ -48,6 +48,10 @@ def handle_models_command(query: str):
         subcmd = "/add_provider"
         query = query.replace("/add_provider", "", 1).strip()
 
+    if "/fork" in query:
+        subcmd = "/fork"
+        query = query.replace("/fork", "", 1).strip()
+
     if "/remove" in query:
         subcmd = "/remove"
         query = query.replace("/remove", "", 1).strip()
@@ -439,6 +443,50 @@ def handle_models_command(query: str):
             meta={"action": "models", "input": {"query": query}},
         )
 
+    elif subcmd == "/fork":
+        args = query.strip().split()
+        if len(args) < 2:
+            message = "Usage: /models /fork <name> <new_name>"
+            printer.print_str_in_terminal(message, style="red")
+            result_manager.add_result(
+                content=message,
+                meta={"action": "models", "input": {"query": query}},
+            )
+            return
+
+        name, new_name = args[0], args[1]
+        if not llm_manager.check_model_exists(name):
+            message = f"Model not found: {name}"
+            printer.print_str_in_terminal(message, style="red")
+            result_manager.add_result(
+                content=message,
+                meta={"action": "models", "input": {"query": query}},
+            )
+            return
+        if llm_manager.check_model_exists(new_name):
+            message = f"Model already exists: {new_name}"
+            printer.print_str_in_terminal(message, style="yellow")
+            result_manager.add_result(
+                content=message,
+                meta={"action": "models", "input": {"query": query}},
+            )
+            return
+
+        forked = llm_manager.fork_model(name, new_name)
+        if forked:
+            message = (
+                f"Forked model {name} -> {new_name}\n"
+                f"Use /models {new_name} <api_key> to configure its API key."
+            )
+            printer.print_str_in_terminal(message, style="green")
+        else:
+            message = f"Failed to fork model: {name} -> {new_name}"
+            printer.print_str_in_terminal(message, style="red")
+        result_manager.add_result(
+            content=message,
+            meta={"action": "models", "input": {"query": query}},
+        )
+
     elif subcmd == "/remove":
         args = query.strip().split(" ")
         if len(args) < 1:

{auto_coder-3.0.48 → auto_coder-3.0.50}/src/autocoder/common/__init__.py

@@ -288,6 +288,7 @@ class AutoCoderArgs(pydantic.BaseModel):
     enable_agentic_dangerous_command_check: bool = False
     enable_display_agentic_reasoning_content: bool = True
     enable_agentic_interleaving_thinking: bool = True
+    enable_subagent_orchestration: bool = False
 
     enable_agentic_replace_ask_followup_question_with_attempt_completion: bool = True
 

{auto_coder-3.0.48 → auto_coder-3.0.50}/src/autocoder/common/code_auto_generate.py

@@ -282,10 +282,9 @@ class CodeAutoGenerate:
                                         "stream_out_type": CodeGenerateStreamOutType.CODE_GENERATE.value
                                     },
                                 )
-                                return ChatWithContinueResult(
+                                return ChatWithContinueResult.from_metadata(
                                     content=full_response,
-                                    input_tokens_count=last_meta.input_tokens_count,
-                                    generated_tokens_count=last_meta.generated_tokens_count,
+                                    metadata=last_meta,
                                 )
 
                             futures.append(executor.submit(job))

{auto_coder-3.0.48 → auto_coder-3.0.50}/src/autocoder/common/code_auto_generate_diff.py

@@ -493,10 +493,9 @@ class CodeAutoGenerateDiff:
                                         "stream_out_type": CodeGenerateStreamOutType.CODE_GENERATE.value
                                     },
                                 )
-                                return ChatWithContinueResult(
+                                return ChatWithContinueResult.from_metadata(
                                     content=full_response,
-                                    input_tokens_count=last_meta.input_tokens_count,
-                                    generated_tokens_count=last_meta.generated_tokens_count,
+                                    metadata=last_meta,
                                 )
 
                             futures.append(executor.submit(job))

{auto_coder-3.0.48 → auto_coder-3.0.50}/src/autocoder/common/code_auto_generate_editblock.py

@@ -603,10 +603,9 @@ class CodeAutoGenerateEditBlock:
                                         "stream_out_type": CodeGenerateStreamOutType.CODE_GENERATE.value
                                     },
                                 )
-                                return ChatWithContinueResult(
+                                return ChatWithContinueResult.from_metadata(
                                     content=full_response,
-                                    input_tokens_count=last_meta.input_tokens_count,
-                                    generated_tokens_count=last_meta.generated_tokens_count,
+                                    metadata=last_meta,
                                 )
 
                             futures.append(executor.submit(job))

{auto_coder-3.0.48 → auto_coder-3.0.50}/src/autocoder/common/code_auto_generate_strict_diff.py

@@ -469,10 +469,9 @@ class CodeAutoGenerateStrictDiff:
                                             "stream_out_type": CodeGenerateStreamOutType.CODE_GENERATE.value
                                         },
                                     )
-                                    return ChatWithContinueResult(
+                                    return ChatWithContinueResult.from_metadata(
                                         content=full_response,
-                                        input_tokens_count=last_meta.input_tokens_count,
-                                        generated_tokens_count=last_meta.generated_tokens_count,
+                                        metadata=last_meta,
                                     )
 
                                 futures.append(executor.submit(job))

{auto_coder-3.0.48 → auto_coder-3.0.50}/src/autocoder/common/conf_validator.py

@@ -154,6 +154,11 @@ class ConfigValidator:
             "type": bool,
             "default": True,
             "description": "是否展示 reasoning 流式内容,关闭后只显示 ◇ Reasoning... 指示器,不渲染思考文本"
+        },
+        "enable_subagent_orchestration": {
+            "type": bool,
+            "default": False,
+            "description": "是否在 V3 /auto 中注入 subagent 调度规则"
         }
     }