规范outpath的路径

.env

@@ -1,61 +0,0 @@
-# API Key (required)
-# Get yours at: https://console.anthropic.com/
-ANTHROPIC_API_KEY=sk-9wTK68ZO58_s4w5_SUsR7w
-
-# Model ID (required)
-MODEL_ID=gemini-3-flash-thinking
-
-# Base URL (optional, for Anthropic-compatible providers)
-ANTHROPIC_BASE_URL=https://coding.qunhequnhe.com
-
-# =============================================================================
-#  Anthropic-compatible providers
-#
-#  Provider         MODEL_ID              SWE-bench  TB2     Base URL
-#  ---------------  --------------------  ---------  ------  -------------------
-#  Anthropic        claude-sonnet-4-6     79.6%      59.1%   (default)
-#  MiniMax          MiniMax-M2.5          80.2%        -     see below
-#  GLM (Zhipu)      glm-5                77.8%        -     see below
-#  Kimi (Moonshot)  kimi-k2.5            76.8%        -     see below
-#  DeepSeek         deepseek-chat        73.0%        -     see below
-#                   (V3.2)
-#
-#  SWE-bench = SWE-bench Verified (Feb 2026)
-#  TB2       = Terminal-Bench 2.0 (Feb 2026)
-# =============================================================================
-
-# ---- International ----
-
-# MiniMax          https://www.minimax.io
-# ANTHROPIC_BASE_URL=https://api.minimax.io/anthropic
-# MODEL_ID=MiniMax-M2.5
-
-# GLM (Zhipu)      https://z.ai
-# ANTHROPIC_BASE_URL=https://api.z.ai/api/anthropic
-# MODEL_ID=glm-5
-
-# Kimi (Moonshot)  https://platform.moonshot.ai
-# ANTHROPIC_BASE_URL=https://api.moonshot.ai/anthropic
-# MODEL_ID=kimi-k2.5
-
-# DeepSeek         https://platform.deepseek.com
-# ANTHROPIC_BASE_URL=https://api.deepseek.com/anthropic
-# MODEL_ID=deepseek-chat
-
-# ---- China mainland ----
-
-# MiniMax          https://platform.minimax.io
-# ANTHROPIC_BASE_URL=https://api.minimaxi.com/anthropic
-# MODEL_ID=MiniMax-M2.5
-
-# GLM (Zhipu)      https://open.bigmodel.cn
-# ANTHROPIC_BASE_URL=https://open.bigmodel.cn/api/anthropic
-# MODEL_ID=glm-5
-
-# Kimi (Moonshot)  https://platform.moonshot.cn
-# ANTHROPIC_BASE_URL=https://api.moonshot.cn/anthropic
-# MODEL_ID=kimi-k2.5
-
-# DeepSeek (no regional split, same endpoint globally)
-# ANTHROPIC_BASE_URL=https://api.deepseek.com/anthropic
-# MODEL_ID=deepseek-chat

.gitignore

@@ -0,0 +1,27 @@
+# Local secrets
+.env
+.env.*
+!.env.example
+
+# Python caches and test output
+__pycache__/
+*.py[cod]
+*$py.class
+.pytest_cache/
+.mypy_cache/
+.ruff_cache/
+.coverage
+htmlcov/
+
+# Local virtual environments
+.venv/
+venv/
+env/
+
+# Generated CAD artifacts
+outputs/
+
+# OS and editor files
+.DS_Store
+.idea/
+.vscode/

agent_loop.py

@@ -3,7 +3,9 @@ import os
 import subprocess
 import sys
 import textwrap
+from datetime import datetime
 from pathlib import Path
+from uuid import uuid4
 
 try:
     from dotenv import load_dotenv
@@ -17,6 +19,8 @@ if os.getenv("ANTHROPIC_BASE_URL"):
     os.environ.pop("ANTHROPIC_AUTH_TOKEN", None)
 
 WORKDIR = Path.cwd()
