synth-ai 0.2.6.dev1__py3-none-any.whl → 0.4.3__py3-none-any.whl

synth_ai/__init__.py

@@ -1,36 +1,56 @@
-"""
-Synth AI - Software for aiding the best and multiplying the will.
-"""
+from __future__ import annotations
 
-# Environment exports - moved from synth-env
-from synth_ai.environments import *  # noqa
-import synth_ai.environments as environments  # expose module name for __all__
-try:
-    from synth_ai.lm.core.main import LM  # Moved from zyk to lm for better organization
-except Exception:  # allow minimal imports (e.g., tracing) without LM stack
-    LM = None  # type: ignore
-try:
-    from synth_ai.lm.provider_support.anthropic import Anthropic, AsyncAnthropic
-except Exception:  # optional in minimal environments
-    Anthropic = AsyncAnthropic = None  # type: ignore
+from importlib import metadata as _metadata
+from importlib.metadata import PackageNotFoundError
+from pathlib import Path
 
-# Provider support exports - moved from synth-sdk to synth_ai/lm
+# Install log filter as early as possible to suppress noisy codex_otel logs
 try:
-    from synth_ai.lm.provider_support.openai import AsyncOpenAI, OpenAI
+    from synth_ai.core.log_filter import install_log_filter
+    install_log_filter()
 except Exception:
-    AsyncOpenAI = OpenAI = None  # type: ignore
+    # Silently fail if log filter can't be installed
+    pass
+
+# Judge schemas moved to sdk/judging/schemas.py
+from synth_ai.sdk.judging.schemas import (
+    CriterionScorePayload,
+    JudgeOptions,
+    JudgeScoreRequest,
+    JudgeScoreResponse,
+    JudgeTaskApp,
+    JudgeTracePayload,
+    ReviewPayload,
+)
+
+try:  # Prefer the installed package metadata when available
+    __version__ = _metadata.version("synth-ai")
+except PackageNotFoundError:  # Fallback to pyproject version for editable installs
+    try:
+        import tomllib as _toml  # Python 3.11+
+    except ModuleNotFoundError:  # pragma: no cover - legacy interpreter guard
+        import tomli as _toml  # type: ignore[no-redef]
+
+    try:
+        pyproject_path = Path(__file__).resolve().parents[1] / "pyproject.toml"
+        with pyproject_path.open("rb") as fh:
+            _pyproject = _toml.load(fh)
+        __version__ = str(_pyproject["project"]["version"])
+    except Exception:
+        __version__ = "0.0.0.dev0"
 
 # Legacy tracing v1 is not required for v3 usage and can be unavailable in minimal envs.
 tracing = None  # type: ignore
 EventPartitionElement = RewardSignal = SystemTrace = TrainingQuestion = None  # type: ignore
 trace_event_async = trace_event_sync = upload = None  # type: ignore
 
-__version__ = "0.2.6.dev1"
 __all__ = [
-    "LM",
-    "OpenAI",
-    "AsyncOpenAI",
-    "Anthropic",
-    "AsyncAnthropic",
-    "environments",
+    # Judge API contracts
+    "JudgeScoreRequest",
+    "JudgeScoreResponse",
+    "JudgeOptions",
+    "JudgeTaskApp",
+    "JudgeTracePayload",
+    "ReviewPayload",
+    "CriterionScorePayload",
 ]  # Explicitly define public API (v1 tracing omitted in minimal env)

synth_ai/__main__.py

