smartify-ai 0.1.0__tar.gz

smartify_ai-0.1.0/.gitignore

@@ -0,0 +1,34 @@
+# Python
+.venv/
+venv/
+env/
+__pycache__/
+*.py[cod]
+*.pyo
+.pytest_cache/
+.mypy_cache/
+*.egg-info/
+.eggs/
+dist/
+build/
+
+# Local state and secrets
+*.db
+smartify_state.db
+.env
+.env.*
+!.env.example
+*.local
+
+# OS and IDE
+.DS_Store
+.idea/
+.vscode/
+*.swp
+*.swo
+*~
+
+# Coverage and tools
+coverage.xml
+htmlcov/
+.ruff_cache/

smartify_ai-0.1.0/DESIGN.md

@@ -0,0 +1,389 @@
+# Smartify Runtime MVP - Design Document
+
+**Author:** Umbra  
+**Date:** 2026-02-01  
+**Status:** Draft
+
+## Overview
+
+Build a 100% local Python-based MVP runtime for the Smartify Grid specification. This runtime will orchestrate AI agents with guardrails, execute tasks in parallel, and optionally run workloads in an isolated sandbox container.
+
+**Goals:**
+- Parse and validate Grid YAML specifications
+- Orchestrate agent execution following the Grid topology
+- Enforce guardrails (token/time/cost limits, breakers)
+- Support parallel task execution
+- API and CLI interface only (no UI)
+
+---
+
+## Grid Specification Summary
+
+### Root Structure
+```yaml
+apiVersion: smartify.ai/v1
+kind: GridSpec
+metadata:       # Required - Grid identification
+topology:       # Required - Node graph structure
+inputs:         # Optional - Input parameters
+environment:    # Optional - Variables and secrets
+outputs:        # Optional - Artifacts and success criteria
+agents:         # Optional - Agent definitions
+tools:          # Optional - Tool configuration
+guardrails:     # Optional - Limits and breaker actions
+workspace:      # Optional - Execution environment
+coordination:   # Optional - State management
+observability:  # Optional - Logging and events
+ui:             # Optional - Dashboard hints
+```
+
+### Grid States
+```
+draft → ready → energized → running → completed
+                    ↓
+              (paused | stopped | failed)
+```
+
+### Node Types
+
+**Agent-driven (user-defined):**
+- `controller` - Primary orchestrator (exactly 1 per grid)
+- `relay` - Coordination/delegation node (parent: controller)
+- `substation` - Task execution node (parent: relay)
+
+**Runtime-only (not user-defined):**
+- `spark` - Ephemeral helpers spawned automatically by substations
+
+**Deterministic nodes:**
+- `foreach` - Fan-out iteration over a list
+- `expr` - Expression evaluation
+- `aggregate` - Fan-in merge of outputs
+- `approval` - Human-in-the-loop checkpoint
+
+### Hierarchy
+```
+Grid
+ └── Controller (1)
+      └── Relay(s) (0-N)
+           └── Substation(s) (0-N)
+                └── Spark(s) (runtime-spawned, 0-N)
+```
+
+### Breaker Types
+| Type | Monitors |
+|------|----------|
+| `tokens` | Input/output token usage |
+| `time` | Runtime duration and task duration |
+| `cost` | API cost per run and per day |
+| `requests` | Requests per minute and concurrent agents |
+
+**Breaker Status:** `ok` → `warning` (>80%) → `tripped` (>=100%)
+
+**Trip Actions:** `notify`, `pause`, `cooldown`, `require_approval`, `stop`, `downgrade`, `block`
+
+### Autonomy Modes
+- `observe` - Read-only, no modifications
+- `recommend` - Suggest changes, require approval
+- `act_with_limits` - Execute within guardrails
+- `full_autonomy` - Execute without restrictions
+
+### Trigger Types
+- `manual` - Started by user action
+- `schedule` - Started on a cron schedule
+- `webhook` - Started by HTTP webhook
+- `event` - Started by system event
+
+### Assignment Lifecycle
+```
+assigned → accepted → executing → completed
+              ↓
+          blocked → accepted (when unblocked)
+```
+
+### Inbox Items
+- `assignment_delivery` - New work to process
+- `signal` - Control messages (pause, resume, stop)
+- `output` - Results from other nodes
+
+---
+
+## Architecture
+
+### Core Components
+
+```
+┌─────────────────────────────────────────────────────────────────────┐
+│                      Smartify Runtime                                │
+├─────────────────────────────────────────────────────────────────────┤
+│                                                                      │
+│  ┌──────────────┐  ┌──────────────┐  ┌──────────────────────────┐  │
+│  │   CLI        │  │   API        │  │   Validator              │  │
+│  │   Interface  │  │   Server     │  │   (Grid Spec Checker)    │  │
+│  └──────┬───────┘  └──────┬───────┘  └──────────────────────────┘  │
+│         │                 │                                         │
+│         └────────┬────────┘                                         │
+│                  │                                                   │
+│         ┌────────▼────────┐                                         │
+│         │   Grid Engine   │                                         │
+│         │   (Orchestrator)│                                         │
+│         └────────┬────────┘                                         │
+│                  │                                                   │
+│    ┌─────────────┼─────────────┐                                    │
+│    │             │             │                                    │
+│    ▼             ▼             ▼                                    │
+│ ┌──────┐   ┌──────────┐   ┌──────────┐                             │
+│ │State │   │Scheduler │   │Guardrails│                             │
+│ │Store │   │(DAG)     │   │Monitor   │                             │
+│ └──────┘   └────┬─────┘   └──────────┘                             │
+│                 │                                                   │
+│         ┌───────┴───────┐                                          │
+│         │               │                                          │
+│         ▼               ▼                                          │
+│   ┌──────────┐   ┌──────────────┐                                  │
+│   │  Agent   │   │   Tool       │                                  │
+│   │  Runner  │   │   Registry   │                                  │
+│   └────┬─────┘   └──────────────┘                                  │
+│        │                                                            │
+│        ▼                                                            │
+│   ┌──────────────────────────────────┐                             │
+│   │     LLM Provider Adapters        │                             │
+│   │  (Anthropic, OpenAI, etc.)       │                             │
+│   └──────────────────────────────────┘                             │
+│                                                                     │
+└─────────────────────────────────────────────────────────────────────┘
+                              │
+                              ▼
+                    ┌─────────────────┐
+                    │  Sandbox        │
+                    │  Container      │
+                    │  (Optional)     │
+                    └─────────────────┘
+```
+
+### Module Breakdown
+
+1. **CLI Interface** (`smartify/cli/`)
+   - `main.py` - Entry point, argument parsing
+   - `run.py` - Run a grid from YAML file
+   - `validate.py` - Validate grid spec
+   - `status.py` - Check running grid status
+   - `stop.py` - Stop a running grid
+
+2. **API Server** (`smartify/api/`)
+   - FastAPI-based REST API
+   - Endpoints: `/grids`, `/runs`, `/status`, `/control`
+   - WebSocket for real-time updates (optional for MVP)
+
+3. **Validator** (`smartify/validator/`)
+   - Schema validation (JSON Schema or Pydantic)
+   - Semantic validation (topology consistency, no cycles, etc.)
+   - Warning/error reporting
+
+4. **Grid Engine** (`smartify/engine/`)
+   - `grid.py` - Grid state machine
+   - `orchestrator.py` - Main execution loop
+   - `scheduler.py` - DAG-based task scheduling
+   - `executor.py` - Node execution dispatch
+
+5. **State Store** (`smartify/state/`)
+   - In-memory store (MVP)
+   - SQLite persistence (optional)
+   - Grid state, node states, assignment tracking
+
+6. **Agent Runner** (`smartify/agents/`)
+   - `runner.py` - Agent execution wrapper
+   - `adapters/` - LLM provider adapters (Anthropic, OpenAI)
+   - `prompts/` - Built-in system prompts
+
+7. **Guardrails** (`smartify/guardrails/`)
+   - `breakers.py` - Breaker implementation
+   - `monitor.py` - Token/time/cost tracking
+   - `actions.py` - Trip action handlers
+
+8. **Tools** (`smartify/tools/`)
+   - `registry.py` - Tool registration
+   - `builtin/` - Built-in tools (terminal, filesystem, git, browser)
+
+9. **Workspace** (`smartify/workspace/`)
+   - `local.py` - Local filesystem workspace
+   - `container.py` - Docker container workspace
+   - `sandbox.py` - Sandbox integration
+
+---
+
+## Data Models (Pydantic)
+
+```python
+# Core models
+class GridSpec(BaseModel):
+    apiVersion: str = "smartify.ai/v1"
+    kind: str = "GridSpec"
+    metadata: MetadataSpec
+    topology: TopologySpec
+    inputs: Optional[List[InputSpec]]
+    environment: Optional[EnvironmentSpec]
+    outputs: Optional[OutputsSpec]
+    agents: Optional[Dict[str, AgentSpec]]
+    tools: Optional[ToolsSpec]
+    guardrails: Optional[GuardrailsSpec]
+    workspace: Optional[WorkspaceSpec]
+
+class NodeSpec(BaseModel):
+    id: str
+    kind: NodeKind  # controller, relay, substation, foreach, expr, aggregate, approval
+    name: str
+    description: Optional[str]
+    parent: Optional[str]
+    agent: Optional[str]
+    capabilities: List[str] = []
+    when: Optional[str]  # Expression
+    parallel: bool = True
+    runAfter: Optional[List[str]]
+    retry: Optional[RetrySpec]
+    outputSchema: Optional[dict]
+
+class BreakerSpec(BaseModel):
+    tokens: Optional[TokenLimits]
+    time: Optional[TimeLimits]
+    cost: Optional[CostLimits]
+    requests: Optional[RequestLimits]
+
+class BreakerActions(BaseModel):
+    onTokensLimit: TripAction = TripAction.PAUSE
+    onTimeLimit: TripAction = TripAction.STOP
+    onCostLimit: TripAction = TripAction.PAUSE
+    onRequestsLimit: TripAction = TripAction.COOLDOWN
+```
+
+---
+
+## MVP Scope
+
+### Phase 1: Core Infrastructure (Week 1)
+- [ ] Grid YAML parsing and validation
+- [ ] Pydantic models for all spec types
+- [ ] CLI skeleton (validate, run)
+- [ ] In-memory state store
+
+### Phase 2: Execution Engine (Week 1-2)
+- [ ] DAG-based scheduler
+- [ ] Node execution dispatch
+- [ ] Assignment delivery system
+- [ ] Parent-child execution flow
+
+### Phase 3: Agent Integration (Week 2)
+- [ ] LLM provider adapters (start with Anthropic)
+- [ ] Built-in system prompts
+- [ ] Tool execution framework
+- [ ] Basic tools (terminal, filesystem)
+
+### Phase 4: Guardrails (Week 2-3)
+- [ ] Token counting and limits
+- [ ] Time tracking
+- [ ] Breaker implementation
+- [ ] Trip actions (pause, stop, notify)
+
+### Phase 5: Polish & Testing (Week 3-4)
+- [ ] API server
+- [ ] Comprehensive validation
+- [ ] Error handling
+- [ ] Test suite
+- [ ] Documentation
+
+---
+
+## CLI Commands
+
+```bash
+# Validate a grid spec
+smartify validate grid.yaml
+
+# Run a grid
+smartify run grid.yaml --input project_name=myapp
+
+# Check status of running grid
+smartify status <run_id>
+
+# Stop a running grid
+smartify stop <run_id>
+
+# List recent runs
+smartify list
+
+# Show grid info
+smartify info grid.yaml
+```
+
+---
+
+## API Endpoints
+
+```
+POST   /api/v1/grids              # Create/upload grid spec
+GET    /api/v1/grids              # List grids
+GET    /api/v1/grids/{id}         # Get grid details
+DELETE /api/v1/grids/{id}         # Delete grid
+
+POST   /api/v1/runs               # Start a grid run
+GET    /api/v1/runs               # List runs
+GET    /api/v1/runs/{id}          # Get run status
+POST   /api/v1/runs/{id}/control  # pause, resume, stop
+GET    /api/v1/runs/{id}/nodes    # List node states
+GET    /api/v1/runs/{id}/logs     # Get execution logs
+
+POST   /api/v1/validate           # Validate a grid spec
+```
+
+---
+
+## Sandbox Integration
+
+The runtime can optionally execute agent tasks in an isolated Docker container (similar to the sandbox we built). Configuration via `workspace` section:
+
+```yaml
+workspace:
+  type: container
+  config:
+    image: smartify-sandbox:latest
+    resources:
+      cpus: 2
+      memoryMb: 4096
+    mounts:
+      - src: ./output
+        dst: /workspace/output
+```
+
+---
+
+## Key Design Decisions
+
+1. **Python-based** - Easier integration with ML/AI ecosystem, fast development
+2. **Pydantic for validation** - Strong typing, automatic validation, serialization
+3. **DAG scheduler** - Natural fit for topology with dependencies
+4. **In-memory first** - Fast iteration, add persistence later
+5. **Adapter pattern for LLMs** - Easy to add new providers
+6. **Built-in tools** - Start minimal, expand based on need
+
+---
+
+## Risks & Mitigations
+
+| Risk | Mitigation |
+|------|------------|
+| Scope creep | Strict MVP scope, defer features to backlog |
+| LLM rate limits | Implement proper backoff, cost tracking |
+| Container overhead | Make sandbox optional, default to local |
+| Complex topologies | Start with simple parent-child, add edges later |
+
+---
+
+## Next Steps
+
+1. Set up Python project structure
+2. Implement Pydantic models for Grid spec
+3. Build validator CLI command
+4. Implement basic orchestrator
+5. Add Anthropic adapter
+6. Implement breakers
+7. Build API server
+8. Test with example grids