+DEFAULT_OUTPUT_PATH = "outputs/model.step"
+STEP_SUFFIXES = (".step", ".stp")
 
 SYSTEM = f"""
 You are a CAD generation agent at {WORKDIR}.
@@ -26,6 +30,7 @@ Your only tool is execute. For CAD tasks:
 - The code must assign the final model to a variable named result.
 - You may use cadquery as cq; it is pre-imported by the tool.
 - Call execute with the code and optional output_path.
+- Each successful execute writes into a unique run directory to avoid overwriting previous models.
 - If execute returns ok=false, inspect the structured error, fix the code, and call execute again.
 - When execute returns ok=true, report the output_path to the user.
 
@@ -46,6 +51,77 @@ def safe_path(p: str) -> Path:
     return path
 
 
+def workspace_relative(path: Path) -> str:
+    return str(path.relative_to(WORKDIR))
+
+
+def new_run_id() -> str:
+    timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+    return f"{timestamp}_{uuid4().hex[:6]}"
+
+
+def resolve_run_output(requested_output_path: str) -> tuple[Path, Path, str]:
+    requested_path = safe_path(requested_output_path)
+    suffix = requested_path.suffix.lower()
+
+    if suffix in STEP_SUFFIXES:
+        output_root = requested_path.parent
+        output_name = requested_path.name
+    elif suffix:
+        raise ValueError("Only STEP output is supported in this version. Use a .step/.stp file path or a directory path.")
+    else:
+        output_root = requested_path
+        output_name = "model.step"
+
+    for _ in range(20):
+        run_id = new_run_id()
+        run_dir = output_root / "runs" / run_id
+        if not run_dir.exists():
+            return run_dir, run_dir / output_name, run_id
+
+    raise RuntimeError("Failed to allocate a unique output run directory.")
+
+
+def update_latest_link(output_root: Path, run_dir: Path) -> str | None:
+    latest = output_root / "latest"
+    try:
+        if latest.is_symlink() or latest.is_file():
+            latest.unlink()
+        elif latest.exists():
+            return f"Skipped latest link because {workspace_relative(latest)} already exists and is not a symlink."
+
+        latest.symlink_to(Path("runs") / run_dir.name, target_is_directory=True)
+    except OSError as exc:
+        return f"Failed to update latest link: {exc}"
+
+    return None
+
+
+def write_manifest(
+    run_dir: Path,
+    run_id: str,
+    requested_output_path: str,
+    output_path: Path,
+    code: str,
+    prompt: str | None,
+    payload: dict,
+) -> Path:
+    manifest_path = run_dir / "manifest.json"
+    manifest = {
+        "run_id": run_id,
+        "created_at": datetime.now().astimezone().isoformat(timespec="seconds"),
+        "prompt": prompt,
+        "requested_output_path": requested_output_path,
+        "output_path": workspace_relative(output_path),
+        "format": output_path.suffix.lstrip(".").lower(),
+        "code": code,
+        "stdout": payload.get("stdout", ""),
+        "stderr": payload.get("stderr", ""),
+    }
+    manifest_path.write_text(json.dumps(manifest, ensure_ascii=False, indent=2), encoding="utf-8")
+    return manifest_path
+
+
 CADQUERY_RUNNER = r"""
 import contextlib
 import io
@@ -159,7 +235,7 @@ def _json_response(payload: dict) -> str:
     return json.dumps(payload, ensure_ascii=False, indent=2)
 
 
-def run_execute(code: str, output_path: str = "outputs/model.step") -> str:
+def run_execute(code: str, output_path: str = DEFAULT_OUTPUT_PATH, prompt: str | None = None) -> str:
     try:
         if not code or not code.strip():
             return _json_response({
@@ -172,17 +248,8 @@ def run_execute(code: str, output_path: str = "outputs/model.step") -> str:
                 "stderr": "",
             })
 
