astra-sdk 1.0.0__tar.gz

astra_sdk-1.0.0/MANIFEST.in

@@ -0,0 +1,3 @@
+include README.md
+include LICENSE
+recursive-include codeastra *.py *.pyi

astra_sdk-1.0.0/PKG-INFO

@@ -0,0 +1,32 @@
+Metadata-Version: 2.4
+Name: astra-sdk
+Version: 1.0.0
+Summary: AI agent safety infrastructure. One line to connect.
+Author-email: Codeastra <hello@codeastra.dev>
+License: MIT
+Project-URL: Homepage, https://codeastra.dev
+Project-URL: Documentation, https://docs.codeastra.dev
+Project-URL: Repository, https://github.com/codeastra/codeastra-python
+Project-URL: Bug Tracker, https://github.com/codeastra/codeastra-python/issues
+Keywords: ai,agents,safety,llm,openai,anthropic
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+Requires-Dist: requests>=2.28.0
+Requires-Dist: httpx>=0.25.0
+Provides-Extra: all
+Requires-Dist: openai>=1.0.0; extra == "all"
+Requires-Dist: anthropic>=0.20.0; extra == "all"
+Requires-Dist: boto3>=1.26.0; extra == "all"
+Requires-Dist: google-generativeai>=0.4.0; extra == "all"
+Requires-Dist: langchain>=0.1.0; extra == "all"
+Requires-Dist: langchain-openai>=0.1.0; extra == "all"
+Requires-Dist: langchain-anthropic>=0.1.0; extra == "all"

astra_sdk-1.0.0/astra_sdk.egg-info/PKG-INFO

@@ -0,0 +1,32 @@
+Metadata-Version: 2.4
+Name: astra-sdk
+Version: 1.0.0
+Summary: AI agent safety infrastructure. One line to connect.
+Author-email: Codeastra <hello@codeastra.dev>
+License: MIT
+Project-URL: Homepage, https://codeastra.dev
+Project-URL: Documentation, https://docs.codeastra.dev
+Project-URL: Repository, https://github.com/codeastra/codeastra-python
+Project-URL: Bug Tracker, https://github.com/codeastra/codeastra-python/issues
+Keywords: ai,agents,safety,llm,openai,anthropic
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+Requires-Dist: requests>=2.28.0
+Requires-Dist: httpx>=0.25.0
+Provides-Extra: all
+Requires-Dist: openai>=1.0.0; extra == "all"
+Requires-Dist: anthropic>=0.20.0; extra == "all"
+Requires-Dist: boto3>=1.26.0; extra == "all"
+Requires-Dist: google-generativeai>=0.4.0; extra == "all"
+Requires-Dist: langchain>=0.1.0; extra == "all"
+Requires-Dist: langchain-openai>=0.1.0; extra == "all"
+Requires-Dist: langchain-anthropic>=0.1.0; extra == "all"

astra_sdk-1.0.0/astra_sdk.egg-info/SOURCES.txt

@@ -0,0 +1,21 @@
+MANIFEST.in
+pyproject.toml
+astra_sdk.egg-info/PKG-INFO
+astra_sdk.egg-info/SOURCES.txt
+astra_sdk.egg-info/dependency_links.txt
+astra_sdk.egg-info/entry_points.txt
+astra_sdk.egg-info/requires.txt
+astra_sdk.egg-info/top_level.txt
+codeastra/__init__.py
+codeastra/async_client.py
+codeastra/cli.py
+codeastra/client.py
+codeastra/config.py
+codeastra/decorators.py
+codeastra/detector.py
+codeastra/exceptions.py
+codeastra/patch.py
+codeastra/progress.py
+codeastra/py.typed
+codeastra/session.py
+codeastra/types.py

astra_sdk-1.0.0/astra_sdk.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

astra_sdk-1.0.0/astra_sdk.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+codeastra = codeastra.cli:main

astra_sdk-1.0.0/astra_sdk.egg-info/requires.txt

@@ -0,0 +1,11 @@
+requests>=2.28.0
+httpx>=0.25.0
+
+[all]
+openai>=1.0.0
+anthropic>=0.20.0
+boto3>=1.26.0
+google-generativeai>=0.4.0
+langchain>=0.1.0
+langchain-openai>=0.1.0
+langchain-anthropic>=0.1.0

astra_sdk-1.0.0/astra_sdk.egg-info/top_level.txt

@@ -0,0 +1 @@
+codeastra

astra_sdk-1.0.0/codeastra/__init__.py

