ak-agentbase 0.1.0a1__py3-none-any.whl

agentbase/__init__.py

@@ -0,0 +1,78 @@
+__version__ = "0.1.0a1"
+
+from pathlib import Path
+
+from agentbase.config import get_environment
+from agentbase.config import load_config as _load_config
+from agentbase.exceptions import (
+    AgentBaseError,
+    AgentNotRegisteredError,
+    ConfigValidationError,
+    ContractViolationError,
+    ModelResolutionError,
+)
+from agentbase.models import resolve as _resolve
+from agentbase.registry import load_registry
+from agentbase.types import (
+    AgentBaseConfig,
+    AgentMetadata,
+    AgentStatus,
+    ResolvedAgent,
+    TracingConfig,
+)
+
+__all__ = [
+    "__version__",
+    "load_config",
+    "resolve",
+    "init_tracing",
+    "AgentBaseConfig",
+    "AgentMetadata",
+    "AgentStatus",
+    "ResolvedAgent",
+    "TracingConfig",
+    "AgentBaseError",
+    "AgentNotRegisteredError",
+    "ConfigValidationError",
+    "ContractViolationError",
+    "ModelResolutionError",
+]
+
+_config: AgentBaseConfig | None = None
+_registry: dict[str, AgentMetadata] | None = None
+_environment: str | None = None
+
+
+def load_config(
+    config_path: str | Path | None = None,
+    registry_path: str | Path | None = None,
+) -> AgentBaseConfig:
+    global _config, _registry, _environment
+
+    _config = _load_config(config_path)
+    _environment = get_environment(_config)
+
+    if registry_path is None:
+        base = Path(config_path).parent if config_path else Path.cwd()
+        registry_path = base / "agents.yaml"
+
+    _registry = load_registry(registry_path, _config, _environment)
+    return _config
+
+
+def resolve(agent_name: str, environment: str | None = None) -> ResolvedAgent:
+    if _config is None or _registry is None:
+        raise AgentBaseError(
+            "AgentBase is not initialized. Call agentbase.load_config() before using resolve()."
+        )
+    return _resolve(agent_name, _registry, _config, environment or _environment)
+
+
+def init_tracing() -> None:
+    if _config is None:
+        raise AgentBaseError(
+            "AgentBase is not initialized. Call agentbase.load_config() before init_tracing()."
+        )
+    from agentbase.tracing import init_tracing as _init_tracing
+
+    _init_tracing(_config)

agentbase/__main__.py

@@ -0,0 +1,3 @@
+from agentbase.cli import main
+
+main()

agentbase/cli.py

@@ -0,0 +1,73 @@
+import argparse
+import os
+import sys
+
+from agentbase.config import _config_cache, get_environment, load_config
+from agentbase.exceptions import AgentBaseError
+from agentbase.registry import _registry_cache, load_registry
+
+
+def _validate(config_path: str, registry_path: str) -> bool:
+    """Validate config and registry files.
+
+    Returns True if valid, False if any errors found.
+    """
+    _config_cache.clear()
+    _registry_cache.clear()
+
+    config = None
+    errors: list[str] = []
+
+    # Step 1: Validate agentbase.yaml
+    try:
+        config = load_config(config_path)
+        print(f"✓ {config_path} — project: {config.project}")
+    except AgentBaseError as e:
+        print(f"✗ {e}")
+        errors.append(str(e))
+
+    # Step 2: Validate agents.yaml (if config loaded successfully)
+    if config is not None:
+        try:
+            environment = get_environment(config)
+            load_registry(registry_path, config, environment)
+            print(f"✓ {registry_path} — environment: {environment}")
+        except AgentBaseError as e:
+            print(f"✗ {e}")
+            errors.append(str(e))
+
+        # Step 3: Validate tracing env vars (if using LangSmith)
+        if config.tracing.enabled and config.tracing.backend == "langsmith":
+            if os.environ.get("LANGCHAIN_API_KEY"):
+                print("✓ LANGCHAIN_API_KEY present")
+            else:
+                msg = "LANGCHAIN_API_KEY is not set (required when tracing.backend=langsmith)"
+                print(f"✗ {msg}")
+                errors.append(msg)
+
+    if not errors:
+        print("✓ All checks passed")
+    return not errors
+
+
+def main() -> None:
+    """CLI entry point."""
+    parser = argparse.ArgumentParser(prog="agentbase", description="AgentBase CLI")
+    sub = parser.add_subparsers(dest="command")
+
+    val = sub.add_parser("validate", help="Validate agentbase.yaml and agents.yaml")
+    val.add_argument(
+        "config", nargs="?", default="agentbase.yaml", help="Path to agentbase.yaml"
+    )
+    val.add_argument(
+        "agents", nargs="?", default="agents.yaml", help="Path to agents.yaml"
+    )
+
+    args = parser.parse_args()
+
+    if args.command == "validate":
+        ok = _validate(args.config, args.agents)
+        sys.exit(0 if ok else 1)
+    else:
+        parser.print_help()
+        sys.exit(1)

