provision-stack-composio 0.1.0__tar.gz

provision_stack_composio-0.1.0/.gitignore

@@ -0,0 +1,34 @@
+node_modules
+dist
+build
+coverage
+
+.env
+.env.*
+!.env.example
+
+.turbo
+
+.DS_Store
+
+.vscode/settings.json
+
+*.log
+
+# Generated Terraform deployment artifacts (written to user's cwd, not repo)
+terraform/
+
+# Local SQLite state (DATABASE_PATH default location)
+data/
+
+# Local deploy secrets (NEVER commit — deploy-time env lives here)
+.env.local
+deploy/.env
+
+# Host SSH keys + terraform state (local artifacts)
+deploy/hosting/provision-stack-host-key
+deploy/hosting/provision-stack-host-key.pub
+deploy/hosting/.terraform/
+deploy/hosting/terraform.tfstate*
+deploy/hosting/.terraform.lock.hcl
+__pycache__/

provision_stack_composio-0.1.0/PKG-INFO

@@ -0,0 +1,92 @@
+Metadata-Version: 2.4
+Name: provision-stack-composio
+Version: 0.1.0
+Summary: Composio integration for Provision Stack — deploy cloud infrastructure via AI agents.
+Project-URL: Homepage, https://provision-stack.com
+Project-URL: Documentation, https://docs.provision-stack.com
+Project-URL: Repository, https://github.com/TravisLinkey/provision-stack
+Author: Provision Stack
+License-Expression: MIT
+Keywords: ai-agents,autogen,aws,composio,crewai,gcp,infrastructure,langchain,mcp
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Python: >=3.10
+Requires-Dist: composio-core>=0.6.0
+Requires-Dist: provision-stack>=0.1.0
+Provides-Extra: test
+Requires-Dist: pytest-mock>=3.12; extra == 'test'
+Requires-Dist: pytest>=8.0; extra == 'test'
+Description-Content-Type: text/markdown
+
+# provision-stack-composio
+
+> Composio integration for Provision Stack — deploy cloud infrastructure via AI agents.
+
+## Install
+
+```bash
+pip install provision-stack-composio
+```
+
+## Quick Start
+
+```python
+from composio import ComposioToolSet
+from provision_stack_composio import register_provision_stack_tools
+
+toolset = ComposioToolSet()
+register_provision_stack_tools(toolset, api_key="your-token", sandbox=True)
+tools = toolset.get_tools()
+
+# Now use with any Composio-supported framework:
+# LangChain, CrewAI, AutoGen, LlamaIndex, etc.
+```
+
+## What This Does
+
+Registers Provision Stack as a Composio integration, making it available
+to any framework that uses Composio. One integration → all frameworks.
+
+## Available Actions
+
+| Action | Description |
+|--------|-------------|
+| `PROVISION_STACK_SUGGEST` | Get deployment suggestions with tier options and costs |
+| `PROVISION_STACK_DEPLOY` | Deploy infrastructure (fee held, captured after verification) |
+| `PROVISION_STACK_STATUS` | Check deployment status and verification results |
+| `PROVISION_STACK_DESTROY` | Destroy all resources owned by a deployment |
+| `PROVISION_STACK_BALANCE` | Check account credit balance |
+| `PROVISION_STACK_TOPUP` | Add credits via Stripe or XRP |
+
+## Selective Registration
+
+```python
+# Register only specific actions
+register_provision_stack_tools(
+    toolset,
+    api_key="your-token",
+    actions=["SUGGEST", "DEPLOY"],  # only these two
+)
+```
+
+## Configuration
+
+```python
+register_provision_stack_tools(
+    toolset,
+    api_key="your-token",         # or PROVISION_STACK_API_KEY env var
+    base_url="https://...",       # or PROVISION_STACK_API_URL env var
+    sandbox=True,                 # use sandbox (mock Terraform)
+)
+```
+
+## License
+
+MIT

provision_stack_composio-0.1.0/README.md

