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

{auto_coder-3.0.49/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.49
+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.49 → auto_coder-3.0.50}/pyproject.toml

@@ -5,7 +5,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "auto-coder"
-version = "3.0.49"
+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.49 → 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.49 → 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.49
+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.49 → auto_coder-3.0.50}/src/auto_coder.egg-info/SOURCES.txt

@@ -881,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.49 → 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.49 → 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.49 → auto_coder-3.0.50}/src/autocoder/auto_coder_terminal_v3.py

@@ -96,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,
@@ -302,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.49 → 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.49 → 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.49 → 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.49 → 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.49 → auto_coder-3.0.50}/src/autocoder/common/conversations/llm_stats_models.py

@@ -7,6 +7,12 @@ from pydantic import BaseModel, Field, ConfigDict
 import time
 from loguru import logger
 
+from autocoder.common.llms.pricing import lookup_usage_field
+
+
+def _is_simple_scalar(value: Any) -> bool:
+    return isinstance(value, (int, float, str, bool, type(None)))
+
 
 class LLMUsageStats(BaseModel):
     """LLM 使用统计信息模型"""
@@ -18,10 +24,14 @@ class LLMUsageStats(BaseModel):
     # 缓存相关信息
     cache_creation_input_tokens: Optional[int] = Field(default=None, description="缓存创建输入token数量")
     cache_read_input_tokens: Optional[int] = Field(default=None, description="缓存读取输入token数量")
+    reasoning_tokens: Optional[int] = Field(default=None, description="推理token数量")
     
     # 成本信息
     input_cost: Optional[float] = Field(default=None, description="输入成本")
     output_cost: Optional[float] = Field(default=None, description="输出成本")
+    cache_creation_cost: Optional[float] = Field(default=None, description="缓存创建成本")
+    cache_read_cost: Optional[float] = Field(default=None, description="缓存读取成本")
+    reasoning_cost: Optional[float] = Field(default=None, description="推理成本")
     total_cost: Optional[float] = Field(default=None, description="总成本")
     
     # 模型信息
@@ -95,8 +105,23 @@ class LLMCallMetadata(BaseModel):
         usage_data = None
         if "usage" in raw_metadata:
             usage_data = raw_metadata["usage"]
-        elif any(key in raw_metadata for key in ["prompt_tokens", "completion_tokens", "input_tokens", "output_tokens", "total_tokens", 
-                                                "input_tokens_count", "generated_tokens_count", "total_tokens_count"]):
+        elif any(
+            lookup_usage_field(raw_metadata, key) is not None
+            for key in [
+                "prompt_tokens",
+                "completion_tokens",
+                "input_tokens",
+                "output_tokens",
+                "total_tokens",
+                "input_tokens_count",
+                "generated_tokens_count",
+                "total_tokens_count",
+                "cache_creation_input_tokens",
+                "cache_read_input_tokens",
+                "prompt_cached_tokens",
+                "reasoning_tokens",
+            ]
+        ):
             # 如果直接包含使用统计字段，则使用 raw_metadata 本身
             usage_data = raw_metadata
         
@@ -117,12 +142,9 @@ class LLMCallMetadata(BaseModel):
     def _extract_usage_stats(cls, usage_data: Union[Dict[str, Any], object], raw_metadata: Dict[str, Any]) -> Optional[LLMUsageStats]:
         """从usage数据中提取统计信息，支持dict和对象两种形态"""
         def safe_get(data, *keys):
-            """安全获取值，支持dict和对象属性访问"""
+            """安全获取值，支持 dict / 对象 / extra_info。"""
             for key in keys:
-                if isinstance(data, dict):
-                    value = data.get(key)
-                else:
-                    value = getattr(data, key, None)
+                value = lookup_usage_field(data, key)
                 # 检查值是否有效（不是Mock对象或其他无效类型）
                 if value is not None and not str(type(value)).startswith("<class 'unittest.mock."):
                     # 验证基本数据类型
@@ -146,17 +168,60 @@ class LLMCallMetadata(BaseModel):
         
         # 提取缓存相关token数量 (支持多种字段名变体)
         cache_creation_input_tokens = safe_get(usage_data, "cache_creation_input_tokens", "cache_creation_tokens")
-        cache_read_input_tokens = safe_get(usage_data, "cache_read_input_tokens", "cache_read_tokens")
+        cache_read_input_tokens = safe_get(
+            usage_data,
+            "cache_read_input_tokens",
+            "cache_read_tokens",
+            "prompt_cached_tokens",
+        )
+        reasoning_tokens = safe_get(usage_data, "reasoning_tokens")
+        
+        # 标准化input_tokens: 永远只包含非缓存输入token，避免重复计数
+        # - Anthropic原生格式: input_tokens原本就是非缓存的，无需修改
+        # - OpenAI兼容格式(如TaoToken网关): prompt_tokens已经包含缓存token，需要减去缓存部分得到纯非缓存输入
+        if input_tokens is not None:
+            cache_total = (cache_creation_input_tokens or 0) + (cache_read_input_tokens or 0)
+            if cache_total > 0 and input_tokens >= cache_total:
+                input_tokens = input_tokens - cache_total
         
         # 提取成本信息
         input_cost = safe_get(usage_data, "input_cost", "prompt_cost")
         output_cost = safe_get(usage_data, "output_cost", "completion_cost")