agentbase/config.py

@@ -0,0 +1,115 @@
+import os
+import re
+from pathlib import Path
+from typing import Any
+
+import yaml
+
+from agentbase.exceptions import ConfigValidationError
+from agentbase.types import AgentBaseConfig, AgentBaseDefaults, ModelAliasConfig, TracingConfig
+
+_config_cache: dict[str, AgentBaseConfig] = {}
+_ENV_VAR_RE = re.compile(r"\$\{([^}]+)\}")
+
+
+def _interpolate(value: Any) -> Any:
+    if isinstance(value, str):
+
+        def _sub(m: re.Match) -> str:
+            var = m.group(1)
+            if var not in os.environ:
+                raise ConfigValidationError(
+                    f"Environment variable '{var}' is referenced in agentbase.yaml but not set. "
+                    f"Set '{var}' in your environment before starting the application."
+                )
+            return os.environ[var]
+
+        return _ENV_VAR_RE.sub(_sub, value)
+    if isinstance(value, dict):
+        return {k: _interpolate(v) for k, v in value.items()}
+    if isinstance(value, list):
+        return [_interpolate(v) for v in value]
+    return value
+
+
+def _parse_models(raw_models: dict) -> dict[str, ModelAliasConfig]:
+    result = {}
+    for alias, raw in raw_models.items():
+        if not isinstance(raw, dict):
+            raise ConfigValidationError(
+                f"Model alias '{alias}' must be a YAML mapping in agentbase.yaml."
+            )
+        alias_dict = dict(raw)
+        default_params = alias_dict.pop("default_params", {})
+        if not alias_dict:
+            raise ConfigValidationError(
+                f"Model alias '{alias}' has no environment mappings in agentbase.yaml."
+            )
+        result[alias] = ModelAliasConfig(environments=alias_dict, default_params=default_params)
+    return result
+
+
+def _validate_coverage(models: dict[str, ModelAliasConfig]) -> None:
+    all_envs: set[str] = set()
+    for alias_config in models.values():
+        all_envs.update(alias_config.environments.keys())
+    for alias, alias_config in models.items():
+        missing = all_envs - set(alias_config.environments)
+        if missing:
+            raise ConfigValidationError(
+                f"Model alias '{alias}' is missing mappings for environment(s): "
+                f"{', '.join(sorted(missing))}. "
+                f"Add these under 'models.{alias}' in agentbase.yaml."
+            )
+
+
+def load_config(path: str | Path | None = None) -> AgentBaseConfig:
+    resolved = Path(path).resolve() if path else (Path.cwd() / "agentbase.yaml").resolve()
+    cache_key = str(resolved)
+
+    if cache_key in _config_cache:
+        return _config_cache[cache_key]
+
+    if not resolved.exists():
+        raise ConfigValidationError(
+            f"Config file not found: {resolved}. Create agentbase.yaml in your project root."
+        )
+
+    with open(resolved) as f:
+        raw = yaml.safe_load(f)
+
+    if not isinstance(raw, dict):
+        raise ConfigValidationError("agentbase.yaml must be a YAML mapping at the top level.")
+
+    raw = _interpolate(raw)
+
+    for field in ("project", "models"):
+        if field not in raw:
+            raise ConfigValidationError(f"agentbase.yaml is missing required field '{field}'.")
+
+    models = _parse_models(raw["models"])
+
+    defaults_raw = raw.get("defaults", {})
+    defaults = AgentBaseDefaults(**defaults_raw) if defaults_raw else AgentBaseDefaults()
+
+    tracing_raw = raw.get("tracing", {})
+    try:
+        tracing = TracingConfig(**tracing_raw) if tracing_raw else TracingConfig()
+    except Exception as e:
+        raise ConfigValidationError(f"Invalid 'tracing' section in agentbase.yaml: {e}") from e
+
+    config = AgentBaseConfig(
+        project=raw["project"],
+        models=models,
+        defaults=defaults,
+        tracing=tracing,
+    )
+
+    _validate_coverage(config.models)
+
+    _config_cache[cache_key] = config
+    return config
+
+
+def get_environment(config: AgentBaseConfig) -> str:
+    return os.environ.get("AGENTBASE_ENV", config.defaults.environment)

