synth-ai 0.3.1.dev3__tar.gz → 0.3.1.dev5__tar.gz

{synth_ai-0.3.1.dev3/synth_ai.egg-info → synth_ai-0.3.1.dev5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: synth-ai
-Version: 0.3.1.dev3
+Version: 0.3.1.dev5
 Summary: Serverless Posttraining for Agents - Core AI functionality and tracing
 Author-email: Synth AI <josh@usesynth.ai>
 License-Expression: MIT

{synth_ai-0.3.1.dev3 → synth_ai-0.3.1.dev5}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "synth-ai"
-version = "0.3.1.dev3"
+version = "0.3.1.dev5"
 description = "Serverless Posttraining for Agents - Core AI functionality and tracing"
 authors = [{name = "Synth AI", email = "josh@usesynth.ai"}]
 license = "MIT"

{synth_ai-0.3.1.dev3 → synth_ai-0.3.1.dev5}/synth_ai/sdk/api/train/validators.py

@@ -2143,36 +2143,62 @@ def validate_mipro_config_from_file(config_path: Path) -> Tuple[bool, List[str]]
                                             f"❌ mipro.modules[{module_idx}].stages[{stage_idx}].max_demo_slots must be an integer"
                                         )
                                 
-                                # Validate per-stage policy config (REQUIRED)
+                                # Validate per-stage policy config
+                                # Policy is OPTIONAL if top-level [prompt_learning.policy] has model+provider
+                                # Policy is REQUIRED if no valid top-level policy exists
                                 stage_policy = stage_entry.get("policy")
+                                has_top_level_policy = (
+                                    isinstance(policy_section, dict) and 
+                                    policy_section.get("model") and 
+                                    policy_section.get("provider")
+                                )
+                                
                                 if stage_policy is None:
-                                    errors.append(
-                                        f"❌ mipro.modules[{module_idx}].stages[{stage_idx}]: [policy] table is REQUIRED. "
-                                        f"Each stage must have its own policy configuration with 'model' and 'provider' fields."
-                                    )
+                                    # No per-stage policy - only error if no top-level fallback
+                                    if not has_top_level_policy:
+                                        errors.append(
+                                            f"❌ mipro.modules[{module_idx}].stages[{stage_idx}]: [policy] is required. "
+                                            f"Either add [prompt_learning.policy] with model+provider (applies to all stages), "
+                                            f"OR add [prompt_learning.mipro.modules.stages.policy] for this stage."
+                                        )
                                 elif not isinstance(stage_policy, dict):
                                     errors.append(
                                         f"❌ mipro.modules[{module_idx}].stages[{stage_idx}]: [policy] must be a table/dict, got {type(stage_policy).__name__}"
                                     )
                                 else:
-                                    # Validate required fields in stage policy
-                                    if not stage_policy.get("model"):
-                                        errors.append(
-                                            f"❌ mipro.modules[{module_idx}].stages[{stage_idx}]: [policy].model is required"
-                                        )
-                                    if not stage_policy.get("provider"):
-                                        errors.append(
-                                            f"❌ mipro.modules[{module_idx}].stages[{stage_idx}]: [policy].provider is required"
-                                        )
-                                    # Validate model/provider combination
+                                    # Per-stage policy exists - validate it (model/provider can inherit from top-level)
                                     stage_model = stage_policy.get("model")
                                     stage_provider = stage_policy.get("provider")
-                                    if stage_model and stage_provider:
+                                    
+                                    # If stage specifies model, it must also specify provider (and vice versa)
+                                    # Unless inheriting from top-level
+                                    if stage_model and not stage_provider:
+                                        if has_top_level_policy:
+                                            # Inherit provider from top-level
+                                            stage_provider = policy_section.get("provider")
+                                        else:
+                                            errors.append(
+                                                f"❌ mipro.modules[{module_idx}].stages[{stage_idx}]: [policy].provider is required when model is specified"
+                                            )
+                                    elif stage_provider and not stage_model:
+                                        if has_top_level_policy:
+                                            # Inherit model from top-level
+                                            stage_model = policy_section.get("model")
+                                        else:
+                                            errors.append(
+                                                f"❌ mipro.modules[{module_idx}].stages[{stage_idx}]: [policy].model is required when provider is specified"
+                                            )
+                                    
+                                    # Validate model/provider combination if both are available
+                                    effective_model = stage_model or (policy_section.get("model") if has_top_level_policy else None)
+                                    effective_provider = stage_provider or (policy_section.get("provider") if has_top_level_policy else None)
+                                    if effective_model and effective_provider:
                                         errors.extend(_validate_model_for_provider(
-                                            stage_model, stage_provider,
+                                            effective_model, effective_provider,
                                             f"prompt_learning.mipro.modules[{module_idx}].stages[{stage_idx}].policy.model",
                                             allow_nano=True,  # Policy models can be nano
                                         ))
