terradev-cli 5.5.2__tar.gz → 5.5.4__tar.gz

{terradev_cli-5.5.2 → terradev_cli-5.5.4}/Deployment Package/BNF_GRAMMAR.md

@@ -123,9 +123,12 @@
     [--spot-strategy <spot-strategy>]
     [--backend <inference-backend>]
     [--prefer-local]
+    [--select <selection>]
+    [--auto]
 
 <provision-type>   ::= inference | training | jupyter | custom
-<spot-strategy>    ::= cheapest | most-available | balanced
+<spot-strategy>    ::= aggressive | cheapest | balanced | conservative | safe
+<selection>       ::= <integer> | "cheapest" | "cheapest-spot" | "cheapest-secure"
 
 <instance-command> ::= instance
     -i <string>

{terradev_cli-5.5.2 → terradev_cli-5.5.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: terradev-cli
-Version: 5.5.2
+Version: 5.5.4
 Summary: An imperative command-line-interface for AI workload orchestration.
 Author-email: Terradev Team <team@terradev.com>
 Maintainer-email: Terradev Team <team@terradev.com>

{terradev_cli-5.5.2 → terradev_cli-5.5.4}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "terradev-cli"
-version = "5.5.2"
+version = "5.5.4"
 description = "An imperative command-line-interface for AI workload orchestration."
 readme = "README.md"
 license = {text = "Apache-2.0"}

{terradev_cli-5.5.2 → terradev_cli-5.5.4}/terradev_cli/cli.py

@@ -507,6 +507,7 @@ class TerradevAPI:
                         "availability": "spot" if q.get("spot") else "on-demand",
                         "gpu_count": q.get("gpu_count", 1),
                         "instance_type": q.get("instance_type", "N/A"),
+                        "memory_gb": q.get("memory_gb", 0),
                     }
                 )
             return quotes
@@ -2338,9 +2339,9 @@ profiles:
 )
 @click.option(
     "--spot-strategy",
-    type=click.Choice(["aggressive", "balanced", "conservative"]),
+    type=click.Choice(["aggressive", "cheapest", "balanced", "conservative", "safe"]),
     default="balanced",
-    help="Spot instance strategy: aggressive (cheapest), balanced, conservative (most stable)",
+    help="Spot instance strategy: aggressive/cheapest, balanced, conservative/safe (most stable)",
 )
 @click.option(
     "--backend",
@@ -2378,6 +2379,18 @@ profiles:
     default="fp16",
     help="KV cache dtype. fp8 halves KV VRAM requirement.",
 )