agentbase/exceptions.py

@@ -0,0 +1,36 @@
+class AgentBaseError(Exception):
+    pass
+
+
+class ConfigValidationError(AgentBaseError):
+    def __init__(self, message: str) -> None:
+        super().__init__(message)
+
+
+class AgentNotRegisteredError(AgentBaseError):
+    def __init__(self, agent_name: str) -> None:
+        super().__init__(
+            f"Agent '{agent_name}' is not registered in agents.yaml. "
+            f"Add an entry for '{agent_name}' with all required contract fields."
+        )
+        self.agent_name = agent_name
+
+
+class ContractViolationError(AgentBaseError):
+    def __init__(self, agent_name: str, missing_field: str) -> None:
+        super().__init__(
+            f"Agent '{agent_name}' is missing required contract field '{missing_field}'. "
+            f"Add '{missing_field}' to the '{agent_name}' entry in agents.yaml."
+        )
+        self.agent_name = agent_name
+        self.missing_field = missing_field
+
+
+class ModelResolutionError(AgentBaseError):
+    def __init__(self, alias: str, environment: str) -> None:
+        super().__init__(
+            f"Model alias '{alias}' has no mapping for environment '{environment}'. "
+            f"Add a '{environment}' entry under 'models.{alias}' in agentbase.yaml."
+        )
+        self.alias = alias
+        self.environment = environment

agentbase/models.py

@@ -0,0 +1,33 @@
+from agentbase.config import get_environment
+from agentbase.exceptions import ModelResolutionError
+from agentbase.registry import get_agent
+from agentbase.tracing import build_trace_metadata
+from agentbase.types import AgentBaseConfig, AgentMetadata, ResolvedAgent
+
+
+def resolve_model(agent: AgentMetadata, config: AgentBaseConfig, environment: str) -> str | None:
+    if agent.model_alias is None:
+        return None
+    alias_config = config.models[agent.model_alias]
+    if environment not in alias_config.environments:
+        raise ModelResolutionError(agent.model_alias, environment)
+    return alias_config.environments[environment]
+
+
+def resolve(
+    agent_name: str,
+    registry: dict[str, AgentMetadata],
+    config: AgentBaseConfig,
+    environment: str | None = None,
+) -> ResolvedAgent:
+    env = environment or get_environment(config)
+    agent = get_agent(agent_name, registry)
+    model_id = resolve_model(agent, config, env)
+    default_params = config.models[agent.model_alias].default_params if agent.model_alias else {}
+    trace_metadata = build_trace_metadata(agent, model_id)
+    return ResolvedAgent(
+        agent_name=agent.agent_name,
+        model_id=model_id,
+        default_params=default_params,
+        trace_metadata=trace_metadata,
+    )

agentbase/registry.py

