ciris-agent 1.7.7__py3-none-any.whl

ciris_engine/logic/adapters/base_vision.py

@@ -0,0 +1,312 @@
+"""
+Base Vision Helper for multimodal image processing.
+
+Provides a common base class for all adapters to handle image processing,
+supporting both legacy text-description mode and native multimodal mode.
+"""
+
+import base64
+import logging
+from abc import ABC, abstractmethod
+from typing import Any, List, Optional, Protocol, runtime_checkable
+
+import aiohttp
+
+from ciris_engine.schemas.runtime.models import ImageContent
+from ciris_engine.schemas.services.llm import (
+    ContentBlock,
+    ImageContentBlock,
+    ImageURLDetail,
+    LLMMessage,
+    TextContentBlock,
+)
+from ciris_engine.schemas.types import JSONDict
+
+logger = logging.getLogger(__name__)
+
+
+# Maximum image size (20MB default)
+DEFAULT_MAX_IMAGE_SIZE = 20 * 1024 * 1024
+
+# Default media type for images
+DEFAULT_IMAGE_MEDIA_TYPE = "image/jpeg"
+
+
+@runtime_checkable
+class ImageAttachment(Protocol):
+    """Protocol for image attachments from various sources."""
+
+    @property
+    def url(self) -> str:
+        """URL to download the image."""
+        ...
+
+    @property
+    def content_type(self) -> Optional[str]:
+        """MIME type of the image."""
+        ...
+
+    @property
+    def filename(self) -> str:
+        """Filename of the attachment."""
+        ...
+
+    @property
+    def size(self) -> int:
+        """Size in bytes."""
+        ...
+
+
+class BaseVisionHelper(ABC):
+    """
+    Base class for vision helpers across all adapters.
+
+    Provides common functionality for:
+    - Converting attachments to ImageContent objects
+    - Building multimodal LLM messages
+    - Image size validation
+    - Base64 encoding
+
+    Subclasses can override methods for adapter-specific behavior.
+    """
+
+    def __init__(self, max_image_size: int = DEFAULT_MAX_IMAGE_SIZE) -> None:
+        """
+        Initialize the base vision helper.
+
+        Args:
+            max_image_size: Maximum allowed image size in bytes
+        """
+        self.max_image_size = max_image_size
+
+    async def attachment_to_image_content(self, attachment: ImageAttachment) -> Optional[ImageContent]:
+        """
+        Convert an attachment to an ImageContent object.
+
+        Downloads the image and encodes it as base64.
+
+        Args:
+            attachment: An object implementing the ImageAttachment protocol
+
+        Returns:
+            ImageContent object or None if conversion failed
+        """
+        # Validate size
+        if attachment.size > self.max_image_size:
+            logger.warning(
+                f"Image {attachment.filename} too large: {attachment.size} bytes (max {self.max_image_size} bytes)"
+            )
+            return None
+
+        # Validate content type
+        content_type = attachment.content_type or DEFAULT_IMAGE_MEDIA_TYPE
+        if not content_type.startswith("image/"):
+            logger.warning(f"Attachment {attachment.filename} is not an image: {content_type}")
+            return None
+
+        try:
+            # Download the image
+            async with aiohttp.ClientSession() as session:
+                async with session.get(attachment.url) as response:
+                    if response.status != 200:
+                        logger.error(f"Failed to download image {attachment.filename}: HTTP {response.status}")
+                        return None
+
+                    image_data = await response.read()
+                    base64_data = base64.b64encode(image_data).decode("utf-8")
+
+            return ImageContent(
+                source_type="base64",
+                data=base64_data,
+                media_type=content_type,
+                filename=attachment.filename,
+                size_bytes=len(image_data),
+            )
+
+        except Exception as e:
+            logger.exception(f"Error converting attachment {attachment.filename}: {e}")
+            return None
+
+    async def url_to_image_content(
+        self,
+        url: str,
+        media_type: str = DEFAULT_IMAGE_MEDIA_TYPE,
+        filename: Optional[str] = None,
+    ) -> Optional[ImageContent]:
+        """
+        Convert a URL to an ImageContent object.
+
+        Downloads the image and encodes it as base64.
+
+        Args:
+            url: URL of the image
+            media_type: MIME type of the image
+            filename: Optional filename
+
+        Returns:
+            ImageContent object or None if conversion failed
+        """
+        try:
+            async with aiohttp.ClientSession() as session:
+                async with session.get(url) as response:
+                    if response.status != 200:
+                        logger.error(f"Failed to download image from {url}: HTTP {response.status}")
+                        return None
+
+                    image_data = await response.read()
+
+                    # Check size after download
+                    if len(image_data) > self.max_image_size:
+                        logger.warning(
+                            f"Image from {url} too large: {len(image_data)} bytes (max {self.max_image_size} bytes)"
+                        )
+                        return None
+
+                    base64_data = base64.b64encode(image_data).decode("utf-8")
+
+            return ImageContent(
+                source_type="base64",
+                data=base64_data,
+                media_type=media_type,
+                filename=filename or url.split("/")[-1] or "image",
+                size_bytes=len(image_data),
+            )
+
+        except Exception as e:
+            logger.exception(f"Error downloading image from {url}: {e}")
+            return None
+
+    def bytes_to_image_content(
+        self,
+        data: bytes,
+        media_type: str = DEFAULT_IMAGE_MEDIA_TYPE,
+        filename: Optional[str] = None,
+    ) -> Optional[ImageContent]:
+        """
+        Convert raw bytes to an ImageContent object.
+
+        Args:
+            data: Raw image bytes
+            media_type: MIME type of the image
+            filename: Optional filename
+
+        Returns:
+            ImageContent object or None if conversion failed
+        """
+        if len(data) > self.max_image_size:
+            logger.warning(f"Image data too large: {len(data)} bytes (max {self.max_image_size} bytes)")
+            return None
+
+        try:
+            base64_data = base64.b64encode(data).decode("utf-8")
+            return ImageContent(
+                source_type="base64",
+                data=base64_data,
+                media_type=media_type,
+                filename=filename or "image",
+                size_bytes=len(data),
+            )
+        except Exception as e:
+            logger.exception(f"Error encoding image bytes: {e}")
+            return None
+
+    @staticmethod
+    def build_multimodal_message(
+        text: str,
+        images: List[ImageContent],
+        role: str = "user",
+    ) -> LLMMessage:
+        """
+        Build a multimodal LLM message from text and images.
+
+        Args:
+            text: Text content of the message
+            images: List of ImageContent objects
+            role: Message role (user, system, assistant)
+
+        Returns:
+            LLMMessage with multimodal content if images present, text-only otherwise
+        """
+        if not images:
+            return LLMMessage(role=role, content=text)
+
+        # Build content blocks
+        content: List[ContentBlock] = [TextContentBlock(text=text)]
+
+        for img in images:
+            image_block = ImageContentBlock(image_url=ImageURLDetail(url=img.to_data_url()))
+            content.append(image_block)
+
+        return LLMMessage(role=role, content=content)
+
+    @staticmethod
+    def build_multimodal_content_blocks(
+        text: str,
+        images: List[ImageContent],
+    ) -> List[ContentBlock]:
+        """
+        Build content blocks for multimodal messages.
+
+        Useful when you need the raw content blocks without wrapping in LLMMessage.
+
+        Args:
+            text: Text content
+            images: List of ImageContent objects
+
+        Returns:
+            List of content blocks
+        """
+        content: List[ContentBlock] = [TextContentBlock(text=text)]
+
+        for img in images:
+            image_block = ImageContentBlock(image_url=ImageURLDetail(url=img.to_data_url()))
+            content.append(image_block)
+
+        return content
+
+    def get_status(self) -> JSONDict:
+        """
+        Get current status of the vision helper.
+
+        Returns:
+            Status dictionary
+        """
+        return {
+            "max_image_size_mb": self.max_image_size / 1024 / 1024,
+            "multimodal_enabled": True,
+        }
+
+    @abstractmethod
+    def is_available(self) -> bool:
+        """
+        Check if vision processing is available.
+
+        Returns:
+            True if vision processing can be performed
+        """
+        ...
+
+
+class SimpleVisionHelper(BaseVisionHelper):
+    """
+    Simple vision helper implementation.
+
+    Always available, used for adapters that just need basic
+    image-to-ImageContent conversion without external API calls.
+    """
+
+    def is_available(self) -> bool:
+        """Always available for basic image handling."""
+        return True
+
+
+# Singleton instance for simple cases
+_simple_vision_helper: Optional[SimpleVisionHelper] = None
+
+
+def get_simple_vision_helper() -> SimpleVisionHelper:
+    """Get or create the simple vision helper singleton."""
+    global _simple_vision_helper
+    if _simple_vision_helper is None:
+        _simple_vision_helper = SimpleVisionHelper()
+    return _simple_vision_helper