@@ -3,7 +3,34 @@
 Allow running synth_ai as a module: python -m synth_ai
 """
 
-from .cli import cli
+import sys
+import traceback
 
-if __name__ == "__main__":
-    cli()
+# Log CLI invocation immediately
+if "train" in sys.argv:
+    sys.stderr.write(f"[SYNTH_AI_MAIN] Module invoked with args: {sys.argv}\n")
+    sys.stderr.flush()
+
+try:
+    from .cli import cli
+    
+    if "train" in sys.argv:
+        sys.stderr.write("[SYNTH_AI_MAIN] CLI imported successfully\n")
+        sys.stderr.flush()
+    
+    if __name__ == "__main__":
+        if "train" in sys.argv:
+            sys.stderr.write("[SYNTH_AI_MAIN] About to call cli()\n")
+            sys.stderr.flush()
+        try:
+            cli()
+        except Exception as e:
+            sys.stderr.write(f"[SYNTH_AI_MAIN] CLI call failed: {type(e).__name__}: {e}\n")
+            sys.stderr.flush()
+            traceback.print_exc(file=sys.stderr)
+            raise
+except Exception as e:
+    sys.stderr.write(f"[SYNTH_AI_MAIN] Import failed: {type(e).__name__}: {e}\n")
+    sys.stderr.flush()
+    traceback.print_exc(file=sys.stderr)
+    raise

synth_ai/cli/__init__.py

@@ -1,11 +1,22 @@
 """CLI subcommands for Synth AI.
 
