idun-agent-engine 0.1.0__py3-none-any.whl → 0.2.1__py3-none-any.whl

idun_agent_engine-0.2.1.dist-info/METADATA

@@ -0,0 +1,278 @@
+Metadata-Version: 2.4
+Name: idun-agent-engine
+Version: 0.2.1
+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
+Project-URL: Documentation, https://github.com/geoffreyharrazi/idun-agent-platform/tree/main/libs/idun_agent_engine
+Project-URL: Issues, https://github.com/geoffreyharrazi/idun-agent-platform/issues
+Author-email: Geoffrey HARRAZI <geoffreyharrazi@gmail.com>
+License-Expression: MIT
+Keywords: agents,fastapi,langgraph,llm,observability,sdk
+Classifier: Framework :: FastAPI
+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.13
+Classifier: Topic :: Software Development :: Libraries
+Classifier: Typing :: Typed
+Requires-Python: <3.14,>=3.13
+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: 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: 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
+Requires-Dist: langfuse-haystack>=2.3.0
+Requires-Dist: langfuse==2.60.8
+Requires-Dist: langgraph-checkpoint-sqlite<3.0.0,>=2.0.11
+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: streamlit<2.0.0,>=1.47.1
+Requires-Dist: uvicorn<0.36.0,>=0.35.0
+Description-Content-Type: text/markdown
+
+# 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.dist-info/RECORD

@@ -0,0 +1,35 @@
+idun_agent_engine/__init__.py,sha256=PhOL6foq5V0eXaoXw7xKUeCWXIWrOHrAFB8OuJnBqyM,550
+idun_agent_engine/_version.py,sha256=2WvDrIJqGamS4FV-cYq6pcahq2_0MjtB-8l3Ci7hhKs,72
+idun_agent_engine/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+idun_agent_engine/agent/__init__.py,sha256=foyOoRdI_04q1b6f2A5EXEpWSCKjZxpgWMWrKcsHNl8,220
+idun_agent_engine/agent/base.py,sha256=xzuHIV_P7EwGyK7V2qbFUZccpm5xHaAjAkIxJL4tAwo,2856
+idun_agent_engine/agent/haystack/__init__.py,sha256=y5ADrD8gWBeYIvV7tmu6OpPdJ8POHt-tyraIL7RkkWI,179
+idun_agent_engine/agent/haystack/haystack.py,sha256=6xq7tOlvQxyc2w9KxikpS5S6vmXjUlK9Giwhmzg2X0w,10556
+idun_agent_engine/agent/haystack/haystack_model.py,sha256=EtOYnsWRufcrQufTRMeB3V-rZVQqfnmwKwPsYGfZdCs,362
+idun_agent_engine/agent/haystack/utils.py,sha256=sKRoPhzZWFw1NPsYwCockafzMBCCq3lGOrndbNE_C3M,609
+idun_agent_engine/agent/langgraph/__init__.py,sha256=CoBdkp9P4livdy5B0bvj9o7ftoqKmXEr9cZv4TZLncs,107
+idun_agent_engine/agent/langgraph/langgraph.py,sha256=z9-3fPeFCteHk39YsuxCdo_LaNcpVhIdF5268DutY1o,17312
+idun_agent_engine/cli/__init__.py,sha256=5S_Oo7n7YwKk5VPyqborrRqKVz6lvwODQ5olj70wbnQ,490
+idun_agent_engine/core/__init__.py,sha256=F0DMDlWcSWS_1dvh3xMbrdcVvZRHVnoAFFgREuSJfBI,408
+idun_agent_engine/core/app_factory.py,sha256=fqxX6n4huCAsEY5lzPQPtBb7nWWaxzvhYaPsRUbZuEY,2333
+idun_agent_engine/core/config_builder.py,sha256=nqlFEASHN9zlZhUnu5NAhRo2DeFkFVQ0rpx-yfnBuIw,16283
+idun_agent_engine/core/engine_config.py,sha256=pHa-qiYUS7mvzW2eb6sXJoxxJCxC5fwcNUTcqiO90c0,584
+idun_agent_engine/core/server_runner.py,sha256=01_aAJC-s0C5fdkEUQzwk4Vlf1SX4lsZwRTkVaJx0VE,4898
+idun_agent_engine/observability/__init__.py,sha256=Jei-E8SgYulxFu5HkJz9HfcorIfQ6O7WZWGzP41ZK-4,298
+idun_agent_engine/observability/base.py,sha256=uVCptXKmU_8OAvLRZliK5RqG6fOxj3a3bg18GVGMeHU,3575
+idun_agent_engine/observability/langfuse/__init__.py,sha256=J8XcHV4aT1pF97k5EZiqrnYYPs9VjwfV5rUMihc5Pgk,128
+idun_agent_engine/observability/langfuse/langfuse_handler.py,sha256=Hn3FxqiYDrLmGNF3JXNRBpFit_c8s2w61jl2EQO_Lco,2385
+idun_agent_engine/observability/phoenix/__init__.py,sha256=tEwJYijcvSGNhFW4QJmvBcTu1D0YVJkZRTmkNCGTteM,130
+idun_agent_engine/observability/phoenix/phoenix_handler.py,sha256=lGqSq-L1vmoEhAr9rbWO3KlNX5HSgBhCKESHMdZ-AfY,2539
+idun_agent_engine/observability/phoenix_local/__init__.py,sha256=m9dIw1GWGKAW4wP08jxA7j4yrOg0Nxq_08bwVh8YogE,146
+idun_agent_engine/observability/phoenix_local/phoenix_local_handler.py,sha256=Xd0yHNXqs42UOuXP9N_Y8sQg6dVh2qdgxGj5-4JDGiA,4254
+idun_agent_engine/server/__init__.py,sha256=WaFektUsy37bNg2niAUy_TykzStukgWPnxC-t49CEwo,177
+idun_agent_engine/server/dependencies.py,sha256=7yGYWxqbL4xNafpj8g8-S-TQ_GmGlPnSB_wRbW_lfMA,824
+idun_agent_engine/server/lifespan.py,sha256=BC914qErOmKLNZY0-XkMkYnA0aVhLZFY7nhpKXx2D_g,1301
+idun_agent_engine/server/server_config.py,sha256=RYA7Y0c5aRw_WXaX8svFUIEtTPqzn3o-WQRm2p52C6g,213
+idun_agent_engine/server/routers/__init__.py,sha256=BgNzSVvHtGPGn5zhXhomwpKlDYBkeFi7xCbdcWVOgc8,102
+idun_agent_engine/server/routers/agent.py,sha256=7vVzhnKXYv6yZEKP8o-ETMWhIa0Hd2qyMu63MhoiLL0,2361
+idun_agent_engine/server/routers/base.py,sha256=BWueBPN7ecdNWOyQaxpdpnd6GxOcN78N8bFWN_aNgmU,1899
+idun_agent_engine-0.2.1.dist-info/METADATA,sha256=MyA8VwWdZt3rfzpWGxJyBnGOb79CvDuWbXZevUQK6Nw,8536
+idun_agent_engine-0.2.1.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+idun_agent_engine-0.2.1.dist-info/RECORD,,

