auto-coder 3.0.40__tar.gz → 3.0.41__tar.gz

{auto_coder-3.0.40/src/auto_coder.egg-info → auto_coder-3.0.41}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: auto-coder
-Version: 3.0.40
+Version: 3.0.41
 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.206
+Requires-Dist: byzerllm[saas]>=0.1.207
 Requires-Dist: patch
 Requires-Dist: diff_match_patch
 Requires-Dist: GitPython

{auto_coder-3.0.40 → auto_coder-3.0.41}/pyproject.toml

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

{auto_coder-3.0.40 → auto_coder-3.0.41}/requirements.txt

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

{auto_coder-3.0.40 → auto_coder-3.0.41/src/auto_coder.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: auto-coder
-Version: 3.0.40
+Version: 3.0.41
 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.206
+Requires-Dist: byzerllm[saas]>=0.1.207
 Requires-Dist: patch
 Requires-Dist: diff_match_patch
 Requires-Dist: GitPython

{auto_coder-3.0.40 → auto_coder-3.0.41}/src/auto_coder.egg-info/SOURCES.txt

@@ -806,6 +806,7 @@ src/autocoder/terminal/utils/paths.py
 src/autocoder/terminal/utils/shell.py
 src/autocoder/terminal_core/__init__.py
 src/autocoder/terminal_core/cloud_bridge.py
+src/autocoder/terminal_core/cloud_command_dispatcher.py
 src/autocoder/terminal_core/command_registry.py
 src/autocoder/terminal_core/execution_broker.py
 src/autocoder/terminal_core/forward_input.py

{auto_coder-3.0.40 → auto_coder-3.0.41}/src/auto_coder.egg-info/requires.txt

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

{auto_coder-3.0.40 → auto_coder-3.0.41}/src/autocoder/auto_coder_terminal_v3.py

@@ -48,6 +48,7 @@ V3_COMMANDS = [
     "/memory",
     "/models",
     "/new",
+    "/rules",
     "/status",
     "/workflow",
 ]

{auto_coder-3.0.40 → auto_coder-3.0.41}/src/autocoder/common/v2/agent/agentic_edit.py

@@ -72,6 +72,9 @@ from autocoder.common.v2.agent.agentic_edit_types import (
     WindowLengthChangeEvent,
     ConversationIdEvent,
     ConversationForwardedEvent,
+    ModelUsageEvent,
+    ModelIdentity,
+    AgentIdentity,
     AgentContext,
     AgenticEditConversationConfig,
     ConversationAction,
@@ -3193,6 +3196,11 @@ class AgenticEdit:
                                     f"Failed to update llm_metadata for message {pending_assistant_message_id[:8]}: {e}"
                                 )
 
+                        model_usage_event = self._create_model_usage_event(
+                            event, conversation_round=len(conversations) - 1
+                        )
+                        if model_usage_event:
+                            yield model_usage_event
                         yield event
                     continue
 
@@ -3484,6 +3492,11 @@ class AgenticEdit:
                                 f"Failed to update llm_metadata for message {pending_assistant_message_id[:8]}: {e}"
                             )
 
+                    model_usage_event = self._create_model_usage_event(
+                        event, conversation_round=len(conversations) - 1
+                    )
+                    if model_usage_event:
+                        yield model_usage_event
                     yield event
 
             if round_policy.tools_executed_count == 0:
@@ -3588,6 +3601,67 @@ class AgenticEdit:
     def apply_changes(self):
         return self.change_manager.apply_changes()
 