@@ -0,0 +1,65 @@
+# provision-stack-composio
+
+> Composio integration for Provision Stack — deploy cloud infrastructure via AI agents.
+
+## Install
+
+```bash
+pip install provision-stack-composio
+```
+
+## Quick Start
+
+```python
+from composio import ComposioToolSet
+from provision_stack_composio import register_provision_stack_tools
+
+toolset = ComposioToolSet()
+register_provision_stack_tools(toolset, api_key="your-token", sandbox=True)
+tools = toolset.get_tools()
+
+# Now use with any Composio-supported framework:
+# LangChain, CrewAI, AutoGen, LlamaIndex, etc.
+```
+
+## What This Does
+
+Registers Provision Stack as a Composio integration, making it available
+to any framework that uses Composio. One integration → all frameworks.
+
+## Available Actions
+
+| Action | Description |
+|--------|-------------|
+| `PROVISION_STACK_SUGGEST` | Get deployment suggestions with tier options and costs |
+| `PROVISION_STACK_DEPLOY` | Deploy infrastructure (fee held, captured after verification) |
+| `PROVISION_STACK_STATUS` | Check deployment status and verification results |
+| `PROVISION_STACK_DESTROY` | Destroy all resources owned by a deployment |
+| `PROVISION_STACK_BALANCE` | Check account credit balance |
+| `PROVISION_STACK_TOPUP` | Add credits via Stripe or XRP |
+
+## Selective Registration
+
+```python
+# Register only specific actions
+register_provision_stack_tools(
+    toolset,
+    api_key="your-token",
+    actions=["SUGGEST", "DEPLOY"],  # only these two
+)
+```
+
+## Configuration
+
+```python
+register_provision_stack_tools(
+    toolset,
+    api_key="your-token",         # or PROVISION_STACK_API_KEY env var
+    base_url="https://...",       # or PROVISION_STACK_API_URL env var
+    sandbox=True,                 # use sandbox (mock Terraform)
+)
+```
+
+## License
+
+MIT

provision_stack_composio-0.1.0/provision_stack_composio/__init__.py

@@ -0,0 +1,23 @@
+"""
+Provision Stack integration for Composio.
+
+Composio connects AI agents to 200+ apps and services.
+This integration registers Provision Stack as a Composio tool,
+making it available to LangChain, CrewAI, AutoGen, and other
+frameworks through Composio's tool marketplace.
+
+Usage::
+
+    from composio import ComposioToolSet
+    from provision_stack_composio import register_provision_stack_tools
+
+    toolset = ComposioToolSet()
+    register_provision_stack_tools(toolset, api_key="your-token")
+    tools = toolset.get_tools()
+
+    # Now use with any Composio-supported framework
+"""
+
+from provision_stack_composio.tools import register_provision_stack_tools
+
+__all__ = ["register_provision_stack_tools"]

provision_stack_composio-0.1.0/provision_stack_composio/tools.py