+                                    
                                     # Reject inference_url in stage policy (trainer provides it)
                                     if "inference_url" in stage_policy:
                                         errors.append(
@@ -2243,14 +2269,48 @@ def validate_mipro_config_from_file(config_path: Path) -> Tuple[bool, List[str]]
         elif len(initial_prompt.get("messages", [])) == 0:
             errors.append("❌ [prompt_learning.initial_prompt].messages cannot be empty")
     
-    # Check policy section
-    if not isinstance(policy_section, dict):
-        errors.append("❌ [prompt_learning.policy] section is missing or invalid")
+    # Check policy section - EITHER top-level OR per-stage policies required
+    # First, check if all stages have their own policy
+    all_stages_have_policy = True
+    if isinstance(modules_config, list):
+        for module_entry in modules_config:
+            if isinstance(module_entry, dict):
+                stages = module_entry.get("stages")
+                if isinstance(stages, list):
+                    for stage_entry in stages:
+                        if isinstance(stage_entry, dict):
+                            stage_policy = stage_entry.get("policy")
+                            if not isinstance(stage_policy, dict) or not stage_policy.get("model") or not stage_policy.get("provider"):
+                                all_stages_have_policy = False
+                                break
+                    if not all_stages_have_policy:
+                        break
     else:
-        if not policy_section.get("model"):
-            errors.append("❌ [prompt_learning.policy].model is required")
-        if not policy_section.get("provider"):
-            errors.append("❌ [prompt_learning.policy].provider is required")
+        all_stages_have_policy = False  # No modules means we need top-level policy
+    
+    has_valid_top_level_policy = (
+        isinstance(policy_section, dict) and 
+        policy_section.get("model") and 
+        policy_section.get("provider")
+    )
+    
+    # Only require top-level policy if NOT all stages have their own
+    if not has_valid_top_level_policy and not all_stages_have_policy:
+        if not isinstance(policy_section, dict):
+            errors.append(
+                "❌ [prompt_learning.policy] section is missing. "
+                "Either add [prompt_learning.policy] with model+provider (applies to all stages), "
+                "OR add [policy] to each stage in [prompt_learning.mipro.modules.stages]."
+            )
+        else:
+            if not policy_section.get("model"):
+                errors.append(
+                    "❌ [prompt_learning.policy].model is required (unless all stages have their own [policy].model)"
+                )
+            if not policy_section.get("provider"):
+                errors.append(
+                    "❌ [prompt_learning.policy].provider is required (unless all stages have their own [policy].provider)"
+                )
     
     # Validate proxy_models section (can be at top-level or mipro-specific)
     proxy_models_section = pl_section.get("proxy_models") or mipro_section.get("proxy_models")

{synth_ai-0.3.1.dev3 → synth_ai-0.3.1.dev5}/synth_ai/sdk/task/in_process.py

@@ -230,12 +230,12 @@ async def _verify_preconfigured_url_ready(
     Verify that a preconfigured tunnel URL is routing traffic.
     
     This is similar to _verify_tunnel_ready but designed for external tunnel
-    providers (Daytona, ngrok, etc.) where we don't control the tunnel setup.
+    providers (ngrok, etc.) where we don't control the tunnel setup.
     
     Args:
         tunnel_url: The external tunnel URL to verify
         api_key: API key for task app authentication
-        extra_headers: Additional headers for the tunnel (e.g., Daytona preview token)
+        extra_headers: Additional headers for the tunnel (e.g., auth tokens)
         max_retries: Number of retry attempts
         retry_delay: Delay between retries in seconds
         timeout_per_request: Timeout for each HTTP request
@@ -249,23 +249,19 @@ async def _verify_preconfigured_url_ready(
         "Authorization": f"Bearer {api_key}",
     }
     
-    # Add any extra headers (e.g., x-daytona-preview-token)
+    # Add any extra headers (e.g., custom auth tokens)
     if extra_headers:
         headers.update(extra_headers)
     
-    # Also add Daytona skip warning header by default for convenience
-    headers["X-Daytona-Skip-Preview-Warning"] = "true"
-    
     logger.info(f"Verifying preconfigured URL is accessible (max {max_retries} attempts)...")
     
     for attempt in range(max_retries):
         try:
-            # Use verify=False since external tunnels may have different certs
-            async with httpx.AsyncClient(timeout=timeout_per_request, verify=False) as client:
+            async with httpx.AsyncClient(timeout=timeout_per_request) as client:
                 health = await client.get(f"{base}/health", headers=headers)
             
-            # Accept various success codes - the tunnel is working if we get any response
-            if health.status_code in (200, 400, 401, 403, 404, 405):
+            # Only accept 200 for health checks - other codes may indicate misrouting
+            if health.status_code == 200:
                 logger.info(
                     f"Preconfigured URL ready after {attempt + 1} attempt(s): "
                     f"health={health.status_code}"
@@ -314,7 +310,7 @@ class InProcessTaskApp:
     - "named": Cloudflare named/managed tunnel
     - "local": No tunnel, use localhost URL directly
     - "preconfigured": Use externally-provided URL (set via preconfigured_url param or
-      SYNTH_TASK_APP_URL env var). Useful for Daytona, ngrok, or other tunnel providers.
+      SYNTH_TASK_APP_URL env var). Useful for ngrok or other external tunnel providers.
     
     Example:
         ```python
@@ -328,12 +324,12 @@ class InProcessTaskApp:
         ) as task_app:
             print(f"Task app running at: {task_app.url}")
         
-        # Use preconfigured URL (e.g., from Daytona preview, ngrok, etc.)
+        # Use preconfigured URL (e.g., from ngrok, localtunnel, etc.)
         async with InProcessTaskApp(
             config_factory=build_config,
             port=8000,
             tunnel_mode="preconfigured",
-            preconfigured_url="https://8000-sandbox123.proxy.daytona.work",
+            preconfigured_url="https://abc123.ngrok.io",
         ) as task_app:
             print(f"Task app running at: {task_app.url}")
         ```
@@ -373,7 +369,7 @@ class InProcessTaskApp:
             preconfigured_url: External tunnel URL to use when tunnel_mode="preconfigured".
                               Can also be set via SYNTH_TASK_APP_URL env var.
             preconfigured_auth_header: Optional auth header name for preconfigured URL
-                                       (e.g., "x-daytona-preview-token")
+                                       (e.g., "x-custom-auth-token")
             preconfigured_auth_token: Optional auth token value for preconfigured URL
             api_key: API key for health checks (defaults to ENVIRONMENT_API_KEY env var)
             health_check_timeout: Max time to wait for health check in seconds
@@ -398,7 +394,7 @@ class InProcessTaskApp:
         if not (1024 <= port <= 65535):
             raise ValueError(f"Port must be in range [1024, 65535], got {port}")
 
-        # Validate host (allow 0.0.0.0 for container environments like Daytona)
+        # Validate host (allow 0.0.0.0 for container environments)
         allowed_hosts = ("127.0.0.1", "localhost", "0.0.0.0")
         if host not in allowed_hosts:
             raise ValueError(
@@ -567,7 +563,7 @@ class InProcessTaskApp:
         override_host = os.getenv("SYNTH_TUNNEL_HOSTNAME")
         
         if mode == "preconfigured":
-            # Preconfigured mode: use externally-provided URL (e.g., Daytona preview, ngrok)
+            # Preconfigured mode: use externally-provided URL (e.g., ngrok, localtunnel)
             # This bypasses Cloudflare entirely - the caller is responsible for the tunnel
             if not self.preconfigured_url:
                 raise ValueError(

{synth_ai-0.3.1.dev3 → synth_ai-0.3.1.dev5}/synth_ai/sdk/task/in_process_runner.py

@@ -12,7 +12,7 @@ Tunnel Modes:
 - "named": Uses Cloudflare managed tunnel (requires setup)
 - "local": No tunnel, uses localhost URL directly
 - "preconfigured": Uses externally-provided URL - for container environments
-  (Daytona, ngrok, etc.) where Cloudflare tunnels don't work
+  (ngrok, etc.) where Cloudflare tunnels don't work
 
 Environment Variables:
 - SYNTH_TASK_APP_URL: If set, auto-enables preconfigured mode with this URL

{synth_ai-0.3.1.dev3 → synth_ai-0.3.1.dev5/synth_ai.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: synth-ai
-Version: 0.3.1.dev3
+Version: 0.3.1.dev5
 Summary: Serverless Posttraining for Agents - Core AI functionality and tracing
 Author-email: Synth AI <josh@usesynth.ai>
 License-Expression: MIT