aegis-security-sdk 0.1.0__tar.gz

aegis_security_sdk-0.1.0/PKG-INFO

@@ -0,0 +1,95 @@
+Metadata-Version: 2.4
+Name: aegis-security-sdk
+Version: 0.1.0
+Summary: Aegis AI Security & Governance SDK
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+Requires-Dist: langchain-core>=0.3.0
+Requires-Dist: langchain-groq>=0.2.0
+Requires-Dist: langgraph>=0.2.0
+Requires-Dist: pydantic>=2.0.0
+Requires-Dist: python-dotenv>=1.0.0
+Requires-Dist: httpx>=0.27.0
+Provides-Extra: openai
+Requires-Dist: langchain-openai>=0.2.0; extra == "openai"
+Provides-Extra: anthropic
+Requires-Dist: langchain-anthropic>=0.3.0; extra == "anthropic"
+Provides-Extra: google
+Requires-Dist: langchain-google-genai>=2.0.0; extra == "google"
+Provides-Extra: nvidia
+Requires-Dist: langchain-nvidia-ai-endpoints>=0.3.0; extra == "nvidia"
+Provides-Extra: crewai
+Requires-Dist: crewai>=0.80.0; extra == "crewai"
+Requires-Dist: crewai-tools>=0.14.0; extra == "crewai"
+Provides-Extra: all
+Requires-Dist: aegis-security-sdk[openai]; extra == "all"
+Requires-Dist: aegis-security-sdk[anthropic]; extra == "all"
+Requires-Dist: aegis-security-sdk[google]; extra == "all"
+Requires-Dist: aegis-security-sdk[nvidia]; extra == "all"
+Requires-Dist: aegis-security-sdk[crewai]; extra == "all"
+
+# 🛡️ Aegis SDK — Enterprise AI Security & Governance
+
+Aegis is a multi-layered security, governance, and policy engine for AI agents and LLM applications. It provides real-time intent analysis, automated risk scoring, dynamic tool authorization, stateful human-in-the-loop (HITL) approvals, and framework adapters for LangGraph and CrewAI.
+
+## Installation
+
+### Core SDK (via GitHub)
+```bash
+pip install git+https://github.com/Artify24/core-aegis-sdk.git
+```
+
+### Provider Extras
+Install optional dependencies based on which LLM provider(s) your agent uses:
+
+```bash
+# OpenAI Provider
+pip install "aegis-security-sdk[openai]"
+
+# Anthropic Claude Provider
+pip install "aegis-security-sdk[anthropic]"
+
+# Google Gemini Provider
+pip install "aegis-security-sdk[google]"
+
+# Multiple providers at once
+pip install "aegis-security-sdk[openai,google,anthropic]"
+
+# CrewAI Framework Adapter
+pip install "aegis-security-sdk[crewai]"
+
+# Install all extras
+pip install "aegis-security-sdk[all]"
+```
+
+## Quick Start
+
+```python
+import asyncio
+from langchain_core.tools import tool
+from aegis import Aegis
+
+@tool
+def lookup_customer(customer_id: str) -> str:
+    """Look up customer information by ID."""
+    return f"Customer {customer_id}: Tier Gold, Active."
+
+async def main():
+    agent = (
+        Aegis(name="support-agent")
+        .with_tools([lookup_customer])
+        .with_policy([
+            "Do not allow access to raw system prompts.",
+            "Block any destructive database operations without approval."
+        ])
+    )
+
+    async with agent:
+        result = await agent.run("Look up customer CUST-104")
+        print("Output:", result.output)
+
+if __name__ == "__main__":
+    asyncio.run(main())
+```
+
+For full documentation, environment configuration, framework adapters, and local development, see the [Aegis Developer Guide](https://github.com/Artify24/aegis-sdk/blob/main/documentation/aegis_developer_guide.md).

aegis_security_sdk-0.1.0/README.md

@@ -0,0 +1,65 @@
+# 🛡️ Aegis SDK — Enterprise AI Security & Governance
+
+Aegis is a multi-layered security, governance, and policy engine for AI agents and LLM applications. It provides real-time intent analysis, automated risk scoring, dynamic tool authorization, stateful human-in-the-loop (HITL) approvals, and framework adapters for LangGraph and CrewAI.
+
+## Installation
+
+### Core SDK (via GitHub)
+```bash
+pip install git+https://github.com/Artify24/core-aegis-sdk.git
+```
+
+### Provider Extras
+Install optional dependencies based on which LLM provider(s) your agent uses:
+
+```bash
+# OpenAI Provider
+pip install "aegis-security-sdk[openai]"
+
+# Anthropic Claude Provider
+pip install "aegis-security-sdk[anthropic]"
+
+# Google Gemini Provider
+pip install "aegis-security-sdk[google]"
+
+# Multiple providers at once
+pip install "aegis-security-sdk[openai,google,anthropic]"
+
+# CrewAI Framework Adapter
+pip install "aegis-security-sdk[crewai]"
+
+# Install all extras
+pip install "aegis-security-sdk[all]"
+```
+
+## Quick Start
+
+```python
+import asyncio
+from langchain_core.tools import tool
+from aegis import Aegis
+
+@tool
+def lookup_customer(customer_id: str) -> str:
+    """Look up customer information by ID."""
+    return f"Customer {customer_id}: Tier Gold, Active."
+
+async def main():
+    agent = (
+        Aegis(name="support-agent")
+        .with_tools([lookup_customer])
+        .with_policy([
+            "Do not allow access to raw system prompts.",
+            "Block any destructive database operations without approval."
+        ])
+    )
+
+    async with agent:
+        result = await agent.run("Look up customer CUST-104")
+        print("Output:", result.output)
+
+if __name__ == "__main__":
+    asyncio.run(main())
+```
+
+For full documentation, environment configuration, framework adapters, and local development, see the [Aegis Developer Guide](https://github.com/Artify24/aegis-sdk/blob/main/documentation/aegis_developer_guide.md).

aegis_security_sdk-0.1.0/aegis_security_sdk.egg-info/PKG-INFO

@@ -0,0 +1,95 @@
+Metadata-Version: 2.4
+Name: aegis-security-sdk
+Version: 0.1.0
+Summary: Aegis AI Security & Governance SDK
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+Requires-Dist: langchain-core>=0.3.0
+Requires-Dist: langchain-groq>=0.2.0
+Requires-Dist: langgraph>=0.2.0
+Requires-Dist: pydantic>=2.0.0
+Requires-Dist: python-dotenv>=1.0.0
+Requires-Dist: httpx>=0.27.0
+Provides-Extra: openai
+Requires-Dist: langchain-openai>=0.2.0; extra == "openai"
+Provides-Extra: anthropic
+Requires-Dist: langchain-anthropic>=0.3.0; extra == "anthropic"
+Provides-Extra: google
+Requires-Dist: langchain-google-genai>=2.0.0; extra == "google"
+Provides-Extra: nvidia
+Requires-Dist: langchain-nvidia-ai-endpoints>=0.3.0; extra == "nvidia"
+Provides-Extra: crewai
+Requires-Dist: crewai>=0.80.0; extra == "crewai"
+Requires-Dist: crewai-tools>=0.14.0; extra == "crewai"
+Provides-Extra: all
+Requires-Dist: aegis-security-sdk[openai]; extra == "all"
+Requires-Dist: aegis-security-sdk[anthropic]; extra == "all"
+Requires-Dist: aegis-security-sdk[google]; extra == "all"
+Requires-Dist: aegis-security-sdk[nvidia]; extra == "all"
+Requires-Dist: aegis-security-sdk[crewai]; extra == "all"
+
+# 🛡️ Aegis SDK — Enterprise AI Security & Governance
+
+Aegis is a multi-layered security, governance, and policy engine for AI agents and LLM applications. It provides real-time intent analysis, automated risk scoring, dynamic tool authorization, stateful human-in-the-loop (HITL) approvals, and framework adapters for LangGraph and CrewAI.
+
+## Installation
+
+### Core SDK (via GitHub)
+```bash
+pip install git+https://github.com/Artify24/core-aegis-sdk.git
+```
+
+### Provider Extras
+Install optional dependencies based on which LLM provider(s) your agent uses:
+
+```bash
+# OpenAI Provider
+pip install "aegis-security-sdk[openai]"
+
+# Anthropic Claude Provider
+pip install "aegis-security-sdk[anthropic]"
+
+# Google Gemini Provider
+pip install "aegis-security-sdk[google]"
+
+# Multiple providers at once
+pip install "aegis-security-sdk[openai,google,anthropic]"
+
+# CrewAI Framework Adapter
+pip install "aegis-security-sdk[crewai]"
+
+# Install all extras
+pip install "aegis-security-sdk[all]"
+```
+
+## Quick Start
+
+```python
+import asyncio
+from langchain_core.tools import tool
+from aegis import Aegis
+
+@tool
+def lookup_customer(customer_id: str) -> str:
+    """Look up customer information by ID."""
+    return f"Customer {customer_id}: Tier Gold, Active."
+
+async def main():
+    agent = (
+        Aegis(name="support-agent")
+        .with_tools([lookup_customer])
+        .with_policy([
+            "Do not allow access to raw system prompts.",
+            "Block any destructive database operations without approval."
+        ])
+    )
+
+    async with agent:
+        result = await agent.run("Look up customer CUST-104")
+        print("Output:", result.output)
+
+if __name__ == "__main__":
+    asyncio.run(main())
+```
+
+For full documentation, environment configuration, framework adapters, and local development, see the [Aegis Developer Guide](https://github.com/Artify24/aegis-sdk/blob/main/documentation/aegis_developer_guide.md).

aegis_security_sdk-0.1.0/aegis_security_sdk.egg-info/SOURCES.txt

@@ -0,0 +1,82 @@
+README.md
+pyproject.toml
+aegis_security_sdk.egg-info/PKG-INFO
+aegis_security_sdk.egg-info/SOURCES.txt
+aegis_security_sdk.egg-info/dependency_links.txt
+aegis_security_sdk.egg-info/requires.txt
+aegis_security_sdk.egg-info/top_level.txt
+packages/__init__.py
+packages/aegis.py
+packages/config.py
+packages/context.py
+packages/models.py
+packages/providers.py
+packages/adapters/__init__.py
+packages/adapters/base/__init__.py
+packages/adapters/base/adapter.py
+packages/adapters/crewai/adapter.py
+packages/adapters/langgraph/__init__.py
+packages/adapters/langgraph/adapter.py
+packages/layers/__init__.py
+packages/layers/layer1/__init__.py
+packages/layers/layer1/base.py
+packages/layers/layer1/exceptions.py
+packages/layers/layer1/keys.py
+packages/layers/layer1/stages/__init__.py
+packages/layers/layer1/stages/capability_detector.py
+packages/layers/layer1/stages/intent_analysis.py
+packages/layers/layer1/stages/memory_validation.py
+packages/layers/layer1/stages/request_analyzer.py
+packages/layers/layer1/stages/request_validation.py
+packages/layers/layer1/stages/risk_engine.py
+packages/layers/layer2/__init__.py
+packages/layers/layer2/audit.py
+packages/layers/layer2/engine.py
+packages/layers/layer2/validators.py
+packages/layers/layer5/__init__.py
+packages/layers/layer5/consumer.py
+packages/memory/__init__.py
+packages/memory/conversation.py
+packages/memory/manager.py
+packages/memory/policies.py
+packages/memory/provider.py
+packages/memory/registry.py
+packages/memory/retrieval.py
+packages/memory/semantic.py
+packages/memory/adapters/__init__.py
+packages/memory/adapters/langgraph_adapter.py
+packages/observability/__init__.py
+packages/observability/models.py
+packages/observability/store.py
+packages/policy/__init__.py
+packages/policy/base.py
+packages/policy/nl_policy.py
+packages/runtime/__init__.py
+packages/runtime/factory.py
+packages/runtime/graph.py
+packages/runtime/events/__init__.py
+packages/runtime/events/bus.py
+packages/runtime/events/models.py
+packages/runtime/hooks/__init__.py
+packages/runtime/hooks/base.py
+packages/runtime/hooks/policy.py
+packages/runtime/kernel/__init__.py
+packages/runtime/kernel/kernel.py
+packages/runtime/kernel/state.py
+packages/runtime/managers/__init__.py
+packages/runtime/managers/executor.py
+packages/runtime/managers/kill_switch.py
+packages/runtime/managers/monitor.py
+packages/runtime/managers/normalizer.py
+packages/runtime/managers/provider_executor.py
+packages/runtime/managers/provider_registry.py
+packages/runtime/managers/registry.py
+packages/runtime/managers/retry.py
+packages/runtime/managers/sanitizer.py
+packages/runtime/managers/streaming.py
+packages/runtime/managers/supervisor.py
+packages/runtime/managers/timeout.py
+packages/runtime/managers/tracker.py
+packages/runtime/nodes/__init__.py
+packages/runtime/nodes/executor.py
+packages/runtime/nodes/planner.py

aegis_security_sdk-0.1.0/aegis_security_sdk.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

aegis_security_sdk-0.1.0/aegis_security_sdk.egg-info/requires.txt

@@ -0,0 +1,29 @@
+langchain-core>=0.3.0
+langchain-groq>=0.2.0
+langgraph>=0.2.0
+pydantic>=2.0.0
+python-dotenv>=1.0.0
+httpx>=0.27.0
+
+[all]
+aegis-security-sdk[openai]
+aegis-security-sdk[anthropic]
+aegis-security-sdk[google]
+aegis-security-sdk[nvidia]
+aegis-security-sdk[crewai]
+
+[anthropic]
+langchain-anthropic>=0.3.0
+
+[crewai]
+crewai>=0.80.0
+crewai-tools>=0.14.0
+
+[google]
+langchain-google-genai>=2.0.0
+
+[nvidia]
+langchain-nvidia-ai-endpoints>=0.3.0
+
+[openai]
+langchain-openai>=0.2.0

aegis_security_sdk-0.1.0/aegis_security_sdk.egg-info/top_level.txt

@@ -0,0 +1 @@
+packages

aegis_security_sdk-0.1.0/packages/__init__.py

@@ -0,0 +1 @@
+# Aegis internal subpackages module

aegis_security_sdk-0.1.0/packages/adapters/__init__.py

@@ -0,0 +1,4 @@
+from .base.adapter import FrameworkAdapter
+from .langgraph.adapter import LangGraphAdapter
+
+__all__ = ["FrameworkAdapter", "LangGraphAdapter"]

aegis_security_sdk-0.1.0/packages/adapters/base/__init__.py

@@ -0,0 +1,3 @@
+from .adapter import FrameworkAdapter
+
+__all__ = ["FrameworkAdapter"]

aegis_security_sdk-0.1.0/packages/adapters/base/adapter.py

@@ -0,0 +1,26 @@
+from typing import Protocol, Any
+from ...context import ExecutionContext
+from ...observability.models import ExecutionReport
+from ...models import ExecutionResult
+
+class FrameworkAdapter(Protocol):
+    """
+    Protocol for plugging an external agent framework into the Aegis Runtime.
+    Adapters handle Layer 3 (Execution) while keeping Layer 1, 2, and 4 intact.
+    """
+    async def execute(
+        self, 
+        context: ExecutionContext, 
+        inputs: dict[str, Any], 
+        report: ExecutionReport
+    ) -> ExecutionResult:
+        """
+        Execute the external framework.
+        
+        The adapter is responsible for:
+        1. Invoking the framework's runtime.
+        2. Intercepting telemetry (tool calls, tokens, latency, steps).
+        3. Populating the `ExecutionReport` with the captured telemetry.
+        4. Returning a standardized `ExecutionResult`.
+        """
+        ...

aegis_security_sdk-0.1.0/packages/adapters/crewai/adapter.py

@@ -0,0 +1,263 @@
+import time
+from typing import Any, Dict
+from langchain_core.callbacks import BaseCallbackHandler
+from langchain_core.messages import AIMessage
+from crewai import Crew
+
+from ...context import ExecutionContext
+from ...observability.models import ExecutionReport, ToolCallRecord, ExecutionPlanStep
+from ...models import ExecutionResult
+from ..base.adapter import FrameworkAdapter
+
+import uuid
+
+class CrewAITelemetryHandler(BaseCallbackHandler):
+    """
+    Captures synchronous and asynchronous callbacks from CrewAI execution.
+    CrewAI internally uses LangChain tools and LLMs, so these callbacks will fire.
+    """
+    def __init__(self, report: ExecutionReport):
+        self.report = report
+        self.tool_starts: dict[str, dict[str, Any]] = {}
+        self.llm_starts: dict[str, float] = {}
+        self.step_counter = 0
+
+    def on_llm_start(self, serialized: dict[str, Any], prompts: list[str], **kwargs: Any) -> None:
+        run_id = str(kwargs.get("run_id", ""))
+        self.llm_starts[run_id] = time.time()
+        self.report.metrics.resources.llm_calls += 1
+
+    async def on_llm_start_async(self, serialized: dict[str, Any], prompts: list[str], **kwargs: Any) -> None:
+        self.on_llm_start(serialized, prompts, **kwargs)
+
+    def on_llm_end(self, response: Any, **kwargs: Any) -> None:
+        run_id = str(kwargs.get("run_id", ""))
+        start = self.llm_starts.get(run_id, time.time())
+        latency = (time.time() - start) * 1000
+        self.report.planner.latency_ms += latency
+        
+        # Check for tool calls to populate execution plan
+        if hasattr(response, "generations"):
+            for gen_list in response.generations:
+                for gen in gen_list:
+                    msg = getattr(gen, "message", None)
+                    if isinstance(msg, AIMessage) and hasattr(msg, "tool_calls") and msg.tool_calls:
+                        self.report.planner.planning_iterations += 1
+                        for tc in msg.tool_calls:
+                            self.step_counter += 1
+                            tool_name = tc.get("name", "unknown")
+                            args = tc.get("args", {})
+                            arg_keys = list(args.keys())[:3]
+                            purpose_hint = ", ".join(arg_keys)
+                            self.report.execution_plan.append(ExecutionPlanStep(
+                                step=self.step_counter,
+                                tool=tool_name,
+                                purpose=f"Execute {tool_name}" + (f" ({purpose_hint})" if purpose_hint else ""),
+                            ))
+
+    async def on_llm_end_async(self, response: Any, **kwargs: Any) -> None:
+        self.on_llm_end(response, **kwargs)
+
+    def on_tool_start(self, serialized: dict[str, Any], input_str: str, **kwargs: Any) -> None:
+        run_id = str(kwargs.get("run_id", ""))
+        self.tool_starts[run_id] = {
+            "start": time.time(),
+            "name": serialized.get("name", "unknown") if serialized else "unknown",
+            "input": input_str
+        }
+
+    async def on_tool_start_async(self, serialized: dict[str, Any], input_str: str, **kwargs: Any) -> None:
+        self.on_tool_start(serialized, input_str, **kwargs)
+
+    def on_tool_end(self, output: str, **kwargs: Any) -> None:
+        run_id = str(kwargs.get("run_id", ""))
+        tdata = self.tool_starts.get(run_id)
+        if tdata:
+            duration = (time.time() - tdata["start"]) * 1000
+            tc = ToolCallRecord(
+                tool_call_id=run_id,
+                tool=tdata["name"],
+                status="SUCCESS",
+                duration_ms=round(duration, 2),
+                input_summary=tdata["input"],
+                output_summary=str(output)
+            )
+            self.report.tool_calls.append(tc)
+            self.report.add_timeline_event(
+                "Runtime",
+                f"Tool Executed: {tdata['name']}",
+                metadata={"tool_call_id": run_id, "status": "SUCCESS", "duration_ms": duration}
+            )
+
+    async def on_tool_end_async(self, output: str, **kwargs: Any) -> None:
+        self.on_tool_end(output, **kwargs)
+
+    def on_tool_error(self, error: BaseException, **kwargs: Any) -> None:
+        run_id = str(kwargs.get("run_id", ""))
+        tdata = self.tool_starts.get(run_id)
+        if tdata:
+            duration = (time.time() - tdata["start"]) * 1000
+            tc = ToolCallRecord(
+                tool_call_id=run_id,
+                tool=tdata["name"],
+                status="FAILED",
+                duration_ms=round(duration, 2),
+                input_summary=tdata["input"],
+                error=str(error)
+            )
+            self.report.tool_calls.append(tc)
+            self.report.add_timeline_event(
+                "Runtime",
+                f"Tool Failed: {tdata['name']}",
+                metadata={"tool_call_id": run_id, "status": "FAILED", "duration_ms": duration}
+            )
+
+    async def on_tool_error_async(self, error: BaseException, **kwargs: Any) -> None:
+        self.on_tool_error(error, **kwargs)
+
+
+class CrewAIAdapter(FrameworkAdapter):
+    """
+    Adapter for executing CrewAI crews through Aegis.
+    """
+    def __init__(self, crew: Crew):
+        self.crew = crew
+
+    def _wrap_tool(self, tool: Any, report: ExecutionReport) -> Any:
+        tool_name = getattr(tool, "name", str(tool))
+        orig_run = getattr(tool, "_run", None) or getattr(tool, "run", None) or getattr(tool, "func", None)
+        if not orig_run or getattr(tool, "_aegis_wrapped", False):
+            return tool
+
+        step_counter = [len(report.execution_plan) + 1]
+
+        def wrapped_run(*args: Any, **kwargs: Any) -> Any:
+            t_start = time.time()
+            tool_id = str(uuid.uuid4())
+            input_summary = str(kwargs) if kwargs else (str(args) if args else "")
+
+            report.execution_plan.append(ExecutionPlanStep(
+                step=step_counter[0],
+                tool=tool_name,
+                purpose=f"Execute {tool_name}"
+            ))
+            step_counter[0] += 1
+
+            status = "SUCCESS"
+            error_msg = None
+            result = None
+            try:
+                result = orig_run(*args, **kwargs)
+                return result
+            except Exception as e:
+                status = "FAILED"
+                error_msg = str(e)
+                raise e
+            finally:
+                duration_ms = round((time.time() - t_start) * 1000, 2)
+                output_str = str(result) if result is not None else (error_msg or "")
+
+                tc = ToolCallRecord(
+                    tool_call_id=tool_id,
+                    tool=tool_name,
+                    status=status,
+                    duration_ms=duration_ms,
+                    input_summary=input_summary[:300],
+                    output_summary=output_str[:300],
+                    error=error_msg
+                )
+                report.tool_calls.append(tc)
+                report.add_timeline_event(
+                    "Runtime",
+                    f"Tool Executed: {tool_name}" if status == "SUCCESS" else f"Tool Failed: {tool_name}",
+                    metadata={"tool_call_id": tool_id, "status": status, "duration_ms": duration_ms}
+                )
+
+        if hasattr(tool, "_run"):
+            tool._run = wrapped_run
+        elif hasattr(tool, "run"):
+            tool.run = wrapped_run
+        elif hasattr(tool, "func"):
+            tool.func = wrapped_run
+
+        setattr(tool, "_aegis_wrapped", True)
+        return tool
+
+    async def execute(
+        self, 
+        context: ExecutionContext, 
+        inputs: dict[str, Any], 
+        report: ExecutionReport
+    ) -> ExecutionResult:
+        
+        # 1. Setup Telemetry Handler
+        handler = CrewAITelemetryHandler(report)
+        
+        # 2. Inject handler & wrap tools for telemetry capture
+        for agent in self.crew.agents:
+            if getattr(agent, "callbacks", None) is None:
+                agent.callbacks = []
+            agent.callbacks.append(handler)
+
+            if hasattr(agent, "tools") and agent.tools:
+                wrapped_tools = []
+                for tool in agent.tools:
+                    wrapped_tools.append(self._wrap_tool(tool, report))
+                agent.tools = wrapped_tools
+        
+        report.add_timeline_event("Planner", "CrewAI Execution Started")
+        start_time = time.time()
+        
+        # 3. Clean Inputs
+        clean_inputs = {}
+        if "messages" in inputs and inputs["messages"]:
+            prompt = inputs["messages"][-1].content
+            clean_inputs["prompt"] = prompt
+        else:
+            clean_inputs["prompt"] = context.request.prompt
+            
+        # 4. Invoke Crew
+        crew_output = await self.crew.kickoff_async(inputs=clean_inputs)
+        
+        elapsed = (time.time() - start_time) * 1000
+        report.add_timeline_event("Planner", "CrewAI Execution Finished")
+        
+        output_str = crew_output.raw if hasattr(crew_output, "raw") else str(crew_output)
+        
+        # 5. Extract token usage if available from CrewOutput
+        if hasattr(crew_output, "token_usage") and crew_output.token_usage:
+            usage = crew_output.token_usage
+            if isinstance(usage, dict):
+                p_tokens = usage.get("prompt_tokens", 0) or usage.get("input_tokens", 0)
+                c_tokens = usage.get("completion_tokens", 0) or usage.get("output_tokens", 0)
+                t_tokens = usage.get("total_tokens", 0) or (p_tokens + c_tokens)
+                llm_calls = usage.get("successful_requests", 1)
+            else:
+                p_tokens = getattr(usage, "prompt_tokens", 0) or getattr(usage, "input_tokens", 0)
+                c_tokens = getattr(usage, "completion_tokens", 0) or getattr(usage, "output_tokens", 0)
+                t_tokens = getattr(usage, "total_tokens", 0) or (p_tokens + c_tokens)
+                llm_calls = getattr(usage, "successful_requests", 1)
+
+            report.planner.input_tokens = p_tokens
+            report.planner.output_tokens = c_tokens
+            report.planner.total_tokens = t_tokens
+            report.planner.total_llm_calls = llm_calls if llm_calls else 1
+            report.planner.planning_iterations = max(len(report.execution_plan), 1)
+            report.metrics.resources.llm_calls = report.planner.total_llm_calls
+
+            report.metrics.cost.input_tokens = p_tokens
+            report.metrics.cost.output_tokens = c_tokens
+            report.metrics.cost.total_tokens = t_tokens
+                
+        # 6. Finalize tool metrics
+        report.metrics.resources.tool_calls = len(report.tool_calls)
+        total_tool_latency = sum(tc.duration_ms for tc in report.tool_calls)
+        report.metrics.performance.tool_latency_ms = round(total_tool_latency, 2)
+
+        return ExecutionResult(
+            output=output_str,
+            tool_calls=[tc.tool for tc in report.tool_calls],
+            tokens_used=report.planner.total_tokens,
+            execution_time=elapsed,
+            metadata={"layer1": getattr(context, "layer1", {})}
+        )

aegis_security_sdk-0.1.0/packages/adapters/langgraph/__init__.py

@@ -0,0 +1,3 @@
+from .adapter import LangGraphAdapter
+
+__all__ = ["LangGraphAdapter"]