{idun_agent_engine-0.1.0.dist-info → idun_agent_engine-0.2.1.dist-info}/WHEEL

@@ -1,4 +1,4 @@
 Wheel-Version: 1.0
-Generator: poetry-core 2.1.3
+Generator: hatchling 1.27.0
 Root-Is-Purelib: true
 Tag: py3-none-any

idun_agent_engine-0.1.0.dist-info/METADATA

@@ -1,317 +0,0 @@
-Metadata-Version: 2.3
-Name: idun-agent-engine
-Version: 0.1.0
-Summary: Python SDK and runtime to serve AI agents with FastAPI, LangGraph, and observability.
-License: MIT
-Keywords: agents,langgraph,fastapi,sdk,llm,observability
-Author: Geoffrey HARRAZI
-Author-email: geoffreyharrazi@gmail.com
-Requires-Python: >=3.13,<3.14
-Classifier: Framework :: FastAPI
-Classifier: Intended Audience :: Developers
-Classifier: License :: OSI Approved :: MIT License
-Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.13
-Classifier: Programming Language :: Python :: 3 :: Only
-Classifier: Topic :: Software Development :: Libraries
-Classifier: Typing :: Typed
-Requires-Dist: ag-ui-protocol (>=0.1.8,<0.2.0)
-Requires-Dist: aiosqlite (>=0.21.0,<0.22.0)
-Requires-Dist: arize-phoenix (>=11.22.0,<12.0.0)
-Requires-Dist: arize-phoenix-otel (>=0.2.0,<1.0.0)
-Requires-Dist: fastapi (>=0.116.1,<0.117.0)
-Requires-Dist: google-adk (>=1.9.0,<2.0.0)
-Requires-Dist: httpx (>=0.28.1,<0.29.0)
-Requires-Dist: langchain (>=0.3.27,<0.4.0)
-Requires-Dist: langchain-core (>=0.3.72,<0.4.0)
-Requires-Dist: langchain-google-vertexai (>=2.0.27,<3.0.0)
-Requires-Dist: langfuse (>=3.2.2,<4.0.0)
-Requires-Dist: langgraph (>=0.6.3,<0.7.0)
-Requires-Dist: langgraph-checkpoint-sqlite (>=2.0.11,<3.0.0)
-Requires-Dist: openinference-instrumentation-langchain (>=0.1.13,<1.0.0)
-Requires-Dist: pydantic (>=2.11.7,<3.0.0)
-Requires-Dist: streamlit (>=1.47.1,<2.0.0)
-Requires-Dist: uvicorn (>=0.35.0,<0.36.0)
-Project-URL: Documentation, https://github.com/geoffreyharrazi/idun-agent-manager/tree/main/libs/idun_agent_engine
-Project-URL: Homepage, https://github.com/geoffreyharrazi/idun-agent-manager
-Project-URL: Issues, https://github.com/geoffreyharrazi/idun-agent-manager/issues
-Project-URL: Repository, https://github.com/geoffreyharrazi/idun-agent-manager
-Description-Content-Type: text/markdown
-
-# Idun Agent Engine - User Guide
-
-The Idun Agent Engine provides a simple, powerful way to turn your conversational AI agents into production-ready web services. With just a few lines of code, you can expose your LangGraph, CrewAI, or custom agents through a FastAPI server with built-in features like streaming, persistence, and monitoring.
-
-## 🚀 Quick Start
-
-### Installation
-```bash
-pip install idun-agent-engine
-```
-
-### Basic Usage
-
-```python
-from idun_agent_engine import create_app, run_server
-
-# Create your FastAPI app with your agent
-app = create_app(config_path="config.yaml")
-
-# Run the server
-run_server(app, port=8000)
-```
-
-That's it! Your agent is now running at `http://localhost:8000` with full API documentation at `http://localhost:8000/docs`.
-
-## 📋 Configuration
-
-### Option 1: YAML Configuration File
-
-Create a `config.yaml` file:
-
-```yaml
-engine:
-  api:
-    port: 8000
-  telemetry:
-    provider: "langfuse"
-
-agent:
-  type: "langgraph"
-  config:
-    name: "My Awesome Agent"
-    graph_definition: "my_agent.py:graph"
-    checkpointer:
-      type: "sqlite"
-      db_url: "sqlite:///agent.db"
-```
-
-### Option 2: Programmatic Configuration
-
-```python
-from idun_agent_engine import ConfigBuilder, create_app, run_server
-
-config = (ConfigBuilder()
-          .with_api_port(8080)
-          .with_langgraph_agent(
-              name="My Agent",
-              graph_definition="my_agent.py:graph",
-              sqlite_checkpointer="agent.db")
-          .build())
-
-app = create_app(config_dict=config)
-run_server(app)
-```
-
-## 🤖 Supported Agent Types
-
-### LangGraph Agents
-
-```python
-# Your LangGraph agent file (my_agent.py)
-from langgraph.graph import StateGraph, END
-from typing import TypedDict
-
-class AgentState(TypedDict):
-    messages: list
-
-def my_node(state):
-    # Your agent logic here
-    return {"messages": [("ai", "Hello from LangGraph!")]}
-
-graph = StateGraph(AgentState)
-graph.add_node("agent", my_node)
-graph.set_entry_point("agent")
-graph.add_edge("agent", END)
-```
-
-### Future Agent Types
-- CrewAI agents (coming soon)
-- AutoGen agents (coming soon)
-- Custom agent implementations
-
-## 🌐 API Endpoints
-
-Once your server is running, you get these endpoints automatically:
-
-### POST `/agent/invoke`
-Send a single message and get a complete response:
-
-```bash
-curl -X POST "http://localhost:8000/agent/invoke" \
-  -H "Content-Type: application/json" \
-  -d '{
-    "query": "Hello, how are you?",
-    "session_id": "user-123"
-  }'
-```
-
-### POST `/agent/stream`
-Stream responses in real-time:
-
-```bash
-curl -X POST "http://localhost:8000/agent/stream" \
-  -H "Content-Type: application/json" \
-  -d '{
-    "query": "Tell me a story",
-    "session_id": "user-123"
-  }'
-```
-
-### GET `/health`
-Health check for monitoring:
-
-```bash
-curl "http://localhost:8000/health"
-```
-
-## 🔧 Advanced Usage
-
-### Development Mode
-```python
-# Enable auto-reload for development
-run_server(app, reload=True)
-```
-
-### Production Deployment
-```python
-# Run with multiple workers for production
-run_server(app, workers=4, host="0.0.0.0", port=8000)
-```
-
-### One-Line Server
-```python
-from idun_agent_engine.core.server_runner import run_server_from_config
-
-# Create and run server in one call
-run_server_from_config("config.yaml", port=8080, reload=True)
-```
-
-### Custom FastAPI Configuration
-```python
-from idun_agent_engine import create_app
-from fastapi.middleware.cors import CORSMiddleware
-
-app = create_app("config.yaml")
-
-# Add custom middleware
-app.add_middleware(
-    CORSMiddleware,
-    allow_origins=["*"],
-    allow_methods=["*"],
-    allow_headers=["*"],
-)
-
-# Add custom routes
-@app.get("/custom")
-def custom_endpoint():
-    return {"message": "Custom endpoint"}
-```
-
-## 🛠️ Configuration Reference
-
-### Engine Configuration
-```yaml
-engine:
-  api:
-    port: 8000                    # Server port
-  telemetry:
-    provider: "langfuse"          # Telemetry provider
-```
-
-### LangGraph Agent Configuration
-```yaml
-agent:
-  type: "langgraph"
-  config:
-    name: "Agent Name"            # Human-readable name
-    graph_definition: "path.py:graph"  # Path to your graph
-    checkpointer:                 # Optional persistence
-      type: "sqlite"
-      db_url: "sqlite:///agent.db"
-    store:                        # Optional store (future)
-      type: "memory"
-```
-
-## 📚 Examples
-
-Check out the `examples/` directory for complete working examples:
-
-- **Basic LangGraph Agent**: Simple question-answering agent
-- **ConfigBuilder Usage**: Programmatic configuration
-- **Custom Middleware**: Adding authentication and CORS
-- **Production Setup**: Multi-worker deployment configuration
-
-## 🔍 Validation and Debugging
-
-```python
-from idun_agent_engine.utils.validation import validate_config_dict, diagnose_setup
-
-# Validate your configuration
-config = {...}
-errors = validate_config_dict(config)
-if errors:
-    print("Configuration errors:", errors)
-
-# Diagnose your setup
-diagnosis = diagnose_setup()
-print("System diagnosis:", diagnosis)
-```
-
-## 🚀 Deployment
-
-### Docker
-```dockerfile
-FROM python:3.11-slim
-
-COPY requirements.txt .
-RUN pip install -r requirements.txt
-
-COPY . .
-
-CMD ["python", "-m", "idun_agent_engine", "run", "config.yaml"]
-```
-
-### Cloud Platforms
-- Heroku: `Procfile` with `web: python main.py`
-- Railway: Deploy with one click
-- AWS Lambda: Use with Mangum adapter
-- Google Cloud Run: Deploy Docker container
-
-## 🤝 Contributing
-
-The Idun Agent Engine is designed to be extensible. To add support for new agent frameworks:
-
-1. Implement the `BaseAgent` interface
-2. Add configuration models for your agent type
-3. Register your agent in the factory
-4. Submit a pull request!
-
-## 📖 Documentation
-
-- [Full API Documentation](https://docs.idun-agent-engine.com)
-- [Agent Framework Guide](https://docs.idun-agent-engine.com/frameworks)
-- [Deployment Guide](https://docs.idun-agent-engine.com/deployment)
-- [Contributing Guide](https://docs.idun-agent-engine.com/contributing)
-
-## 📄 License
-
-MIT License - see LICENSE file for details.
-
----
-
-### Release & Publishing
-
-This package is built with Poetry. To publish a new release to PyPI:
-
-1. Update version in `pyproject.toml`.
-2. Commit and tag with the pattern `idun-agent-engine-vX.Y.Z`.
-3. Push the tag to GitHub. The `Publish idun-agent-engine` workflow will build and publish to PyPI using `PYPI_API_TOKEN` secret.
-
-Manual build (optional):
-
-```bash
-cd libs/idun_agent_engine
-poetry build
-```
-

idun_agent_engine-0.1.0.dist-info/RECORD

@@ -1,6 +0,0 @@
-idun_agent_engine/__init__.py,sha256=26POsr5dcEKjaasCyghn5xq1iBnEzyripAj-OaKhFrI,1471
-idun_agent_engine/_version.py,sha256=6TpxMitT_P6rTobGO07lWrTBf1CNK8giofFXhNSBnS0,72
-idun_agent_engine/py.typed,sha256=cJop7713r6RxY0ks5pWo7USgH7UFlZsBhyByVzA4q_o,61
-idun_agent_engine-0.1.0.dist-info/METADATA,sha256=2he27WE8SahXhQPOj5rTQDLJuCtc535x3c-IC4zozzU,8306
-idun_agent_engine-0.1.0.dist-info/WHEEL,sha256=b4K_helf-jlQoXBBETfwnf4B04YC67LOev0jo4fX5m8,88
-idun_agent_engine-0.1.0.dist-info/RECORD,,