@@ -0,0 +1,269 @@
+"""
+Composio tool registration for Provision Stack.
+
+Registers Provision Stack actions with the Composio toolset,
+making them available to any framework that uses Composio
+(LangChain, CrewAI, AutoGen, LlamaIndex, etc.).
+
+Composio actions follow a specific pattern:
+- Each action has a name, description, and input schema
+- Actions are registered with the ComposioToolSet
+- The toolset handles framework-specific wrapping
+"""
+
+from __future__ import annotations
+
+import json
+from typing import Any, Callable
+
+from provision_stack.client import ProvisionStackClient
+from provision_stack.config import PRODUCT_NAME
+
+
+def _register_action(
+    toolset: Any,
+    name: str,
+    description: str,
+    schema: dict[str, Any],
+    handler: Callable[..., Any],
+) -> None:
+    """
+    Register a single action with the Composio toolset.
+
+    Composio supports custom actions via toolset.set_actions() or
+    by defining action classes. This helper handles both patterns.
+    """
+    try:
+        # Composio >=0.6: use set_actions with a dict
+        toolset.set_actions(
+            {
+                name: {
+                    "description": description,
+                    "schema": schema,
+                    "handler": handler,
+                }
+            }
+        )
+    except AttributeError:
+        # Older Composio: try the action class pattern
+        try:
+            from composio import Action
+
+            action_cls = type(
+                f"Action{name}",
+                (Action,),
+                {
+                    "name": name,
+                    "description": description,
+                    "schema": schema,
+                    "execute": staticmethod(handler),
+                },
+            )
+            toolset.register_action(action_cls)
+        except ImportError:
+            raise RuntimeError(
+                "Composio is not installed. "
+                "Install with: pip install composio-core"
+            )
+
+
+def register_provision_stack_tools(
+    toolset: Any,
+    api_key: str | None = None,
+    base_url: str | None = None,
+    sandbox: bool = False,
+    actions: list[str] | None = None,
+) -> None:
+    """
+    Register Provision Stack tools with a Composio toolset.
+
+    Parameters
+    ----------
+    toolset : ComposioToolSet
+        The Composio toolset to register actions with.
+    api_key : str, optional
+        API token. Falls back to PROVISION_STACK_API_KEY env var.
+    base_url : str, optional
+        API base URL. Falls back to env var or default.
+    sandbox : bool
+        If True, use sandbox (mock Terraform, no real deploys).
+    actions : list[str], optional
+        Subset of actions to register. None = all actions.
+        Options: "SUGGEST", "DEPLOY", "STATUS", "DESTROY",
+                 "BALANCE", "TOPUP".
+
+    Examples
+    --------
+    ::
+
+        from composio import ComposioToolSet
+        from provision_stack_composio import register_provision_stack_tools
+
+        toolset = ComposioToolSet()
+        register_provision_stack_tools(toolset)
+        tools = toolset.get_tools()
+
+        # Register only specific actions
+        register_provision_stack_tools(toolset, actions=["SUGGEST", "DEPLOY"])
+    """
+    client = ProvisionStackClient(
+        api_key=api_key, base_url=base_url, sandbox=sandbox
+    )
+
+    all_actions = {
+        "SUGGEST": {
+            "name": "PROVISION_STACK_SUGGEST",
+            "description": (
+                f"Get deployment suggestions from {PRODUCT_NAME}. "
+                "Returns tier options (Starter/MVP/Startup/Enterprise) "
+                "with monthly cost estimates across cloud providers."
+            ),
+            "schema": {
+                "type": "object",
+                "properties": {
+                    "outcome": {
+                        "type": "string",
+                        "description": "Natural language description of desired infrastructure",
+                    },
+                    "region": {
+                        "type": "string",
+                        "description": "Cloud region (e.g. 'us-east-1')",
+                    },
+                    "provider": {
+                        "type": "string",
+                        "enum": ["aws", "gcp", "azure", "oracle"],
+                        "description": "Restrict to one provider",
+                    },
+                    "max_monthly_cost_usd": {
+                        "type": "number",
+                        "description": "Monthly cost cap in USD",
+                    },
+                },
+                "required": ["outcome"],
+            },
+            "handler": lambda outcome, region=None, provider=None,
+            max_monthly_cost_usd=None, **kw: client.suggest(
+                outcome=outcome,
+                region=region,
+                provider=provider,
+                max_monthly_cost_usd=max_monthly_cost_usd,
+            ),
+        },
+        "DEPLOY": {
+            "name": "PROVISION_STACK_DEPLOY",
+            "description": (
+                f"Deploy infrastructure via {PRODUCT_NAME}. "
+                "Fee held from balance, captured after verification."
+            ),
+            "schema": {
+                "type": "object",
+                "properties": {
+                    "outcome": {
+                        "type": "string",
+                        "description": "What to deploy",
+                    },
+                    "tier": {
+                        "type": "string",
+                        "enum": ["Starter", "MVP", "Startup", "Enterprise"],
+                        "description": "Deployment tier",
+                    },
+                    "region": {
+                        "type": "string",
+                        "description": "Target region",
+                    },
+                    "max_monthly_cost_usd": {
+                        "type": "number",
+                        "description": "Monthly cost cap",
+                    },
+                },
+                "required": ["outcome"],
+            },
+            "handler": lambda outcome, tier=None, region=None,
+            max_monthly_cost_usd=None, **kw: client.deploy(
+                outcome=outcome,
+                tier=tier,
+                region=region,
+                max_monthly_cost_usd=max_monthly_cost_usd,
+            ),
+        },
+        "STATUS": {
+            "name": "PROVISION_STACK_STATUS",
+            "description": f"Check status of a {PRODUCT_NAME} deployment.",
+            "schema": {
+                "type": "object",
+                "properties": {
+                    "deployment_id": {
+                        "type": "string",
+                        "description": "Deployment ID to check",
+                    },
+                },
+                "required": ["deployment_id"],
+            },
+            "handler": lambda deployment_id, **kw: client.status(deployment_id),
+        },
+        "DESTROY": {
+            "name": "PROVISION_STACK_DESTROY",
+            "description": f"Destroy all resources in a {PRODUCT_NAME} deployment.",
+            "schema": {
+                "type": "object",
+                "properties": {
+                    "deployment_id": {
+                        "type": "string",
+                        "description": "Deployment ID to destroy",
+                    },
+                },
+                "required": ["deployment_id"],
+            },
+            "handler": lambda deployment_id, **kw: client.destroy(deployment_id),
+        },
+        "BALANCE": {
+            "name": "PROVISION_STACK_BALANCE",
+            "description": f"Check {PRODUCT_NAME} account credit balance.",
+            "schema": {
+                "type": "object",
+                "properties": {},
+            },
+            "handler": lambda **kw: client.balance(),
+        },
+        "TOPUP": {
+            "name": "PROVISION_STACK_TOPUP",
+            "description": f"Add credits to {PRODUCT_NAME} account.",
+            "schema": {
+                "type": "object",
+                "properties": {
+                    "amount_usd": {
+                        "type": "number",
+                        "description": "Amount in USD",
+                    },
+                    "rail": {
+                        "type": "string",
+                        "enum": ["stripe", "xrp"],
+                        "description": "Payment method",
+                    },
+                },
+                "required": ["amount_usd"],
+            },
+            "handler": lambda amount_usd, rail="stripe", **kw: (
+                client.topup_xrp(amount_usd) if rail == "xrp"
+                else client.topup_stripe(amount_usd)
+            ),
+        },
+    }
+
+    # Register requested actions
+    to_register = actions or list(all_actions.keys())
+
+    for action_key in to_register:
+        action = all_actions.get(action_key)
+        if action is None:
+            raise ValueError(
+                f"Unknown action: {action_key}. "
+                f"Available: {list(all_actions.keys())}"
+            )
+        _register_action(
+            toolset,
+            name=action["name"],
+            description=action["description"],
+            schema=action["schema"],
+            handler=action["handler"],
+        )

