idun-agent-engine 0.2.1__tar.gz → 0.2.3__tar.gz

{idun_agent_engine-0.2.1 → idun_agent_engine-0.2.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: idun-agent-engine
-Version: 0.2.1
+Version: 0.2.3
 Summary: Python SDK and runtime to serve AI agents with FastAPI, LangGraph, and observability.
 Project-URL: Homepage, https://github.com/geoffreyharrazi/idun-agent-platform
 Project-URL: Repository, https://github.com/geoffreyharrazi/idun-agent-platform
@@ -14,18 +14,20 @@ Classifier: Intended Audience :: Developers
 Classifier: License :: OSI Approved :: MIT License
 Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
 Classifier: Topic :: Software Development :: Libraries
 Classifier: Typing :: Typed
-Requires-Python: <3.14,>=3.13
+Requires-Python: <3.14,>=3.12
 Requires-Dist: ag-ui-protocol<0.2.0,>=0.1.8
 Requires-Dist: aiosqlite<0.22.0,>=0.21.0
 Requires-Dist: arize-phoenix-otel<1.0.0,>=0.2.0
-Requires-Dist: arize-phoenix<12,>=11.22.0
+Requires-Dist: arize-phoenix<12.0.0,>=11.22.0
+Requires-Dist: click>=8.2.1
 Requires-Dist: fastapi<0.117.0,>=0.116.1
 Requires-Dist: google-adk<2.0.0,>=1.9.0
 Requires-Dist: httpx<0.29.0,>=0.28.1
-Requires-Dist: idun-agent-schema<0.3.0,>=0.2.0
+Requires-Dist: idun-agent-schema<0.3.0,>=0.2.3
 Requires-Dist: langchain-core<0.4.0,>=0.3.72
 Requires-Dist: langchain-google-vertexai<3.0.0,>=2.0.27
 Requires-Dist: langchain<0.4,>=0.3.27
@@ -36,6 +38,7 @@ Requires-Dist: langgraph<0.7.0,>=0.6.3
 Requires-Dist: openinference-instrumentation-langchain<1.0.0,>=0.1.13
 Requires-Dist: pydantic<3.0.0,>=2.11.7
 Requires-Dist: python-dotenv>=1.1.1
+Requires-Dist: sqlalchemy<3.0.0,>=2.0.36
 Requires-Dist: streamlit<2.0.0,>=1.47.1
 Requires-Dist: uvicorn<0.36.0,>=0.35.0
 Description-Content-Type: text/markdown

{idun_agent_engine-0.2.1 → idun_agent_engine-0.2.3}/README.md

@@ -1,236 +1,236 @@
-# Idun Agent Engine
-
-Turn any LangGraph-based agent into a production-grade API in minutes.
-
-Idun Agent Engine is a lightweight runtime and SDK that wraps your agent with a FastAPI server, adds streaming, structured responses, config validation, and optional observability — with zero boilerplate. Use a YAML file or a fluent builder to configure and run.
-
-## Installation
-
-```bash
-pip install idun-agent-engine
-```
-
-- Requires Python 3.13
-- Ships with FastAPI, Uvicorn, LangGraph, SQLite checkpointing, and optional observability hooks
-
-## Quickstart
-
-### 1) Minimal one-liner (from a YAML config)
-
-```python
-from idun_agent_engine.core.server_runner import run_server_from_config
-
-run_server_from_config("config.yaml")
-```
-
-Example `config.yaml`:
-
-```yaml
-server:
-  api:
-    port: 8000
-
-agent:
-  type: "langgraph"
-  config:
-    name: "My Example LangGraph Agent"
-    graph_definition: "./examples/01_basic_config_file/example_agent.py:app"
-    # Optional: conversation persistence
-    checkpointer:
-      type: "sqlite"
-      db_url: "sqlite:///example_checkpoint.db"
-    # Optional: provider-agnostic observability
-    observability:
-      provider: langfuse   # or phoenix
-      enabled: true
-      options:
-        host: ${LANGFUSE_HOST}
-        public_key: ${LANGFUSE_PUBLIC_KEY}
-        secret_key: ${LANGFUSE_SECRET_KEY}
-        run_name: "idun-langgraph-run"
-```
-
-Run and open docs at `http://localhost:8000/docs`.
-
-### 2) Programmatic setup with the fluent builder
-
-```python
-from pathlib import Path
-from idun_agent_engine import ConfigBuilder, create_app, run_server
-
-config = (
-    ConfigBuilder()
-    .with_api_port(8000)
-    .with_langgraph_agent(
-        name="Programmatic Example Agent",
-        graph_definition=str(Path("./examples/02_programmatic_config/smart_agent.py:app")),
-        sqlite_checkpointer="programmatic_example.db",
-    )
-    .build()
-)
-
-app = create_app(engine_config=config)
-run_server(app, reload=True)
-```
-
-## Endpoints
-
-All servers expose these by default:
-
-- POST `/agent/invoke`: single request/response
-- POST `/agent/stream`: server-sent events stream of `ag-ui` protocol events
-- GET `/health`: service health with engine version
-- GET `/`: root landing with links
-
-Invoke example:
-
-```bash
-curl -X POST "http://localhost:8000/agent/invoke" \
-  -H "Content-Type: application/json" \
-  -d '{"query": "Hello!", "session_id": "user-123"}'
-```
-
-Stream example:
-
-```bash
-curl -N -X POST "http://localhost:8000/agent/stream" \
-  -H "Content-Type: application/json" \
-  -d '{"query": "Tell me a story", "session_id": "user-123"}'
-```
-
-## LangGraph integration
-
-Point the engine to a `StateGraph` variable in your file using `graph_definition`:
-
-```python
-# examples/01_basic_config_file/example_agent.py
-import operator
-from typing import Annotated, TypedDict
-from langgraph.graph import END, StateGraph
-
-class AgentState(TypedDict):
-    messages: Annotated[list, operator.add]
-
-def greeting_node(state):
-    user_message = state["messages"][-1] if state["messages"] else ""
-    return {"messages": [("ai", f"Hello! You said: '{user_message}'")]}
-
-graph = StateGraph(AgentState)
-graph.add_node("greet", greeting_node)
-graph.set_entry_point("greet")
-graph.add_edge("greet", END)
-
-# This variable name is referenced by graph_definition
-app = graph
-```
-
-Then reference it in config:
-
-```yaml
-agent:
-  type: "langgraph"
-  config:
-    graph_definition: "./examples/01_basic_config_file/example_agent.py:app"
-```
-
-Behind the scenes, the engine:
-
-- Validates config with Pydantic models
-- Loads your `StateGraph` from disk
-- Optionally wires a SQLite checkpointer via `langgraph.checkpoint.sqlite`
-- Exposes `invoke` and `stream` endpoints
-- Bridges LangGraph events to `ag-ui` stream events
-
-## Observability (optional)
-
-Enable provider-agnostic observability via the `observability` block in your agent config. Today supports Langfuse and Arize Phoenix (OpenInference) patterns; more coming soon.
-
-```yaml
-agent:
-  type: "langgraph"
-  config:
-    observability:
-      provider: langfuse   # or phoenix
-      enabled: true
-      options:
-        host: ${LANGFUSE_HOST}
-        public_key: ${LANGFUSE_PUBLIC_KEY}
-        secret_key: ${LANGFUSE_SECRET_KEY}
-        run_name: "idun-langgraph-run"
-```
-
-## Configuration reference
-
-- `server.api.port` (int): HTTP port (default 8000)
-- `agent.type` (enum): currently `langgraph` (CrewAI placeholder exists but not implemented)
-- `agent.config.name` (str): human-readable name
-- `agent.config.graph_definition` (str): absolute or relative `path/to/file.py:variable`
-- `agent.config.checkpointer` (sqlite): `{ type: "sqlite", db_url: "sqlite:///file.db" }`
-- `agent.config.observability` (optional): provider options as shown above
-
-Config can be sourced by:
-
-- `engine_config` (preferred): pass a validated `EngineConfig` to `create_app`
-- `config_dict`: dict validated at runtime
-- `config_path`: path to YAML; defaults to `config.yaml`
-
-## Examples
-
-The `examples/` folder contains complete projects:
-
-- `01_basic_config_file`: YAML config + simple agent
-- `02_programmatic_config`: `ConfigBuilder` usage and advanced flows
-- `03_minimal_setup`: one-line server from config
-
-Run any example with Python 3.13 installed.
-
-## CLI and runtime helpers
-
-Top-level imports for convenience:
-
-```python
-from idun_agent_engine import (
-  create_app,
-  run_server,
-  run_server_from_config,
-  run_server_from_builder,
-  ConfigBuilder,
-)
-```
-
-- `create_app(...)` builds the FastAPI app and registers routes
-- `run_server(app, ...)` runs with Uvicorn
-- `run_server_from_config(path, ...)` loads config, builds app, and runs
-- `run_server_from_builder(builder, ...)` builds from a builder and runs
-
-## Production notes
-
-- Use a process manager (e.g., multiple Uvicorn workers behind a gateway). Note: `reload=True` is for development and incompatible with multi-worker mode.
-- Mount behind a reverse proxy and enable TLS where appropriate.
-- Persist conversations using the SQLite checkpointer in production or replace with a custom checkpointer when available.
-
-## Roadmap
-
-- CrewAI adapter (placeholder exists, not yet implemented)
-- Additional stores and checkpointers
-- First-class CLI for `idun` commands
-
-## Contributing
-
-Issues and PRs are welcome. See the repository:
-
-- Repo: `https://github.com/geoffreyharrazi/idun-agent-platform`
-- Package path: `libs/idun_agent_engine`
-- Open an issue: `https://github.com/geoffreyharrazi/idun-agent-platform/issues`
-
-Run locally:
-
-```bash
-cd libs/idun_agent_engine
-poetry install
-poetry run pytest -q
-```
-
-## License
-
-MIT — see `LICENSE` in the repo root.
+# Idun Agent Engine
+
+Turn any LangGraph-based agent into a production-grade API in minutes.
+
+Idun Agent Engine is a lightweight runtime and SDK that wraps your agent with a FastAPI server, adds streaming, structured responses, config validation, and optional observability — with zero boilerplate. Use a YAML file or a fluent builder to configure and run.
+
+## Installation
+
+```bash
+pip install idun-agent-engine
+```
+
+- Requires Python 3.13
+- Ships with FastAPI, Uvicorn, LangGraph, SQLite checkpointing, and optional observability hooks
+
+## Quickstart
+
+### 1) Minimal one-liner (from a YAML config)
+
+```python
+from idun_agent_engine.core.server_runner import run_server_from_config
+
+run_server_from_config("config.yaml")
+```
+
+Example `config.yaml`:
+
+```yaml
+server:
+  api:
+    port: 8000
+
+agent:
+  type: "langgraph"
+  config:
+    name: "My Example LangGraph Agent"
+    graph_definition: "./examples/01_basic_config_file/example_agent.py:app"
+    # Optional: conversation persistence
+    checkpointer:
+      type: "sqlite"
+      db_url: "sqlite:///example_checkpoint.db"
+    # Optional: provider-agnostic observability
+    observability:
+      provider: langfuse   # or phoenix
+      enabled: true
+      options:
+        host: ${LANGFUSE_HOST}
+        public_key: ${LANGFUSE_PUBLIC_KEY}
+        secret_key: ${LANGFUSE_SECRET_KEY}
+        run_name: "idun-langgraph-run"
+```
+
+Run and open docs at `http://localhost:8000/docs`.
+
+### 2) Programmatic setup with the fluent builder
+
+```python
+from pathlib import Path
+from idun_agent_engine import ConfigBuilder, create_app, run_server
+
+config = (
+    ConfigBuilder()
+    .with_api_port(8000)
+    .with_langgraph_agent(
+        name="Programmatic Example Agent",
+        graph_definition=str(Path("./examples/02_programmatic_config/smart_agent.py:app")),
+        sqlite_checkpointer="programmatic_example.db",
+    )
+    .build()
+)
+
+app = create_app(engine_config=config)
+run_server(app, reload=True)
+```
+
+## Endpoints
+
+All servers expose these by default:
+
+- POST `/agent/invoke`: single request/response
+- POST `/agent/stream`: server-sent events stream of `ag-ui` protocol events
+- GET `/health`: service health with engine version
+- GET `/`: root landing with links
+
+Invoke example:
+
+```bash
+curl -X POST "http://localhost:8000/agent/invoke" \
+  -H "Content-Type: application/json" \
+  -d '{"query": "Hello!", "session_id": "user-123"}'
+```
+
+Stream example:
+
+```bash
+curl -N -X POST "http://localhost:8000/agent/stream" \
+  -H "Content-Type: application/json" \
+  -d '{"query": "Tell me a story", "session_id": "user-123"}'
+```
+
+## LangGraph integration
+
+Point the engine to a `StateGraph` variable in your file using `graph_definition`:
+
+```python
+# examples/01_basic_config_file/example_agent.py
+import operator
+from typing import Annotated, TypedDict
+from langgraph.graph import END, StateGraph
+
+class AgentState(TypedDict):
+    messages: Annotated[list, operator.add]
+
+def greeting_node(state):
+    user_message = state["messages"][-1] if state["messages"] else ""
+    return {"messages": [("ai", f"Hello! You said: '{user_message}'")]}
+
+graph = StateGraph(AgentState)
+graph.add_node("greet", greeting_node)
+graph.set_entry_point("greet")
+graph.add_edge("greet", END)
+
+# This variable name is referenced by graph_definition
+app = graph
+```
+
+Then reference it in config:
+
+```yaml
+agent:
+  type: "langgraph"
+  config:
+    graph_definition: "./examples/01_basic_config_file/example_agent.py:app"
+```
+
+Behind the scenes, the engine:
+
+- Validates config with Pydantic models
+- Loads your `StateGraph` from disk
+- Optionally wires a SQLite checkpointer via `langgraph.checkpoint.sqlite`
+- Exposes `invoke` and `stream` endpoints
+- Bridges LangGraph events to `ag-ui` stream events
+
+## Observability (optional)
+
+Enable provider-agnostic observability via the `observability` block in your agent config. Today supports Langfuse and Arize Phoenix (OpenInference) patterns; more coming soon.
+
+```yaml
+agent:
+  type: "langgraph"
+  config:
+    observability:
+      provider: langfuse   # or phoenix
+      enabled: true
+      options:
+        host: ${LANGFUSE_HOST}
+        public_key: ${LANGFUSE_PUBLIC_KEY}
+        secret_key: ${LANGFUSE_SECRET_KEY}
+        run_name: "idun-langgraph-run"
+```
+
+## Configuration reference
+
+- `server.api.port` (int): HTTP port (default 8000)
+- `agent.type` (enum): currently `langgraph` (CrewAI placeholder exists but not implemented)
+- `agent.config.name` (str): human-readable name
+- `agent.config.graph_definition` (str): absolute or relative `path/to/file.py:variable`
+- `agent.config.checkpointer` (sqlite): `{ type: "sqlite", db_url: "sqlite:///file.db" }`
+- `agent.config.observability` (optional): provider options as shown above
+
+Config can be sourced by:
+
+- `engine_config` (preferred): pass a validated `EngineConfig` to `create_app`
+- `config_dict`: dict validated at runtime
+- `config_path`: path to YAML; defaults to `config.yaml`
+
+## Examples
+
+The `examples/` folder contains complete projects:
+
+- `01_basic_config_file`: YAML config + simple agent
+- `02_programmatic_config`: `ConfigBuilder` usage and advanced flows
+- `03_minimal_setup`: one-line server from config
+
+Run any example with Python 3.13 installed.
+
+## CLI and runtime helpers
+
+Top-level imports for convenience:
+
+```python
+from idun_agent_engine import (
+  create_app,
+  run_server,
+  run_server_from_config,
+  run_server_from_builder,
+  ConfigBuilder,
+)
+```
+
+- `create_app(...)` builds the FastAPI app and registers routes
+- `run_server(app, ...)` runs with Uvicorn
+- `run_server_from_config(path, ...)` loads config, builds app, and runs
+- `run_server_from_builder(builder, ...)` builds from a builder and runs
+
+## Production notes
+
+- Use a process manager (e.g., multiple Uvicorn workers behind a gateway). Note: `reload=True` is for development and incompatible with multi-worker mode.
+- Mount behind a reverse proxy and enable TLS where appropriate.
+- Persist conversations using the SQLite checkpointer in production or replace with a custom checkpointer when available.
+
+## Roadmap
+
+- CrewAI adapter (placeholder exists, not yet implemented)
+- Additional stores and checkpointers
+- First-class CLI for `idun` commands
+
+## Contributing
+
+Issues and PRs are welcome. See the repository:
+
+- Repo: `https://github.com/geoffreyharrazi/idun-agent-platform`
+- Package path: `libs/idun_agent_engine`
+- Open an issue: `https://github.com/geoffreyharrazi/idun-agent-platform/issues`
+
+Run locally:
+
+```bash
+cd libs/idun_agent_engine
+poetry install
+poetry run pytest -q
+```
+
+## License
+
+MIT — see `LICENSE` in the repo root.

{idun_agent_engine-0.2.1 → idun_agent_engine-0.2.3}/pyproject.toml

@@ -1,9 +1,9 @@
 [project]
 name = "idun-agent-engine"
-version = "0.2.1"
+version = "0.2.3"
 description = "Python SDK and runtime to serve AI agents with FastAPI, LangGraph, and observability."
 authors = [{ name = "Geoffrey HARRAZI", email = "geoffreyharrazi@gmail.com" }]
-requires-python = ">=3.13,<3.14"
+requires-python = ">=3.12,<3.14"
 readme = "README.md"
 license = "MIT"
 keywords = [
@@ -18,6 +18,7 @@ classifiers = [
     "License :: OSI Approved :: MIT License",
     "Programming Language :: Python :: 3",
     "Programming Language :: Python :: 3 :: Only",
+    "Programming Language :: Python :: 3.12",
     "Programming Language :: Python :: 3.13",
     "Framework :: FastAPI",
     "Intended Audience :: Developers",
@@ -41,14 +42,21 @@ dependencies = [
     "arize-phoenix-otel>=0.2.0,<1.0.0",
     "openinference-instrumentation-langchain>=0.1.13,<1.0.0",
     "langchain>=0.3.27,<0.4",
-    "arize-phoenix>=11.22.0,<12",
-    # Centralized schema package
-    "idun-agent-schema>=0.2.0,<0.3.0",
-    # "haystack-ai>=2.17.1",
+    # Pin <12: 12.x currently depends on placeholder jmespath==99.99.99 and fails in Docker
+    "arize-phoenix>=11.22.0,<12.0.0",
+    "idun-agent-schema>=0.2.3,<0.3.0",
     "langfuse-haystack>=2.3.0",
     "python-dotenv>=1.1.1",
+    "click>=8.2.1",
+    # Pin SQLAlchemy for Python 3.13 compatibility (required by Phoenix)
+    "sqlalchemy>=2.0.36,<3.0.0",
 ]
 
+
+[project.scripts]
+idun = "idun_platform_cli.main:cli"
+
+
 [project.urls]
 Homepage = "https://github.com/geoffreyharrazi/idun-agent-platform"
 Repository = "https://github.com/geoffreyharrazi/idun-agent-platform"
@@ -71,16 +79,11 @@ dev = [
 include = [
     "src/idun_agent_engine",
     "src/idun_agent_engine/py.typed",
+    "src/idun_platform_cli",
 ]
 
 [tool.hatch.build.targets.wheel]
-include = [
-    "src/idun_agent_engine",
-    "src/idun_agent_engine/py.typed",
-]
-
-[tool.hatch.build.targets.wheel.sources]
-"src/idun_agent_engine" = "idun_agent_engine"
+packages = ["src/idun_agent_engine", "src/idun_platform_cli"]
 
 [build-system]
 requires = ["hatchling"]
@@ -88,7 +91,7 @@ build-backend = "hatchling.build"
 
 [tool.black]
 line-length = 88
-target-version = ["py313"]
+target-version = ["py312", "py313"]
 include = "\\.pyi?$"
 exclude = '''
 (
@@ -100,7 +103,7 @@ exclude = '''
 '''
 
 [tool.ruff]
-target-version = "py313"
+target-version = "py312"
 line-length = 88
 extend-exclude = [
     "build",
@@ -132,7 +135,7 @@ extend-ignore = [
 convention = "google"
 
 [tool.mypy]
-python_version = "3.13"
+python_version = "3.12"
 warn_return_any = true
 warn_unused_ignores = true
 ignore_missing_imports = true

{idun_agent_engine-0.2.1 → idun_agent_engine-0.2.3}/src/idun_agent_engine/_version.py

@@ -1,3 +1,3 @@
 """Version information for Idun Agent Engine."""
 
-__version__ = "0.2.1"
+__version__ = "0.2.3"

{idun_agent_engine-0.2.1 → idun_agent_engine-0.2.3}/src/idun_agent_engine/agent/langgraph/langgraph.py

@@ -207,8 +207,10 @@ class LanggraphAgent(agent_base.BaseAgent):
             ) from None
 
         try:
+            from pathlib import Path
+            resolved_path = Path(module_path).resolve()
             spec = importlib.util.spec_from_file_location(
-                graph_variable_name, module_path
+                graph_variable_name, str(resolved_path)
             )
             if spec is None or spec.loader is None:
                 raise ImportError(f"Could not load spec for module at {module_path}")

{idun_agent_engine-0.2.1 → idun_agent_engine-0.2.3}/src/idun_agent_engine/observability/phoenix_local/phoenix_local_handler.py

@@ -23,7 +23,7 @@ class PhoenixLocalHandler(ObservabilityHandlerBase):
     def __init__(
         self,
         options: dict[str, Any] | None = None,
-        default_endpoint: str = "http://127.0.0.1:6006",
+        default_endpoint: str = "http://0.0.0.0:6006",
     ):
         """Initialize handler, start Phoenix via CLI, and set up instrumentation.
 

idun_agent_engine-0.2.3/src/idun_platform_cli/groups/agent/main.py

@@ -0,0 +1,16 @@
+"""Manage, Deploy and package agents."""
+
+import click
+
+from .package import package_command
+from .serve import serve_command
+
+
+@click.group()
+def agent():
+    """Agent command entrypoint."""
+    pass
+
+
+agent.add_command(serve_command, name="serve")
+agent.add_command(package_command, name="package")

idun_agent_engine-0.2.3/src/idun_platform_cli/groups/agent/package.py

@@ -0,0 +1,70 @@
+import sys
+from enum import StrEnum
+from pathlib import Path
+
+import click
+
+
+class Dependency(StrEnum):
+    """Dependency Enum."""
+
+    REQUIREMENT = "requirements.txt"
+    PYPROJECT = "pyproject.toml"
+    NONE = "none"
+
+
+def get_dependencies(path: str) -> Dependency:
+    """Verifies if the path folder contains a `requirements.txt` or `pyproject.toml`, and returns which."""
+    """:param path: Path pointing to the agent's folder."""
+    agent_path = Path(path).resolve()
+    if (agent_path / "requirements.txt").exists():
+        return Dependency.REQUIREMENT
+    elif (agent_path / "pyproject.toml").exists():
+        return Dependency.PYPROJECT
+    else:
+        return Dependency.NONE
+
+
+def generate_dockerfile(dependency: Dependency) -> str:
+    # TODO: add envs vars based on source
+    """Generates Dockerfile based on given params."""
+    if dependency == Dependency.NONE:
+        print(
+            "[ERROR]: No pyproject.toml or requirements.txt found. Please make sure to include them."
+        )
+        sys.exit(1)
+        return ""  # Unreachable, but satisfies type checker
+    if dependency == Dependency.REQUIREMENT:
+        # TODO: use from file
+        requirements_dockerfile = f"""FROM python:3.13-slim
+RUN apt-get update && pip install uv
+
+RUN uv pip install idun-agent-schema==0.2.3 --system
+RUN uv pip install idun-agent-engine==0.2.3 --system
+
+COPY . .
+RUN uv pip install -r requirements.txt --system
+
+CMD ["idun", "agent", "serve", "--source=manager"]
+"""
+        return requirements_dockerfile
+    if dependency == Dependency.PYPROJECT:
+        # TODO: implement pyproject.toml support
+        raise NotImplementedError("pyproject.toml support is not yet implemented")
+    raise ValueError(f"Unknown dependency type: {dependency}")
+
+
+@click.command("package")
+@click.argument("path", default=".")
+@click.option("--target", required=False, default=".")
+def package_command(path: str, target: str):
+    """Packages the agent and it's dependencies into a Dockerfile. You can specifiy the input path and the destination. Defaults to current directory."""
+    dependency = get_dependencies(path)
+    dockerfile = generate_dockerfile(dependency)
+    target_path = Path(target)
+    dockerfile_path = target_path / "Dockerfile"
+    try:
+        dockerfile_path.write_text(dockerfile)
+        print(f"Dockerfile generated in {target}")
+    except OSError as e:
+        print(f"[ERROR]: Cannot write dockerfile to path {target}: {e}")

idun_agent_engine-0.2.3/src/idun_platform_cli/groups/agent/serve.py

@@ -0,0 +1,104 @@
+import os
+import sys
+from enum import StrEnum
+
+import click
+from idun_agent_engine.core.app_factory import create_app
+from idun_agent_engine.core.config_builder import ConfigBuilder
+from idun_agent_engine.core.engine_config import EngineConfig
+from idun_agent_engine.core.server_runner import run_server
+
+
+class ServerSource(StrEnum):
+    """Enum for source types."""
+
+    MANAGER = "manager"
+    FILE = "file"
+
+
+class Serve:
+    """Helper class to run the server."""
+
+    def __init__(self, source: ServerSource, path: str | None = None) -> None:
+        self._source: ServerSource = source
+        self._path: str | None = path or None
+
+        if self._source == ServerSource.MANAGER and (
+            not os.getenv("IDUN_AGENT_API_KEY") or not os.getenv("IDUN_MANAGER_HOST")
+        ):
+            print(
+                "[ERROR]: either IDUN_AGENT_API_KEY or IDUN_MANAGER_HOST are not found. Make sure you add them both to your env variables, as `manager` source requires both."
+            )
+            sys.exit(1)
+
+        if self._source == ServerSource.MANAGER:
+            self._url: str = os.environ["IDUN_MANAGER_HOST"]
+            self._agent_api_key: str = os.environ["IDUN_AGENT_API_KEY"]
+
+        self._config: EngineConfig | None = self._resolve_source()
+
+    def _resolve_source(self):
+        """Returns the EngineConfig based on the type of the source."""
+        if self._source == ServerSource.MANAGER:
+            print("Getting the config for the manager...")
+            return self._fetch_from_manager()
+        elif self._source == ServerSource.FILE:
+            print(f"Building config from: {self._path}")
+            return self._fetch_from_path()
+
+    def _fetch_from_path(self) -> EngineConfig | None:
+        try:
+            config = ConfigBuilder().load_from_file(self._path)
+            print(f"Successfully fetched and built config from {self._path}")
+            return config
+
+        except Exception as e:
+            print(f"[ERROR]: Cannot fetch config from {self._path}: {e} ")
+            sys.exit(1)
+
+    def _fetch_from_manager(self) -> EngineConfig | None:
+        """Fetches the config from the api."""
+        try:
+            config = (
+                ConfigBuilder()
+                .with_config_from_api(agent_api_key=self._agent_api_key, url=self._url)
+                .build()
+            )
+            print(f"Successfully fetched and built config from {self._url}")
+            return config
+        except Exception as e:
+            print(f"[ERROR]: Cannot fetch config from {self._url}: {e} ")
+            sys.exit(1)
+
+    def serve(self) -> None:
+        """Run the server using the idun engine."""
+        try:
+            app = create_app(engine_config=self._config)
+            run_server(app, port=self._config.server.api.port, reload=False)  # pyright: ignore
+        except Exception as e:
+            raise ValueError(f"[ERROR]: Cannot start the agent server: {e}") from e
+
+
+@click.command("serve")
+@click.option("--source", required=True)
+@click.option("--path")
+def serve_command(source: str, path: str | None):
+    """Reads a config and exposes it's agent as an API. Config is either fetched from the manager, or from a path.
+
+    Note: Fetching from the manager requires env vars: IDUN_AGENT_API_KEY and IDUN_MANAGER_HOST.
+    """
+    match source:
+        case ServerSource.MANAGER:
+            s = Serve(source=source)
+            s.serve()
+
+        case ServerSource.FILE:
+            if not path:
+                print(
+                    "[ERROR]: No config path provided. You need to specify the path of your config.yaml"
+                )
+                sys.exit(1)
+            s = Serve(source=source, path=path)
+            s.serve()
+        case _:
+            print(f"[ERROR]: Argument {source} not recognized.")

idun_agent_engine-0.2.3/src/idun_platform_cli/main.py

@@ -0,0 +1,14 @@
+import click
+from idun_platform_cli.groups.agent.main import agent
+
+
+@click.group()
+def cli():
+    """Entrypoint of the CLI."""
+    pass
+
+
+cli.add_command(agent)
+
+if __name__ == "__main__":
+    cli()