eil-card 0.1.1__tar.gz

eil_card-0.1.1/.gitignore

@@ -0,0 +1,25 @@
+node_modules/
+dist/
+__pycache__/
+*.py[cod]
+.next/
+.env
+.env.local
+.env.production
+.env.prod
+*.tsbuildinfo
+drizzle/meta/
+.DS_Store
+Thumbs.db
+
+# Internal planning — keep local, do not publish
+digital.md
+saha-analizi.md
+is-plani.md
+faz.md
+pilot-sektor.md
+teknik-stack.md
+.cursor/*
+!.cursor/rules/
+!.cursor/rules/**
+schema/examples/organization.sinyalle.json

eil_card-0.1.1/PKG-INFO

@@ -0,0 +1,162 @@
+Metadata-Version: 2.4
+Name: eil-card
+Version: 0.1.1
+Summary: EIL Card Python SDK — resolve verified entity identity for AI agents
+Project-URL: Homepage, https://eilcard.com
+Project-URL: Documentation, https://eilcard.com/docs/agents
+Project-URL: Repository, https://github.com/Mendocan/eilcard
+Project-URL: Issues, https://github.com/Mendocan/eilcard/issues
+Author: EIL Card
+License-Expression: MIT
+Keywords: agents,crewai,digital-card,eil,entity-identity,langchain
+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
+Requires-Python: >=3.10
+Requires-Dist: requests>=2.31
+Provides-Extra: all
+Requires-Dist: crewai>=0.80; extra == 'all'
+Requires-Dist: langchain-core>=0.3; extra == 'all'
+Requires-Dist: llama-index-core>=0.11; extra == 'all'
+Provides-Extra: crewai
+Requires-Dist: crewai>=0.80; extra == 'crewai'
+Provides-Extra: crypto
+Requires-Dist: cryptography>=42; extra == 'crypto'
+Provides-Extra: dev
+Requires-Dist: pytest>=8; extra == 'dev'
+Requires-Dist: responses>=0.25; extra == 'dev'
+Provides-Extra: langchain
+Requires-Dist: langchain-core>=0.3; extra == 'langchain'
+Provides-Extra: llamaindex
+Requires-Dist: llama-index-core>=0.11; extra == 'llamaindex'
+Description-Content-Type: text/markdown
+
+# EIL Card Python SDK (`eil-card`)
+
+Resolve verified organization and person identity from the EIL Card registry — with LangChain, CrewAI, and LlamaIndex integrations.
+
+## Install
+
+```bash
+pip install eil-card
+```
+
+Optional framework extras:
+
+```bash
+pip install eil-card[langchain]
+pip install eil-card[llamaindex]
+pip install eil-card[crewai]
+pip install eil-card[all]
+```
+
+## Quick start
+
+```python
+from eil_card import DigitalCard, discover_capabilities, discover_act_capabilities
+
+result = DigitalCard.resolve(domain="sinyalle.com")
+card = result["card"]
+print(card["name"]["official"], card.get("verified"))
+
+caps = discover_capabilities(card)
+if caps["available"]:
+    print("Gateway:", caps["agent_gateway"])
+
+act = discover_act_capabilities(card)
+print("Write/act scopes:", act["scopes_parsed"]["write"], act["scopes_parsed"]["act"])
+```
+
+## LangChain
+
+```python
+from eil_card.integrations.langchain import create_eil_resolve_tool
+
+tool = create_eil_resolve_tool()
+# tools = [tool]
+```
+
+Tool name matches the TypeScript SDK: `resolve_entity_identity`.
+
+## CrewAI
+
+```python
+from crewai import Agent
+from eil_card.integrations.crewai import create_eil_resolve_crewai_tool
+
+resolve_tool = create_eil_resolve_crewai_tool()
+agent = Agent(role="Researcher", goal="Verify entities", tools=[resolve_tool])
+```
+
+## LlamaIndex
+
+```python
+from eil_card.integrations.llamaindex import EILReader
+
+docs = EILReader().load_data(domain="sinyalle.com")
+```
+
+## JWS trust (Registry+)
+
+```python
+from eil_card import DigitalCard
+
+result = DigitalCard.resolve(domain="sinyalle.com", verify_jws=True)
+print(result.get("trust", {}).get("jws"))
+
+# Crypto verify: pip install eil-card[crypto]
+result = DigitalCard.resolve(
+    domain="sinyalle.com",
+    verify_jws={"public_key_pem": open("registry-public.pem").read(), "require_valid": True},
+)
+```
+
+## Agent act headers (pilot gateway)
+
+```python
+from eil_card import build_idempotency_key, build_agent_act_headers, agent_act_headers_to_fetch
+
+key = build_idempotency_key(
+    agent_client_id="my-agent",
+    action_id="create_post",
+    entity_id="sinyalle.com",
+    nonce="run-1",
+)
+headers = agent_act_headers_to_fetch(
+    build_agent_act_headers(
+        access_token="...",
+        idempotency_key=key,
+        action_id="create_post",
+        card_id="sinyalle.com",
+    )
+)
+```
+
+## Development
+
+```bash
+cd packages/python
+pip install -e ".[dev]"
+pytest
+```
+
+## Publish (maintainers)
+
+```bash
+pip install build twine
+python -m build
+twine upload dist/*
+```
+
+Set `PYPI_API_TOKEN` in the environment or `~/.pypirc`.
+
+## Docs
+
+- https://eilcard.com/docs/agents
+- TypeScript SDK parity: `packages/sdk/SDK.md`

eil_card-0.1.1/README.md

@@ -0,0 +1,123 @@
+# EIL Card Python SDK (`eil-card`)
+
+Resolve verified organization and person identity from the EIL Card registry — with LangChain, CrewAI, and LlamaIndex integrations.
+
+## Install
+
+```bash
+pip install eil-card
+```
+
+Optional framework extras:
+
+```bash
+pip install eil-card[langchain]
+pip install eil-card[llamaindex]
+pip install eil-card[crewai]
+pip install eil-card[all]
+```
+
+## Quick start
+
+```python
+from eil_card import DigitalCard, discover_capabilities, discover_act_capabilities
+
+result = DigitalCard.resolve(domain="sinyalle.com")
+card = result["card"]
+print(card["name"]["official"], card.get("verified"))
+
+caps = discover_capabilities(card)
+if caps["available"]:
+    print("Gateway:", caps["agent_gateway"])
+
+act = discover_act_capabilities(card)
+print("Write/act scopes:", act["scopes_parsed"]["write"], act["scopes_parsed"]["act"])
+```
+
+## LangChain
+
+```python
+from eil_card.integrations.langchain import create_eil_resolve_tool
+
+tool = create_eil_resolve_tool()
+# tools = [tool]
+```
+
+Tool name matches the TypeScript SDK: `resolve_entity_identity`.
+
+## CrewAI
+
+```python
+from crewai import Agent
+from eil_card.integrations.crewai import create_eil_resolve_crewai_tool
+
+resolve_tool = create_eil_resolve_crewai_tool()
+agent = Agent(role="Researcher", goal="Verify entities", tools=[resolve_tool])
+```
+
+## LlamaIndex
+
+```python
+from eil_card.integrations.llamaindex import EILReader
+
+docs = EILReader().load_data(domain="sinyalle.com")
+```
+
+## JWS trust (Registry+)
+
+```python
+from eil_card import DigitalCard
+
+result = DigitalCard.resolve(domain="sinyalle.com", verify_jws=True)
+print(result.get("trust", {}).get("jws"))
+
+# Crypto verify: pip install eil-card[crypto]
+result = DigitalCard.resolve(
+    domain="sinyalle.com",
+    verify_jws={"public_key_pem": open("registry-public.pem").read(), "require_valid": True},
+)
+```
+
+## Agent act headers (pilot gateway)
+
+```python
+from eil_card import build_idempotency_key, build_agent_act_headers, agent_act_headers_to_fetch
+
+key = build_idempotency_key(
+    agent_client_id="my-agent",
+    action_id="create_post",
+    entity_id="sinyalle.com",
+    nonce="run-1",
+)
+headers = agent_act_headers_to_fetch(
+    build_agent_act_headers(
+        access_token="...",
+        idempotency_key=key,
+        action_id="create_post",
+        card_id="sinyalle.com",
+    )
+)
+```
+
+## Development
+
+```bash
+cd packages/python
+pip install -e ".[dev]"
+pytest
+```
+
+## Publish (maintainers)
+
+```bash
+pip install build twine
+python -m build
+twine upload dist/*
+```
+
+Set `PYPI_API_TOKEN` in the environment or `~/.pypirc`.
+
+## Docs
+
+- https://eilcard.com/docs/agents
+- TypeScript SDK parity: `packages/sdk/SDK.md`

eil_card-0.1.1/eil_card/__init__.py

@@ -0,0 +1,64 @@
+"""EIL Card Python SDK — resolve verified entity identity for AI agents."""
+
+from eil_card.act import (
+    agent_act_headers_to_fetch,
+    build_agent_act_headers,
+    build_idempotency_key,
+    discover_act_capabilities,
+    parse_capability_scopes,
+)
+from eil_card.agent_tool import (
+    format_resolve_tool_error,
+    format_resolve_tool_result,
+    invoke_eil_resolve,
+    invoke_eil_resolve_async,
+)
+from eil_card.capabilities import discover_capabilities
+from eil_card.client import DigitalCard, DigitalCardClient, normalize_domain
+from eil_card.errors import (
+    CardNotFoundError,
+    DigitalCardError,
+    InvalidResolveInputError,
+    JwsVerificationError,
+    RegistryError,
+    SchemaValidationError,
+)
+from eil_card.jws import canonical_card_without_signatures, verify_registry_jws
+from eil_card.tool_schema import (
+    EIL_RESOLVE_TOOL_DESCRIPTION,
+    EIL_RESOLVE_TOOL_NAME,
+    build_eil_resolve_tool_definitions,
+    build_resolve_input_json_schema,
+)
+from eil_card.types import SCHEMA_VERSION
+
+__all__ = [
+    "SCHEMA_VERSION",
+    "DigitalCard",
+    "DigitalCardClient",
+    "normalize_domain",
+    "discover_capabilities",
+    "discover_act_capabilities",
+    "parse_capability_scopes",
+    "build_idempotency_key",
+    "build_agent_act_headers",
+    "agent_act_headers_to_fetch",
+    "invoke_eil_resolve",
+    "invoke_eil_resolve_async",
+    "format_resolve_tool_result",
+    "format_resolve_tool_error",
+    "EIL_RESOLVE_TOOL_NAME",
+    "EIL_RESOLVE_TOOL_DESCRIPTION",
+    "build_resolve_input_json_schema",
+    "build_eil_resolve_tool_definitions",
+    "DigitalCardError",
+    "CardNotFoundError",
+    "InvalidResolveInputError",
+    "JwsVerificationError",
+    "RegistryError",
+    "SchemaValidationError",
+    "canonical_card_without_signatures",
+    "verify_registry_jws",
+]
+
+__version__ = "0.1.1"

eil_card-0.1.1/eil_card/act.py

@@ -0,0 +1,98 @@
+from __future__ import annotations
+
+import re
+from typing import Any
+
+from eil_card.capabilities import discover_capabilities
+from eil_card.types import DiscoveredActCapabilities, ParsedCapabilityScopes
+
+_SCOPE_KIND_PATTERN = re.compile(r"^(read|write|act):")
+
+
+def parse_capability_scopes(scopes: list[str] | None = None) -> ParsedCapabilityScopes:
+    result: ParsedCapabilityScopes = {
+        "read": [],
+        "write": [],
+        "act": [],
+        "unknown": [],
+        "all": list(scopes) if scopes else [],
+    }
+    if not scopes:
+        return result
+
+    for scope in scopes:
+        if scope.startswith("read:"):
+            result["read"].append(scope)
+        elif scope.startswith("write:"):
+            result["write"].append(scope)
+        elif scope.startswith("act:"):
+            result["act"].append(scope)
+        elif _SCOPE_KIND_PATTERN.match(scope):
+            result["unknown"].append(scope)
+        else:
+            result["unknown"].append(scope)
+
+    return result
+
+
+def discover_act_capabilities(card: dict[str, Any]) -> DiscoveredActCapabilities:
+    base = discover_capabilities(card)
+    scopes_parsed = parse_capability_scopes(base.get("scopes"))
+    actions = (card.get("capabilities") or {}).get("actions")
+
+    return {
+        **base,
+        "scopes_parsed": scopes_parsed,
+        "actions": actions,
+        "has_write_or_act": bool(
+            scopes_parsed["write"] or scopes_parsed["act"] or (actions or [])
+        ),
+    }
+
+
+def build_idempotency_key(
+    *,
+    agent_client_id: str,
+    action_id: str,
+    entity_id: str,
+    nonce: str,
+) -> str:
+    def slug(value: str) -> str:
+        out = value.strip().lower()
+        out = re.sub(r"[^a-z0-9._-]+", "-", out)
+        out = re.sub(r"-+", "-", out)
+        return out.strip("-")
+
+    return "/".join(
+        [
+            "eil-act",
+            slug(agent_client_id),
+            slug(action_id),
+            slug(entity_id),
+            slug(nonce),
+        ]
+    )
+
+
+def build_agent_act_headers(
+    *,
+    access_token: str,
+    idempotency_key: str,
+    action_id: str,
+    card_id: str,
+) -> dict[str, str]:
+    return {
+        "authorization": f"Bearer {access_token}",
+        "idempotency_key": idempotency_key,
+        "action_id": action_id,
+        "card_id": card_id,
+    }
+
+
+def agent_act_headers_to_fetch(headers: dict[str, str]) -> dict[str, str]:
+    return {
+        "Authorization": headers["authorization"],
+        "Idempotency-Key": headers["idempotency_key"],
+        "X-EIL-Action-Id": headers["action_id"],
+        "X-EIL-Card-Id": headers["card_id"],
+    }

eil_card-0.1.1/eil_card/agent_tool.py

@@ -0,0 +1,60 @@
+from __future__ import annotations
+
+import json
+from typing import Any
+
+from eil_card.client import DigitalCard, DigitalCardClient
+from eil_card.errors import InvalidResolveInputError
+from eil_card.tool_schema import EIL_RESOLVE_TOOL_DESCRIPTION, EIL_RESOLVE_TOOL_NAME
+
+
+async def invoke_eil_resolve_async(
+    *,
+    domain: str | None = None,
+    handle: str | None = None,
+    registry_base_url: str = "https://eilcard.com",
+    api_key: str | None = None,
+    timeout: float = 10.0,
+    skip_well_known_fallback: bool = False,
+) -> dict[str, Any]:
+    """Async wrapper — runs sync resolve in thread pool if needed by frameworks."""
+    return invoke_eil_resolve(
+        domain=domain,
+        handle=handle,
+        registry_base_url=registry_base_url,
+        api_key=api_key,
+        timeout=timeout,
+        skip_well_known_fallback=skip_well_known_fallback,
+    )
+
+
+def invoke_eil_resolve(
+    *,
+    domain: str | None = None,
+    handle: str | None = None,
+    registry_base_url: str = "https://eilcard.com",
+    api_key: str | None = None,
+    timeout: float = 10.0,
+    skip_well_known_fallback: bool = False,
+) -> dict[str, Any]:
+    """Framework-agnostic handler for tool-calling agents."""
+    client = DigitalCardClient(
+        registry_base_url=registry_base_url,
+        api_key=api_key,
+        timeout=timeout,
+        skip_well_known_fallback=skip_well_known_fallback,
+    )
+    if domain:
+        return client.resolve(domain=domain)
+    if handle:
+        return client.resolve(handle=handle)
+    raise InvalidResolveInputError()
+
+
+def format_resolve_tool_result(result: dict[str, Any]) -> str:
+    return json.dumps(result, indent=2, ensure_ascii=False)
+
+
+def format_resolve_tool_error(entity: str, error: Exception | str) -> str:
+    message = str(error)
+    return f"Could not resolve EIL identity for {entity}: {message}"

eil_card-0.1.1/eil_card/capabilities.py

@@ -0,0 +1,42 @@
+from __future__ import annotations
+
+from typing import Any
+
+from eil_card.types import DiscoveredCapabilities
+
+
+def discover_capabilities(card: dict[str, Any]) -> DiscoveredCapabilities:
+    """Read capability manifest from a resolved card (Registry+ only)."""
+    edition = card.get("edition") or "core"
+
+    if edition != "registry_plus":
+        return {
+            "available": False,
+            "edition": edition,
+            "reason": "Capabilities require Registry+ edition (schema 1.2)",
+        }
+
+    caps = card.get("capabilities")
+    if not caps:
+        return {
+            "available": False,
+            "edition": edition,
+            "reason": "No capabilities object on card",
+        }
+
+    if not caps.get("agent_gateway"):
+        return {
+            "available": False,
+            "edition": edition,
+            "auth": caps.get("auth"),
+            "scopes": caps.get("scopes"),
+            "reason": "capabilities.agent_gateway is not set",
+        }
+
+    return {
+        "available": True,
+        "edition": edition,
+        "agent_gateway": caps["agent_gateway"],
+        "auth": caps.get("auth"),
+        "scopes": caps.get("scopes"),
+    }