smartify_ai-0.1.0/GAPS.md

@@ -0,0 +1,59 @@
+# Smartify Runtime - Implementation Status
+
+## Current Status
+- **Tests:** 170/170 passing ✅
+- **LOC:** ~8,500 lines Python
+- **Core:** Orchestrator, Scheduler, Validator, API Server, Anthropic + OpenAI Adapters, Breakers, Tool Registry + Builtins, State Store, Webhook Notifications, Checkpoint/Resume
+
+## Completed ✅
+
+### 1. Builtin Tools (`tools/`)
+- `ToolRegistry` - Registration, lookup, format conversion
+- `ShellTool` - Command execution with timeout, security checks
+- `FileReadTool` / `FileWriteTool` / `FileListTool` / `FileDeleteTool`  
+- `HttpTool` - HTTP requests with host filtering
+- Integrated into orchestrator
+
+### 2. State Persistence (`state/`)
+- `RunRecord` / `NodeOutput` data classes
+- `InMemoryStore` - For testing
+- `SQLiteStore` - Persistent storage with full CRUD
+- Run history, status tracking, cost/token aggregation
+
+### 3. Validator Improvements
+- Pre-validation for required fields (apiVersion, metadata.id, etc.)
+- 11 error detection tests passing
+- Catches: missing fields, duplicate IDs, invalid parents, cycles
+
+### 4. CLI Commands
+- `validate` - Grid validation ✅
+- `run` - Execute grids ✅
+- `status` - Check run status ✅
+- `stop` - Stop running grids ✅
+- `list` - List runs with filters ✅
+- `serve` - API server ✅
+- `info` - Grid inspection ✅
+
+### 5. Example Grids
+- `minimal.yaml` - Basic single-controller grid
+- `file-creator.yaml` - Tool execution test
+- `parallel-swarm.yaml` - Multi-agent parallel execution with guardrails
+
+## Remaining Gaps
+
+### Medium Priority
+- **Workspace isolation** - Sandboxed file operations per run
+- **Spark nodes** - Dynamic node spawning
+- **Approval flow** - Notifications, webhook callbacks
+
+### Lower Priority
+- **Retry improvements** - Exponential backoff, configurable strategies
+- **Streaming output** - Real-time node progress
+- **Metrics export** - Prometheus/OpenTelemetry integration
+
+## E2E Verified
+- Grid loading and validation
+- Orchestrator lifecycle (draft → energized → running → completed)
+- Tool execution (file_write creates files)
+- Parallel node execution
+- Token/cost tracking