ciris_engine/logic/adapters/cirisnode_client.py

@@ -0,0 +1,307 @@
+import logging
+from typing import TYPE_CHECKING, Any, Dict, List, Optional, cast
+
+import httpx
+
+from ciris_engine.logic.adapters.base import Service
+from ciris_engine.schemas.adapters.cirisnode import (
+    AssessmentResult,
+    AssessmentSubmission,
+    ChaosTestRequest,
+    ChaosTestResult,
+    EventLogRequest,
+    EventLogResponse,
+    HE300Request,
+    HE300Result,
+    SimpleBenchRequest,
+    SimpleBenchResult,
+    WAServiceRequest,
+    WAServiceResponse,
+)
+
+# Configuration loaded via environment variables - no get_config dependency
+from ciris_engine.schemas.config.essential import CIRISNodeConfig
+from ciris_engine.schemas.runtime.audit import AuditActionContext
+from ciris_engine.schemas.runtime.enums import HandlerActionType, ServiceType
+from ciris_engine.schemas.types import JSONDict
+
+if TYPE_CHECKING:
+    from ciris_engine.logic.registries.base import ServiceRegistry
+    from ciris_engine.protocols.services import AuditService
+
+logger = logging.getLogger(__name__)
+
+
+class CIRISNodeClient(Service):
+    """Asynchronous client for interacting with CIRISNode."""
+
+    def __init__(self, service_registry: Optional["ServiceRegistry"] = None, base_url: Optional[str] = None) -> None:
+        # Configure retry settings for HTTP operations
+        retry_config = {
+            "retry": {
+                "global": {
+                    "max_retries": 3,
+                    "base_delay": 1.0,
+                    "max_delay": 30.0,  # Shorter max delay for API calls
+                },
+                "http_request": {
+                    "retryable_exceptions": (httpx.ConnectError, httpx.TimeoutException, httpx.HTTPStatusError),
+                    "non_retryable_exceptions": (httpx.HTTPStatusError,),  # Will be filtered by status code
+                },
+            }
+        }
+        super().__init__(config=retry_config)
+
+        self.service_registry = service_registry
+        self._audit_service: Optional["AuditService"] = None
+
+        # Use base_url if provided, otherwise use default
+        if base_url:
+            self.base_url = base_url
+        else:
+            # Default to localhost for testing/development
+            node_cfg = CIRISNodeConfig()
+            node_cfg.load_env_vars()
+            self.base_url = node_cfg.base_url or "http://localhost:8080"
+
+        self._client = httpx.AsyncClient(base_url=self.base_url)
+        self._closed = False
+
+    async def _get_audit_service(self) -> Optional["AuditService"]:
+        """Retrieve the audit service from the registry with caching."""
+        if self._audit_service is not None:
+            return self._audit_service
+
+        if not self.service_registry:
+            logger.debug("CIRISNodeClient has no service registry; audit logging disabled")
+            return None
+
+        self._audit_service = await self.service_registry.get_service(
+            self.__class__.__name__, ServiceType.AUDIT, required_capabilities=["log_action"]
+        )
+
+        if not self._audit_service:
+            logger.warning("No audit service available for CIRISNodeClient")
+        return self._audit_service
+
+    async def start(self) -> None:
+        """Start the client service."""
+        await super().start()
+
+    async def stop(self) -> None:
+        """Stop the client service and clean up resources."""
+        await self._client.aclose()
+        await super().stop()
+        self._closed = True
+
+    async def close(self) -> None:
+        """Alias for stop() for backwards compatibility."""
+        await self.stop()
+
+    def is_closed(self) -> bool:
+        return self._closed
+
+    async def _post(self, endpoint: str, payload: JSONDict) -> Any:
+        async def _make_request() -> Any:
+            resp = await self._client.post(endpoint, json=payload)
+            if 400 <= resp.status_code < 500:
+                resp.raise_for_status()  # Don't retry 4xx client errors
+            resp.raise_for_status()  # Raise for any other errors (will be retried)
+            return await resp.json()
+
+        return await self.retry_with_backoff(
+            _make_request,
+            retryable_exceptions=(httpx.ConnectError, httpx.TimeoutException),
+            non_retryable_exceptions=(httpx.HTTPStatusError,),
+            **self.get_retry_config("http_request"),
+        )
+
+    async def _get(self, endpoint: str, params: JSONDict) -> Any:
+        from typing import Mapping, cast
+
+        async def _make_request() -> Any:
+            resp = await self._client.get(endpoint, params=cast(Mapping[str, str | int | float | bool | None], params))
+            if 400 <= resp.status_code < 500:
+                resp.raise_for_status()  # Don't retry 4xx client errors
+            resp.raise_for_status()  # Raise for any other errors (will be retried)
+            return await resp.json()
+
+        return await self.retry_with_backoff(
+            _make_request,
+            retryable_exceptions=(httpx.ConnectError, httpx.TimeoutException),
+            non_retryable_exceptions=(httpx.HTTPStatusError,),
+            **self.get_retry_config("http_request"),
+        )
+
+    async def _put(self, endpoint: str, payload: JSONDict) -> Any:
+        async def _make_request() -> Any:
+            resp = await self._client.put(endpoint, json=payload)
+            if 400 <= resp.status_code < 500:
+                resp.raise_for_status()  # Don't retry 4xx client errors
+            resp.raise_for_status()  # Raise for any other errors (will be retried)
+            return await resp.json()
+
+        return await self.retry_with_backoff(
+            _make_request,
+            retryable_exceptions=(httpx.ConnectError, httpx.TimeoutException),
+            non_retryable_exceptions=(httpx.HTTPStatusError,),
+            **self.get_retry_config("http_request"),
+        )
+
+    async def run_simplebench(self, model_id: str, agent_id: str) -> SimpleBenchResult:
+        """Run the simple bench benchmark for the given model."""
+        request = SimpleBenchRequest(model_id=model_id, agent_id=agent_id)
+        response = await self._post("/simplebench", request.model_dump())
+        result = SimpleBenchResult.model_validate(response)
+        audit_service = await self._get_audit_service()
+        if audit_service:
+            await audit_service.log_action(
+                HandlerActionType.TOOL,
+                AuditActionContext(
+                    thought_id=agent_id,
+                    task_id="simplebench",
+                    handler_name="cirisnode_client",
+                    parameters={"model_id": model_id, "agent_id": agent_id},
+                ),
+                outcome=f"SimpleBench completed with score {result.score}",
+            )
+        return result
+
+    async def run_he300(self, model_id: str, agent_id: str) -> HE300Result:
+        """Run the HE-300 benchmark for the given model."""
+        request = HE300Request(model_id=model_id, agent_id=agent_id)
+        response = await self._post("/he300", request.model_dump())
+        result = HE300Result.model_validate(response)
+        audit_service = await self._get_audit_service()
+        if audit_service:
+            await audit_service.log_action(
+                HandlerActionType.TOOL,
+                AuditActionContext(
+                    thought_id=agent_id,
+                    task_id="he300",
+                    handler_name="cirisnode_client",
+                    parameters={"model_id": model_id, "agent_id": agent_id},
+                ),
+                outcome=f"HE-300 completed with ethics score {result.ethics_score}",
+            )
+        return result
+
+    async def run_chaos_tests(self, agent_id: str, scenarios: List[str]) -> List[ChaosTestResult]:
+        """Run chaos test scenarios and return verdicts."""
+        request = ChaosTestRequest(agent_id=agent_id, scenarios=scenarios)
+        response = await self._post("/chaos", request.model_dump())
+        result = [ChaosTestResult.model_validate(r) for r in response]
+        audit_service = await self._get_audit_service()
+        if audit_service:
+            await audit_service.log_action(
+                HandlerActionType.TOOL,
+                AuditActionContext(
+                    thought_id=agent_id,
+                    task_id="chaos_tests",
+                    handler_name="cirisnode_client",
+                    parameters={"agent_id": agent_id, "scenarios": scenarios},
+                ),
+                outcome=f"Chaos tests completed: {len(result)} scenarios",
+            )
+        return result
+
+    async def run_wa_service(self, service: str, action: str, params: JSONDict) -> WAServiceResponse:
+        """Call a WA service on CIRISNode."""
+        request = WAServiceRequest(service=service, action=action, params=params)
+        response = await self._post(f"/wa/{service}", request.model_dump())
+        result = WAServiceResponse.model_validate(response)
+        audit_service = await self._get_audit_service()
+        if audit_service:
+            await audit_service.log_action(
+                HandlerActionType.TOOL,
+                AuditActionContext(
+                    thought_id=params.get("agent_id", "unknown"),
+                    task_id=f"wa_service_{service}",
+                    handler_name="cirisnode_client",
+                    parameters={"service": service, "action": action, **params},
+                ),
+                outcome=f"WA service {service} completed",
+            )
+        return result
+
+    async def log_event(
+        self, event_type: str, event_data: JSONDict, agent_id: Optional[str] = None
+    ) -> EventLogResponse:
+        """Send an event payload to CIRISNode for storage."""
+        request = EventLogRequest(event_type=event_type, event_data=event_data, agent_id=agent_id)
+        response = await self._post("/events", request.model_dump())
+        result = EventLogResponse.model_validate(response)
+        audit_service = await self._get_audit_service()
+        if audit_service:
+            await audit_service.log_action(
+                HandlerActionType.TOOL,
+                AuditActionContext(
+                    thought_id=agent_id or "unknown",
+                    task_id="log_event",
+                    handler_name="cirisnode_client",
+                    parameters={"event_type": event_type, "agent_id": agent_id},
+                ),
+                outcome=f"Event logged: {event_type}",
+            )
+        return result
+
+    async def fetch_benchmark_prompts(
+        self,
+        benchmark: str,
+        model_id: str,
+        agent_id: str,
+    ) -> List[JSONDict]:
+        """Retrieve benchmark prompts from CIRISNode."""
+        result = cast(
+            List[JSONDict],
+            await self._get(
+                f"/bench/{benchmark}/prompts",
+                {"model_id": model_id, "agent_id": agent_id},
+            ),
+        )
+        audit_service = await self._get_audit_service()
+        if audit_service:
+            await audit_service.log_action(
+                HandlerActionType.TOOL,
+                AuditActionContext(
+                    thought_id=agent_id,
+                    task_id=f"fetch_{benchmark}_prompts",
+                    handler_name="cirisnode_client",
+                    parameters={"benchmark": benchmark, "model_id": model_id, "agent_id": agent_id},
+                ),
+                outcome=f"Fetched {len(result)} {benchmark} prompts",
+            )
+        return result
+
+    async def submit_benchmark_answers(
+        self,
+        benchmark: str,
+        model_id: str,
+        agent_id: str,
+        answers: List[JSONDict],
+    ) -> AssessmentResult:
+        """Send benchmark answers back to CIRISNode."""
+        submission = AssessmentSubmission(assessment_id=benchmark, agent_id=agent_id, answers=answers)
+        response = await self._put(
+            f"/bench/{benchmark}/answers",
+            submission.model_dump(),
+        )
+        result = AssessmentResult.model_validate(response)
+        audit_service = await self._get_audit_service()
+        if audit_service:
+            await audit_service.log_action(
+                HandlerActionType.TOOL,
+                AuditActionContext(
+                    thought_id=agent_id,
+                    task_id=f"submit_{benchmark}_answers",
+                    handler_name="cirisnode_client",
+                    parameters={
+                        "benchmark": benchmark,
+                        "model_id": model_id,
+                        "agent_id": agent_id,
+                        "answer_count": len(answers),
+                    },
+                ),
+                outcome=f"Submitted {len(answers)} {benchmark} answers",
+            )
+        return result

ciris_engine/logic/adapters/cli/__init__.py

@@ -0,0 +1,3 @@
+from .adapter import CliPlatform
+
+Adapter = CliPlatform