@@ -0,0 +1,434 @@
+"""
+Codeastra SDK
+═════════════
+AI agent safety infrastructure. One line to connect.
+
+Usage:
+    import codeastra
+
+    codeastra.init(
+        api_key      = "sk-guard-...",
+        goal         = codeastra.Goal.approvals(100),
+        auto_deploy  = True,
+        real_connections = codeastra.RealConnections(
+            stripe_secret_key = "sk_live_...",
+            sendgrid_api_key  = "SG.xxx",
+        )
+    )
+
+    # Your existing agent code — ZERO changes
+    from openai import OpenAI
+    client = OpenAI(api_key="sk-...")
+    # Every tool call now runs through Twin World automatically
+"""
+
+from __future__ import annotations
+
+import logging
+import uuid
+from typing import Callable, Optional, Union
+
+from .exceptions  import (
+    AstraError, AstraAuthError, AstraConnectionError,
+    AstraSessionError, AstraGoalError, AstraWorldError,
+    AstraDeployError, AstraRateLimitError,
+)
+from .types       import Goal, RealConnections, SessionConfig, SessionResult
+from .session     import Session
+from .decorators  import agent
+from .client       import AstraClient
+from .async_client import AsyncAstraClient
+from .progress     import (
+    WorldWatcher, AsyncWorldWatcher,
+    TickEvent, GoalReachedEvent, ViolationEvent,
+    watch, awatch,
+)
+
+__version__ = "1.0.0"
+__all__     = [
+    "init", "connect", "session", "create_world", "worlds",
+    "report", "deploy", "fork", "compare", "status",
+    "Session", "Goal", "RealConnections", "agent",
+    "AstraError", "AstraAuthError", "AstraConnectionError",
+    "AsyncAstraClient",
+    "WorldWatcher", "AsyncWorldWatcher",
+    "TickEvent", "GoalReachedEvent", "ViolationEvent",
+    "watch", "awatch",
+]
+
+log = logging.getLogger("codeastra")
+
+# ── Global state ──────────────────────────────────────────────────────────────
+
+_state: dict = {
+    "api_key":          "",
+    "proxy_url":        "https://proxy.codeastra.dev",
+    "dev_session":      "",
+    "patched_providers":[],
+    "active_session":   None,
+    "initialized":      False,
+}
+
+
+def _s(key: str, default=None):
+    return _state.get(key, default)
+
+
+# ── Main API ──────────────────────────────────────────────────────────────────
+
+def init(
+    api_key:          str                       = "",
+    proxy_url:        str                       = "",
+    goal:             Optional[Union[Goal, dict]] = None,
+    auto_deploy:      bool                      = False,
+    real_connections: Optional[Union[RealConnections, dict]] = None,
+    world_id:         str                       = "",
+    domain:           str                       = "general",
+    reserves:         float                     = 5_000_000.0,
+    dev_session:      str                       = "",
+    name:             str                       = "sdk-session",
+    silent:           bool                      = False,
+    patch:            bool                      = True,
+) -> SessionResult:
+    """
+    Initialize Codeastra. Patches all detected AI providers and creates
+    a Twin World session. Call this once at the start of your agent script.
+
+    Args:
+        api_key:          Your Codeastra API key (or set ASTRA_API_KEY env var)
+        proxy_url:        Proxy URL (default: https://proxy.codeastra.dev)
+        goal:             What success looks like — Goal.approvals(100), etc.
+        auto_deploy:      Auto-deploy to reality when goal is met
+        real_connections: Stripe, SendGrid, DB credentials for auto-deploy
+        world_id:         Custom AI-generated world ID from create_world()
+        domain:           Built-in physics domain (insurance, general, etc.)
+        reserves:         Initial capital for physics simulation
+        dev_session:      Optional session identifier (auto-generated if not set)
+        name:             Session name for display
+        silent:           Suppress console output
+        patch:            Auto-patch all detected AI providers (default: True)
+
+    Returns:
+        SessionResult with session info, detected providers, and proxy URL
+    """
+    from . import config as _cfg, patch as _patch, detector as _det
+
+    # Load API key from env/config if not provided
+    if not api_key:
+        api_key = _cfg.get_api_key()
+    if not api_key:
+        raise AstraAuthError(
+            "API key required. Pass api_key= or set ASTRA_API_KEY env var.\n"
+            "Get your key at app.codeastra.dev"
+        )
+
+    # Load proxy URL
+    if not proxy_url:
+        proxy_url = _cfg.get_proxy_url()
+
+    # Normalize goal
+    if isinstance(goal, dict):
+        goal = _dict_to_goal(goal)
+
+    # Normalize real_connections
+    if isinstance(real_connections, dict):
+        real_connections = _dict_to_connections(real_connections)
+
+    # Update global state
+    session_key = dev_session or str(uuid.uuid4())
+    _state.update({
+        "api_key":     api_key,
+        "proxy_url":   proxy_url,
+        "dev_session": session_key,
+        "initialized": True,
+    })
+
+    # Auto-detect and patch providers
+    patched = []
+    if patch:
+        patched = _patch.apply_all(api_key, proxy_url, session_key)
+        _state["patched_providers"] = patched
+        if not silent and patched:
+            print(f"[Astra] Connected providers: {', '.join(patched)}")
+
+    # Create session on proxy
+    config = SessionConfig(
+        api_key          = api_key,
+        proxy_url        = proxy_url,
+        dev_session      = session_key,
+        goal             = goal,
+        auto_deploy      = auto_deploy,
+        real_connections = real_connections,
+        world_id         = world_id,
+        domain           = domain,
+        reserves         = reserves,
+        name             = name,
+        silent           = silent,
+    )
+    sess = Session(config)
+    result = sess.start()
+    _state["active_session"] = sess
+
+    # Start real-time watcher if requested or callbacks provided
+    if watch_progress or on_tick or on_goal or on_violation:
+        from .progress import WorldWatcher as _WW
+        watcher = _WW(
+            api_key      = api_key,
+            dev_session  = session_key,
+            proxy_url    = proxy_url,
+            on_tick      = on_tick,
+            on_goal      = on_goal,
+            on_violation = on_violation,
+            silent       = silent,
+        )
+        watcher.start()
+        _state["watcher"] = watcher
+
+    return result
+
+
+def connect(
+    api_key: str = "",
+    **kwargs,
+) -> SessionResult:
+    """
+    Alias for init(). Auto-detects everything.
+
+    connect() without arguments reads from env vars / ~/.codeastra/config.json
+    """
+    return init(api_key=api_key, **kwargs)
+
+
+# ── Session shortcuts ─────────────────────────────────────────────────────────
+
+def session(
+    goal:             Optional[Union[Goal, dict]] = None,
+    auto_deploy:      bool                        = False,
+    real_connections: Optional[Union[RealConnections, dict]] = None,
+    **kwargs,
+) -> Session:
+    """
+    Create a new session context manager.
+
+    Usage:
+        with codeastra.session(goal=Goal.approvals(100)) as s:
+            agent.run()
+        print(s.report())
+    """
+    api_key   = _s("api_key") or kwargs.pop("api_key", "")
+    proxy_url = _s("proxy_url", "https://proxy.codeastra.dev")
+
+    if isinstance(goal, dict):
+        goal = _dict_to_goal(goal)
+    if isinstance(real_connections, dict):
+        real_connections = _dict_to_connections(real_connections)
+
+    config = SessionConfig(
+        api_key          = api_key,
+        proxy_url        = proxy_url,
+        goal             = goal,
+        auto_deploy      = auto_deploy,
+        real_connections = real_connections,
+        **kwargs,
+    )
+    return Session(config)
+
+
+# ── World Builder ─────────────────────────────────────────────────────────────
+
+def create_world(description: str) -> dict:
+    """
+    Create a custom AI-generated Twin World from plain English.
+
+    Claude generates physics rules, hard limits, and autonomous actors
+    specific to your business domain.
+
+    Usage:
+        world = codeastra.create_world(
+            "I'm building a claims processing agent for an insurance company.
+             Approving claims depletes reserves. Fraudulent claims increase risk.
+             Regulator intervenes if risk exceeds 0.8."
+        )
+        codeastra.init(api_key="...", world_id=world["world_id"])
+    """
+    api_key   = _s("api_key")
+    proxy_url = _s("proxy_url", "https://proxy.codeastra.dev")
+    if not api_key:
+        raise AstraAuthError("Call codeastra.init() or pass api_key first")
+
+    client = AstraClient(api_key, proxy_url)
+    result = client.create_world(description)
+
+    if not _s("silent"):
+        world_id = result.get("world_id", "?")
+        domain   = result.get("domain_name", "?")
+        print(f"[Astra] World created: {domain} (id: {world_id})")
+
+    return result
+
+
+def worlds() -> list:
+    """List all available worlds for your API key."""
+    api_key   = _s("api_key")
+    proxy_url = _s("proxy_url", "https://proxy.codeastra.dev")
+    if not api_key:
+        raise AstraAuthError("Call codeastra.init() first")
+    return AstraClient(api_key, proxy_url).list_worlds().get("worlds", [])
+
+
+# ── Session operations ────────────────────────────────────────────────────────
+
+def report(dev_session: str = "") -> dict:
+    """Get Twin World outcome report for current or specified session."""
+    sess = dev_session or _s("dev_session")
+    if not sess:
+        raise AstraSessionError("No active session. Call codeastra.init() first.")
+    return _client().get_report(sess)
+
+
+def status(dev_session: str = "") -> dict:
+    """Get current world state for active session."""
+    sess = dev_session or _s("dev_session")
+    if not sess:
+        raise AstraSessionError("No active session.")
+    return _client().get_session(sess)
+
+
+def deploy(
+    real_connections: Optional[Union[RealConnections, dict]] = None,
+    dev_session: str = "",
+) -> dict:
+    """Manually deploy winning session actions to production."""
+    sess = dev_session or _s("dev_session")
+    if not sess:
+        raise AstraSessionError("No active session.")
+    if isinstance(real_connections, RealConnections):
+        real_connections = real_connections.to_dict()
+    return _client().deploy(sess, real_connections or {})
+
+
+def history(dev_session: str = "") -> dict:
+    """Full tick-by-tick world evolution."""
+    sess = dev_session or _s("dev_session")
+    return _client().get_history(sess)
+
+
+def actor_events(dev_session: str = "") -> dict:
+    """Full history of autonomous actor reactions."""
+    sess = dev_session or _s("dev_session")
+    return _client().get_actor_events(sess)
+
+
+def fork(
+    branches:    list[str],
+    dev_session: str  = "",
+    world_id:    str  = "",
+) -> dict:
+    """
+    Fork current session into parallel branches for strategy comparison.
+
+    Usage:
+        fork_result = codeastra.fork(["aggressive", "conservative", "balanced"])
+        # Run agent in each branch using the returned dev_session_keys
+        winner = codeastra.compare()
+    """
+    sess = dev_session or _s("dev_session")
+    wid  = world_id or _s("world_id", "")
+    return _client().fork(sess, branches, wid)
+
+
+def compare(dev_session: str = "") -> dict:
+    """Compare forked branches. Returns ranked results and winner."""
+    sess = dev_session or _s("dev_session")
+    return _client().compare(sess)
+
+
+def sync_csv(path: str, table: str = "data", dev_session: str = "") -> dict:
+    """Load CSV data into active Twin World session."""
+    sess = dev_session or _s("dev_session")
+    with open(path, "rb") as f:
+        return _client().sync_csv(sess, f.read(), table)
+
+
+def sync_db(
+    connection_url: str,
+    query:          str = "",
+    dev_session:    str = "",
+) -> dict:
+    """Sync data from real database into Twin World session."""
+    sess = dev_session or _s("dev_session")
+    return _client().sync_db(sess, connection_url, query)
+
+
+async def async_init(
+    api_key:      str  = "",
+    **kwargs,
+) -> SessionResult:
+    """
+    Async version of init() for async agent frameworks.
+    Usage:
+        await codeastra.async_init(api_key="sk-guard-...")
+    """
+    from .async_client import AsyncAstraClient as _ACC
+    from . import config as _cfg
+    if not api_key:
+        api_key = _cfg.get_api_key()
+    if not api_key:
+        raise AstraAuthError("api_key required")
+    # init() is sync but session creation can be done async separately
+    # For now delegate to sync init — patches happen synchronously
+    return init(api_key=api_key, **kwargs)
+
+
+def disconnect() -> None:
+    """Remove all provider patches and reset state."""
+    from . import patch as _patch
+    _patch.remove_all()
+    _state.update({
+        "initialized":       False,
+        "patched_providers": [],
+        "active_session":    None,
+    })
+    print("[Astra] Disconnected. All patches removed.")
+
+
+def health() -> dict:
+    """Check proxy and engine health."""
+    proxy_url = _s("proxy_url", "https://proxy.codeastra.dev")
+    api_key   = _s("api_key", "")
+    try:
+        import requests
+        r = requests.get(f"{proxy_url}/health", timeout=5)
+        return r.json() if r.ok else {"status": "unreachable"}
+    except Exception as e:
+        return {"status": "unreachable", "error": str(e)}
+
+
+# ── Helpers ───────────────────────────────────────────────────────────────────
+
+def _client() -> AstraClient:
+    api_key   = _s("api_key")
+    proxy_url = _s("proxy_url", "https://proxy.codeastra.dev")
+    if not api_key:
+        raise AstraAuthError("Call codeastra.init() first")
+    return AstraClient(api_key, proxy_url)
+
+
+def _dict_to_goal(d: dict) -> Goal:
+    gtype = d.get("type", "")
+    if gtype == "world_state":
+        return Goal("world_state", d.get("value", 0),
+                    d.get("field", ""), d.get("op", "gte"))
+    return Goal(gtype, d.get("value", 0))
+
+
+def _dict_to_connections(d: dict) -> RealConnections:
+    return RealConnections(
+        stripe_secret_key = d.get("stripe_secret_key", ""),
+        sendgrid_api_key  = d.get("sendgrid_api_key",  ""),
+        resend_api_key    = d.get("resend_api_key",    ""),
+        slack_bot_token   = d.get("slack_bot_token",   ""),
+        database_url      = d.get("database_url",      ""),
+        from_email        = d.get("from_email",        ""),
+        webhook_url       = d.get("webhook_url",       ""),
+    )