@@ -0,0 +1,88 @@
+from pathlib import Path
+
+import yaml
+
+from agentbase.exceptions import (
+    AgentNotRegisteredError,
+    ConfigValidationError,
+    ContractViolationError,
+)
+from agentbase.types import AgentBaseConfig, AgentMetadata
+
+_CONTRACT_FIELDS = ("agent_name", "agent_version", "model_alias", "prompt_ref", "owner", "status")
+
+_registry_cache: dict[str, dict[str, AgentMetadata]] = {}
+
+
+def _validate_agent(raw: dict, config: AgentBaseConfig, environment: str) -> AgentMetadata:
+    agent_name = raw.get("agent_name") or "<unknown>"
+
+    for field in _CONTRACT_FIELDS:
+        if field == "model_alias":
+            continue
+        if not raw.get(field):
+            raise ContractViolationError(agent_name, field)
+
+    model_alias = raw.get("model_alias")
+    if model_alias is not None and model_alias not in config.models:
+        raise ConfigValidationError(
+            f"Agent '{agent_name}' references model alias '{model_alias}' which is not defined "
+            f"in agentbase.yaml. Available aliases: {', '.join(sorted(config.models))}."
+        )
+
+    return AgentMetadata(
+        project=config.project,
+        environment=environment,
+        agent_name=raw["agent_name"],
+        agent_version=str(raw["agent_version"]),
+        model_alias=raw.get("model_alias"),
+        prompt_ref=raw["prompt_ref"],
+        owner=raw["owner"],
+        status=raw["status"],
+    )
+
+
+def load_registry(
+    path: str | Path,
+    config: AgentBaseConfig,
+    environment: str,
+) -> dict[str, AgentMetadata]:
+    resolved = Path(path).resolve()
+    cache_key = f"{resolved}:{environment}"
+
+    if cache_key in _registry_cache:
+        return _registry_cache[cache_key]
+
+    if not resolved.exists():
+        raise ConfigValidationError(
+            f"Agent registry not found: {resolved}. Create agents.yaml in your project root."
+        )
+
+    with open(resolved) as f:
+        raw = yaml.safe_load(f)
+
+    if not isinstance(raw, dict) or "agents" not in raw:
+        raise ConfigValidationError("agents.yaml must have a top-level 'agents' list.")
+
+    agents_raw = raw["agents"]
+    if not isinstance(agents_raw, list):
+        raise ConfigValidationError("'agents' in agents.yaml must be a list.")
+
+    registry: dict[str, AgentMetadata] = {}
+    for agent_raw in agents_raw:
+        metadata = _validate_agent(agent_raw, config, environment)
+        if metadata.agent_name in registry:
+            raise ConfigValidationError(
+                f"Duplicate agent name '{metadata.agent_name}' in agents.yaml. "
+                f"Each agent must have a unique name within a project."
+            )
+        registry[metadata.agent_name] = metadata
+
+    _registry_cache[cache_key] = registry
+    return registry
+
+
+def get_agent(name: str, registry: dict[str, AgentMetadata]) -> AgentMetadata:
+    if name not in registry:
+        raise AgentNotRegisteredError(name)
+    return registry[name]

agentbase/tracing.py