-        output = safe_path(output_path)
-        if output.suffix.lower() not in (".step", ".stp"):
-            return _json_response({
-                "ok": False,
-                "stage": "input",
-                "error_type": "UnsupportedOutputFormat",
-                "error": "Only STEP output is supported in this version. Use a .step or .stp path.",
-                "traceback_tail": "",
-                "stdout": "",
-                "stderr": "",
-            })
+        run_dir, output, run_id = resolve_run_output(output_path)
+        output_root = run_dir.parent.parent
     except Exception as exc:
         return _json_response({
             "ok": False,
@@ -266,14 +333,32 @@ def run_execute(code: str, output_path: str = "outputs/model.step") -> str:
         }
 
     if payload.get("ok") and payload.get("output_path"):
-        payload["output_path"] = str(Path(payload["output_path"]).relative_to(WORKDIR))
+        exported_path = Path(payload["output_path"])
+        manifest_path = write_manifest(
+            run_dir=run_dir,
+            run_id=run_id,
+            requested_output_path=output_path,
+            output_path=exported_path,
+            code=code,
+            prompt=prompt,
+            payload=payload,
+        )
+        latest_warning = update_latest_link(output_root, run_dir)
+
+        payload["run_id"] = run_id
+        payload["run_dir"] = workspace_relative(run_dir)
+        payload["output_path"] = workspace_relative(exported_path)
+        payload["manifest_path"] = workspace_relative(manifest_path)
+        payload["latest_path"] = workspace_relative(output_root / "latest")
+        if latest_warning:
+            payload["warning"] = latest_warning
 
     return _json_response(payload)
 
 
 # -- The dispatch map: {tool_name: handler} --
 TOOL_HANDLERS = {
-    "execute": lambda **kw: run_execute(kw["code"], kw.get("output_path", "outputs/model.step")),
+    "execute": lambda **kw: run_execute(kw["code"], kw.get("output_path", DEFAULT_OUTPUT_PATH)),
 }
 
 TOOLS = [
@@ -282,7 +367,9 @@ TOOLS = [
         "description": textwrap.dedent("""
             Execute CadQuery Python code and export the result as a STEP file.
             The code must assign the final CadQuery model to a variable named result.
-            cadquery is pre-imported as cq. output_path is optional and defaults to outputs/model.step.
+            cadquery is pre-imported as cq.
+            output_path is optional. If it is a .step/.stp file path, the file name is used inside a unique run directory.
+            If it is a directory path, model.step is written inside a unique run directory under that root.
         """).strip(),
         "input_schema": {
             "type": "object",
@@ -293,7 +380,7 @@ TOOLS = [
                 },
                 "output_path": {
                     "type": "string",
-                    "description": "Optional workspace-relative STEP path. Defaults to outputs/model.step.",
+                    "description": "Optional workspace-relative STEP file path or output directory. Defaults to outputs/model.step.",
                 },
             },
             "required": ["code"],
@@ -302,6 +389,13 @@ TOOLS = [
 ]
 
 
+def latest_user_prompt(messages: list) -> str | None:
+    for message in reversed(messages):
+        if message.get("role") == "user" and isinstance(message.get("content"), str):
+            return message["content"]
+    return None
+
+
 def agent_loop(messages: list):
     client = get_client()
     model = os.environ["MODEL_ID"]
@@ -315,10 +409,18 @@ def agent_loop(messages: list):
         if response.stop_reason != "tool_use":
             return
         results = []
+        prompt = latest_user_prompt(messages)
         for block in response.content:
             if block.type == "tool_use":
-                handler = TOOL_HANDLERS.get(block.name)
-                output = handler(**block.input) if handler else f"Unknown tool: {block.name}"
+                if block.name == "execute":
+                    output = run_execute(
+                        code=block.input["code"],
+                        output_path=block.input.get("output_path", DEFAULT_OUTPUT_PATH),
+                        prompt=prompt,
+                    )
+                else:
+                    handler = TOOL_HANDLERS.get(block.name)
+                    output = handler(**block.input) if handler else f"Unknown tool: {block.name}"
                 print(f"> {block.name}: {output[:200]}")
                 results.append({"type": "tool_result", "tool_use_id": block.id, "content": output})
         messages.append({"role": "user", "content": results})