-This package hosts modular commands (watch, traces, recent, calc, status)
-and exposes a top-level Click group named `cli` compatible with the
-pyproject entry point `synth_ai.cli:cli`.
+This package hosts modular commands and exposes a top-level Click group
+named `cli` compatible with the pyproject entry point `synth_ai.cli:cli`.
 """
 
-from __future__ import annotations
+import importlib
+import sys
+from collections.abc import Callable
+from typing import Any
+
+from synth_ai.cli.agents import claude_cmd, codex_cmd, opencode_cmd
+from synth_ai.cli.demos.demo import demo_cmd
+from synth_ai.cli.deploy import deploy_cmd
+from synth_ai.cli.infra.mcp import mcp_cmd
+from synth_ai.cli.infra.modal_app import modal_app_cmd
+from synth_ai.cli.infra.setup import setup_cmd
+from synth_ai.cli.task_apps import task_app_cmd
+from synth_ai.cli.training.train_cfg import train_cfg_cmd
 
 # Load environment variables from a local .env if present (repo root)
 try:
@@ -17,61 +28,105 @@ except Exception:
     # dotenv is optional at runtime; proceed if unavailable
     pass
 
+def _callable_from(module: Any, attr: str) -> Callable[..., Any] | None:
+    candidate = getattr(module, attr, None)
+    return candidate if callable(candidate) else None
 
-from .root import cli  # new canonical CLI entrypoint
 
-# Register subcommands from this package onto the group
-try:
-    from . import watch as _watch
+def _maybe_import(module_path: str) -> Any | None:
+    try:
+        return importlib.import_module(module_path)
+    except Exception:
+        return None
 
-    _watch.register(cli)
-except Exception:
-    pass
-try:
-    from . import balance as _balance
 
-    _balance.register(cli)
-except Exception:
-    pass
-try:
-    from . import man as _man
+def _maybe_call(module_path: str, attr: str, *args: Any, **kwargs: Any) -> None:
+    module = _maybe_import(module_path)
+    if not module:
+        return
+    fn = _callable_from(module, attr)
+    if fn:
+        fn(*args, **kwargs)
 
-    _man.register(cli)
-except Exception:
-    pass
-try:
-    from . import traces as _traces
 
-    _traces.register(cli)
-except Exception:
-    pass
-try:
-    from . import recent as _recent
+# Apply Typer patch if available
+_maybe_call("synth_ai.cli._internal.typer_patch", "patch_typer_make_metavar")
 
-    _recent.register(cli)
-except Exception:
-    pass
-try:
-    from . import calc as _calc
 
-    _calc.register(cli)
-except Exception:
-    pass
-try:
-    from . import status as _status
+_cli_module = _maybe_import("synth_ai.cli.root")
+if not _cli_module:
+    raise ImportError("synth_ai.cli.root is required for CLI entrypoint")
+cli = _cli_module.cli  # type: ignore[attr-defined]
 
-    _status.register(cli)
-except Exception:
-    pass
-try:
-    from . import demo as _demo
 
-    _demo.register(cli)
-except Exception:
-    pass
+
+# Register core commands implemented as standalone modules
+
+cli.add_command(claude_cmd, name="claude")
+cli.add_command(codex_cmd, name="codex")
+cli.add_command(demo_cmd, name="demo")
+cli.add_command(deploy_cmd, name="deploy")
+cli.add_command(mcp_cmd, name="mcp")
+cli.add_command(modal_app_cmd, name="modal-app")
+cli.add_command(opencode_cmd, name="opencode")
+cli.add_command(setup_cmd, name="setup")
+cli.add_command(task_app_cmd, name="task-app")
+cli.add_command(train_cfg_cmd, name="train-cfg")
+
+
+# Register optional subcommands packaged under synth_ai.cli.*
+for _module_path in ("synth_ai.cli.commands.demo", "synth_ai.cli.infra.turso"):
+    module = _maybe_import(_module_path)
+    if not module:
+        continue
+    sub_name = _module_path.rsplit(".", 1)[-1]
+    setattr(sys.modules[__name__], sub_name, module)
+    fn = _callable_from(module, "register")
+    if fn:
+        fn(cli)
+
+# Smoke command registration (CLI-only helper)
 try:
-    from . import rl_demo as _rl_demo
+    from synth_ai.cli.commands.smoke import register as register_smoke
 
-    _rl_demo.register(cli)
+    register_smoke(cli)
 except Exception:
     pass
+
+# Register help command
+_maybe_call("synth_ai.cli.commands.help.core", "register", cli)
+
+# Register scan command
+_maybe_call("synth_ai.cli.commands.scan", "register", cli)
+
+# Register eval command
+_maybe_call("synth_ai.cli.commands.eval", "register", cli)
+
+# Train CLI lives under synth_ai.sdk.api.train
+_maybe_call("synth_ai.sdk.api.train", "register", cli)
+
+# Task app group/commands are optional and have richer API surface
+_task_apps_module = _maybe_import("synth_ai.cli.task_apps")
+#if _task_apps_module:
+task_app_group = getattr(_task_apps_module, "task_app_group", None)
+if task_app_group is not None:
+    cli.add_command(task_app_group, name="task-app-group")
+    # Expose common aliases when present
+    commands = getattr(task_app_group, "commands", None)
+    if isinstance(commands, dict):
+        for alias, name in (("serve", "serve"), ("deploy", "deploy"), ("modal-serve", "modal-serve")):
+            command = commands.get(name)
+            if command is not None:
+                cli.add_command(command, name=alias)
+register_task_apps = _callable_from(_task_apps_module, "register")
+if register_task_apps:
+    register_task_apps(cli)
+
+# Top-level 'info' alias removed; use `synth-ai task-app info` instead
+
+# Experiment queue commands
+_maybe_call("synth_ai.cli.utils.experiments", "register", cli)
+_maybe_call("synth_ai.cli.utils.queue", "register", cli)
+
+# Artifacts commands
+_maybe_call("synth_ai.cli.commands.artifacts", "register", cli)

synth_ai/cli/__main__.py

@@ -0,0 +1,42 @@
+#!/usr/bin/env python3
+"""
+Allow running synth_ai.cli as a module: python -m synth_ai.cli
+"""
+
+import sys
+import traceback
+
+# Log CLI invocation immediately
+if "train" in sys.argv:
+    sys.stderr.write(f"[CLI_MAIN] Module synth_ai.cli invoked with args: {sys.argv}\n")
+    sys.stderr.flush()
+
+try:
+    from . import cli
+    
+    if "train" in sys.argv:
+        sys.stderr.write("[CLI_MAIN] CLI imported successfully\n")
+        sys.stderr.flush()
+    
+    if __name__ == "__main__":
+        if "train" in sys.argv:
+            sys.stderr.write("[CLI_MAIN] About to call cli()\n")
+            sys.stderr.flush()
+        try:
+            cli()
+        except Exception as e:
+            sys.stderr.write(f"[CLI_MAIN] CLI call failed: {type(e).__name__}: {e}\n")
+            sys.stderr.flush()
+            traceback.print_exc(file=sys.stderr)
+            raise
+except Exception as e:
+    sys.stderr.write(f"[CLI_MAIN] Import failed: {type(e).__name__}: {e}\n")
+    sys.stderr.flush()
+    traceback.print_exc(file=sys.stderr)
+    raise
+
+
+
+
+
+

synth_ai/cli/_internal/__init__.py

@@ -0,0 +1,5 @@
+"""Internal CLI utilities (not part of public API)."""
+
+__all__: list[str] = []
+
+

synth_ai/cli/_internal/modal_wrapper.py

@@ -0,0 +1,31 @@
+from __future__ import annotations
+
+import importlib
+import sys
+
+
+def main() -> int:
+    # Apply Typer compatibility patch before Modal CLI bootstraps Click/Typer internals.
+    try:
+        module = importlib.import_module("synth_ai.cli._typer_patch")
+    except Exception:
+        module = None
+    if module is not None:
+        patch = getattr(module, "patch_typer_make_metavar", None)
+        if callable(patch):
+            patch()
+
+    from modal.__main__ import main as modal_main
+
+    # Present ourselves as the upstream `modal` CLI so Typer/Click parsing stays intact.
+    if sys.argv:
+        sys.argv[0] = "modal"
+    else:
+        sys.argv = ["modal"]
+
+    result = modal_main()
+    return result if result is not None else 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

synth_ai/cli/_internal/storage.py

@@ -0,0 +1,20 @@
+"""Dynamic loader for tracing storage components.
+
+This avoids hard dependencies on the tracing_v3 storage package during import
+time, which keeps CLI modules usable in constrained environments while still
+allowing type checkers to resolve the symbols dynamically.
+"""
+
+from __future__ import annotations
+
+import importlib
+from collections.abc import Callable
+from typing import Any, cast
+
+
+def load_storage() -> tuple[Any, Any]:
+    """Return (create_storage, StorageConfig) from tracing_v3.storage."""
+    storage_module = cast(Any, importlib.import_module("synth_ai.core.tracing_v3.storage"))
+    create_storage = cast(Callable[..., Any], storage_module.create_storage)
+    storage_config = storage_module.StorageConfig
+    return create_storage, storage_config

synth_ai/cli/_internal/typer_patch.py

@@ -0,0 +1,47 @@
+from click import Parameter
+
+
+def patch_typer_make_metavar() -> None:
+    try:
+        from typer.main import TyperArgument, TyperOption  # type: ignore[import-untyped]
+    except Exception:
+        return
+
+    def _call_get_metavar(param_type: object, param: Parameter) -> str | None:
+        getter = getattr(param_type, "get_metavar", None)
+        if getter is None:
+            return None
+        try:
+            return getter(param)
+        except TypeError:
+            try:
+                return getter(param, None)
+            except TypeError:
+                return None
+
+    def _patched_argument_make_metavar(self, ctx=None) -> str:
+        if self.metavar is not None:
+            return self.metavar
+        var = (self.name or "").upper()
+        if not self.required:
+            var = f"[{var}]"
+        type_var = _call_get_metavar(self.type, self)
+        if type_var:
+            var += f":{type_var}"
+        if self.nargs != 1:
+            var += "..."
+        return var
+
+    def _patched_option_make_metavar(self, ctx=None) -> str:
+        if self.metavar is not None:
+            return self.metavar
+        metavar = _call_get_metavar(self.type, self)
+        if not metavar:
+            name = getattr(self.type, "name", "") or ""
+            metavar = name.upper()
+        if self.nargs != 1:
+            metavar += "..."
+        return metavar
+
+    TyperArgument.make_metavar = _patched_argument_make_metavar  # type: ignore[assignment]
+    TyperOption.make_metavar = _patched_option_make_metavar  # type: ignore[assignment]

synth_ai/cli/_internal/validate_task_app.py

@@ -0,0 +1,29 @@
+"""Task app validation utilities - imported by task_apps.py"""
+
+# This module provides the validate_task_app function for CLI use
+# The actual implementation is imported from the task module
+
+import importlib
+from collections.abc import Callable
+from typing import Any
+
+_validators_module: Any | None = None
+validate_task_app: Callable[..., Any] | None = None
+
+try:
+    _validators_module = importlib.import_module("synth_ai.sdk.task.validators")
+except Exception:
+    _validators_module = None
+
+if _validators_module is not None:
+    candidate = getattr(_validators_module, "validate_task_app_endpoint", None)
+    if callable(candidate):
+        validate_task_app = candidate
+
+if validate_task_app is None:
+    def _missing_validate_task_app(*_args: Any, **_kwargs: Any) -> None:
+        raise RuntimeError("task validation utilities are unavailable in this environment")
+
+    validate_task_app = _missing_validate_task_app
+
+__all__ = ["validate_task_app"]

synth_ai/cli/agents/__init__.py

@@ -0,0 +1,17 @@
+"""Coding agent integrations (Claude Code, Codex, OpenCode).
+
+These commands launch coding agents with Synth backend configuration
+and optional session management for spending limits.
+"""
+
+from synth_ai.cli.agents.claude import claude_cmd
+from synth_ai.cli.agents.codex import codex_cmd
+from synth_ai.cli.agents.opencode import opencode_cmd
+
+__all__ = [
+    "claude_cmd",
+    "codex_cmd",
+    "opencode_cmd",
+]
+
+

synth_ai/cli/agents/claude.py

@@ -0,0 +1,77 @@
+import os
+import subprocess
+
+import click
+
+from synth_ai.cli.lib.agents import write_agents_md
+from synth_ai.cli.lib.bin import install_bin, verify_bin
+from synth_ai.cli.lib.env import resolve_env_var
+from synth_ai.core.paths import get_bin_path
+from synth_ai.core.urls import BACKEND_URL_SYNTH_RESEARCH_ANTHROPIC
+
+
+@click.command("claude")
+@click.option(
+    "--model",
+    "model_name",
+    type=str,
+    default=None,
+    help="Model name to use (Claude Code uses Anthropic models directly)"
+)
+@click.option(
+    "--force",
+    is_flag=True,
+    help="Prompt for API keys even if cached values exist."
+)
+@click.option(
+    "--url",
+    "override_url",
+    type=str,
+    default=None,
+)
+def claude_cmd(
+    model_name: str | None = None,
+    force: bool = False,
+    override_url: str | None = None
+) -> None:
+    """Launch Claude Code with optional Synth backend routing.
+    
+    Note: Claude Code uses Anthropic models directly. The --model option
+    is for routing through Synth's Anthropic-compatible backend.
+    """
+    while True:
+        bin_path = get_bin_path("claude")
+        if bin_path:
+            break
+        if not install_bin(
+            "Claude Code",
+            ["curl -fsSL https://claude.ai/install.sh | bash"]
+        ):
+            print("Failed to find your installed Claude Code")
+            print("Please install from: https://claude.com/claude-code")
+            return
+    print(f"Using Claude at {bin_path}")
+
+    if not verify_bin(bin_path):
+        print("Failed to verify Claude Code is runnable")
+        return
+
+    write_agents_md()
+    env = os.environ.copy()
+
+    if model_name is not None:
+        # Route through Synth's Anthropic-compatible backend
+        if override_url:
+            url = f"{override_url.rstrip('/')}/{model_name}"
+            print(f"Using override URL with model: {url}")
+        else:
+            url = f"{BACKEND_URL_SYNTH_RESEARCH_ANTHROPIC}/{model_name}"
+        env["ANTHROPIC_BASE_URL"] = url
+        api_key = resolve_env_var("SYNTH_API_KEY", override_process_env=force)
+        env["ANTHROPIC_AUTH_TOKEN"] = api_key
+        env["SYNTH_API_KEY"] = api_key
+
+    try:
+        subprocess.run(["claude"], check=True, env=env)
+    except subprocess.CalledProcessError:
+        print("Failed to launch Claude Code")