@@ -0,0 +1,49 @@
+import os
+from typing import Any
+
+from agentbase.exceptions import ConfigValidationError
+from agentbase.types import AgentBaseConfig, AgentMetadata
+
+
+def init_tracing(config: AgentBaseConfig) -> None:
+    tc = config.tracing
+    if not tc.enabled or tc.backend == "none":
+        return
+    if tc.backend == "langsmith":
+        _init_langsmith(config.project)
+    else:
+        raise ConfigValidationError(
+            f"Unknown tracing backend '{tc.backend}' in agentbase.yaml. "
+            f"Supported values: 'langsmith', 'none'."
+        )
+
+
+def _init_langsmith(project: str) -> None:
+    if not os.environ.get("LANGCHAIN_API_KEY"):
+        raise ConfigValidationError(
+            "Missing environment variable LANGCHAIN_API_KEY "
+            "(required for LangSmith tracing). "
+            "Get a key at smith.langchain.com and set LANGCHAIN_API_KEY in your environment."
+        )
+    os.environ["LANGCHAIN_TRACING_V2"] = "true"
+    os.environ["LANGCHAIN_PROJECT"] = project
+
+
+def build_trace_metadata(agent: AgentMetadata, model_id: str | None) -> dict[str, Any]:
+    metadata = {
+        "project": agent.project,
+        "environment": agent.environment,
+        "agent_name": agent.agent_name,
+        "agent_version": agent.agent_version,
+        "owner": agent.owner,
+    }
+    if agent.model_alias is not None:
+        metadata["model_alias"] = agent.model_alias
+    if model_id is not None:
+        metadata["model_id"] = model_id
+    return {
+        "generation_name": agent.agent_name,
+        "trace_name": f"{agent.project}/{agent.agent_name}",
+        "tags": [agent.project, agent.environment, agent.status.value],
+        "metadata": metadata,
+    }

agentbase/types.py

@@ -0,0 +1,65 @@
+from enum import StrEnum
+from typing import Any
+
+from pydantic import BaseModel
+
+
+class AgentStatus(StrEnum):
+    experimental = "experimental"
+    active = "active"
+    deprecated = "deprecated"
+
+
+class AgentMetadata(BaseModel):
+    project: str
+    environment: str
+    agent_name: str
+    agent_version: str
+    model_alias: str | None = None
+    prompt_ref: str
+    owner: str
+    status: AgentStatus
+
+
+class ModelAliasConfig(BaseModel):
+    environments: dict[str, str]
+    default_params: dict[str, Any] = {}
+
+
+class AgentBaseDefaults(BaseModel):
+    environment: str = "dev"
+    model_alias: str = "smart"
+
+
+class TracingConfig(BaseModel):
+    backend: str = "none"  # "langsmith" | "none"
+    enabled: bool = True
+
+
+class AgentBaseConfig(BaseModel):
+    project: str
+    models: dict[str, ModelAliasConfig]
+    defaults: AgentBaseDefaults = AgentBaseDefaults()
+    tracing: TracingConfig = TracingConfig()
+
+    @property
+    def environments(self) -> set[str]:
+        envs: set[str] = set()
+        for alias_config in self.models.values():
+            envs.update(alias_config.environments.keys())
+        return envs
+
+
+class ResolvedAgent(BaseModel):
+    agent_name: str
+    model_id: str | None
+    default_params: dict[str, Any] = {}
+    trace_metadata: dict[str, Any] = {}
+
+    def langchain_config(self) -> dict[str, Any]:
+        """RunnableConfig dict — pass as config= to any LangChain call."""
+        return {
+            "run_name": self.trace_metadata.get("generation_name", self.agent_name),
+            "tags": self.trace_metadata.get("tags", []),
+            "metadata": self.trace_metadata.get("metadata", {}),
+        }

ak_agentbase-0.1.0a1.dist-info/METADATA