smartify_ai-0.1.0/LAUNCH_PLAN.md

@@ -0,0 +1,144 @@
+# Smartify Runtime — Launch Plan
+
+Plan for open-source launch: MCP integration, repo cleanup, and license/docs alignment.
+
+---
+
+## 1. MCP (Model Context Protocol) Integration
+
+**Goal:** Allow grids to use tools from external MCP servers so existing MCP integrations work plug-and-play with Smartify agent swarms.
+
+**Reference:** [MCP Python SDK](https://github.com/modelcontextprotocol/python-sdk) — official client; supports stdio, SSE, Streamable HTTP. Install: `pip install mcp` (Python ≥3.10).
+
+### 1.1 Architecture
+
+- **MCP as tool source:** One or more MCP servers are configured per run (or globally). The runtime connects as an MCP **client**, calls `tools/list` to discover tools, and exposes each MCP tool as a Smartify `Tool` so the existing `ToolRegistry` and orchestrator can use them.
+- **Adapter pattern:** Add `McpToolAdapter` (or `McpServerBridge`) that:
+  - Connects to an MCP server (stdio command, SSE URL, or Streamable HTTP URL).
+  - Lists tools via MCP `tools/list`.
+  - For each MCP tool, creates a wrapper that implements Smartify's `Tool` interface (`name`, `description`, `parameters` from MCP schema, `execute` → MCP `tools/call`).
+- **Naming:** MCP tools can clash with builtins. Use a prefix per server (e.g. `mcp_fileread` for server label `mcp`) or a configurable prefix in grid/context so nodes can refer to `mcp_fileread` or `filesystem.read_file`.
+
+### 1.2 Phases
+
+#### Phase A: Dependency and MCP client wrapper (foundation)
+
+- [x] Add optional dependency: `mcp` in `pyproject.toml` (e.g. `mcp>=1.0` in `[project.optional-dependencies]` as `mcp` or under `integrations`).
+- [x] Create `src/smartify/tools/mcp/` package:
+  - [x] `__init__.py` — export public API.
+  - [x] `client.py` — thin wrapper around MCP Python SDK client:
+    - Connect (stdio command list, or SSE/HTTP URL) from config.
+    - `list_tools() -> List[McpToolDef]` (name, description, parameters schema).
+    - `call_tool(name: str, arguments: dict) -> ToolResult` (async).
+  - [x] Handle connection lifecycle (connect when building registry or on first use; disconnect on shutdown or run end). Prefer one client per MCP server process/URL.
+
+#### Phase B: Smartify `Tool` adapter for MCP
+
+- [x] In `src/smartify/tools/mcp/`, add `adapter.py`:
+  - [x] Class `McpToolWrapper(Tool)`:
+    - Takes an MCP client (or server session) + one MCP tool definition.
+    - `name`: MCP tool name, optionally prefixed (e.g. `mcp_filesystem_read`) to avoid clashes.
+    - `description`, `parameters`: from MCP tool definition (map to our JSON Schema shape if needed).
+    - `execute(**kwargs)`: call MCP `tools/call` with the tool name and kwargs; map MCP result (e.g. content list or error) to `ToolResult(success=..., output=..., error=...)`.
+  - [x] Add tests (unit: mock MCP client; optional integration: real MCP server in CI or behind `pytest -m mcp`).
+
+#### Phase C: Registry integration
+
+- [x] Add `McpRegistryBuilder` or a function `register_mcp_server(registry: ToolRegistry, config: McpServerConfig) -> None`:
+  - Connect to MCP server, list tools, create `McpToolWrapper` per tool, `registry.register(wrapper)` for each.
+  - Config: transport type (stdio / sse / streamable_http), command or URL, optional tool name prefix, optional allow-list of tool names.
+- [x] Ensure `create_builtin_registry()` (or the factory used by the orchestrator) can accept optional MCP configs and call `register_mcp_server` for each, so builtins + MCP tools are in one registry.
+
+#### Phase D: Grid YAML and runtime wiring
+
+- [x] Extend grid spec (e.g. in `models/grid.py`):
+  - [x] Add `McpServerSpec` (e.g. `id`, `transport: stdio | sse | streamable_http`, `command` or `url`, optional `prefix`, optional `tools: [names]`).
+  - [x] In `ToolsSpec`, add `mcpServers: List[McpServerSpec]` (or under `tools.mcp`).
+- [x] Validator: validate `mcpServers` entries (required fields, valid transport).
+- [x] Orchestrator (or the place that builds `ToolRegistry` for a run):
+  - [x] When building the registry for a run, read grid's `tools.mcpServers` (or equivalent), and for each server call `register_mcp_server(registry, server_config)`.
+  - [x] If MCP is optional dependency, catch import error and raise a clear "install smartify[mcp] to use MCP servers" (or similar).
+- [x] Document in README: "Using MCP servers" with a small example (one stdio server and one tool used in a grid).
+
+#### Phase E: Docs and optional extras
+
+- [x] README section: "Tool integrations" — builtins + MCP; link to MCP spec/sdk.
+- [x] Example grid YAML that uses one MCP server (e.g. filesystem or a simple test server) so users can run it with `smartify run examples/grid-with-mcp.yaml`.
+- [x] Optional: `smartify[mcp]` or `smartify[integrations]` extra in pyproject so MCP is opt-in for minimal installs.
+
+### 1.3 Out of scope for initial launch (backlog)
+
+- MCP resources/prompts (only tools first).
+- Dynamic tool approval for MCP calls (can add later if needed).
+- Caching or connection pooling across runs (keep simple: connect per run or per process).
+
+---
+
+## 2. Repo cleanup (pre-push)
+
+### 2.1 Add a proper `.gitignore`
+
+- [x] Add `.gitignore` at repo root with:
+  - Python: `.venv/`, `venv/`, `env/`, `__pycache__/`, `*.py[cod]`, `*.pyo`, `.pytest_cache/`, `.mypy_cache/`, `*.egg-info/`, `dist/`, `build/`
+  - Local data: `*.db`, `smartify_state.db`, `.env`, `*.local`
+  - OS/IDE: `.DS_Store`, `.idea/`, `*.swp`, `*.swo`
+  - Optional: `coverage.xml`, `htmlcov/` if you use coverage
+
+### 2.2 Files to delete before pushing to Git
+
+- [x] **`ai_healthcare_research.md`** — domain-specific research; not part of runtime.
+- [x] **`AI_Healthcare_Historical_Research.md`** — same.
+- [x] **`smartify_state.db`** — runtime SQLite DB; should not be committed (and is ignored via `.gitignore`).
+- [x] **`.DS_Store`** — macOS metadata (and ignored).
+- **Root-level E2E scripts — keep them:**  
+  **`test_e2e.py`**, **`test_e2e_tools.py`**, **`test_parallel_swarm.py`** are manual smoke tests that run the **actual example YAML files** (`examples/minimal.yaml`, `file-creator.yaml`, `parallel-swarm.yaml`) with a real API. They complement `tests/test_integration_live.py` (which uses inline YAML and pytest). Use them for quick checks after changing examples: `python test_e2e.py`, `python test_e2e_tools.py`, `python test_parallel_swarm.py "topic"`.
+
+### 2.3 Optional
+
+- Move or trim **`GAPS.md`** (e.g. move to `docs/` or fold into README "Roadmap") so the repo reads as launch-ready.
+
+---
+
+## 3. License and project alignment
+
+### 3.1 Add LICENSE file
+
+- [x] Add **`LICENSE`** at repo root.
+- [x] Use **MIT** to match `pyproject.toml` (already "MIT" and "License :: OSI Approved :: MIT License").
+- [x] In LICENSE, set **Copyright (c) YEAR Smartify** (or your legal entity) and keep standard MIT text.
+
+### 3.2 Align README and pyproject.toml
+
+- [x] **README.md:** Change "License" section from "BSL 1.1" to **"MIT"** and add a one-line pointer: "See [LICENSE](LICENSE)."
+- [x] **pyproject.toml:** Leave as-is (already MIT); no change unless you later switch to BSL 1.1 (then update both LICENSE file and both docs).
+
+---
+
+## Checklist summary
+
+| Item | Status |
+|------|--------|
+| **LAUNCH_PLAN.md** (this file) | ✅ Done |
+| **.gitignore** | ✅ Done |
+| Delete healthcare research files | ✅ Done |
+| Delete `smartify_state.db` / .DS_Store | ✅ Done |
+| Keep root-level E2E scripts (restored) | ✅ Done |
+| **LICENSE** (MIT) | ✅ Done |
+| README license → MIT | ✅ Done |
+| **MCP integration** | ✅ Done |
+
+---
+
+## MCP Integration Complete
+
+All phases implemented:
+
+- **Phase A**: Added optional `mcp` dependency in pyproject.toml; created `src/smartify/tools/mcp/` package with `client.py` (MCP client wrapper supporting stdio/sse/streamable_http).
+- **Phase B**: Created `adapter.py` with `McpToolWrapper(Tool)` that wraps MCP tools for use in Smartify.
+- **Phase C**: Created `registry.py` with `register_mcp_server()` function to register MCP server tools into a ToolRegistry.
+- **Phase D**: Added `McpServerSpec` to `models/grid.py`, added `mcpServers` to `ToolsSpec`, wired orchestrator to auto-register MCP servers on `energize()`.
+- **Phase E**: Updated README with MCP section, added `examples/mcp-filesystem.yaml`, added `tests/test_mcp.py` (14 tests passing).
+
+**Tests**: 355 passing (excluding OpenAI adapter tests with pre-existing httpx version conflict from mcp package).
+
+The repo is now ready for open-source launch with "plug and play with existing tool integrations and MCP" and multi-agent providers.

smartify_ai-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Smartify
+
+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.