bonito-cli 0.9.0__tar.gz → 0.9.2__tar.gz

{bonito_cli-0.9.0 → bonito_cli-0.9.2}/.gitignore

@@ -12,3 +12,4 @@ secrets/*.yaml
 !secrets/*.enc.yaml
 benchmarks/locomo-repo
 bonito-kb-sa-key.json
+.claude/worktrees/

{bonito_cli-0.9.0 → bonito_cli-0.9.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: bonito-cli
-Version: 0.9.0
+Version: 0.9.2
 Summary: Bonito CLI — Unified multi-cloud AI management from your terminal
 Author-email: Bonito <hello@getbonito.com>
 License: MIT

{bonito_cli-0.9.0 → bonito_cli-0.9.2}/bonito_cli/commands/auth.py

@@ -299,7 +299,7 @@ def token_create(
 
     try:
         with console.status("[cyan]Creating token…[/cyan]"):
-            result = api.post("/tokens", json=body)
+            result = api.post("/tokens", data=body)
 
         raw_token = result.get("token", "")
         console.print(

{bonito_cli-0.9.0 → bonito_cli-0.9.2}/bonito_cli/commands/deploy.py

@@ -68,7 +68,41 @@ def _find_unresolved(value: Any, path: str = "") -> List[str]:
 
 _REQUIRED_TOP_KEYS = {"version", "name"}
 _KNOWN_TOP_KEYS = {"version", "name", "description", "gateway", "mcp_servers",
-                    "knowledge_bases", "agents", "observability", "secrets"}
+                    "knowledge_bases", "agents", "observability", "secrets",
+                    "integrations", "budget_stops"}
+
+
+def _normalize_section(section: Any) -> Any:
+    """Accept a section as EITHER a mapping (name -> cfg) OR a list of
+    {name, ...} entries; always return a mapping keyed by name. Non-conforming
+    shapes are returned unchanged so _validate can report them."""
+    if isinstance(section, list):
+        out: Dict[str, Any] = {}
+        for entry in section:
+            if isinstance(entry, dict) and entry.get("name"):
+                name = entry["name"]
+                out[name] = {k: v for k, v in entry.items() if k != "name"}
+        return out
+    return section
+
+
+def _normalize_agents(section: Any) -> Any:
+    """Normalize agents to the mapping form + reconcile field aliases so the
+    list-style schema (model_id / system_prompt_path / model_config) works the
+    same as the mapping-style schema (model.primary / system_prompt / parameters)."""
+    agents = _normalize_section(section)
+    if not isinstance(agents, dict):
+        return agents
+    for cfg in agents.values():
+        if not isinstance(cfg, dict):
+            continue
+        if "system_prompt" not in cfg and "system_prompt_path" in cfg:
+            cfg["system_prompt"] = cfg["system_prompt_path"]
+        if "model" not in cfg and "model_id" in cfg:
+            cfg["model"] = {"primary": cfg["model_id"]}
+        if "parameters" not in cfg and isinstance(cfg.get("model_config"), dict):
+            cfg["parameters"] = cfg["model_config"]
+    return agents
 
 
 def _validate(cfg: Dict[str, Any]) -> List[str]:
@@ -93,6 +127,14 @@ def _validate(cfg: Dict[str, Any]) -> List[str]:
     if "knowledge_bases" in cfg and not isinstance(cfg["knowledge_bases"], dict):
         errors.append("'knowledge_bases' must be a mapping of kb-name -> config")
 
+    if "integrations" in cfg:
+        if not isinstance(cfg["integrations"], list):
+            errors.append("'integrations' must be a list of integration entries")
+        else:
+            for i, entry in enumerate(cfg["integrations"]):
+                if not isinstance(entry, dict) or not entry.get("type"):
+                    errors.append(f"integrations[{i}]: must be a mapping with a 'type'")
+
     # Validate each agent
     for agent_name, agent_cfg in (cfg.get("agents") or {}).items():
         if not isinstance(agent_cfg, dict):
@@ -117,22 +159,26 @@ class DeployResult:
         self.mcp_servers: List[Dict[str, str]] = []
         self.knowledge_bases: List[Dict[str, str]] = []
         self.agents: List[Dict[str, str]] = []
+        self.integrations: List[Dict[str, str]] = []
 
     @property
     def total(self) -> int:
-        return len(self.providers) + len(self.mcp_servers) + len(self.knowledge_bases) + len(self.agents)
+        return (
+            len(self.providers) + len(self.mcp_servers) + len(self.knowledge_bases)
+            + len(self.agents) + len(self.integrations)
+        )
 
     @property
     def errors(self) -> int:
         return sum(
-            1 for items in (self.providers, self.mcp_servers, self.knowledge_bases, self.agents)
+            1 for items in (self.providers, self.mcp_servers, self.knowledge_bases, self.agents, self.integrations)
             for item in items if item["status"] == "error"
         )
 
     @property
     def skipped(self) -> int:
         return sum(
-            1 for items in (self.providers, self.mcp_servers, self.knowledge_bases, self.agents)
+            1 for items in (self.providers, self.mcp_servers, self.knowledge_bases, self.agents, self.integrations)
             for item in items if item["status"] == "skipped"
         )
 
@@ -827,6 +873,93 @@ def _print_next_steps(
     ))
 
 
+# -- step: integrations ------------------------------------------------------
+
+
+def _deploy_integrations(
+    integrations: List[Dict[str, Any]],
+    agent_id_map: Dict[str, str],
+    result: DeployResult,
+    dry_run: bool,
+    verbose: bool,
+) -> None:
+    """Provision declared integrations (Slack today) against the API.
+
+    Each entry is connected, pointed at an inbound agent, and bound to the
+    listed agents. Agent references resolve by name via agent_id_map.
+    Schema: integrations: [{type: slack, bot_token, signing_secret,
+    inbound_agent, inbound_routes: {channel_id: agent}, bindings: [agent...]}].
+    """
+    if not integrations:
+        return
+
+    console.print("\n[bold cyan]Integrations[/bold cyan]")
+    for entry in integrations:
+        if not isinstance(entry, dict):
+            result.integrations.append({"name": "integration", "status": "error", "detail": "must be a mapping"})
+            continue
+        itype = (entry.get("type") or "").lower()
+        name = itype or "integration"
+        try:
+            if dry_run:
+                result.integrations.append({"name": name, "status": "ok", "detail": "dry-run"})
+                console.print(f"  [dim]~ {name} (dry-run)[/dim]")
+                continue
+
+            if itype != "slack":
+                result.integrations.append({"name": name, "status": "error", "detail": f"unsupported type '{itype}' (only slack today)"})
+                console.print(f"  [red]x {name}: unsupported (only slack today)[/red]")
+                continue
+
+            inbound_name = entry.get("inbound_agent")
+            inbound_id = agent_id_map.get(inbound_name) if inbound_name else None
+            if inbound_name and not inbound_id:
+                result.integrations.append({"name": name, "status": "error", "detail": f"inbound_agent '{inbound_name}' not in this deploy"})
+                console.print(f"  [red]x slack: inbound_agent '{inbound_name}' not found[/red]")
+                continue
+
+            # 1. Connect the customer-owned Slack app (team_id auto-resolved)
+            payload: Dict[str, Any] = {
+                "bot_token": entry.get("bot_token"),
+                "signing_secret": entry.get("signing_secret"),
+            }
+            if inbound_id:
+                payload["inbound_agent_id"] = inbound_id
+            conn = api.post("/integrations/slack/connect/app", payload)
+            conn_id = conn.get("id")
+            detail = [f"connected ({conn.get('account_label') or 'slack'})"]
+
+            # 2. Per-channel inbound routing overrides (channel_id -> agent name)
+            routes_cfg = entry.get("inbound_routes") or {}
+            resolved = {ch: agent_id_map[a] for ch, a in routes_cfg.items() if a in agent_id_map}
+            if resolved:
+                body: Dict[str, Any] = {"inbound_routes": resolved}
+                if inbound_id:
+                    body["inbound_agent_id"] = inbound_id
+                api.patch(f"/integrations/connections/{conn_id}/inbound", body)
+                detail.append(f"{len(resolved)} channel route(s)")
+
+            # 3. Outbound bindings (give agents the slack_post_message tool)
+            bound = 0
+            for agent_name in (entry.get("bindings") or []):
+                aid = agent_id_map.get(agent_name)
+                if not aid:
+                    continue
+                try:
+                    api.post("/integrations/bindings", {"agent_id": aid, "connection_id": conn_id})
+                    bound += 1
+                except APIError:
+                    pass
+            if bound:
+                detail.append(f"{bound} binding(s)")
+
+            result.integrations.append({"name": name, "status": "ok", "detail": ", ".join(detail)})
+            console.print(f"  [green]v[/green] slack [dim]({', '.join(detail)})[/dim]")
+        except (APIError, Exception) as exc:
+            result.integrations.append({"name": name, "status": "error", "detail": str(exc)})
+            console.print(f"  [red]x {name}: {exc}[/red]")
+
+
 # -- main command ------------------------------------------------------------
 
 
@@ -884,6 +1017,13 @@ def deploy(
     # -- 2. Resolve env vars -------------------------------------------------
     cfg = _resolve_env(cfg)
 
+    # Accept BOTH the mapping form (name -> cfg) and the list form
+    # ([{name, ...}]) for agents + knowledge_bases, reconciling field aliases.
+    if "agents" in cfg:
+        cfg["agents"] = _normalize_agents(cfg["agents"])
+    if "knowledge_bases" in cfg:
+        cfg["knowledge_bases"] = _normalize_section(cfg["knowledge_bases"])
+
     unresolved = _find_unresolved(cfg)
     if unresolved:
         console.print(f"\n[yellow]{len(unresolved)} unresolved environment variable(s):[/yellow]")
@@ -966,6 +1106,9 @@ def deploy(
     # -- 8. Agent connections (delegation) -----------------------------------
     _create_agent_connections(agents, agent_id_map, result, dry_run, verbose)
 
+    # -- 8b. Integrations (Slack etc.) ---------------------------------------
+    _deploy_integrations(cfg.get("integrations", []), agent_id_map, result, dry_run, verbose)
+
     # -- 9. Summary ----------------------------------------------------------
     _print_summary(result, stack_name, dry_run)
 

{bonito_cli-0.9.0 → bonito_cli-0.9.2}/bonito_cli/commands/projects.py

@@ -367,7 +367,7 @@ def project_token_create(
 
     try:
         with console.status("[cyan]Creating project token…[/cyan]"):
-            result = api.post(f"/projects/{project_id}/tokens", json=body)
+            result = api.post(f"/projects/{project_id}/tokens", data=body)
 
         raw_token = result.get("token", "")
         console.print(

{bonito_cli-0.9.0 → bonito_cli-0.9.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "bonito-cli"
-version = "0.9.0"
+version = "0.9.2"
 description = "Bonito CLI — Unified multi-cloud AI management from your terminal"
 readme = "README.md"
 license = {text = "MIT"}