provision_stack_composio-0.1.0/pyproject.toml

@@ -0,0 +1,54 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "provision-stack-composio"
+version = "0.1.0"
+description = "Composio integration for Provision Stack — deploy cloud infrastructure via AI agents."
+readme = "README.md"
+license = "MIT"
+requires-python = ">=3.10"
+authors = [
+    { name = "Provision Stack" },
+]
+keywords = [
+    "composio",
+    "ai-agents",
+    "infrastructure",
+    "aws",
+    "gcp",
+    "mcp",
+    "langchain",
+    "crewai",
+    "autogen",
+]
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "Intended Audience :: Developers",
+    "License :: OSI Approved :: MIT License",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+    "Topic :: Software Development :: Libraries :: Python Modules",
+]
+dependencies = [
+    "provision-stack>=0.1.0",
+    "composio-core>=0.6.0",
+]
+
+[project.urls]
+Homepage = "https://provision-stack.com"
+Documentation = "https://docs.provision-stack.com"
+Repository = "https://github.com/TravisLinkey/provision-stack"
+
+[project.optional-dependencies]
+test = [
+    "pytest>=8.0",
+    "pytest-mock>=3.12",
+]
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]

provision_stack_composio-0.1.0/tests/test_tools.py

@@ -0,0 +1,104 @@
+"""Tests for provision_stack_composio.tools — Composio integration."""
+
+from __future__ import annotations
+
+import sys
+from unittest.mock import MagicMock
+import pytest
+
+# Mock composio before importing our tools
+mock_composio = MagicMock()
+sys.modules.setdefault("composio", mock_composio)
+
+from provision_stack_composio.tools import register_provision_stack_tools
+
+
+# ── Registration ──────────────────────────────────────────────────
+
+
+class TestRegisterProvisionStackTools:
+    def test_registers_all_actions_by_default(self):
+        mock_toolset = MagicMock()
+        register_provision_stack_tools(mock_toolset, api_key="test")
+        # set_actions is called once per action (6 times total)
+        assert mock_toolset.set_actions.call_count == 6
+
+    def test_registers_subset_when_specified(self):
+        mock_toolset = MagicMock()
+        register_provision_stack_tools(
+            mock_toolset, api_key="test", actions=["SUGGEST", "DEPLOY"]
+        )
+        assert mock_toolset.set_actions.call_count == 2
+        # Check both calls contain the right action names
+        registered = set()
+        for call in mock_toolset.set_actions.call_args_list:
+            registered.update(call[0][0].keys())
+        assert registered == {"PROVISION_STACK_SUGGEST", "PROVISION_STACK_DEPLOY"}
+
+    def test_raises_on_unknown_action(self):
+        mock_toolset = MagicMock()
+        with pytest.raises(ValueError, match="Unknown action"):
+            register_provision_stack_tools(
+                mock_toolset, api_key="test", actions=["FAKE_ACTION"]
+            )
+
+    def test_actions_have_schemas(self):
+        mock_toolset = MagicMock()
+        register_provision_stack_tools(mock_toolset, api_key="test")
+        for call in mock_toolset.set_actions.call_args_list:
+            action = call[0][0]
+            name = list(action.keys())[0]
+            assert "schema" in action[name], f"{name} missing schema"
+            assert "properties" in action[name]["schema"], f"{name} schema missing properties"
+
+    def test_actions_have_handlers(self):
+        mock_toolset = MagicMock()
+        register_provision_stack_tools(mock_toolset, api_key="test")
+        for call in mock_toolset.set_actions.call_args_list:
+            action = call[0][0]
+            name = list(action.keys())[0]
+            assert "handler" in action[name], f"{name} missing handler"
+            assert callable(action[name]["handler"]), f"{name} handler not callable"
+
+    def test_actions_have_descriptions(self):
+        mock_toolset = MagicMock()
+        register_provision_stack_tools(mock_toolset, api_key="test")
+        for call in mock_toolset.set_actions.call_args_list:
+            action = call[0][0]
+            name = list(action.keys())[0]
+            assert "description" in action[name], f"{name} missing description"
+            assert len(action[name]["description"]) > 10
+
+    def _get_action(self, mock_toolset, action_name: str) -> dict:
+        """Retrieve a specific action dict from the set_actions calls."""
+        for call in mock_toolset.set_actions.call_args_list:
+            action = call[0][0]
+            if action_name in action:
+                return action[action_name]
+        raise KeyError(f"{action_name} not found in set_actions calls")
+
+    def test_suggest_action_schema_has_outcome(self):
+        mock_toolset = MagicMock()
+        register_provision_stack_tools(mock_toolset, api_key="test")
+        suggest = self._get_action(mock_toolset, "PROVISION_STACK_SUGGEST")
+        assert "outcome" in suggest["schema"]["properties"]
+
+    def test_deploy_action_schema_has_outcome(self):
+        mock_toolset = MagicMock()
+        register_provision_stack_tools(mock_toolset, api_key="test")
+        deploy = self._get_action(mock_toolset, "PROVISION_STACK_DEPLOY")
+        assert "outcome" in deploy["schema"]["properties"]
+
+    def test_status_action_schema_has_deployment_id(self):
+        mock_toolset = MagicMock()
+        register_provision_stack_tools(mock_toolset, api_key="test")
+        status = self._get_action(mock_toolset, "PROVISION_STACK_STATUS")
+        assert "deployment_id" in status["schema"]["properties"]
+        assert "deployment_id" in status["schema"]["required"]
+
+    def test_topup_action_schema_has_amount(self):
+        mock_toolset = MagicMock()
+        register_provision_stack_tools(mock_toolset, api_key="test")
+        topup = self._get_action(mock_toolset, "PROVISION_STACK_TOPUP")
+        assert "amount_usd" in topup["schema"]["properties"]
+        assert "amount_usd" in topup["schema"]["required"]