+@click.option(
+    "--select",
+    "select_instance",
+    default=None,
+    help="Select instance by number or keyword: 1-N, cheapest, cheapest-spot, cheapest-secure, SXM4-40GB, SXM4-80GB, 80GB PCIe",
+)
+@click.option(
+    "--auto",
+    is_flag=True,
+    default=False,
+    help="Auto-select cheapest instance without prompting (CI/CD mode)",
+)
 def provision(
     gpu_type,
     count,
@@ -2399,6 +2412,8 @@ def provision(
     context_k,
     sharing_topology,
     dtype,
+    select_instance,
+    auto,
 ):
     """Provision GPU instances across multiple clouds with auto-optimization.
 
@@ -2565,6 +2580,9 @@ def provision(
 
     # ── Spot vs On-Demand Selection Logic ──
     use_spot = None
+    # Normalize spot strategy aliases
+    _strategy_aliases = {"cheapest": "aggressive", "safe": "conservative"}
+    spot_strategy = _strategy_aliases.get(spot_strategy, spot_strategy)
     if spot and on_demand:
         print("ERROR: Cannot specify both --spot and --on-demand")
         return 1
@@ -2811,6 +2829,107 @@ def provision(
                 f"LOCKED: Only on-demand instances available ({len(on_demand_quotes)} options)"
             )
 
+    # ── Instance Selection Logic ──
+    # Display instance table and handle selection (interactive, --select, --auto)
+    import sys
+    
+    def _select_instance(quotes, select_arg, auto_mode):
+        """Select an instance from quotes based on selection criteria"""
+        if not quotes:
+            return None
+        
+        # Display instance table
+        print(f"\nAvailable {gpu_type} Instances:")
+        print(f"{'#':<4} {'Provider':<14} {'Region':<14} {'$/hr':<10} {'VRAM':<8} {'Instance':<20} {'Spot'}")
+        print("-" * 78)
+        for i, q in enumerate(quotes):
+            vram_str = f"{q.get('memory_gb', 0):.0f}GB" if q.get('memory_gb') else "N/A"
+            spot_mark = "✓" if q.get("availability") == "spot" else ""
+            instance_short = q.get("instance_type", "N/A")[:20]
+            print(f"{i+1:<4} {q['provider']:<14} {q['region']:<14} ${q['price']:<9.2f} {vram_str:<8} {instance_short:<20} {spot_mark}")
+        print("-" * 78)
+        
+        # Determine selection
+        selected_index = None
+        
+        if select_arg:
+            # --select flag specified
+            if select_arg.isdigit():
+                # Numeric selection
+                idx = int(select_arg) - 1
+                if 0 <= idx < len(quotes):
+                    selected_index = idx
+                else:
+                    print(f"ERROR: Invalid selection {select_arg}. Must be 1-{len(quotes)}")
+                    return None
+            elif select_arg == "cheapest":
+                selected_index = 0
+            elif select_arg == "cheapest-spot":
+                spot_quotes = [q for q in quotes if q.get("availability") == "spot"]
+                if spot_quotes:
+                    selected_index = quotes.index(spot_quotes[0])
+                else:
+                    print("ERROR: No spot instances available")
+                    return None
+            elif select_arg == "cheapest-secure":
+                secure_quotes = [q for q in quotes if q.get("availability") != "spot"]
+                if secure_quotes:
+                    selected_index = quotes.index(secure_quotes[0])
+                else:
+                    print("ERROR: No secure (non-spot) instances available")
+                    return None
+            else:
+                # GPU memory variant selection (e.g., SXM4-40GB, 80GB PCIe)
+                select_lower = select_arg.lower()
+                for i, q in enumerate(quotes):
+                    instance_type = q.get("instance_type", "").lower()
+                    if select_lower in instance_type:
+                        selected_index = i
+                        break
+                if selected_index is None:
+                    print(f"ERROR: No instance matching '{select_arg}' found")
+                    return None
+        elif auto_mode or not sys.stdin.isatty():
+            # --auto or non-interactive context: select cheapest
+            selected_index = 0
+            print(f"Auto-selecting cheapest instance (option 1)")
+        else:
+            # Interactive mode: prompt for selection
+            try:
+                user_input = input(f"\nSelect instance [1-{len(quotes)}] (default: 1, Enter to confirm): ").strip()
+                if not user_input:
+                    selected_index = 0
+                elif user_input.isdigit():
+                    idx = int(user_input) - 1
+                    if 0 <= idx < len(quotes):
+                        selected_index = idx
+                    else:
+                        print(f"ERROR: Invalid selection. Must be 1-{len(quotes)}")
+                        return None
+                else:
+                    print(f"ERROR: Invalid input. Enter a number 1-{len(quotes)}")
+                    return None
+            except (EOFError, KeyboardInterrupt):
+                print("\nSelection cancelled")
+                return None
+        
+        if selected_index is not None:
+            selected = quotes[selected_index]
+            print(f"\nSelected: {selected['provider']} {selected['region']} ${selected['price']:.2f}/hr {selected.get('instance_type', 'N/A')}")
+            return selected
+        
+        return None
+    
+    # Apply instance selection
+    selected_instance = _select_instance(all_quotes, select_instance, auto)
+    if selected_instance is None:
+        print("ERROR: No instance selected")
+        return
+    
+    # Use only the selected instance for provisioning
+    all_quotes = [selected_instance]
+    count = 1  # Always provision 1 when selecting specific instance
+
     # Record to cost DB
     try:
         from terradev_cli.core.cost_tracker import record_quotes
@@ -2962,8 +3081,8 @@ def provision(
                 t0 = time.monotonic()
                 try:
                     provider = factory.create_provider(pname, creds)
-                    spot_flag = q.get("availability") == "spot"
-                    itype = f"{pname}-{'spot' if spot_flag else 'ondemand'}-{gpu_type.lower()}"
+                    # Use the instance_type from the quote (provider-specific format)
+                    itype = q.get("instance_type", f"{pname}-{gpu_type.lower()}")
 
                     # Wrap provision with rate limiter
                     async def _provision_with_rate_limit():
@@ -2971,6 +3090,7 @@ def provision(
                             itype,
                             q.get("region", "us-east-1"),
                             gpu_type,
+                            ssh_public_key=_provision_ssh_pubkey,
                         )
 
                     result = await rate_limiter.execute_with_rate_limit(
@@ -3270,6 +3390,11 @@ def provision(
         for r in failed:
             print(f"   {r['provider']}/{r['region']}: {r['error']}")
     print(f"Total provision time: {provision_time:.0f}ms")
+    if _provision_ssh_pubkey and succeeded:
+        print(f"\nSSH key (Ed25519, encrypted): ~/.terradev/ssh/{group_id}.key")
+        print("Instance is provisioning — SSH available once status is 'running'.")
+        print("Check status:  terradev manage -i <instance-id> -a status")
+        print("Then connect:  (SSH command shown automatically with IP)")
     if type == "inference":
         print(f"Model: {model_name or 'Not specified'}")
         print("Type: Inference workload")
@@ -3413,7 +3538,27 @@ def manage(instance_id, action):
             print(f"Status: {st}")
 
         if isinstance(result, dict):
-            for k in ("ip_address", "public_ip", "gpu_utilization", "uptime"):
+            ip = result.get("ip") or result.get("ip_address") or result.get("public_ip")
+            port = result.get("port") or result.get("ssh_port")
+            if ip:
+                ssh_cmd = f"ssh root@{ip}"
+                if port and port != 22:
+                    ssh_cmd += f" -p {port}"
+                try:
+                    from terradev_cli.core.ssh_key_manager import decrypt_private_key
+                    group_id = None
+                    for inst in api.usage.get("instances_created", []):
+                        if inst.get("id") == instance_id:
+                            group_id = inst.get("parallel_group")
+                            break
+                    if group_id:
+                        tmp_key = decrypt_private_key(group_id)
+                        if tmp_key:
+                            ssh_cmd += f" -i {tmp_key}"
+                except Exception:
+                    pass
+                print(f"   SSH: {ssh_cmd}")
+            for k in ("gpu_utilization", "uptime"):
                 if result.get(k):
                     print(f"   {k}: {result[k]}")
 
@@ -3846,6 +3991,11 @@ def optimize(instance_id, auto_apply):
     """
     all_optimizations = []
 
+    api = TerradevAPI()
+    instances = api.usage.get("instances_created", [])
+    if instance_id:
+        instances = [inst for inst in instances if inst.get("id") == instance_id]
+
     try:
         # Fetch fresh quotes for cost optimization
         gpu_types = list(set(inst.get("gpu_type", "A100") for inst in instances))
@@ -4282,6 +4432,8 @@ def job(job_file, optimize):
 
     # Load job configuration
     try:
+        import yaml
+
         with open(job_file, "r") as f:
             job_config = yaml.safe_load(f)
 
@@ -8546,7 +8698,7 @@ def init(
 @click.option("--namespace", default="gitops-system", help="Namespace for GitOps tools")
 def bootstrap(tool, cluster, namespace):
     """Bootstrap GitOps tool on the cluster"""
-    from terradev_cli.core.gitops_manager import GitOpsManager, GitOpsConfig, GitOpsTool
+    from terradev_cli.core.gitops_manager import GitOpsManager, GitOpsConfig, GitOpsTool, GitProvider
 
     # This is a simplified bootstrap - in practice, you'd load config from previous init
     config = GitOpsConfig(
@@ -8584,7 +8736,7 @@ def bootstrap(tool, cluster, namespace):
 )
 def sync(cluster, environment, tool):
     """Sync cluster with Git repository"""
-    from terradev_cli.core.gitops_manager import GitOpsManager, GitOpsConfig, GitOpsTool
+    from terradev_cli.core.gitops_manager import GitOpsManager, GitOpsConfig, GitOpsTool, GitProvider
 
     # This is a simplified sync - in practice, you'd load config from previous init
     config = GitOpsConfig(
@@ -8618,7 +8770,7 @@ def sync(cluster, environment, tool):
 @click.option("--environment", default="prod", help="Environment to validate")
 def validate(dry_run, cluster, environment):
     """Validate GitOps configuration"""
-    from terradev_cli.core.gitops_manager import GitOpsManager, GitOpsConfig, GitOpsTool
+    from terradev_cli.core.gitops_manager import GitOpsManager, GitOpsConfig, GitOpsTool, GitProvider
 
     # This is a simplified validation - in practice, you'd load config from previous init
     config = GitOpsConfig(
@@ -8652,8 +8804,7 @@ def validate(dry_run, cluster, environment):
             for warning in results["warnings"]:
                 print(f"  Warning: {warning}")
 
-    gitops_manager = GitOpsManager(config)
-    asyncio.run(gitops_manager.validate_configuration(path))
+    asyncio.run(run_validate())
 
 
 # InferX Commands
@@ -14129,7 +14280,7 @@ def disable_trigger(name):
 def fire_event(event_type, data, source):
     """Manually fire an event for testing"""
     try:
-        from terradev_cli.core.event_system import event_bus, EventType
+        from terradev_cli.core.event_system import event_bus, EventType, Event
 
         event_type_enum = EventType(event_type.replace("-", "_").upper())
 
@@ -14328,6 +14479,7 @@ def register_artifact(type, name, uri, environment, artifact_hash, size, user, p
             Environment,
             event_bus,
             EventType,
+            Event,
         )
 
         artifact_type_enum = ArtifactType(type)

{terradev_cli-5.5.2 → terradev_cli-5.5.4}/terradev_cli/core/hf_smart_templates.py

@@ -483,20 +483,24 @@ class SmartTemplateGenerator:
         if not model_spec or model_spec.model_type != "llm":
             return "# Error: This model is not suitable for chat applications"
 
-        return f'''import gradio as gr
+        hardware = model_spec.recommended_hardware.upper()
+        parameters = str(model_spec.parameters)
+        streaming = "✅ Enabled" if model_spec.streaming_capable else "❌ Disabled"
+
+        template = '''import gradio as gr
 import torch
 from transformers import AutoModelForCausalLM, AutoTokenizer, TextIteratorStreamer
 import threading
 import time
 
 # Model configuration
-MODEL_ID = "{model_id}"
+MODEL_ID = "__MODEL_ID__"
 DEVICE = "cuda" if torch.cuda.is_available() else "cpu"
 MAX_LENGTH = 500
 TEMPERATURE = 0.7
 
 # Load model and tokenizer
-print(f"Loading model: {{MODEL_ID}}")
+print(f"Loading model: {MODEL_ID}")
 try:
     tokenizer = AutoTokenizer.from_pretrained(MODEL_ID)
     if tokenizer.pad_token is None:
@@ -512,7 +516,7 @@ try:
     model.eval()
     print("Model loaded successfully!")
 except Exception as e:
-    print(f"Error loading model: {{e}}")
+    print(f"Error loading model: {e}")
     model = None
     tokenizer = None
 
@@ -559,7 +563,7 @@ def generate_response_stream(message, history, temperature=TEMPERATURE, max_leng
             yield partial_text
             
     except Exception as e:
-        yield f"❌ Generation error: {{e}}"
+        yield f"❌ Generation error: {e}"
 
 def generate_response_non_stream(message, history, temperature=TEMPERATURE, max_length=MAX_LENGTH):
     """Generate non-streaming response (fallback)"""
@@ -570,8 +574,8 @@ def generate_response_non_stream(message, history, temperature=TEMPERATURE, max_
         # Simple prompt for non-streaming mode
         prompt = message
         if history:
-            context = "\\n".join([f"User: {{h}}\\nAssistant: {{a}}" for h, a in history[-3:]])
-            prompt = f"{{context}}\\nUser: {{message}}\\nAssistant: "
+            context = "\\n".join([f"User: {h}\\nAssistant: {a}" for h, a in history[-3:]])
+            prompt = f"{context}\\nUser: {message}\\nAssistant: "
         
         inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
         
@@ -589,17 +593,17 @@ def generate_response_non_stream(message, history, temperature=TEMPERATURE, max_
         return response
         
     except Exception as e:
-        return f"❌ Generation error: {{e}}"
+        return f"❌ Generation error: {e}"
 
 # Create enhanced chat interface
-with gr.Blocks(title="{space_name}", theme=gr.themes.Soft()) as demo:
+with gr.Blocks(title="__SPACE_NAME__", theme=gr.themes.Soft()) as demo:
     gr.Markdown(f"""
-    # 🤖 {space_name}
+    # 🤖 __SPACE_NAME__
     
     **Model:** `{MODEL_ID}`  
-    **Hardware:** {model_spec.recommended_hardware.upper()}  
-    **Parameters:** {model_spec.parameters}  
-    **Streaming:** {'✅ Enabled' if model_spec.streaming_capable else '❌ Disabled'}
+    **Hardware:** __HARDWARE__  
+    **Parameters:** __PARAMETERS__  
+    **Streaming:** __STREAMING__
     
     ---
     """)
@@ -717,10 +721,18 @@ if __name__ == "__main__":
     demo.queue()
     demo.launch()
 '''
+        return (
+            template
+            .replace("__MODEL_ID__", model_id)
+            .replace("__SPACE_NAME__", space_name)
+            .replace("__HARDWARE__", hardware)
+            .replace("__PARAMETERS__", parameters)
+            .replace("__STREAMING__", streaming)
+        )
 
     def generate_embedding_template(self, model_id: str, space_name: str) -> str:
         """Generate optimized embedding template"""
-        return f"""import streamlit as st
+        template = """import streamlit as st
 import torch
 from transformers import AutoModel, AutoTokenizer
 import numpy as np
@@ -730,14 +742,14 @@ import plotly.express as px
 import plotly.graph_objects as go
 
 # Model configuration
-MODEL_ID = "{model_id}"
+MODEL_ID = "__MODEL_ID__"
 DEVICE = "cuda" if torch.cuda.is_available() else "cpu"
 BATCH_SIZE = 32
 MAX_SEQ_LENGTH = 512
 
-st.set_page_config(page_title="{space_name}", layout="wide")
+st.set_page_config(page_title="__SPACE_NAME__", layout="wide")
 
-st.title(f"🔤 {space_name}")
+st.title(f"🔤 __SPACE_NAME__")
 st.markdown(f"**Model:** `{MODEL_ID}`")
 st.markdown("**Hardware:** CPU-Optimized for Embeddings")
 
@@ -749,7 +761,7 @@ def load_model():
         model = SentenceTransformer(MODEL_ID)
         return model
     except Exception as e:
-        st.error(f"Error loading model: {{e}}")
+        st.error(f"Error loading model: {e}")
         return None
 
 st.header("Text Embedding Service")
@@ -801,8 +813,8 @@ if st.button("🚀 Generate Embeddings", type="primary"):
                     })
                     
                     # Show summary
-                    st.write(f"✅ Generated embeddings for **{{len(texts)}}** texts")
-                    st.write(f"📏 Embedding dimensions: **{{len(embeddings[0])}}**")
+                    st.write(f"✅ Generated embeddings for **{len(texts)}** texts")
+                    st.write(f"📏 Embedding dimensions: **{len(embeddings[0])}**")
                     
                     # Similarity matrix
                     if len(texts) > 1:
@@ -816,8 +828,8 @@ if st.button("🚀 Generate Embeddings", type="primary"):
                         fig = px.imshow(
                             similarity_matrix,
                             labels=dict(x="Text", y="Text", color="Similarity"),
-                            x=[f"Text {{i+1}}" for i in range(len(texts))],
-                            y=[f"Text {{i+1}}" for i in range(len(texts))],
+                            x=[f"Text {i+1}" for i in range(len(texts))],
+                            y=[f"Text {i+1}" for i in range(len(texts))],
                             color_continuous_scale="viridis"
                         )
                         fig.update_layout(title="Text Similarity Matrix")
@@ -921,6 +933,9 @@ with col2:
 st.markdown("---")
 st.markdown("🚀 **Powered by Terradev** | Multi-Cloud GPU Arbitrage Platform")
 """
+        return template.replace("__MODEL_ID__", model_id).replace(
+            "__SPACE_NAME__", space_name
+        )
 
 
 class HardwareOptimizer:

terradev_cli-5.5.4/terradev_cli/core/monitoring.py

@@ -0,0 +1,31 @@
+"""
+Minimal MetricsCollector stub so optimization modules can import without error.
+"""
+
+import logging
+import time
+from typing import Any, Dict, List, Optional
+
+logger = logging.getLogger(__name__)
+
+
+class MetricsCollector:
+    """Lightweight metrics collector used by the optimization layer."""
+
+    def __init__(self, config: Optional[Any] = None):
+        self.config = config
+        self._metrics: List[Dict[str, Any]] = []
+
+    def record(self, name: str, value: float, tags: Optional[Dict[str, str]] = None) -> None:
+        entry = {"name": name, "value": value, "ts": time.time(), "tags": tags or {}}
+        self._metrics.append(entry)
+        logger.debug("metric %s=%.4f tags=%s", name, value, entry["tags"])
+
+    def increment(self, name: str, tags: Optional[Dict[str, str]] = None) -> None:
+        self.record(name, 1.0, tags)
+
+    def get_metrics(self) -> List[Dict[str, Any]]:
+        return list(self._metrics)
+
+    def reset(self) -> None:
+        self._metrics.clear()

{terradev_cli-5.5.2 → terradev_cli-5.5.4}/terradev_cli/mcp/server.py

@@ -18,6 +18,7 @@ import hashlib
 import json
 import logging
 import os
+import re
 import secrets
 import subprocess
 import sys
@@ -33,7 +34,7 @@ try:
     import aiohttp
 except ImportError:
     aiohttp = None  # type: ignore[assignment]
-from typing import Any, Dict, List
+from typing import Any, Dict, List, Optional
 from urllib.parse import urlencode
 
 try:

{terradev_cli-5.5.2 → terradev_cli-5.5.4}/terradev_cli/ml_services/kubernetes_enhanced.py

@@ -6,12 +6,15 @@ Integrates Karpenter, Prometheus, Grafana, and Terradev monitoring
 
 import os
 import json
+import logging
 import aiohttp
 import subprocess
 from typing import Dict, List, Any, Optional
 
 from .kubernetes_service import KubernetesConfig  # single canonical definition
 
+logger = logging.getLogger(__name__)
+
 
 class EnhancedKubernetesService:
     """Enhanced Kubernetes service with deep monitoring integration"""

{terradev_cli-5.5.2 → terradev_cli-5.5.4}/terradev_cli/ml_services/langgraph_service.py

@@ -9,6 +9,25 @@ from typing import Dict, List, Any, Optional
 from dataclasses import dataclass
 from datetime import datetime
 
+try:
+    from langchain_core.messages import SystemMessage, HumanMessage
+    from langchain_openai import ChatOpenAI
+
+    def LLM(llm: str = "openai/gpt-4", temperature: float = 0.7):
+        """Build a chat model from a 'provider/model' identifier."""
+        model = llm.split("/", 1)[-1]
+        return ChatOpenAI(model=model, temperature=temperature)
+
+except ImportError:  # pragma: no cover - optional dependency
+    SystemMessage = None  # type: ignore[assignment]
+    HumanMessage = None  # type: ignore[assignment]
+
+    def LLM(llm: str = "openai/gpt-4", temperature: float = 0.7):
+        raise RuntimeError(
+            "langchain-openai and langchain-core are required for LangGraph LLM nodes. "
+            "Install with: pip install langchain-openai langchain-core"
+        )
+
 
 @dataclass
 class LangGraphConfig:
@@ -55,7 +74,7 @@ class LangGraphService:
 
             # Test LangSmith connection
             if self.config.langsmith_api_key:
-                langsmith_session = langsmith_session
+                langsmith_session = self.session
 
                 url = f"{self.langsmith_api_base}/v1/organizations"
                 async with langsmith_session.get(
@@ -136,6 +155,24 @@ class LangGraphService:
             # Define the workflow state
             from langgraph.graph import StateGraph, START, END
 
+            workflow_id = (
+                f"terradev-orchestrator-{datetime.now().strftime('%Y%m%d-%H%M%S')}"
+            )
+            enhanced_config = {
+                **workflow_config,
+                "monitoring": {
+                    "enabled": self.config.dashboard_enabled,
+                    "tracing": self.config.tracing_enabled,
+                    "evaluation": self.config.evaluation_enabled,
+                    "deployment": self.config.deployment_enabled,
+                    "observability": self.config.observability_enabled,
+                },
+                "langsmith": {
+                    "project": self.config.project_name or "terradev",
+                    "workspace_id": self.config.workspace_id,
+                },
+            }
+
             # Enhanced state with monitoring
             class WorkflowState:
                 topic: str

{terradev_cli-5.5.2 → terradev_cli-5.5.4}/terradev_cli/optimization/auto_optimizer.py

@@ -473,7 +473,7 @@ class AutoOptimizer:
             base_confidence += 0.05
 
         # Adjust based on historical performance
-        if deployment_id in self.optimization_history:
+        if context.deployment_id in self.optimization_history:
             historical_success = self._calculate_historical_success_rate(
                 context.deployment_id
             )

{terradev_cli-5.5.2 → terradev_cli-5.5.4}/terradev_cli/providers/alibaba_provider.py

@@ -322,7 +322,7 @@ class AlibabaProvider(BaseProvider):
     # ── Provisioning ──────────────────────────────────────────────────
 
     async def provision_instance(
-        self, instance_type: str, region: str, gpu_type: str
+        self, instance_type: str, region: str, gpu_type: str, ssh_public_key: str = ""
     ) -> Dict[str, Any]:
         """Provision Alibaba instance with compliance checks"""
         # CRITICAL: Check compliance before provisioning