hexdag 0.8.0.dev1__tar.gz → 0.8.0.dev3__tar.gz

{hexdag-0.8.0.dev1 → hexdag-0.8.0.dev3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: hexdag
-Version: 0.8.0.dev1
+Version: 0.8.0.dev3
 Summary: Operating system for AI agents — pipelines, ports, drivers, and stdlib so agents don't reinvent infrastructure
 Project-URL: Homepage, https://hexdag.ai
 Project-URL: Repository, https://github.com/omniviser/hexdag

{hexdag-0.8.0.dev1 → hexdag-0.8.0.dev3}/hexdag/kernel/lifecycle_runner.py

@@ -502,6 +502,7 @@ class LifecycleRunner:
             config=self._config,
             port_overrides=self._port_overrides,
             base_path=self._base_path,
+            service_overrides={"entity_state": self._entity_state},
         )
 
         try:

{hexdag-0.8.0.dev1 → hexdag-0.8.0.dev3}/hexdag/kernel/orchestration/orchestrator_factory.py

@@ -67,6 +67,7 @@ class OrchestratorFactory:
         additional_ports: dict[str, Any] | None = None,
         pre_hook_config: "HookConfig | None" = None,
         post_hook_config: "PostDagHookConfig | None" = None,
+        service_overrides: dict[str, Any] | None = None,
     ) -> Orchestrator:
         """Create an orchestrator instance from pipeline configuration.
 
@@ -86,6 +87,10 @@ class OrchestratorFactory:
             Configuration for pre-DAG hooks (health checks, secrets, etc.)
         post_hook_config : PostDagHookConfig | None, optional
             Configuration for post-DAG hooks (cleanup, checkpoints, etc.)
+        service_overrides : dict[str, Any] | None, optional
+            Pre-instantiated services injected by a parent (e.g. System).
+            Merged before auto-registration guards so overrides prevent
+            fresh service creation.
 
         Returns
         -------
@@ -179,6 +184,11 @@ class OrchestratorFactory:
         # Step 4: Instantiate services if configured
         services = self._instantiate_services(pipeline_config, global_ports)
 
+        # Merge parent-injected services (e.g. System's shared EntityState).
+        # Must run before auto-registration guards so overrides take precedence.
+        if service_overrides:
+            services.update(service_overrides)
+
         # Auto-register PipelineMemory (always available, like run_id)
         if "pipeline_memory" not in services:
             from hexdag.stdlib.lib.pipeline_memory import (

{hexdag-0.8.0.dev1 → hexdag-0.8.0.dev3}/hexdag/kernel/pipeline_runner.py

@@ -123,6 +123,7 @@ class PipelineRunner:
         base_path: Path | None = None,
         environment: str | None = None,
         checkpoint_storage: Any | None = None,
+        service_overrides: dict[str, Any] | None = None,
     ) -> None:
         self._config = config
         # Inject checkpoint_storage as a dedicated checkpoint port.
@@ -181,6 +182,8 @@ class PipelineRunner:
         self._builder = YamlPipelineBuilder(base_path=base_path)
         self._factory = OrchestratorFactory()
 
+        self._service_overrides = service_overrides
+
         # Runner-level secret cache: skip load_to_environ on repeat runs
         self._secrets_loaded = False
 
@@ -645,6 +648,7 @@ class PipelineRunner:
             additional_ports=self._port_overrides,
             pre_hook_config=self._pre_hook_config,
             post_hook_config=self._post_hook_config,
+            service_overrides=self._service_overrides,
         )
 
         # 6. Execute

hexdag-0.8.0.dev3/hexdag/stdlib/adapters/database/__init__.py

@@ -0,0 +1,12 @@
+"""Database adapters for HexDAG."""
+
+from hexdag.stdlib.adapters.database.sqlite.sqlite_adapter import SQLiteAdapter
+
+__all__ = ["SQLiteAdapter"]
+
+try:
+    from hexdag.stdlib.adapters.database.pgvector.pgvector_adapter import PgVectorAdapter
+except ImportError:
+    pass
+else:
+    __all__ += ["PgVectorAdapter"]

{hexdag-0.8.0.dev1 → hexdag-0.8.0.dev3}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "hexdag"
-version = "0.8.0.dev1"
+version = "0.8.0.dev3"
 
 description = "Operating system for AI agents — pipelines, ports, drivers, and stdlib so agents don't reinvent infrastructure"
 authors = [{ name = "hexDAG Team", email = "developers@omniviser.ai" }]
@@ -149,10 +149,10 @@ docs = [
 
 
 [tool.hatch.build.targets.sdist]
-packages = ["hexdag", "hexdag_plugins"]
+packages = ["hexdag"]
 
 [tool.hatch.build.targets.wheel]
-packages = ["hexdag", "hexdag_plugins"]
+packages = ["hexdag"]
 
 # For local development with uv - points to local packages not yet on PyPI
 [tool.uv.sources]
@@ -393,7 +393,7 @@ convention = "numpy"
 "hexdag/compiler/yaml_builder.py" = ["E501"] # YAML examples can be long
 
 [tool.ruff.lint.isort]
-known-first-party = ["hexdag"]
+known-first-party = ["hexdag", "hexdag_forge"]
 
 [tool.vulture]
 min_confidence = 90
@@ -474,6 +474,7 @@ exclude = [
     "hexdag_plugins",                         # External plugin directories
     "hexdag-studio",                          # Separate package with its own dependencies
     "hexdag-studio/.venv",                    # Nested venv in studio package
+    "hexdag-forge",                           # Separate package with its own dependencies
 ]
 
 # Per-rule ignores for specific packages

hexdag-0.8.0.dev1/hexdag/stdlib/adapters/database/__init__.py

@@ -1,6 +0,0 @@
-"""Database adapters for HexDAG."""
-
-from hexdag.stdlib.adapters.database.pgvector.pgvector_adapter import PgVectorAdapter
-from hexdag.stdlib.adapters.database.sqlite.sqlite_adapter import SQLiteAdapter
-
-__all__ = ["PgVectorAdapter", "SQLiteAdapter"]

hexdag-0.8.0.dev1/hexdag_plugins/.gitignore

@@ -1,43 +0,0 @@
-# Python
-__pycache__/
-*.py[cod]
-*$py.class
-*.so
-.Python
-*.egg-info/
-dist/
-build/
-*.egg
-
-# Testing
-.coverage
-.pytest_cache/
-htmlcov/
-.tox/
-.hypothesis/
-
-# IDE
-.idea/
-.vscode/
-*.swp
-*.swo
-*~
-.DS_Store
-
-# Virtual environments
-venv/
-env/
-ENV/
-
-# Mypy
-.mypy_cache/
-.dmypy.json
-dmypy.json
-
-# Ruff
-.ruff_cache/
-
-# Plugin builds
-*/dist/
-*/build/
-*/*.egg-info/

hexdag-0.8.0.dev1/hexdag_plugins/README.md

@@ -1,81 +0,0 @@
-# hexDAG Plugins
-
-This directory contains plugins that extend hexDAG's functionality.
-
-## Available Plugins
-
-| Plugin | Description | Port |
-|--------|-------------|------|
-| `mysql_adapter` | Production MySQL adapter with JSON support | database |
-
-## Simple Plugin Workflow
-
-Each plugin is a standalone Python package. Just use standard Python tools:
-
-### Install & Test
-
-```bash
-# Install a plugin
-uv pip install -e hexdag_plugins/mysql_adapter/
-
-# Run tests
-uv run pytest hexdag_plugins/mysql_adapter/tests/
-
-# Format code (uses settings from plugin's pyproject.toml)
-cd hexdag_plugins/mysql_adapter
-uv run ruff format .
-uv run ruff check --fix .
-```
-
-### Pre-commit Integration
-
-Plugin files are automatically handled by the main pre-commit configuration. When you commit:
-- **Plugin files** (`hexdag_plugins/`) use plugin-specific hooks with relaxed rules
-- **Main code** (`hexdag/`) uses strict project hooks
-
-This happens automatically - just commit normally and the right hooks run!
-
-### Plugin Structure
-
-```
-hexdag_plugins/
-└── my_plugin/
-    ├── pyproject.toml      # Plugin configuration & dependencies
-    ├── __init__.py
-    ├── my_plugin.py        # Implementation
-    └── tests/
-        └── test_my_plugin.py
-```
-
-### Creating a New Plugin
-
-1. Copy an existing plugin directory as a template
-2. Update `pyproject.toml` with your plugin details
-3. Implement the required port interface
-4. Write tests
-
-The `pyproject.toml` contains all configuration:
-- Dependencies
-- Tool settings (ruff, mypy, pytest)
-- Plugin metadata for hexDAG
-
-## Using Plugins
-
-Plugins are used by referencing their full module path in YAML:
-
-```yaml
-spec:
-  ports:
-    database:
-      adapter: hexdag_plugins.mysql_adapter.MySQLAdapter
-```
-
-Or import directly in Python:
-
-```python
-from hexdag_plugins.mysql_adapter import MySQLAdapter
-
-adapter = MySQLAdapter(host="localhost", database="mydb")
-```
-
-That's it! No complex scripts or build tools needed.

hexdag-0.8.0.dev1/hexdag_plugins/__init__.py

@@ -1,63 +0,0 @@
-"""External plugins for hexDAG framework.
-
-Plugin Convention
------------------
-All plugins in this namespace follow a standard structure::
-
-    hexdag_plugins/
-    ├── <plugin_name>/
-    │   ├── __init__.py          # Re-exports from adapters/nodes/tools
-    │   ├── adapters/            # Adapter implementations
-    │   │   ├── __init__.py
-    │   │   └── my_adapter.py
-    │   ├── nodes/               # Custom node types
-    │   │   ├── __init__.py
-    │   │   └── my_node.py
-    │   ├── tools/               # Agent tools
-    │   │   ├── __init__.py
-    │   │   └── my_tool.py
-    │   └── ports/               # Custom port protocols (optional)
-    │       └── __init__.py
-
-Adapter Requirements
---------------------
-Adapters MUST inherit from their port protocol to be auto-discovered:
-
-- LLM adapters: inherit from ``LLM``, ``SupportsGeneration``, etc.
-- Memory adapters: inherit from ``Memory``
-- Database adapters: inherit from ``Database`` or ``SQLAdapter``
-- Secret adapters: inherit from ``SecretStore``
-- Storage adapters: inherit from ``FileStorage`` or ``VectorStorePort``
-- Tool adapters: inherit from ``ToolRouter``
-
-Example::
-
-    from hexdag.kernel.ports.llm import LLM
-
-    class MyCustomLLMAdapter(LLM):
-        async def aresponse(self, messages):
-            ...
-
-Node Requirements
------------------
-Custom nodes should inherit from ``BaseNodeFactory``::
-
-    from hexdag.stdlib.nodes.base_node_factory import BaseNodeFactory
-
-    class MyCustomNode(BaseNodeFactory):
-        def __call__(self, name: str, **kwargs) -> NodeSpec:
-            ...
-
-Available Plugins
------------------
-- ``azure``: Azure cloud adapters (OpenAI, Cosmos, KeyVault, Blob)
-- ``storage``: File and vector storage adapters
-- ``hexdag_etl``: ETL pipeline nodes
-"""
-
-try:
-    from importlib.metadata import version as _meta_version
-
-    __version__ = _meta_version("hexdag-plugins")
-except Exception:
-    __version__ = "0.0.0.dev0"  # Fallback for development installs

hexdag-0.8.0.dev1/hexdag_plugins/_ports.py

@@ -1,166 +0,0 @@
-"""Port protocols used by hexdag_plugins.
-
-These protocols were previously in hexdag.kernel.ports but were moved here
-because they are only used by the plugins package, not by core hexDAG.
-"""
-
-import html as html_mod
-import re
-from datetime import datetime
-from html.parser import HTMLParser
-from typing import Any, Protocol, runtime_checkable
-
-from hexdag.kernel.ports.dict_bridge import dict_bridge_call
-from hexdag.kernel.ports.healthcheck import HealthStatus
-from pydantic import BaseModel
-
-# ---------------------------------------------------------------------------
-# Email port
-# ---------------------------------------------------------------------------
-
-
-class SendEmailRequest(BaseModel):
-    """Email send request."""
-
-    to_addresses: list[str]
-    subject: str
-    body_text: str
-    body_html: str | None = None
-    cc_addresses: list[str] | None = None
-    in_reply_to: str | None = None
-    conversation_id: str | None = None
-    metadata: dict[str, Any] | None = None
-
-
-class SendEmailResult(BaseModel):
-    """Email send result."""
-
-    message_id: str
-    conversation_id: str | None = None
-    sent_at: datetime
-    success: bool = True
-    error_message: str | None = None
-
-
-@runtime_checkable
-class SupportsEmail(Protocol):
-    """Protocol for email adapters.
-
-    The adapter handles sending pre-composed emails and fetching
-    new inbound emails. Template rendering is handled separately
-    (e.g. by TemplatedEmailNode).
-    """
-
-    async def send_email(self, request: SendEmailRequest) -> SendEmailResult:
-        """Send an email."""
-        ...
-
-    async def send_email_from_dict(self, request: dict) -> dict:
-        """Send email from dict (for node compatibility).
-
-        Default implementation delegates to :meth:`send_email` via Pydantic
-        ``model_validate`` / ``model_dump(mode="json")``.  Adapters do NOT
-        need to override this.
-        """
-        return await dict_bridge_call(self.send_email, request, SendEmailRequest)
-
-    async def fetch_emails(self, since: datetime | None = None, limit: int = 50) -> list[dict]:
-        """Fetch recent inbound emails from inbox.
-
-        Args:
-            since: Only fetch emails received after this datetime.
-            limit: Maximum number of emails to return.
-
-        Returns:
-            List of email dicts with fields: message_id, conversation_id,
-            in_reply_to, from_address, to_addresses, cc_addresses, subject,
-            body_text, body_html, received_at, has_attachments.
-        """
-        ...
-
-
-# ---------------------------------------------------------------------------
-# Email utilities
-# ---------------------------------------------------------------------------
-
-
-class _HTMLTextExtractor(HTMLParser):
-    """Strips HTML tags and returns plain text."""
-
-    def __init__(self) -> None:
-        super().__init__()
-        self._pieces: list[str] = []
-        self._skip = False
-
-    def handle_starttag(self, tag: str, attrs: list[tuple[str, str | None]]) -> None:
-        if tag in ("script", "style"):
-            self._skip = True
-        elif tag in ("br", "p", "div", "tr", "li"):
-            self._pieces.append("\n")
-
-    def handle_endtag(self, tag: str) -> None:
-        if tag in ("script", "style"):
-            self._skip = False
-
-    def handle_data(self, data: str) -> None:
-        if not self._skip:
-            self._pieces.append(data)
-
-    def get_text(self) -> str:
-        return "".join(self._pieces)
-
-
-def html_to_plain_text(html_content: str) -> str:
-    """Convert HTML to plain text using stdlib parser.
-
-    Args:
-        html_content: Raw HTML string.
-
-    Returns:
-        Plain text with HTML tags stripped, entities decoded, and
-        excessive whitespace collapsed.
-    """
-    if not html_content:
-        return ""
-    extractor = _HTMLTextExtractor()
-    extractor.feed(html_content)
-    text = extractor.get_text()
-    text = html_mod.unescape(text)
-    text = re.sub(r"\n{3,}", "\n\n", text)
-    return text.strip()
-
-
-@runtime_checkable
-class FileStorage(Protocol):
-    """Port for file storage operations.
-
-    Provides a unified interface for local and cloud file storage.
-    """
-
-    async def aupload(self, local_path: str, remote_path: str) -> dict:
-        """Upload a file."""
-        ...
-
-    async def adownload(self, remote_path: str, local_path: str) -> dict:
-        """Download a file."""
-        ...
-
-    async def adelete(self, remote_path: str) -> dict:
-        """Delete a file."""
-        ...
-
-    async def alist(self, prefix: str = "") -> list[str]:
-        """List files with optional prefix."""
-        ...
-
-    async def aexists(self, remote_path: str) -> bool:
-        """Check if file exists."""
-        ...
-
-    async def aget_metadata(self, remote_path: str) -> dict:
-        """Get file metadata."""
-        ...
-
-    async def ahealth_check(self) -> HealthStatus:
-        """Check storage health."""
-        ...

hexdag-0.8.0.dev1/hexdag_plugins/azure/LICENSE

@@ -1,21 +0,0 @@
-MIT License
-
-Copyright (c) 2025 HexDAG Team
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.