auto-coder 0.1.255__tar.gz → 0.1.256__tar.gz

{auto_coder-0.1.255 → auto_coder-0.1.256}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: auto-coder
-Version: 0.1.255
+Version: 0.1.256
 Summary: AutoCoder: AutoCoder
 Author: allwefantasy
 Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
@@ -26,7 +26,7 @@ Requires-Dist: tabulate
 Requires-Dist: jupyter_client
 Requires-Dist: prompt-toolkit
 Requires-Dist: tokenizers
-Requires-Dist: byzerllm[saas]>=0.1.163
+Requires-Dist: byzerllm[saas]>=0.1.164
 Requires-Dist: patch
 Requires-Dist: diff_match_patch
 Requires-Dist: GitPython

{auto_coder-0.1.255 → auto_coder-0.1.256}/src/auto_coder.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: auto-coder
-Version: 0.1.255
+Version: 0.1.256
 Summary: AutoCoder: AutoCoder
 Author: allwefantasy
 Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
@@ -26,7 +26,7 @@ Requires-Dist: tabulate
 Requires-Dist: jupyter_client
 Requires-Dist: prompt-toolkit
 Requires-Dist: tokenizers
-Requires-Dist: byzerllm[saas]>=0.1.163
+Requires-Dist: byzerllm[saas]>=0.1.164
 Requires-Dist: patch
 Requires-Dist: diff_match_patch
 Requires-Dist: GitPython

{auto_coder-0.1.255 → auto_coder-0.1.256}/src/auto_coder.egg-info/requires.txt

@@ -16,7 +16,7 @@ tabulate
 jupyter_client
 prompt-toolkit
 tokenizers
-byzerllm[saas]>=0.1.163
+byzerllm[saas]>=0.1.164
 patch
 diff_match_patch
 GitPython

{auto_coder-0.1.255 → auto_coder-0.1.256}/src/autocoder/auto_coder.py

@@ -1389,11 +1389,25 @@ def main(input_args: Optional[List[str]] = None):
                 elapsed_time = time.time() - start_time
                 printer = Printer()
                 speed = last_meta.generated_tokens_count / elapsed_time