@@ -0,0 +1,313 @@
+Metadata-Version: 2.4
+Name: ak-agentbase
+Version: 0.1.0a1
+Summary: Unified AI agent configuration, observability, and model management for multi-agent applications
+Project-URL: Homepage, https://github.com/Shivam1904/AgentBase
+Project-URL: Documentation, https://github.com/Shivam1904/AgentBase/blob/main/README.md
+Project-URL: Repository, https://github.com/Shivam1904/AgentBase
+Project-URL: Issues, https://github.com/Shivam1904/AgentBase/issues
+Author-email: Shivam Srivastava <shivam.sriv93@gmail.com>
+License: MIT
+License-File: LICENSE
+Keywords: agents,ai,configuration,langsmith,llm,observability
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Python: >=3.11
+Requires-Dist: pydantic==2.12.5
+Requires-Dist: pyyaml==6.0.3
+Provides-Extra: dev
+Requires-Dist: build==1.2.2; extra == 'dev'
+Requires-Dist: pytest-cov==7.1.0; extra == 'dev'
+Requires-Dist: pytest==9.0.3; extra == 'dev'
+Requires-Dist: ruff==0.15.12; extra == 'dev'
+Requires-Dist: twine==6.1.0; extra == 'dev'
+Description-Content-Type: text/markdown
+
+# AgentBase v0.1-alpha
+
+**Unified AI agent configuration, observability, and model management for production multi-agent systems.**
+
+AgentBase is a lightweight, framework-agnostic control plane that standardizes how AI-heavy products configure models, register agents, and emit observability metadata. No framework dependencies. No vendor lock-in. Just YAML + Python.
+
+## Status
+
+✅ **v0.1-alpha** — Core library complete. 96 tests passing. First projects integrated (Writerverse, Skill-Deck pipeline).
+
+## What It Does
+
+```python
+import agentbase
+from langchain_openai import ChatOpenAI
+
+# Load configuration
+agentbase.load_config("agentbase.yaml", "agents.yaml")
+agentbase.init_tracing()
+
+# Resolve an agent
+resolved = agentbase.resolve("my_analyzer")
+
+# Construct LLM with AgentBase config
+llm = ChatOpenAI(model=resolved.model_id, **resolved.default_params)
+
+# Enable LangSmith tracing
+result = llm.invoke(messages, config=resolved.langchain_config())
+```
+
+**Returns:**
+- `model_id`: Resolved model name (e.g., `gpt-4o`, `claude-sonnet-4-20250514`)
+- `default_params`: Model config (temperature, max_tokens, etc.)
+- `langchain_config()`: LangSmith trace metadata (tags, generation_name, metadata)
+
+## Core Features
+
+- **YAML Config** — Single source of truth for all model aliases and agent definitions
+- **Model Aliases** — `fast`, `smart`, `creative` that resolve to provider-specific IDs per environment
+- **Agent Registry** — Centralized agent metadata (owner, version, prompt location, status)
+- **LangSmith Integration** — Automatic trace metadata in every chain/workflow
+- **Environment Switching** — Dev/prod model aliases in one config file
+- **Zero Framework Dependencies** — Works with LangChain, Anthropic SDK, OpenAI SDK, etc.
+- **CLI Validation** — `agentbase validate` checks config and resolves all agents
+
+## Installation
+
+```bash
+pip install agentbase==0.1.0a1
+```
+
+## Quick Start
+
+**1. Create config files:**
+
+`agentbase.yaml`:
+```yaml
+project: my-project
+
+models:
+  fast:
+    dev: gpt-4o-mini
+    production: gpt-4o
+  smart:
+    dev: gpt-4o
+    production: claude-sonnet-4-20250514
+
+defaults:
+  environment: dev
+  model_alias: smart
+
+tracing:
+  backend: langsmith
+  enabled: true
+```
+
+`agents.yaml`:
+```yaml
+agents:
+  - agent_name: analyzer
+    model_alias: fast
+    owner: team
+    status: active
+    agent_version: "0.1.0"
+    prompt_ref: "git:backend/prompts/analyze.py"
+    description: "Analyzes input data"
+```
+
+**2. Set environment variables:**
+
+```bash
+LANGCHAIN_API_KEY=lsv2_pt_xxxxx
+OPENAI_API_KEY=sk-xxxxx
+```
+
+**3. Initialize in your app:**
+
+```python
+import agentbase
+
+agentbase.load_config(config_path="agentbase.yaml", registry_path="agents.yaml")
+agentbase.init_tracing()
+```
+
+**4. Use in your chains:**
+
+```python
+resolved = agentbase.resolve("analyzer")
+llm = ChatOpenAI(model=resolved.model_id, **resolved.default_params)
+result = chain.invoke(input, config=resolved.langchain_config())
+```
+
+See [QUICKSTART.md](QUICKSTART.md) for full setup instructions.
+
+## Architecture
+
+```
+agentbase.load_config()
+  ├─ Loads agentbase.yaml (project, models, defaults, tracing)
+  ├─ Loads agents.yaml (agent registry)
+  └─ Validates all required fields
+
+agentbase.init_tracing()
+  └─ Sets LANGCHAIN_TRACING_V2 and LANGCHAIN_PROJECT env vars
+     (if LangSmith backend is enabled)
+
+agentbase.resolve(agent_name)
+  ├─ Looks up agent in registry
+  ├─ Resolves model_alias → model_id (using defaults.environment)
+  ├─ Returns ResolvedAgent with:
+  │  ├─ model_id (e.g., "gpt-4o")
+  │  ├─ default_params (temperature, max_tokens, etc.)
+  │  ├─ langchain_config() → LangSmith metadata
+  │  └─ trace_metadata → raw metadata dict
+  └─ (Throws ConfigValidationError if not found or invalid)
+```
+
+## API
+
+### Core Functions
+
+```python
+agentbase.load_config(config_path: str, registry_path: str) → None
+  # Load and validate agentbase.yaml and agents.yaml
+  # Raises ConfigValidationError if validation fails
+
+agentbase.init_tracing() → None
+  # Set up LangSmith tracing if enabled in config
+  # Requires LANGCHAIN_API_KEY env var if using LangSmith
+
+agentbase.resolve(agent_name: str) → ResolvedAgent
+  # Resolve agent and return config
+  # Returns ResolvedAgent with model_id, default_params, langchain_config()
+  # Raises ConfigValidationError if agent not found
+
+agentbase.validate(config_path: str, registry_path: str) → None
+  # Validation-only mode (no tracing setup)
+  # Used by CLI and tests
+```
+
+### ResolvedAgent
+
+```python
+@dataclass
+class ResolvedAgent:
+    model_id: str | None          # "gpt-4o", "claude-sonnet-4-20250514", None for workflows
+    default_params: dict[str, Any] # {"temperature": 0.7, "max_tokens": 4096}
+    
+    def langchain_config(self) -> dict[str, Any]:
+        # Returns LangSmith-compatible config for chain.invoke(config=...)
+        # Fields: generation_name, trace_name, tags, metadata
+```
+
+## CLI
+
+```bash
+# Validate config (exit 0 if valid, 1 if errors)
+agentbase validate agentbase.yaml agents.yaml
+
+# Resolve an agent (pretty-print)
+agentbase resolve agent_name --config agentbase.yaml --registry agents.yaml
+
+# Version
+agentbase --version
+```
+
+## Configuration Reference
+
+### agentbase.yaml
+
+```yaml
+project: <string>              # Project name (used in LangSmith traces)
+
+models:
+  <alias>:                      # e.g., "fast", "smart", "creative"
+    dev: <model_id>             # e.g., "gpt-4o-mini"
+    production: <model_id>      # e.g., "gpt-4o"
+
+defaults:
+  environment: <env>            # "dev" or "production"
+  model_alias: <alias>          # Default model alias
+  [other defaults...]
+
+tracing:
+  backend: langsmith | none     # "langsmith" or "none"
+  enabled: true | false         # Enable/disable tracing
+```
+
+### agents.yaml
+
+```yaml
+agents:
+  - agent_name: <string>        # Unique agent identifier
+    model_alias: <string>       # References models.* in agentbase.yaml
+    owner: <string>             # Team or person responsible
+    status: active | inactive   # Status
+    agent_version: <semver>     # e.g., "0.1.0"
+    prompt_ref: <string>        # Reference to prompt (e.g., "git:path/to/file.py")
+    description: <string>       # Human-readable description
+```
+
+## Environment Variables
+
+| Variable | Required | Purpose |
+|----------|----------|---------|
+| `LANGCHAIN_API_KEY` | If tracing enabled | LangSmith API key |
+| `OPENAI_API_KEY` | If using gpt-* models | OpenAI API key |
+| `ANTHROPIC_API_KEY` | If using claude-* models | Anthropic API key |
+
+## Why AgentBase?
+
+**Before AgentBase:**
+- Each project had its own config system (get_ai_config, hardcoded model names)
+- LLM setup was duplicated across chains
+- No unified observability or cost tracking
+- Difficult to switch models for A/B testing
+
+**With AgentBase:**
+- One config file per project, YAML-based
+- Agents registered once, resolved anywhere
+- Automatic LangSmith integration
+- Model switching via `defaults.environment`
+- Cost visibility per agent per environment
+
+## For Projects Using AgentBase
+
+- **Writerverse** — 35 agents + 7 LangGraph workflows (scene generation, consistency analysis, chat, supervisor)
+- **Skill-Deck** — Q&A system with dynamic model routing
+- **Shivam Portfolio** — Proof-of-concept (first integration)
+
+See [QUICKSTART.md](QUICKSTART.md) for project integration steps.
+
+## For Publishing
+
+See [PUBLISH.md](PUBLISH.md) for detailed steps to publish to PyPI.
+
+## Development
+
+```bash
+# Install dev dependencies
+pip install -e .[dev]
+
+# Run tests
+pytest tests/ -v
+
+# Lint
+ruff check agentbase/ tests/
+
+# Format
+ruff format agentbase/ tests/
+```
+
+## License
+
+MIT — see [LICENSE](LICENSE)
+
+## Author
+
+Shivam Srivastava — [GitHub](https://github.com/Shivam1904)
+
+---
+
+**Questions?** Open an issue on [GitHub](https://github.com/Shivam1904/AgentBase/issues)

ak_agentbase-0.1.0a1.dist-info/RECORD

@@ -0,0 +1,14 @@
+agentbase/__init__.py,sha256=ioI1ZEwDA3Q4DvbBAIjyJs1gjHJ_MKy30z3zH_seS7Y,2115
+agentbase/__main__.py,sha256=YJ2L3vBKgUG0jAY6Sh4nfwiaFceLOU2k5zgbUp-zdlU,39
+agentbase/cli.py,sha256=-WN4nxdm-g3aZzP7Bv-wWTVroWzt22hn77GPgmunBHI,2337
+agentbase/config.py,sha256=SAh2A_c9WGCqSh-h4bN3E3ouKdoIntb0xSPVz4ou-es,3916
+agentbase/exceptions.py,sha256=yLNJA2kRbea49ES_nT7vjy-Knze3WJB0s6Bl7DwOOVo,1279
+agentbase/models.py,sha256=atK9HNGM25c4JkvPrNxw3aLgFXg29RrvVerK9B300xg,1275
+agentbase/registry.py,sha256=7Xpf_g13_bPzefP7QKHWk0oQOT33l5oW32ATf4v2hTQ,2885
+agentbase/tracing.py,sha256=XcOXdh6DwKbOeSxyQE8C3B3bALH7fzbisuUJA5GmTEU,1676
+agentbase/types.py,sha256=EBM6Z3l7JS23jiHYANbsmUf5E5uEjfjdx3zDNVGUUPM,1649
+ak_agentbase-0.1.0a1.dist-info/METADATA,sha256=I6MhNCrpPcGjirVUBIJ3tGB6YKRI8NzrZGfvEL_BfYY,9179
+ak_agentbase-0.1.0a1.dist-info/WHEEL,sha256=QccIxa26bgl1E6uMy58deGWi-0aeIkkangHcxk2kWfw,87
+ak_agentbase-0.1.0a1.dist-info/entry_points.txt,sha256=ikSlYfVSxSUSwFN0ZbMFMioyuC2mviQCm-ZaZwFPPOE,49
+ak_agentbase-0.1.0a1.dist-info/licenses/LICENSE,sha256=f3ihmqRSYLpC8ZEWx7Ns0gvqWJnMPCMpS_iKz0ngNhc,1074
+ak_agentbase-0.1.0a1.dist-info/RECORD,,

ak_agentbase-0.1.0a1.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.29.0
+Root-Is-Purelib: true
+Tag: py3-none-any

ak_agentbase-0.1.0a1.dist-info/entry_points.txt

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

ak_agentbase-0.1.0a1.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Shivam Srivastava
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.