+    def _create_model_usage_event(
+        self, token_usage_event, conversation_round: int
+    ) -> Optional[ModelUsageEvent]:
+        """Build a ModelUsageEvent enriched with model identity and agent context."""
+        try:
+            from autocoder.common.llms.manager import LLMManager
+            from autocoder.utils import llms as llm_utils
+
+            registered_name = ",".join(llm_utils.get_llm_names(self.llm))
+            manager = LLMManager()
+            model_info = manager.get_model_info(
+                registered_name, self.args.product_mode
+            )
+
+            model_identity = ModelIdentity(
+                registered_name=registered_name,
+                provider_model_name=model_info["model_name"]
+                if model_info
+                else registered_name,
+                base_url=model_info["base_url"] if model_info else "",
+                provider=model_info.get("provider") if model_info else None,
+                model_type=model_info.get("model_type") if model_info else None,
+            )
+            agent_identity = AgentIdentity(
+                is_sub_agent=self.agent_context.is_sub_agent
+                if self.agent_context
+                else False,
+                agent_name=self.agent_context.subagent_name
+                if self.agent_context
+                else None,
+                conversation_id=self.conversation_config.conversation_id
+                if self.conversation_config
+                else None,
+            )
+
+            input_cost, output_cost = 0.0, 0.0
+            if model_info and token_usage_event.usage:
+                meta = token_usage_event.usage
+                input_price = model_info.get("input_price", 0.0)
+                output_price = model_info.get("output_price", 0.0)
+                input_cost = (
+                    getattr(meta, "input_tokens_count", 0) * input_price / 1_000_000
+                )
+                output_cost = (
+                    getattr(meta, "generated_tokens_count", 0)
+                    * output_price
+                    / 1_000_000
+                )
+
+            return ModelUsageEvent(
+                usage=token_usage_event.usage,
+                model_identity=model_identity,
+                agent_identity=agent_identity,
+                input_cost=input_cost,
+                output_cost=output_cost,
+                conversation_round=conversation_round,
+            )
+        except Exception as e:
+            logger.warning(f"Failed to create ModelUsageEvent: {e}")
+            return None
+
     def _create_event_context(
         self, conversation_id: Optional[str]
     ) -> Tuple[EventContext, EventFactory]:

{auto_coder-3.0.40 → auto_coder-3.0.41}/src/autocoder/common/v2/agent/agentic_edit_types.py

@@ -1,7 +1,8 @@
-from pydantic import BaseModel
+from pydantic import BaseModel, Field
 from typing import List, Dict, Any, Callable, Optional, Type, Union
 from pydantic import SkipValidation
 from enum import Enum
+import time
 
 # Import for Pull Request support and Git operations
 try:
@@ -449,6 +450,58 @@ class TokenUsageEvent(BaseModel):
     usage: Any
 
 
+class ModelIdentity(BaseModel):
+    """模型身份信息，关联注册名与实际 provider 配置"""
+
+    registered_name: str
+    provider_model_name: str
+    base_url: str
+    provider: Optional[str] = None
+    model_type: Optional[str] = None
+
+
+class AgentIdentity(BaseModel):
+    """Agent 身份信息"""
+
+    is_sub_agent: bool = False
+    agent_name: Optional[str] = None
+    conversation_id: Optional[str] = None
+
+
+class ModelUsageEvent(BaseModel):
+    """携带完整模型和 agent 身份的用量事件，每次 LLM 调用产生一条"""
+
+    usage: Any
+    model_identity: ModelIdentity
+    agent_identity: AgentIdentity
+    input_cost: float = 0.0
+    output_cost: float = 0.0
+    conversation_round: Optional[int] = None
+    timestamp: float = Field(default_factory=time.time)
+
+    def to_report_dict(self) -> Dict[str, Any]:
+        meta = self.usage
+        return {
+            "registered_name": self.model_identity.registered_name,
+            "provider_model_name": self.model_identity.provider_model_name,
+            "base_url": self.model_identity.base_url,
+            "provider": self.model_identity.provider,
+            "model_type": self.model_identity.model_type,
+            "agent_type": "sub_agent"
+            if self.agent_identity.is_sub_agent
+            else "main_agent",
+            "agent_name": self.agent_identity.agent_name or "",
+            "conversation_id": self.agent_identity.conversation_id or "",
+            "input_tokens": getattr(meta, "input_tokens_count", 0),
+            "output_tokens": getattr(meta, "generated_tokens_count", 0),
+            "first_token_time": getattr(meta, "first_token_time", 0.0),
+            "input_cost": self.input_cost,
+            "output_cost": self.output_cost,
+            "conversation_round": self.conversation_round,
+            "timestamp": self.timestamp,
+        }
+
+
 class ConversationIdEvent(BaseModel):
     """Represents the conversation id."""
 

{auto_coder-3.0.40 → auto_coder-3.0.41}/src/autocoder/terminal_core/__init__.py

@@ -13,6 +13,7 @@ from .forward_input import resolve_running_conversation_id, submit_forwarded_inp
 from .status import collect_runtime_status, format_status_snapshot
 from .execution_broker import ExecutionBroker, ExecutionResult, RunStatus
 from .cloud_bridge import CloudBridge, CloudConfig