+                
+                # Get model info for pricing
+                from autocoder.utils import llms as llm_utils
+                model_info = llm_utils.get_model_info(model_name, args.product_mode) or {}
+                input_price = model_info.get("input_price", 0.0) if model_info else 0.0
+                output_price = model_info.get("output_price", 0.0) if model_info else 0.0
+                
+                # Calculate costs
+                input_cost = (last_meta.input_tokens_count * input_price) / 1000000  # Convert to millions
+                output_cost = (last_meta.generated_tokens_count * output_price) / 1000000  # Convert to millions
+                
                 printer.print_in_terminal("stream_out_stats", 
+                                    model_name=model_name,
                                     elapsed_time=elapsed_time,
                                     first_token_time=last_meta.first_token_time,
                                     input_tokens=last_meta.input_tokens_count,
                                     output_tokens=last_meta.generated_tokens_count,
+                                    input_cost=round(input_cost, 4),
+                                    output_cost=round(output_cost, 4),
                                     speed=round(speed, 2))
             
             chat_history["ask_conversation"].append(

{auto_coder-0.1.255 → auto_coder-0.1.256}/src/autocoder/common/auto_coder_lang.py

@@ -57,7 +57,7 @@ MESSAGES = {
             "Paste the answer to the input box below, use '/break' to exit, '/clear' to clear the screen, '/eof' to submit."
         ),
         "code_generation_start": "Auto generate the code...",
-        "code_generation_complete": "Code generation completed in {{ duration }} seconds, input_tokens_count: {{ input_tokens }}, generated_tokens_count: {{ output_tokens }}, speed: {{ speed }} tokens/s",
+        "code_generation_complete": "{{ model_names}} Code generation completed in {{ duration }} seconds, input_tokens_count: {{ input_tokens }}, generated_tokens_count: {{ output_tokens }}, input_cost: {{ input_cost }}, output_cost: {{ output_cost }}, speed: {{ speed }} tokens/s",
         "code_merge_start": "Auto merge the code...",
         "code_execution_warning": "Content(send to model) is {{ content_length }} tokens (you may collect too much files), which is larger than the maximum input length {{ max_length }}",
         "quick_filter_start": "{{ model_name }} Starting filter context(quick_filter)...",
@@ -75,12 +75,12 @@ MESSAGES = {
         "ranking_start": "Start ranking {{ count }} candidates using model {{ model_name }}",
         "ranking_failed_request": "Ranking request failed: {{ error }}",
         "ranking_all_failed": "All ranking requests failed",
-        "ranking_complete": "Ranking completed in {{ elapsed }}s, total voters: {{ total_tasks }}, best candidate index: {{ best_candidate }}, scores: {{ scores }}, input_tokens: {{ input_tokens }}, output_tokens: {{ output_tokens }}",
+        "ranking_complete": "{{ model_names }} Ranking completed in {{ elapsed }}s, total voters: {{ total_tasks }}, best candidate index: {{ best_candidate }}, scores: {{ scores }}, input_tokens: {{ input_tokens }}, output_tokens: {{ output_tokens }}, input_cost: {{ input_cost }}, output_cost: {{ output_cost }}",
         "ranking_process_failed": "Ranking process failed: {{ error }}",
         "ranking_failed": "Ranking failed in {{ elapsed }}s, using original order",
         "begin_index_source_code": "🚀 Begin to index source code in {{ source_dir }}",
-        "stream_out_stats": "Elapsed time {{ elapsed_time }} seconds, first token time: {{ first_token_time }} seconds, input tokens: {{ input_tokens }}, output tokens: {{ output_tokens }}, speed: {{ speed }} tokens/s",
-        "quick_filter_stats": "快速过滤器完成，耗时 {{ elapsed_time }} 秒，输入token数: {{ input_tokens }}, 输出token数: {{ output_tokens }}",
+        "stream_out_stats": "Model: {{ model_name }}, Total time: {{ elapsed_time }} seconds, First token time: {{ first_token_time }} seconds, Speed: {{ speed }} tokens/s, Input tokens: {{ input_tokens }}, Output tokens: {{ output_tokens }}, Input cost: {{ input_cost }}, Output cost: {{ output_cost }}",
+        "quick_filter_stats": "{{ model_names }} 快速过滤器完成，耗时 {{ elapsed_time }} 秒，输入token数: {{ input_tokens }}, 输出token数: {{ output_tokens }}, 输入成本: {{ input_cost }}, 输出成本: {{ output_cost }}",
         "upsert_file": "✅ Updated file: {{ file_path }}",  
         "unmerged_blocks_title": "Unmerged Blocks",
         "quick_filter_title": "{{ model_name }} is analyzing how to filter context...",
@@ -150,7 +150,7 @@ MESSAGES = {
             "将获得答案黏贴到下面的输入框，换行后，使用 '/break' 退出，'/clear' 清屏，'/eof' 提交。"
         ),
         "code_generation_start": "正在自动生成代码...",
-        "code_generation_complete": "代码生成完成，耗时 {{ duration }} 秒，输入token数: {{ input_tokens }}, 输出token数: {{ output_tokens }}, 速度: {{ speed }} tokens/秒",
+        "code_generation_complete": "{{ model_names}} 代码生成完成，耗时 {{ duration }} 秒，输入token数: {{ input_tokens }}, 输出token数: {{ output_tokens }}, 输入成本: {{ input_cost }}, 输出成本: {{ output_cost }}, 速度: {{ speed }} tokens/秒",
         "code_merge_start": "正在自动合并代码...",
         "code_execution_warning": "发送给模型的内容长度为 {{ content_length }} tokens（您可能收集了太多文件），超过了最大输入长度 {{ max_length }}",
         "quick_filter_start": "{{ model_name }} 开始查找上下文(quick_filter)...",
@@ -179,11 +179,11 @@ MESSAGES = {
         "ranking_start": "开始对 {{ count }} 个候选项进行排序,使用模型 {{ model_name }} 打分",
         "ranking_failed_request": "排序请求失败: {{ error }}",
         "ranking_all_failed": "所有排序请求都失败",
-        "ranking_complete": "排序完成，耗时 {{ elapsed }} 秒，总投票数: {{ total_tasks }}，最佳候选索引: {{ best_candidate }}，得分: {{ scores }}，输入token数: {{ input_tokens }}，输出token数: {{ output_tokens }}",
+        "ranking_complete": "{{ model_names }} 排序完成，耗时 {{ elapsed }} 秒，总投票数: {{ total_tasks }}，最佳候选索引: {{ best_candidate }}，得分: {{ scores }}，输入token数: {{ input_tokens }}，输出token数: {{ output_tokens }}  输入成本: {{ input_cost }}, 输出成本: {{ output_cost }}",
         "ranking_process_failed": "排序过程失败: {{ error }}",
         "ranking_failed": "排序失败，耗时 {{ elapsed }} 秒，使用原始顺序",
-        "stream_out_stats": "总耗时 {{ elapsed_time }} 秒，首token时间: {{ first_token_time }} 秒，输入token数: {{ input_tokens }}, 输出token数: {{ output_tokens }}, 速度: {{ speed }} tokens/秒",
-        "quick_filter_stats": "Quick filter completed in {{ elapsed_time }} seconds, input tokens: {{ input_tokens }}, output tokens: {{ output_tokens }}",
+        "stream_out_stats": "模型: {{ model_name }},总耗时 {{ elapsed_time }} 秒,首token时间: {{ first_token_time }} 秒, 速度: {{ speed }} tokens/秒, 输入token数: {{ input_tokens }}, 输出token数: {{ output_tokens }}, 输入成本: {{ input_cost }}, 输出成本: {{ output_cost }}",
+        "quick_filter_stats": "{{ model_names }} Quick filter completed in {{ elapsed_time }} seconds, input tokens: {{ input_tokens }}, output tokens: {{ output_tokens }}, input cost: {{ input_cost }}, output cost: {{ output_cost }}",
         "quick_filter_title": "{{ model_name }} 正在分析如何筛选上下文...",
         "quick_filter_failed": "❌ 快速过滤器失败: {{ error }}. ",
         "estimated_chat_input_tokens": "对话输入token预估为: {{ estimated_input_tokens }}",

{auto_coder-0.1.255 → auto_coder-0.1.256}/src/autocoder/common/code_auto_generate.py

@@ -10,6 +10,7 @@ from autocoder.common.utils_code_auto_generate import chat_with_continue
 import json
 from autocoder.common.printer import Printer
 from autocoder.rag.token_counter import count_tokens
+from autocoder.utils import llms as llm_utils
 
 
 class CodeAutoGenerate:
@@ -193,6 +194,9 @@ class CodeAutoGenerate:
         results = []
         input_tokens_count = 0
         generated_tokens_count = 0
+        input_tokens_cost = 0
+        generated_tokens_cost = 0
+        model_names = []
 
         printer = Printer()
         estimated_input_tokens = count_tokens(json.dumps(conversations, ensure_ascii=False))
@@ -206,13 +210,27 @@ class CodeAutoGenerate:
                 futures = []
                 for llm in self.llms:
                     for _ in range(self.generate_times_same_model):
-                        futures.append(executor.submit(
-                            chat_with_continue, llm=llm, conversations=conversations, llm_config=llm_config))
+                        
+                        model_names_list = llm_utils.get_llm_names(llm)
+                        model_name = None
+                        if model_names_list:
+                            model_name = model_names_list[0]                                                    
+                        
+                        for _ in range(self.generate_times_same_model):
+                            model_names.append(model_name)
+                            futures.append(executor.submit(
+                                chat_with_continue, llm=llm, conversations=conversations, llm_config=llm_config))
+                            
                 temp_results = [future.result() for future in futures]
                 for result in temp_results:
                     results.append(result.content)
                     input_tokens_count += result.input_tokens_count
                     generated_tokens_count += result.generated_tokens_count
+                    model_info = llm_utils.get_model_info(model_name, self.args.product_mode)
+                    input_cost = model_info.get("input_price", 0) if model_info else 0
+                    output_cost = model_info.get("output_price", 0) if model_info else 0
+                    input_tokens_cost += input_cost * result.input_tokens_count / 1000000
+                    generated_tokens_cost += output_cost * result.generated_tokens_count / 1000000
             
             for result in results:
                 conversations_list.append(
@@ -227,7 +245,9 @@ class CodeAutoGenerate:
         
         statistics = {
             "input_tokens_count": input_tokens_count,
-            "generated_tokens_count": generated_tokens_count
+            "generated_tokens_count": generated_tokens_count,
+            "input_tokens_cost": input_tokens_cost,
+            "generated_tokens_cost": generated_tokens_cost
         }        
     
         if self.args.request_id and not self.args.skip_events:

{auto_coder-0.1.255 → auto_coder-0.1.256}/src/autocoder/common/code_auto_generate_diff.py

@@ -9,6 +9,7 @@ import json
 from autocoder.common.utils_code_auto_generate import chat_with_continue
 from autocoder.common.printer import Printer
 from autocoder.rag.token_counter import count_tokens
+from autocoder.utils import llms as llm_utils
 
 
 class CodeAutoGenerateDiff:
@@ -341,6 +342,9 @@ class CodeAutoGenerateDiff:
         results = []
         input_tokens_count = 0
         generated_tokens_count = 0
+        input_tokens_cost = 0
+        generated_tokens_cost = 0
+        model_names = []
 
         printer = Printer()
         estimated_input_tokens = count_tokens(json.dumps(conversations, ensure_ascii=False))
@@ -354,13 +358,26 @@ class CodeAutoGenerateDiff:
                 futures = []
                 for llm in self.llms:
                     for _ in range(self.generate_times_same_model):
-                        futures.append(executor.submit(
-                            chat_with_continue, llm=llm, conversations=conversations, llm_config=llm_config))
+                        model_names_list = llm_utils.get_llm_names(llm)
+                        model_name = None
+                        if model_names_list:
+                            model_name = model_names_list[0]
+                        
+                        for _ in range(self.generate_times_same_model):
+                            model_names.append(model_name)
+                            futures.append(executor.submit(
+                                chat_with_continue, llm=llm, conversations=conversations, llm_config=llm_config))
+                
                 temp_results = [future.result() for future in futures]
                 for result in temp_results:
                     results.append(result.content)
                     input_tokens_count += result.input_tokens_count
                     generated_tokens_count += result.generated_tokens_count
+                    model_info = llm_utils.get_model_info(model_name, self.args.product_mode)
+                    input_cost = model_info.get("input_price",0) if model_info else 0
+                    output_cost = model_info.get("output_price",0) if model_info else 0
+                    input_tokens_cost += input_cost * result.input_tokens_count / 1000000
+                    generated_tokens_cost += output_cost * result.generated_tokens_count / 1000000
             
             for result in results:
                 conversations_list.append(
@@ -376,7 +393,9 @@ class CodeAutoGenerateDiff:
         
         statistics = {
             "input_tokens_count": input_tokens_count,
-            "generated_tokens_count": generated_tokens_count
+            "generated_tokens_count": generated_tokens_count,
+            "input_tokens_cost": input_tokens_cost,
+            "generated_tokens_cost": generated_tokens_cost
         }        
     
         if self.args.request_id and not self.args.skip_events:

{auto_coder-0.1.255 → auto_coder-0.1.256}/src/autocoder/common/code_auto_generate_editblock.py

@@ -13,6 +13,7 @@ from concurrent.futures import ThreadPoolExecutor
 from autocoder.common.utils_code_auto_generate import chat_with_continue
 from autocoder.common.printer import Printer
 from autocoder.rag.token_counter import count_tokens
+from autocoder.utils import llms as llm_utils
 
 
 class CodeAutoGenerateEditBlock:
@@ -424,6 +425,11 @@ class CodeAutoGenerateEditBlock:
         input_tokens_count = 0
         generated_tokens_count = 0
 
+        input_tokens_cost = 0
+        generated_tokens_cost = 0
+
+        model_names = []
+
         printer = Printer()
         estimated_input_tokens = count_tokens(
             json.dumps(conversations, ensure_ascii=False))
@@ -437,14 +443,28 @@ class CodeAutoGenerateEditBlock:
             with ThreadPoolExecutor(max_workers=len(self.llms) * self.generate_times_same_model) as executor:
                 futures = []
                 for llm in self.llms:
+                    
+                    model_names_list = llm_utils.get_llm_names(llm) 
+                    model_name = None
+                    if model_names_list:
+                        model_name = model_names_list[0]                    
+
                     for _ in range(self.generate_times_same_model):
+                        model_names.append(model_name)
                         futures.append(executor.submit(
                             chat_with_continue, llm=llm, conversations=conversations, llm_config=llm_config))
+                
                 temp_results = [future.result() for future in futures]
-                for result in temp_results:
+                
+                for result,model_name in zip(temp_results,model_names):
                     results.append(result.content)
                     input_tokens_count += result.input_tokens_count
                     generated_tokens_count += result.generated_tokens_count
+                    model_info = llm_utils.get_model_info(model_name,self.args.product_mode)                    
+                    input_cost = model_info.get("input_price", 0) if model_info else 0
+                    output_cost = model_info.get("output_price", 0) if model_info else 0
+                    input_tokens_cost += input_cost * result.input_tokens_count / 1000000
+                    generated_tokens_cost += output_cost * result.generated_tokens_count / 1000000
 
             for result in results:
                 conversations_list.append(
@@ -461,7 +481,9 @@ class CodeAutoGenerateEditBlock:
 
         statistics = {
             "input_tokens_count": input_tokens_count,
-            "generated_tokens_count": generated_tokens_count
+            "generated_tokens_count": generated_tokens_count,
+            "input_tokens_cost": input_tokens_cost,
+            "generated_tokens_cost": generated_tokens_cost
         }
 
         if self.args.request_id and not self.args.skip_events:

{auto_coder-0.1.255 → auto_coder-0.1.256}/src/autocoder/common/code_auto_generate_strict_diff.py

@@ -9,6 +9,7 @@ import json
 from autocoder.common.utils_code_auto_generate import chat_with_continue
 from autocoder.common.printer import Printer
 from autocoder.rag.token_counter import count_tokens
+from autocoder.utils import llms as llm_utils
 
 class CodeAutoGenerateStrictDiff:
     def __init__(
@@ -311,6 +312,9 @@ class CodeAutoGenerateStrictDiff:
         results = []
         input_tokens_count = 0
         generated_tokens_count = 0
+        input_tokens_cost = 0
+        generated_tokens_cost = 0
+        model_names = []
 
         printer = Printer()
         estimated_input_tokens = count_tokens(json.dumps(conversations, ensure_ascii=False))
@@ -324,14 +328,27 @@ class CodeAutoGenerateStrictDiff:
                 futures = []
                 for llm in self.llms:
                     for _ in range(self.generate_times_same_model):
-                        futures.append(executor.submit(
-                            chat_with_continue, llm=llm, conversations=conversations, llm_config=llm_config))
+                        
+                        model_names_list = llm_utils.get_llm_names(llm)
+                        model_name = None
+                        if model_names_list:
+                            model_name = model_names_list[0]                                                    
+                        
+                        for _ in range(self.generate_times_same_model):
+                            model_names.append(model_name)
+                            futures.append(executor.submit(
+                                chat_with_continue, llm=llm, conversations=conversations, llm_config=llm_config))
+                            
                 temp_results = [future.result() for future in futures]
                 for result in temp_results:
                     results.append(result.content)
                     input_tokens_count += result.input_tokens_count
                     generated_tokens_count += result.generated_tokens_count
-            
+                    model_info = llm_utils.get_model_info(model_name, self.args.product_mode)
+                    input_cost = model_info.get("input_price", 0) if model_info else 0
+                    output_cost = model_info.get("output_price", 0) if model_info else 0
+                    input_tokens_cost += input_cost * result.input_tokens_count / 1000000
+                    generated_tokens_cost += output_cost * result.generated_tokens_count / 1000000
             for result in results:
                 conversations_list.append(
                     conversations + [{"role": "assistant", "content": result}])
@@ -345,7 +362,9 @@ class CodeAutoGenerateStrictDiff:
         
         statistics = {
             "input_tokens_count": input_tokens_count,
-            "generated_tokens_count": generated_tokens_count
+            "generated_tokens_count": generated_tokens_count,
+            "input_tokens_cost": input_tokens_cost,
+            "generated_tokens_cost": generated_tokens_cost
         }        
     
         if self.args.request_id and not self.args.skip_events:

{auto_coder-0.1.255 → auto_coder-0.1.256}/src/autocoder/common/code_modification_ranker.py

@@ -8,8 +8,8 @@ from concurrent.futures import ThreadPoolExecutor, as_completed
 import traceback
 from autocoder.common.utils_code_auto_generate import chat_with_continue
 from byzerllm.utils.str2model import to_model
+from autocoder.utils.llms import get_llm_names, get_model_info
 
-from autocoder.utils.llms import get_llm_names
 class RankResult(BaseModel):
     rank_result: List[int]
 
@@ -97,13 +97,42 @@ class CodeModificationRanker:
 
                 # Collect all results
                 results = []
-                for future in as_completed(futures):
+                # 获取模型名称列表
+                model_names = []
+                for llm in self.llms:
+                    # 获取当前llm实例对应的模型名称
+                    names = get_llm_names(llm)  
+                    model_names.extend(names)
+
+                # 获取模型价格信息
+                model_info_map = {}
+                for name in model_names:
+                    # 第二个参数是产品模式,从args中获取
+                    info = get_model_info(name, self.args.product_mode)  
+                    if info:
+                        model_info_map[name] = {
+                            "input_cost": info.get("input_price", 0.0),  # 每百万tokens成本
+                            "output_cost": info.get("output_price", 0.0) # 每百万tokens成本 
+                        }
+
+                # 计算总成本
+                total_input_cost = 0.0
+                total_output_cost = 0.0
+
+                for future, model_name in zip(futures, model_names):
                     try:
                         result = future.result()
                         input_tokens_count += result.input_tokens_count
                         generated_tokens_count += result.generated_tokens_count
                         v = to_model(result.content,RankResult)                        
                         results.append(v.rank_result)
+
+                        # 计算成本                        
+                        info = model_info_map.get(model_name, {})
+                        # 计算公式:token数 * 单价 / 1000000
+                        total_input_cost += (result.input_tokens_count * info.get("input_cost", 0.0)) / 1000000
+                        total_output_cost += (result.generated_tokens_count * info.get("output_cost", 0.0)) / 1000000
+
                     except Exception as e:
                         self.printer.print_in_terminal(
                             "ranking_failed_request", style="yellow", error=str(e))                        
@@ -113,6 +142,10 @@ class CodeModificationRanker:
                     raise Exception(
                         self.printer.get_message_from_key("ranking_all_failed"))
 
+                # 四舍五入到4位小数
+                total_input_cost = round(total_input_cost, 4)
+                total_output_cost = round(total_output_cost, 4)
+
                 # Calculate scores for each candidate
                 candidate_scores = defaultdict(float)
                 for rank_result in results:
@@ -137,7 +170,10 @@ class CodeModificationRanker:
                     best_candidate=sorted_candidates[0],
                     scores=score_details,
                     input_tokens=input_tokens_count,
-                    output_tokens=generated_tokens_count
+                    output_tokens=generated_tokens_count,
+                    input_cost=total_input_cost,
+                    output_cost=total_output_cost,
+                    model_names=", ".join(model_names)
                 )
 
                 rerank_contents = [generate_result.contents[i]

{auto_coder-0.1.255 → auto_coder-0.1.256}/src/autocoder/dispacher/actions/action.py

@@ -125,13 +125,17 @@ class ActionTSProject(BaseAction):
                     query=args.query, source_content=content
                 )
             elapsed_time = time.time() - start_time
-            speed = generate_result.metadata.get('generated_tokens_count', 0) / elapsed_time if elapsed_time > 0 else 0            
-            model_names = ",".join(get_llm_names(self.llm))
+            speed = generate_result.metadata.get('generated_tokens_count', 0) / elapsed_time if elapsed_time > 0 else 0
+            input_tokens_cost = generate_result.metadata.get('input_tokens_cost', 0)
+            generated_tokens_cost = generate_result.metadata.get('generated_tokens_cost', 0)
+            model_names = ",".join(get_llm_names(generate.llms))
             self.printer.print_in_terminal(
                 "code_generation_complete",
                 duration=elapsed_time,
                 input_tokens=generate_result.metadata.get('input_tokens_count', 0),
                 output_tokens=generate_result.metadata.get('generated_tokens_count', 0),
+                input_cost=input_tokens_cost,
+                output_cost=generated_tokens_cost,
                 speed=round(speed, 2),
                 model_names=model_names
             )
@@ -221,12 +225,16 @@ class ActionPyScriptProject(BaseAction):
 
             elapsed_time = time.time() - start_time
             speed = generate_result.metadata.get('generated_tokens_count', 0) / elapsed_time if elapsed_time > 0 else 0
-            model_names = ",".join(get_llm_names(self.llm))
+            model_names = ",".join(get_llm_names(generate.llms))
+            input_tokens_cost = generate_result.metadata.get('input_tokens_cost', 0)
+            generated_tokens_cost = generate_result.metadata.get('generated_tokens_cost', 0)
             self.printer.print_in_terminal(
                 "code_generation_complete",
                 duration=elapsed_time,
                 input_tokens=generate_result.metadata.get('input_tokens_count', 0),
                 output_tokens=generate_result.metadata.get('generated_tokens_count', 0),
+                input_cost=input_tokens_cost,
+                output_cost=generated_tokens_cost,
                 speed=round(speed, 2),
                 model_names=model_names
             )
@@ -264,13 +272,7 @@ class ActionPyScriptProject(BaseAction):
                     model=self.llm.default_model_name,
                 )
 
-            end_time = time.time()
-            self.printer.print_in_terminal(
-                "code_generation_complete",
-                duration=end_time - start_time,
-                input_tokens=generate_result.metadata.get('input_tokens_count', 0),
-                output_tokens=generate_result.metadata.get('generated_tokens_count', 0)
-            )
+            end_time = time.time()            
             with open(self.args.target_file, "w") as file:
                 file.write(content)
 
@@ -348,12 +350,16 @@ class ActionPyProject(BaseAction):
                 )
             elapsed_time = time.time() - start_time
             speed = generate_result.metadata.get('generated_tokens_count', 0) / elapsed_time if elapsed_time > 0 else 0
-            model_names = ",".join(get_llm_names(self.llm))
+            model_names = ",".join(get_llm_names(generate.llms))
+            input_tokens_cost = generate_result.metadata.get('input_tokens_cost', 0)
+            generated_tokens_cost = generate_result.metadata.get('generated_tokens_cost', 0)
             self.printer.print_in_terminal(
                 "code_generation_complete",
                 duration=elapsed_time,
                 input_tokens=generate_result.metadata.get('input_tokens_count', 0),
                 output_tokens=generate_result.metadata.get('generated_tokens_count', 0),
+                input_cost=input_tokens_cost,
+                output_cost=generated_tokens_cost,
                 speed=round(speed, 2),
                 model_names=model_names
             )
@@ -458,12 +464,16 @@ class ActionSuffixProject(BaseAction):
               
         elapsed_time = time.time() - start_time
         speed = generate_result.metadata.get('generated_tokens_count', 0) / elapsed_time if elapsed_time > 0 else 0
-        model_names = ",".join(get_llm_names(self.llm))
+        model_names = ",".join(get_llm_names(generate.llms))
+        input_tokens_cost = generate_result.metadata.get('input_tokens_cost', 0)
+        generated_tokens_cost = generate_result.metadata.get('generated_tokens_cost', 0)
         self.printer.print_in_terminal(
             "code_generation_complete",
             duration=elapsed_time,
             input_tokens=generate_result.metadata.get('input_tokens_count', 0),
             output_tokens=generate_result.metadata.get('generated_tokens_count', 0),
+            input_cost=input_tokens_cost,
+            output_cost=generated_tokens_cost,
             speed=round(speed, 2),
             model_names=model_names
         )

{auto_coder-0.1.255 → auto_coder-0.1.256}/src/autocoder/dispacher/actions/plugins/action_regex_project.py

@@ -88,11 +88,15 @@ class ActionRegexProject:
             elapsed_time = time.time() - start_time
             speed = generate_result.metadata.get('generated_tokens_count', 0) / elapsed_time if elapsed_time > 0 else 0
             model_names = ",".join(get_llm_names(self.llm))
+            input_tokens_cost = generate_result.metadata.get('input_tokens_cost', 0)
+            generated_tokens_cost = generate_result.metadata.get('generated_tokens_cost', 0)
             self.printer.print_in_terminal(
                 "code_generation_complete",
                 duration=elapsed_time,
                 input_tokens=generate_result.metadata.get('input_tokens_count', 0),
                 output_tokens=generate_result.metadata.get('generated_tokens_count', 0),
+                input_cost=input_tokens_cost,
+                output_cost=generated_tokens_cost,
                 speed=round(speed, 2),
                 model_names=model_names
             )