cred-crewai 0.1.0__tar.gz

cred_crewai-0.1.0/.gitignore

@@ -0,0 +1,50 @@
+node_modules/
+dist/
+build/
+
+# Sprint artifacts
+.factory/
+.sprint-*
+.sprint-pid
+.rewire-done
+.content-rewrite-done
+.hubspot-done
+.integrations-done
+.done
+.validation-report.md
+.sprint-logs/
+.sprint-prompts/
+SESSION_PACKAGE.md
+run-sprint.sh
+validate.sh
+
+# Internal planning docs (not for public repo)
+CLAUDE.md
+PLAN.md
+HANDOFF.md
+VALIDATION.md
+MARKETING-VALIDATION.md
+FINAL-SUBMISSION-VALIDATION.md
+.next/
+out/
+coverage/
+*.tsbuildinfo
+.turbo/
+.DS_Store
+*.pem
+.env
+.env.local
+.env*.local
+!.env.example
+
+# Python
+__pycache__/
+*.py[cod]
+*.pyo
+*.egg-info/
+.pytest_cache/
+.venv/
+venv/
+dist/
+*.dist-info/
+packages/sdk-python/.venv/

cred_crewai-0.1.0/PKG-INFO

@@ -0,0 +1,71 @@
+Metadata-Version: 2.4
+Name: cred-crewai
+Version: 0.1.0
+Summary: Cred CrewAI integration — pre-configured credential delegation tools for CrewAI agents
+Author-email: Cred <hello@cred.ninja>
+License: Apache-2.0
+Keywords: ai-agents,cred,crewai,delegation,oauth
+Requires-Python: >=3.9
+Requires-Dist: cred-auth>=0.1.0
+Requires-Dist: crewai>=0.11
+Requires-Dist: langchain-core>=0.2
+Provides-Extra: dev
+Requires-Dist: hatchling; extra == 'dev'
+Requires-Dist: pytest>=7.0; extra == 'dev'
+Description-Content-Type: text/markdown
+
+# cred-crewai
+
+CrewAI integration for Cred. OAuth2 credential delegation for AI agents.
+
+## Install
+
+```bash
+pip install cred-crewai
+```
+
+## Quick Start
+
+```python
+import os
+from cred_crewai import CredTool
+from crewai import Agent
+
+# Create a pre-configured tool for Google Calendar
+google_tool = CredTool(
+    agent_token=os.environ["CRED_AGENT_TOKEN"],
+    user_id="user_123",
+    service="google",
+    app_client_id="my_app_client_id",
+    scopes=["calendar.readonly"],
+)
+
+# Use with CrewAI agent
+agent = Agent(
+    role="Calendar Manager",
+    goal="Manage user's calendar",
+    tools=[google_tool],
+)
+```
+
+## Key Differences from LangChain
+
+**LangChain integration** (`cred-langchain`):
+- `CredToolkit` returns 3 generic tools: delegate, status, revoke
+- Best for agents that need full credential management
+
+**CrewAI integration** (`cred-crewai`):
+- `CredTool` is pre-configured for a **single service**
+- Tool name auto-generated: `cred_google_delegate`, `cred_github_delegate`, etc.
+- Best for specialized agents (e.g., a "Calendar Manager" agent only needs Google tokens)
+
+One `CredTool` per service per agent = clearer intent, smaller decision space for the LLM.
+
+## Handling Consent
+
+When a user hasn't connected the service yet, `_run()` raises `ConsentRequiredError`.
+Catch it and redirect the user to `e.consent_url` to complete the OAuth flow.
+
+## Cred Cloud (Coming Soon)
+
+Managed cloud delegation is coming. [Join the waitlist](https://cred.ninja/waitlist).

cred_crewai-0.1.0/README.md

@@ -0,0 +1,55 @@
+# cred-crewai
+
+CrewAI integration for Cred. OAuth2 credential delegation for AI agents.
+
+## Install
+
+```bash
+pip install cred-crewai
+```
+
+## Quick Start
+
+```python
+import os
+from cred_crewai import CredTool
+from crewai import Agent
+
+# Create a pre-configured tool for Google Calendar
+google_tool = CredTool(
+    agent_token=os.environ["CRED_AGENT_TOKEN"],
+    user_id="user_123",
+    service="google",
+    app_client_id="my_app_client_id",
+    scopes=["calendar.readonly"],
+)
+
+# Use with CrewAI agent
+agent = Agent(
+    role="Calendar Manager",
+    goal="Manage user's calendar",
+    tools=[google_tool],
+)
+```
+
+## Key Differences from LangChain
+
+**LangChain integration** (`cred-langchain`):
+- `CredToolkit` returns 3 generic tools: delegate, status, revoke
+- Best for agents that need full credential management
+
+**CrewAI integration** (`cred-crewai`):
+- `CredTool` is pre-configured for a **single service**
+- Tool name auto-generated: `cred_google_delegate`, `cred_github_delegate`, etc.
+- Best for specialized agents (e.g., a "Calendar Manager" agent only needs Google tokens)
+
+One `CredTool` per service per agent = clearer intent, smaller decision space for the LLM.
+
+## Handling Consent
+
+When a user hasn't connected the service yet, `_run()` raises `ConsentRequiredError`.
+Catch it and redirect the user to `e.consent_url` to complete the OAuth flow.
+
+## Cred Cloud (Coming Soon)
+
+Managed cloud delegation is coming. [Join the waitlist](https://cred.ninja/waitlist).

cred_crewai-0.1.0/cred_crewai/__init__.py

@@ -0,0 +1,5 @@
+"""Cred CrewAI integration — pre-configured delegation tools for CrewAI agents."""
+
+from .tool import CredTool
+
+__all__ = ["CredTool"]

cred_crewai-0.1.0/cred_crewai/tool.py

@@ -0,0 +1,105 @@
+"""Cred CrewAI Tool — pre-configured delegation tool for a single service.
+
+CrewAI's BaseTool is langchain_core.tools.BaseTool under the hood
+(verified in crewai 0.11.x source). We import from langchain_core so this
+package works in environments where crewai is installed alongside langchain,
+without requiring crewai as a hard build dependency at import time.
+
+When crewai is installed, pass CredTool instances directly to Agent(tools=[...]).
+"""
+
+from __future__ import annotations
+
+import time
+from typing import Any, Optional, Type
+
+from langchain_core.tools import BaseTool
+from pydantic import BaseModel, Field
+
+from cred import Cred
+from cred.exceptions import ConsentRequiredError  # re-export for convenience
+
+
+class _CredToolInput(BaseModel):
+    """Placeholder input — CredTool has no runtime inputs; all params are pre-configured."""
+    pass
+
+
+class CredTool(BaseTool):
+    """A CrewAI-compatible tool that delegates credentials for a single service.
+
+    Pre-configured at construction time with a specific service, user, and
+    optional scopes. The agent calls it with no additional parameters — the
+    service/user context is baked in, keeping the agent's decision surface small.
+
+    Example::
+
+        from cred_crewai import CredTool
+
+        google_tool = CredTool(
+            agent_token=os.environ["CRED_AGENT_TOKEN"],
+            user_id="user_123",
+            service="google",
+            app_client_id="my_app",
+            scopes=["calendar.readonly"],
+        )
+
+        # Use with CrewAI
+        from crewai import Agent
+        agent = Agent(role="Calendar Manager", tools=[google_tool])
+    """
+
+    # langchain_core requires these as class-level annotations
+    name: str = "cred_delegate"
+    description: str = "Get a delegated OAuth access token for a service"
+    args_schema: Type[BaseModel] = _CredToolInput
+
+    # Tool state — set in __init__
+    _cred: Any = None
+    _user_id: str = ""
+    _service: str = ""
+    _app_client_id: str = ""
+    _scopes: list[str] = []
+    _cached_token: str | None = None
+    _cache_expires_at: float = 0.0
+
+    def __init__(
+        self,
+        agent_token: str,
+        user_id: str,
+        service: str,
+        app_client_id: str,
+        scopes: Optional[list[str]] = None,
+        base_url: str = "https://api.cred.ninja",
+        **kwargs: Any,
+    ) -> None:
+        super().__init__(**kwargs)
+        self._cred = Cred(agent_token=agent_token, base_url=base_url)
+        self._user_id = user_id
+        self._service = service
+        self._app_client_id = app_client_id
+        self._scopes = scopes or []
+        # Set dynamic name and description after init
+        self.name = f"cred_{service.replace('-', '_')}_delegate"
+        self.description = (
+            f"Get a delegated OAuth access token for {service} on behalf of the current user. "
+            f"Returns the access token string. "
+            f"Raises ConsentRequiredError (with consent_url) if the user hasn't connected {service}."
+        )
+
+    def _run(self, **kwargs: Any) -> str:
+        """Delegate credentials and return the access token string."""
+        now = time.monotonic()
+        if self._cached_token is not None and self._cache_expires_at > now:
+            return self._cached_token
+
+        result = self._cred.delegate(
+            service=self._service,
+            user_id=self._user_id,
+            app_client_id=self._app_client_id,
+            scopes=self._scopes if self._scopes else None,
+        )
+        self._cached_token = result.access_token
+        expires_in = getattr(result, "expires_in", None)
+        self._cache_expires_at = now + expires_in - 60 if isinstance(expires_in, int) and expires_in > 60 else 0.0
+        return result.access_token

cred_crewai-0.1.0/pyproject.toml

@@ -0,0 +1,27 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "cred-crewai"
+version = "0.1.0"
+description = "Cred CrewAI integration — pre-configured credential delegation tools for CrewAI agents"
+readme = "README.md"
+license = { text = "Apache-2.0" }
+requires-python = ">=3.9"
+authors = [{ name = "Cred", email = "hello@cred.ninja" }]
+keywords = ["cred", "crewai", "oauth", "delegation", "ai-agents"]
+dependencies = [
+    "cred-auth>=0.1.0",
+    "crewai>=0.11",
+    "langchain-core>=0.2",
+]
+
+[project.optional-dependencies]
+dev = ["pytest>=7.0", "hatchling"]
+
+[tool.hatch.build.targets.wheel]
+packages = ["cred_crewai"]
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]

cred_crewai-0.1.0/tests/test_tool.py

@@ -0,0 +1,247 @@
+"""Cred CrewAI Tool tests.
+
+Mocks the Cred client — no real HTTP, no real API calls.
+Tests focus on: tool configuration, naming, input schema, output format, error propagation.
+"""
+
+import warnings
+warnings.filterwarnings("ignore", category=UserWarning)
+
+from datetime import datetime, timezone
+from typing import Optional
+
+import pytest
+import httpx
+from unittest.mock import MagicMock, patch
+
+from cred import DelegationResult, ConsentRequiredError
+from cred_crewai import CredTool
+
+TOKEN = "cred_at_test"
+USER_ID = "user_123"
+APP_CLIENT_ID = "app_1"
+
+
+def make_delegation_result(
+    *,
+    access_token: str = "at",
+    token_type: str = "Bearer",
+    expires_in: int = 3600,
+    service: str = "google",
+    scopes: Optional[list[str]] = None,
+    delegation_id: str = "del_1",
+) -> DelegationResult:
+    return DelegationResult(
+        access_token=access_token,
+        token_type=token_type,
+        expires_in=expires_in,
+        expires_at=datetime(2026, 3, 1, tzinfo=timezone.utc),
+        service=service,
+        scopes=scopes or [],
+        delegation_id=delegation_id,
+    )
+
+
+@pytest.fixture
+def mock_cred():
+    return MagicMock()
+
+
+@pytest.fixture
+def tool(mock_cred):
+    t = CredTool(
+        agent_token=TOKEN,
+        user_id=USER_ID,
+        service="google",
+        app_client_id=APP_CLIENT_ID,
+        scopes=["calendar.readonly"],
+    )
+    t._cred = mock_cred
+    return t
+
+
+# ── constructor & configuration ───────────────────────────────────────────────
+
+class TestConstructor:
+    def test_sets_service_from_param(self):
+        t = CredTool(
+            agent_token=TOKEN,
+            user_id=USER_ID,
+            service="github",
+            app_client_id=APP_CLIENT_ID,
+        )
+        assert t._service == "github"
+        assert "github" in t.name
+
+    def test_dynamic_name_includes_service(self):
+        google_tool = CredTool(
+            agent_token=TOKEN,
+            user_id=USER_ID,
+            service="google-calendar",
+            app_client_id=APP_CLIENT_ID,
+        )
+        assert google_tool.name == "cred_google_calendar_delegate"
+
+    def test_dynamic_description_includes_service(self):
+        t = CredTool(
+            agent_token=TOKEN,
+            user_id=USER_ID,
+            service="github",
+            app_client_id=APP_CLIENT_ID,
+        )
+        assert "github" in t.description
+        assert "access token" in t.description
+
+    def test_stores_user_id(self):
+        t = CredTool(
+            agent_token=TOKEN,
+            user_id="user_456",
+            service="google",
+            app_client_id=APP_CLIENT_ID,
+        )
+        assert t._user_id == "user_456"
+
+    def test_stores_scopes(self):
+        scopes = ["calendar.readonly", "calendar.events"]
+        t = CredTool(
+            agent_token=TOKEN,
+            user_id=USER_ID,
+            service="google",
+            app_client_id=APP_CLIENT_ID,
+            scopes=scopes,
+        )
+        assert t._scopes == scopes
+
+    def test_defaults_scopes_to_empty_list(self):
+        t = CredTool(
+            agent_token=TOKEN,
+            user_id=USER_ID,
+            service="google",
+            app_client_id=APP_CLIENT_ID,
+        )
+        assert t._scopes == []
+
+    def test_custom_base_url(self):
+        with patch("cred_crewai.tool.Cred") as mock_cred_class:
+            CredTool(
+                agent_token=TOKEN,
+                user_id=USER_ID,
+                service="google",
+                app_client_id=APP_CLIENT_ID,
+                base_url="http://localhost:3001",
+            )
+            mock_cred_class.assert_called_once_with(
+                agent_token=TOKEN,
+                base_url="http://localhost:3001",
+            )
+
+
+# ── _run() ────────────────────────────────────────────────────────────────────
+
+class TestRun:
+    def test_returns_access_token_string(self, tool, mock_cred):
+        mock_cred.delegate.return_value = make_delegation_result(
+            access_token="ya29.mock",
+            expires_in=3600,
+            service="google",
+            scopes=["calendar.readonly"],
+            delegation_id="del_abc",
+        )
+
+        result = tool._run()
+
+        assert result == "ya29.mock"
+        assert isinstance(result, str)
+
+    def test_passes_service_user_app_client_id(self, tool, mock_cred):
+        mock_cred.delegate.return_value = make_delegation_result()
+
+        tool._run()
+
+        mock_cred.delegate.assert_called_once_with(
+            service="google",
+            user_id=USER_ID,
+            app_client_id=APP_CLIENT_ID,
+            scopes=["calendar.readonly"],
+        )
+
+    def test_passes_scopes_when_configured(self, tool, mock_cred):
+        tool._scopes = ["calendar.readonly", "calendar.events"]
+        mock_cred.delegate.return_value = make_delegation_result(
+            scopes=["calendar.readonly", "calendar.events"],
+        )
+
+        tool._run()
+
+        call_args = mock_cred.delegate.call_args
+        assert call_args.kwargs["scopes"] == ["calendar.readonly", "calendar.events"]
+
+    def test_passes_none_scopes_when_empty(self, mock_cred):
+        t = CredTool(
+            agent_token=TOKEN,
+            user_id=USER_ID,
+            service="google",
+            app_client_id=APP_CLIENT_ID,
+        )
+        t._cred = mock_cred
+        t._scopes = []
+
+        mock_cred.delegate.return_value = make_delegation_result()
+
+        t._run()
+
+        call_args = mock_cred.delegate.call_args
+        assert call_args.kwargs["scopes"] is None
+
+    def test_propagates_consent_required_error(self, tool, mock_cred):
+        mock_cred.delegate.side_effect = ConsentRequiredError(
+            "User has not consented",
+            "https://api.cred.ninja/api/connect/google/authorize?app_client_id=app_1",
+        )
+
+        with pytest.raises(ConsentRequiredError) as exc_info:
+            tool._run()
+
+        assert "/api/connect/google/authorize" in exc_info.value.consent_url
+
+
+# ── langchain compatibility ───────────────────────────────────────────────────
+
+class TestLangChainCompatibility:
+    def test_has_args_schema(self, tool):
+        assert hasattr(tool, "args_schema")
+        schema = tool.args_schema.model_json_schema()
+        # Placeholder schema should be minimal
+        assert isinstance(schema, dict)
+
+    def test_is_base_tool(self, tool):
+        from langchain_core.tools import BaseTool
+        assert isinstance(tool, BaseTool)
+
+
+class TestIntegrationFlow:
+    def test_real_cred_client_delegates_against_mock_server(self):
+        tool = CredTool(
+            agent_token=TOKEN,
+            user_id=USER_ID,
+            service="google",
+            app_client_id=APP_CLIENT_ID,
+            scopes=["calendar.readonly"],
+            base_url="https://cred.example.com",
+        )
+
+        with patch("httpx.Client.request", return_value=httpx.Response(
+            200,
+            json={
+                "access_token": "ya29.real",
+                "token_type": "Bearer",
+                "expires_in": 3600,
+                "service": "google",
+                "scopes": ["calendar.readonly"],
+                "delegation_id": "del_real",
+            },
+        )) as request_mock:
+            token = tool._run()
+
+        assert token == "ya29.real"
+        assert request_mock.called