+from .cloud_command_dispatcher import CloudCommandDispatcher, CommandResult
 
 __all__ = [
     "CommandRegistry",
@@ -29,4 +30,6 @@ __all__ = [
     "RunStatus",
     "CloudBridge",
     "CloudConfig",
+    "CloudCommandDispatcher",
+    "CommandResult",
 ]

{auto_coder-3.0.40 → auto_coder-3.0.41}/src/autocoder/terminal_core/cloud_bridge.py

@@ -21,7 +21,13 @@ from typing import Any, Dict, List, Optional
 import requests
 from loguru import logger
 
-from autocoder.common.v2.agent.agentic_edit_types import ConversationAction
+from autocoder.common.v2.agent.agentic_edit_types import (
+    ConversationAction,
+    ModelUsageEvent,
+)
+from autocoder.terminal_core.cloud_command_dispatcher import (
+    CloudCommandDispatcher,
+)
 from autocoder.terminal_core.execution_broker import (
     EventCallback,
     ExecutionBroker,
@@ -89,11 +95,18 @@ class CloudBridge:
         config: CloudConfig,
         broker: ExecutionBroker,
         on_remote_event: Optional[EventCallback] = None,
+        command_dispatcher: Optional[CloudCommandDispatcher] = None,
     ):
         self._config = config
         self._broker = broker
         self._on_remote_event = on_remote_event
 
+        if command_dispatcher is not None:
+            self._command_dispatcher = command_dispatcher
+        else:
+            self._command_dispatcher = CloudCommandDispatcher()
+            self._command_dispatcher.register_defaults()
+
         self._instance: Optional[InstanceInfo] = None
         self._session = requests.Session()
         self._session.headers.update(
@@ -106,7 +119,8 @@ class CloudBridge:
         self._heartbeat_task: Optional[asyncio.Task] = None
         self._poll_task: Optional[asyncio.Task] = None
         self._running = False
-        self._executing_run_id: Optional[str] = None
+        self._executing_conversations: Dict[str, str] = {}  # conversation_id -> run_id
+        self._run_tasks: Dict[str, asyncio.Task] = {}  # run_id -> asyncio.Task
 
         project_hash = hashlib.md5(
             (config.project_path or "default").encode()
@@ -173,6 +187,16 @@ class CloudBridge:
                     await task
                 except asyncio.CancelledError:
                     pass
+        # Cancel all in-flight run tasks
+        for run_id, task in list(self._run_tasks.items()):
+            if not task.done():
+                task.cancel()
+                try:
+                    await task
+                except asyncio.CancelledError:
+                    pass
+        self._run_tasks.clear()
+        self._executing_conversations.clear()
         logger.info("CloudBridge stopped")
 
     async def sync_local_run(
@@ -182,6 +206,7 @@ class CloudBridge:
         status: str,
         result_text: Optional[str] = None,
         error_text: Optional[str] = None,
+        usage_details: Optional[List[Dict[str, Any]]] = None,
     ) -> Optional[str]:
         """
         将本地 TUI 发起的 run 同步到云端。
@@ -200,6 +225,8 @@ class CloudBridge:
                 body["resultText"] = result_text
             if error_text:
                 body["errorText"] = error_text
+            if usage_details:
+                body["usageDetails"] = usage_details
 
             resp = await asyncio.get_event_loop().run_in_executor(
                 None,
@@ -279,8 +306,10 @@ class CloudBridge:
         if not self._instance:
             return
         body: Dict[str, Any] = {"instanceId": self._instance.instance_id}
-        if self._executing_run_id:
-            body["currentRunId"] = self._executing_run_id
+        executing_run_ids = list(self._executing_conversations.values())
+        if executing_run_ids:
+            body["currentRunId"] = executing_run_ids[0]
+            body["executingRunIds"] = executing_run_ids
         try:
             await asyncio.get_event_loop().run_in_executor(
                 None,
@@ -296,11 +325,21 @@ class CloudBridge:
         while self._running:
             try:
                 await asyncio.sleep(interval_s)
-                if self._executing_run_id:
-                    continue
+                # Clean up completed tasks
+                done_ids = [rid for rid, t in self._run_tasks.items() if t.done()]
+                for rid in done_ids:
+                    self._run_tasks.pop(rid, None)
+
                 runs = await self._fetch_pending_runs()
                 for run in runs:
-                    await self._process_run(run)
+                    # Skip if this conversation already has an active run
+                    if run.conversation_id in self._executing_conversations:
+                        continue
+                    # Mark conversation as executing before creating task to prevent
+                    # the next poll from picking up another run for the same conversation
+                    self._executing_conversations[run.conversation_id] = run.id
+                    task = asyncio.create_task(self._safe_process_run(run))
+                    self._run_tasks[run.id] = task
             except asyncio.CancelledError:
                 break
             except Exception as e:
@@ -361,12 +400,15 @@ class CloudBridge:
         status: str,
         result_text: Optional[str] = None,
         error_text: Optional[str] = None,
+        usage_details: Optional[List[Dict[str, Any]]] = None,
     ):
         body: Dict[str, Any] = {"status": status}
         if result_text is not None:
             body["resultText"] = result_text
         if error_text is not None:
             body["errorText"] = error_text
+        if usage_details:
+            body["usageDetails"] = usage_details
         try:
             await asyncio.get_event_loop().run_in_executor(
                 None,
@@ -405,34 +447,61 @@ class CloudBridge:
             except Exception as e:
                 logger.warning(f"Download error: {f.original_name}: {e}")
 
+    async def _safe_process_run(self, run: PendingRun):
+        """Wrapper that ensures per-conversation tracking is cleaned up."""
+        try:
+            await self._process_run(run)
+        except Exception as e:
+            logger.error(f"CloudBridge run {run.id} unexpected error: {e}")
+        finally:
+            self._executing_conversations.pop(run.conversation_id, None)
+            self._run_tasks.pop(run.id, None)
+
     async def _process_run(self, run: PendingRun):
         """认领 → 执行 → 回传"""
         claimed = await self._claim_run(run.id)
         if not claimed:
             return
 
-        self._executing_run_id = run.id
-        logger.info(f"CloudBridge executing run {run.id}: {run.prompt_text[:80]}")
+        logger.info(f"CloudBridge executing run {run.id} (conv={run.conversation_id}): {run.prompt_text[:80]}")
 
         await self._report_result(run.id, "RUNNING")
 
         if run.files:
             await self._download_run_files(run)
 
+        if self._command_dispatcher.is_command(run.prompt_text):
+            await self._process_command_run(run)
+            return
+
         local_conv_id = self._conv_map.get(run.conversation_id)
         if local_conv_id:
             conv_action = ConversationAction.RESUME
         else:
             conv_action = ConversationAction.NEW
 
+        usage_details: List[Dict[str, Any]] = []
+
+        def _on_event(event):
+            if isinstance(event, ModelUsageEvent):
+                usage_details.append(event.to_report_dict())
+            if self._on_remote_event:
+                self._on_remote_event(event)
+
         try:
             result: ExecutionResult = await self._broker.execute_async(
                 query=run.prompt_text,
                 conversation_action=conv_action,
                 conversation_id=local_conv_id,
-                on_event=self._on_remote_event,
+                on_event=_on_event,
             )
 
+            for evt in result.model_usage_events:
+                if hasattr(evt, "to_report_dict"):
+                    d = evt.to_report_dict()
+                    if d not in usage_details:
+                        usage_details.append(d)
+
             if result.conversation_id and not local_conv_id:
                 self._conv_map[run.conversation_id] = result.conversation_id
                 self._save_conv_map()
@@ -442,17 +511,36 @@ class CloudBridge:
                     run.id,
                     "COMPLETED",
                     result_text=result.result_text or "",
+                    usage_details=usage_details or None,
                 )
             elif result.status == RunStatus.CANCELLED:
-                await self._report_result(run.id, "FAILED", error_text="Cancelled by user")
+                await self._report_result(run.id, "FAILED", error_text="Cancelled by user", usage_details=usage_details or None)
             else:
                 await self._report_result(
                     run.id,
                     "FAILED",
                     error_text=result.error_text or "Unknown error",
+                    usage_details=usage_details or None,
                 )
         except Exception as e:
             logger.error(f"CloudBridge run {run.id} failed: {e}")
             await self._report_result(run.id, "FAILED", error_text=str(e))
-        finally:
-            self._executing_run_id = None
+
+    async def _process_command_run(self, run: PendingRun):
+        """处理斜杠命令类型的 run（如 /commit），在线程池中执行后回传结果。"""
+        try:
+            loop = asyncio.get_event_loop()
+            cmd_result = await loop.run_in_executor(
+                None, self._command_dispatcher.dispatch, run.prompt_text
+            )
+            if cmd_result.error_text:
+                await self._report_result(
+                    run.id, "FAILED", error_text=cmd_result.error_text
+                )
+            else:
+                await self._report_result(
+                    run.id, "COMPLETED", result_text=cmd_result.result_text or ""
+                )
+        except Exception as e:
+            logger.error(f"CloudBridge command run {run.id} failed: {e}")
+            await self._report_result(run.id, "FAILED", error_text=str(e))