+        cache_creation_cost = safe_get(usage_data, "cache_creation_cost")
+        cache_read_cost = safe_get(usage_data, "cache_read_cost")
+        reasoning_cost = safe_get(usage_data, "reasoning_cost")
         total_cost = safe_get(usage_data, "total_cost")
-        if total_cost is None and input_cost is not None and output_cost is not None:
-            total_cost = input_cost + output_cost
+        if total_cost is None:
+            known_costs = [
+                cost
+                for cost in [
+                    input_cost,
+                    output_cost,
+                    cache_creation_cost,
+                    cache_read_cost,
+                    reasoning_cost,
+                ]
+                if cost is not None
+            ]
+            if known_costs:
+                total_cost = sum(known_costs)
         
         # 提取时间信息
         duration_ms = safe_get(usage_data, "duration_ms", "duration", "response_time_ms")
+
+        if total_tokens is None:
+            total_tokens_parts = [
+                value
+                for value in [
+                    input_tokens,
+                    cache_creation_input_tokens,
+                    cache_read_input_tokens,
+                    output_tokens,
+                ]
+                if value is not None
+            ]
+            if total_tokens_parts:
+                total_tokens = sum(total_tokens_parts)
         
         # 如果没有任何有效的token信息，返回None
         if input_tokens is None and output_tokens is None and total_tokens is None:
@@ -168,8 +233,12 @@ class LLMCallMetadata(BaseModel):
             total_tokens=total_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_creation_cost=cache_creation_cost,
+            cache_read_cost=cache_read_cost,
+            reasoning_cost=reasoning_cost,
             total_cost=total_cost,
             model_name=model_name,
             duration_ms=duration_ms
@@ -178,15 +247,28 @@ class LLMCallMetadata(BaseModel):
     @classmethod
     def _extract_cache_info(cls, raw_metadata: Dict[str, Any]) -> Optional[LLMCacheInfo]:
         """从原始元数据中提取缓存信息"""
-        # 检查是否有缓存相关字段
-        cache_keys = [key for key in raw_metadata.keys() if key.startswith("cache")]
-        if not cache_keys:
+        if not any(
+            lookup_usage_field(raw_metadata, key) is not None
+            for key in [
+                "cache_hit",
+                "is_cache_hit",
+                "cache_type",
+                "cache_provider",
+                "cache_key",
+                "cache_id",
+                "cache_creation_input_tokens",
+                "cache_creation_tokens",
+                "cache_read_input_tokens",
+                "cache_read_tokens",
+                "prompt_cached_tokens",
+            ]
+        ):
             return None
         
         def safe_get(data, *keys):
             """安全获取值"""
             for key in keys:
-                value = data.get(key) if isinstance(data, dict) else getattr(data, key, None)
+                value = lookup_usage_field(data, key)
                 if value is not None:
                     return value
             return None
@@ -196,7 +278,12 @@ class LLMCallMetadata(BaseModel):
         cache_type = safe_get(raw_metadata, "cache_type", "cache_provider")
         cache_key = safe_get(raw_metadata, "cache_key", "cache_id")
         cache_creation_input_tokens = safe_get(raw_metadata, "cache_creation_input_tokens", "cache_creation_tokens")
-        cache_read_input_tokens = safe_get(raw_metadata, "cache_read_input_tokens", "cache_read_tokens")
+        cache_read_input_tokens = safe_get(
+            raw_metadata,
+            "cache_read_input_tokens",
+            "cache_read_tokens",
+            "prompt_cached_tokens",
+        )
         
         return LLMCacheInfo(
             cache_hit=cache_hit,
@@ -233,6 +320,12 @@ def create_llm_metadata_from_token_usage_event(
         if not isinstance(usage_data, dict):
             # 尝试将对象转换为dict
             raw_metadata = {}
+            extra_info = getattr(usage_data, "extra_info", None)
+            if isinstance(extra_info, dict):
+                raw_metadata["extra_info"] = dict(extra_info)
+                for key, value in extra_info.items():
+                    if _is_simple_scalar(value):
+                        raw_metadata[key] = value
             
             # 获取对象的所有属性
             for attr_name in dir(usage_data):
@@ -240,12 +333,12 @@ def create_llm_metadata_from_token_usage_event(
                     try:
                         attr_value = getattr(usage_data, attr_name)
                         # 只保存基本数据类型
-                        if isinstance(attr_value, (int, float, str, bool, type(None))):
+                        if _is_simple_scalar(attr_value):
                             raw_metadata[attr_name] = attr_value
                     except Exception:
                         continue  # 跳过无法访问的属性
         else:
-            raw_metadata = usage_data
+            raw_metadata = dict(usage_data)
         
         # 如果还有其他有用的属性，也加入到metadata中
         if hasattr(token_usage_event, 'model'):

{auto_coder-3.0.49 → auto_coder-3.0.50}/src/autocoder/common/conversations/storage/index_manager.py

@@ -45,7 +45,7 @@ class IndexManager:
                     self._index_data = json.load(f)
             else:
                 self._index_data = {}
-        except (json.JSONDecodeError, OSError, IOError):
+        except (json.JSONDecodeError, UnicodeDecodeError, OSError, IOError):
             # 如果索引损坏，重建空索引
             self._index_data = {}
     
@@ -57,7 +57,7 @@ class IndexManager:
                     self._config_data = json.load(f)
             else:
                 self._config_data = {}
-        except (json.JSONDecodeError, OSError, IOError):
+        except (json.JSONDecodeError, UnicodeDecodeError, OSError, IOError):
             # 如果配置损坏，重建空配置
             self._config_data = {}