deep-agentic-core-mcp 0.1.0__tar.gz

deep_agentic_core_mcp-0.1.0/.github/workflows/ci.yml

@@ -0,0 +1,36 @@
+name: CI
+
+on:
+  push:
+    branches: [main]
+  pull_request:
+
+jobs:
+  test:
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        python-version: ["3.10", "3.11", "3.12"]
+    steps:
+      - uses: actions/checkout@v4
+
+      - uses: actions/setup-python@v5
+        with:
+          python-version: ${{ matrix.python-version }}
+
+      - name: Install dependencies
+        run: |
+          python -m pip install --upgrade pip
+          python -m pip install -e ".[dev]"
+
+      - name: Lint (ruff check)
+        run: ruff check .
+
+      - name: Format check (ruff format)
+        run: ruff format --check .
+
+      - name: Type check (mypy)
+        run: mypy
+
+      - name: Test (pytest)
+        run: pytest --cov

deep_agentic_core_mcp-0.1.0/.github/workflows/release-pypi.yml

@@ -0,0 +1,46 @@
+name: publish-pypi
+
+on:
+  release:
+    types: [published]
+  push:
+    tags:
+      - "v*"
+
+permissions:
+  contents: read
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-python@v5
+        with:
+          python-version: "3.12"
+      - name: Build distributions
+        run: |
+          python -m pip install --upgrade pip
+          python -m pip install build twine
+          python -m build
+          python -m twine check dist/*
+      - name: Upload distributions
+        uses: actions/upload-artifact@v4
+        with:
+          name: python-package-distributions
+          path: dist/
+
+  publish-pypi:
+    runs-on: ubuntu-latest
+    needs: build
+    environment: pypi
+    permissions:
+      id-token: write # required for PyPI Trusted Publishing (OIDC)
+    steps:
+      - name: Download distributions
+        uses: actions/download-artifact@v4
+        with:
+          name: python-package-distributions
+          path: dist/
+      - name: Publish to PyPI
+        uses: pypa/gh-action-pypi-publish@release/v1

deep_agentic_core_mcp-0.1.0/.gitignore

@@ -0,0 +1,10 @@
+.pytest_cache/
+.ruff_cache/
+.mypy_cache/
+.coverage
+dist/
+build/
+*.egg-info/
+.venv/
+__pycache__/
+*.pyc

deep_agentic_core_mcp-0.1.0/PKG-INFO

@@ -0,0 +1,192 @@
+Metadata-Version: 2.4
+Name: deep-agentic-core-mcp
+Version: 0.1.0
+Summary: Unified MCP server for AgenticLens and Agentic Chaos workflows.
+Project-URL: Homepage, https://github.com/DeepAgentLabs/deep-agentic-core-mcp
+Project-URL: Repository, https://github.com/DeepAgentLabs/deep-agentic-core-mcp
+Project-URL: Issues, https://github.com/DeepAgentLabs/deep-agentic-core-mcp/issues
+Author: DeepAgentLabs
+License: MIT
+Keywords: agentic-ai,chaos-engineering,llm,mcp,observability
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Python: >=3.10
+Requires-Dist: mcp>=1.10.0
+Requires-Dist: pydantic<3,>=2.0
+Provides-Extra: dev
+Requires-Dist: build>=1.2; extra == 'dev'
+Requires-Dist: mypy>=1.10; extra == 'dev'
+Requires-Dist: pytest-asyncio>=0.23; extra == 'dev'
+Requires-Dist: pytest-cov>=5.0; extra == 'dev'
+Requires-Dist: pytest>=8.0; extra == 'dev'
+Requires-Dist: ruff>=0.6; extra == 'dev'
+Requires-Dist: twine>=5.1; extra == 'dev'
+Description-Content-Type: text/markdown
+
+# deep-agentic-core-mcp
+
+`deep-agentic-core-mcp` is the shared MCP server layer for the DeepAgentLabs
+ecosystem. It is designed to expose a single MCP interface that combines:
+
+- `agenticlens` style workflow inspection, profiling, and analysis
+- `agentic-chaos` style resilience testing and fault-injection workflows
+
+The goal is one MCP server, one package, and one registry identity rather than
+separate MCP servers for each product surface.
+
+<!-- mcp-name: io.github.deepagentlabs/deep-agentic-core-mcp -->
+
+## Idea
+
+This project is the control plane between LLM hosts and the existing Python
+libraries:
+
+- `agenticlens` remains the core profiling and analysis engine
+- `agentic-chaos` remains the core chaos and resilience engine
+- `deep-agentic-core-mcp` becomes the MCP-native interface that hosts can call
+
+That means MCP clients can connect once and access both observability and chaos
+testing capabilities through one server.
+
+## What This Server Should Eventually Do
+
+Planned capability areas:
+
+- profile an agentic workflow and return structured telemetry summaries
+- analyze workflow artifacts and surface optimization recommendations
+- run controlled chaos experiments against target workflows
+- compare normal versus chaos runs
+- expose shared resources such as workflow schemas, run metadata, and saved
+  reports
+
+## Design Principles
+
+- One MCP identity: publish a single server to the MCP Registry
+- Python-first: package and publish through PyPI
+- Thin orchestration layer: reuse `agenticlens` and `agentic-chaos` instead of
+  re-implementing their logic
+- Local-first: work well as a stdio MCP server for developer workflows
+- Expandable: leave room for a later remote deployment mode if needed
+
+## Initial Scope
+
+The first milestone is foundation only:
+
+- repository structure
+- packaging metadata
+- MCP registry metadata
+- roadmap and product framing
+- minimal server entrypoint and tool layout
+
+The first working implementation can stay intentionally small while the shape of
+the tool surface stabilizes.
+
+## Proposed MCP Surface
+
+Possible first tool groups:
+
+- `lens.profile_workflow`
+- `lens.analyze_workflow`
+- `chaos.run_experiment`
+- `chaos.list_faults`
+- `core.health`
+- `core.version`
+
+These names are placeholders, but the structure matters: one server can expose
+multiple tools without needing multiple MCP packages or registry entries.
+
+## Repository Layout
+
+```text
+mcp-server/
+├── README.md
+├── ROADMAP.md
+├── pyproject.toml
+├── server.json
+├── .gitignore
+├── docs/
+│   └── architecture.md
+├── examples/
+│   └── sample_workflow.json
+├── src/
+│   └── deep_agentic_core_mcp/
+│       ├── __init__.py
+│       ├── server.py
+│       ├── config.py
+│       ├── prompts/
+│       │   ├── __init__.py
+│       │   └── registry.py
+│       ├── resources/
+│       │   ├── __init__.py
+│       │   └── catalog.py
+│       ├── schemas/
+│       │   ├── __init__.py
+│       │   └── tooling.py
+│       ├── services/
+│       │   ├── __init__.py
+│       │   └── registry.py
+│       ├── adapters/
+│       │   ├── __init__.py
+│       │   ├── agentic_chaos.py
+│       │   └── agenticlens.py
+│       └── tools/
+│           ├── __init__.py
+│           ├── registry.py
+│           ├── chaos.py
+│           ├── core.py
+│           └── lens.py
+└── tests/
+    ├── test_imports.py
+    └── test_registry.py
+```
+
+## MCP-Oriented Structure
+
+This repository should have all of the standard layers we expect for a useful
+MCP server:
+
+- `tools/` for callable MCP tools and their registration metadata
+- `resources/` for readable assets such as fault catalogs, templates, and
+  workflow examples
+- `prompts/` for reusable prompt templates exposed through the server
+- `schemas/` for typed request and response contracts
+- `services/` for shared orchestration logic that keeps tool modules thin
+- `adapters/` for integration boundaries to `agenticlens` and
+  `agentic-chaos`
+
+The implementation is still early, but the file structure now reflects that
+shape so we can add functionality without reshuffling the repo later.
+
+## Packaging and Publishing Model
+
+`deep-agentic-core-mcp` should publish in two layers:
+
+1. Publish the Python package to PyPI.
+2. Publish the MCP metadata in `server.json` to the official MCP Registry.
+
+For PyPI-based verification, the `mcp-name` marker above must match the
+`name` field in `server.json`.
+
+## Near-Term Build Order
+
+1. Lock the canonical namespace and package metadata.
+2. Implement the stdio MCP server entrypoint.
+3. Add a minimal `core.health` tool.
+4. Add the first `agenticlens` and `agentic-chaos` adapter-backed tools.
+5. Add examples and publishable packaging checks.
+
+## Notes
+
+This scaffold assumes the intended GitHub namespace is
+`io.github.deepagentlabs/deep-agentic-core-mcp`. If the final publishing
+account or org changes, update:
+
+- the `mcp-name` marker in this README
+- `server.json`
+- any repository URLs in `pyproject.toml`

deep_agentic_core_mcp-0.1.0/README.md

@@ -0,0 +1,161 @@
+# deep-agentic-core-mcp
+
+`deep-agentic-core-mcp` is the shared MCP server layer for the DeepAgentLabs
+ecosystem. It is designed to expose a single MCP interface that combines:
+
+- `agenticlens` style workflow inspection, profiling, and analysis
+- `agentic-chaos` style resilience testing and fault-injection workflows
+
+The goal is one MCP server, one package, and one registry identity rather than
+separate MCP servers for each product surface.
+
+<!-- mcp-name: io.github.deepagentlabs/deep-agentic-core-mcp -->
+
+## Idea
+
+This project is the control plane between LLM hosts and the existing Python
+libraries:
+
+- `agenticlens` remains the core profiling and analysis engine
+- `agentic-chaos` remains the core chaos and resilience engine
+- `deep-agentic-core-mcp` becomes the MCP-native interface that hosts can call
+
+That means MCP clients can connect once and access both observability and chaos
+testing capabilities through one server.
+
+## What This Server Should Eventually Do
+
+Planned capability areas:
+
+- profile an agentic workflow and return structured telemetry summaries
+- analyze workflow artifacts and surface optimization recommendations
+- run controlled chaos experiments against target workflows
+- compare normal versus chaos runs
+- expose shared resources such as workflow schemas, run metadata, and saved
+  reports
+
+## Design Principles
+
+- One MCP identity: publish a single server to the MCP Registry
+- Python-first: package and publish through PyPI
+- Thin orchestration layer: reuse `agenticlens` and `agentic-chaos` instead of
+  re-implementing their logic
+- Local-first: work well as a stdio MCP server for developer workflows
+- Expandable: leave room for a later remote deployment mode if needed
+
+## Initial Scope
+
+The first milestone is foundation only:
+
+- repository structure
+- packaging metadata
+- MCP registry metadata
+- roadmap and product framing
+- minimal server entrypoint and tool layout
+
+The first working implementation can stay intentionally small while the shape of
+the tool surface stabilizes.
+
+## Proposed MCP Surface
+
+Possible first tool groups:
+
+- `lens.profile_workflow`
+- `lens.analyze_workflow`
+- `chaos.run_experiment`
+- `chaos.list_faults`
+- `core.health`
+- `core.version`
+
+These names are placeholders, but the structure matters: one server can expose
+multiple tools without needing multiple MCP packages or registry entries.
+
+## Repository Layout
+
+```text
+mcp-server/
+├── README.md
+├── ROADMAP.md
+├── pyproject.toml
+├── server.json
+├── .gitignore
+├── docs/
+│   └── architecture.md
+├── examples/
+│   └── sample_workflow.json
+├── src/
+│   └── deep_agentic_core_mcp/
+│       ├── __init__.py
+│       ├── server.py
+│       ├── config.py
+│       ├── prompts/
+│       │   ├── __init__.py
+│       │   └── registry.py
+│       ├── resources/
+│       │   ├── __init__.py
+│       │   └── catalog.py
+│       ├── schemas/
+│       │   ├── __init__.py
+│       │   └── tooling.py
+│       ├── services/
+│       │   ├── __init__.py
+│       │   └── registry.py
+│       ├── adapters/
+│       │   ├── __init__.py
+│       │   ├── agentic_chaos.py
+│       │   └── agenticlens.py
+│       └── tools/
+│           ├── __init__.py
+│           ├── registry.py
+│           ├── chaos.py
+│           ├── core.py
+│           └── lens.py
+└── tests/
+    ├── test_imports.py
+    └── test_registry.py
+```
+
+## MCP-Oriented Structure
+
+This repository should have all of the standard layers we expect for a useful
+MCP server:
+
+- `tools/` for callable MCP tools and their registration metadata
+- `resources/` for readable assets such as fault catalogs, templates, and
+  workflow examples
+- `prompts/` for reusable prompt templates exposed through the server
+- `schemas/` for typed request and response contracts
+- `services/` for shared orchestration logic that keeps tool modules thin
+- `adapters/` for integration boundaries to `agenticlens` and
+  `agentic-chaos`
+
+The implementation is still early, but the file structure now reflects that
+shape so we can add functionality without reshuffling the repo later.
+
+## Packaging and Publishing Model
+
+`deep-agentic-core-mcp` should publish in two layers:
+
+1. Publish the Python package to PyPI.
+2. Publish the MCP metadata in `server.json` to the official MCP Registry.
+
+For PyPI-based verification, the `mcp-name` marker above must match the
+`name` field in `server.json`.
+
+## Near-Term Build Order
+
+1. Lock the canonical namespace and package metadata.
+2. Implement the stdio MCP server entrypoint.
+3. Add a minimal `core.health` tool.
+4. Add the first `agenticlens` and `agentic-chaos` adapter-backed tools.
+5. Add examples and publishable packaging checks.
+
+## Notes
+
+This scaffold assumes the intended GitHub namespace is
+`io.github.deepagentlabs/deep-agentic-core-mcp`. If the final publishing
+account or org changes, update:
+
+- the `mcp-name` marker in this README
+- `server.json`
+- any repository URLs in `pyproject.toml`

deep_agentic_core_mcp-0.1.0/ROADMAP.md

@@ -0,0 +1,113 @@
+# Roadmap
+
+## Vision
+
+Build one public MCP server for the DeepAgentLabs ecosystem that unifies:
+
+- workflow observability from `agenticlens`
+- resilience testing from `agentic-chaos`
+
+The result should feel like a coherent platform surface rather than two loosely
+connected products.
+
+## Phase 0: Foundation
+
+Status: current
+
+Goals:
+
+- define project identity and packaging
+- define MCP registry metadata
+- set the package and source tree structure
+- identify the first tool contracts
+
+Deliverables:
+
+- `README.md`
+- `ROADMAP.md`
+- `pyproject.toml`
+- `server.json`
+- initial `src/` and `tests/` layout
+
+## Phase 1: Minimal MCP Server
+
+Goals:
+
+- create a runnable stdio MCP server
+- expose `core.health`
+- expose `core.version`
+- return stable JSON payloads
+
+Success criteria:
+
+- local start command works
+- host can discover at least one tool
+- smoke tests cover imports and server boot
+
+## Phase 2: AgenticLens Integration
+
+Goals:
+
+- wire `agenticlens` into the MCP server through adapter functions
+- expose a first analysis-oriented tool surface
+- support reading workflow JSON artifacts
+
+Possible tools:
+
+- `lens.analyze_workflow`
+- `lens.report_summary`
+
+Success criteria:
+
+- a saved workflow artifact can be analyzed through MCP
+- recommendations are returned in a host-friendly schema
+
+## Phase 3: Agentic Chaos Integration
+
+Goals:
+
+- wire `agentic-chaos` into the MCP server through adapter functions
+- expose fault listing and experiment execution
+- return structured experiment results
+
+Possible tools:
+
+- `chaos.list_faults`
+- `chaos.run_experiment`
+
+Success criteria:
+
+- a target script or workflow can be exercised with selected faults
+- results can be summarized alongside normal run output
+
+## Phase 4: Unified Workflows
+
+Goals:
+
+- combine observability and chaos into joined workflows
+- compare baseline and chaos runs
+- expose reusable resources and prompts
+
+Possible tools:
+
+- `core.compare_runs`
+- `core.export_report`
+
+## Phase 5: Publishing and Adoption
+
+Goals:
+
+- verify PyPI packaging
+- publish to PyPI
+- authenticate with the MCP Registry
+- publish `server.json`
+- add CI for package build and registry publishing
+
+## Open Questions
+
+- Which MCP Python SDK will be the long-term foundation?
+- Should the first release depend on local sibling checkouts or published PyPI
+  releases only?
+- Should `deep-agentic-core-mcp` be a thin wrapper package or eventually own
+  workflow orchestration logic directly?
+- Is stdio-only enough for v0, or do we want a remote deployment path early?

deep_agentic_core_mcp-0.1.0/docs/architecture.md

@@ -0,0 +1,29 @@
+# Architecture
+
+## Overview
+
+`deep-agentic-core-mcp` is intended to be a thin MCP server that orchestrates
+existing DeepAgentLabs capabilities instead of re-implementing them.
+
+The package is organized around six layers:
+
+1. `server.py`
+   The MCP transport entrypoint and registration boundary.
+2. `tools/`
+   Host-facing callable operations such as health checks, workflow analysis,
+   and chaos experiments.
+3. `services/`
+   Shared application logic used by tools.
+4. `schemas/`
+   Request and response models for consistent payloads.
+5. `resources/`
+   Readable static or generated assets that clients may inspect.
+6. `adapters/`
+   Bridges into sibling libraries like `agenticlens` and `agentic-chaos`.
+
+## Why This Shape
+
+- Keeps host-facing interfaces stable even if underlying integrations change.
+- Prevents tool modules from becoming large orchestration files.
+- Makes it easier to expose prompts and resources alongside tools.
+- Gives us a clean place to add typed contracts before networked or remote use.

deep_agentic_core_mcp-0.1.0/examples/sample_workflow.json

@@ -0,0 +1,18 @@
+{
+  "name": "sample-agentic-workflow",
+  "description": "Placeholder workflow artifact for early MCP resource examples.",
+  "steps": [
+    {
+      "name": "Planner",
+      "type": "planner"
+    },
+    {
+      "name": "Retriever",
+      "type": "retriever"
+    },
+    {
+      "name": "Final Answer",
+      "type": "final_response"
+    }
+  ]
+}

deep_agentic_core_mcp-0.1.0/pyproject.toml

@@ -0,0 +1,76 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "deep-agentic-core-mcp"
+version = "0.1.0"
+description = "Unified MCP server for AgenticLens and Agentic Chaos workflows."
+readme = "README.md"
+requires-python = ">=3.10"
+license = { text = "MIT" }
+authors = [{ name = "DeepAgentLabs" }]
+keywords = ["mcp", "agentic-ai", "observability", "chaos-engineering", "llm"]
+classifiers = [
+  "Development Status :: 3 - Alpha",
+  "Intended Audience :: Developers",
+  "License :: OSI Approved :: MIT License",
+  "Programming Language :: Python :: 3",
+  "Programming Language :: Python :: 3.10",
+  "Programming Language :: Python :: 3.11",
+  "Programming Language :: Python :: 3.12",
+  "Topic :: Software Development :: Libraries :: Python Modules",
+]
+dependencies = [
+  "mcp>=1.10.0",
+  "pydantic>=2.0,<3",
+]
+
+[project.optional-dependencies]
+dev = [
+  "pytest>=8.0",
+  "pytest-asyncio>=0.23",
+  "pytest-cov>=5.0",
+  "ruff>=0.6",
+  "mypy>=1.10",
+  "build>=1.2",
+  "twine>=5.1",
+]
+
+[project.scripts]
+deep-agentic-core-mcp = "deep_agentic_core_mcp.server:main"
+
+[project.urls]
+Homepage = "https://github.com/DeepAgentLabs/deep-agentic-core-mcp"
+Repository = "https://github.com/DeepAgentLabs/deep-agentic-core-mcp"
+Issues = "https://github.com/DeepAgentLabs/deep-agentic-core-mcp/issues"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/deep_agentic_core_mcp"]
+
+[tool.ruff]
+line-length = 100
+target-version = "py310"
+src = ["src", "tests"]
+
+[tool.ruff.lint]
+select = ["E", "F", "I", "UP", "B", "SIM", "N"]
+ignore = ["B008"]
+
+[tool.ruff.lint.isort]
+known-first-party = ["deep_agentic_core_mcp"]
+
+[tool.ruff.format]
+quote-style = "double"
+
+[tool.mypy]
+python_version = "3.10"
+strict = true
+packages = ["deep_agentic_core_mcp"]
+mypy_path = "src"
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]
+pythonpath = ["src"]
+addopts = "-ra"
+asyncio_mode = "auto"

deep_agentic_core_mcp-0.1.0/server.json

@@ -0,0 +1,21 @@
+{
+  "$schema": "https://static.modelcontextprotocol.io/schemas/2025-12-11/server.schema.json",
+  "name": "io.github.deepagentlabs/deep-agentic-core-mcp",
+  "title": "Deep Agentic Core MCP",
+  "description": "Unified MCP server for AgenticLens and Agentic Chaos capabilities.",
+  "version": "0.1.0",
+  "repository": {
+    "url": "https://github.com/DeepAgentLabs/deep-agentic-core-mcp",
+    "source": "github"
+  },
+  "packages": [
+    {
+      "registryType": "pypi",
+      "identifier": "deep-agentic-core-mcp",
+      "version": "0.1.0",
+      "transport": {
+        "type": "stdio"
+      }
+    }
+  ]
+}

deep_agentic_core_mcp-0.1.0/src/deep_agentic_core_mcp/__init__.py

@@ -0,0 +1,5 @@
+"""Core package for the DeepAgentLabs unified MCP server."""
+
+__all__ = ["__version__"]
+
+__version__ = "0.1.0"

deep_agentic_core_mcp-0.1.0/src/deep_agentic_core_mcp/adapters/__init__.py

@@ -0,0 +1 @@
+"""Integration adapters for sibling DeepAgentLabs projects."""

deep_agentic_core_mcp-0.1.0/src/deep_agentic_core_mcp/adapters/agentic_chaos.py

@@ -0,0 +1,6 @@
+"""Adapter boundary for agentic-chaos integration."""
+
+
+def describe_capabilities() -> list[str]:
+    """Return the initial capability placeholders for chaos integration."""
+    return ["list_faults", "run_experiment"]

deep_agentic_core_mcp-0.1.0/src/deep_agentic_core_mcp/adapters/agenticlens.py

@@ -0,0 +1,6 @@
+"""Adapter boundary for agenticlens integration."""
+
+
+def describe_capabilities() -> list[str]:
+    """Return the initial capability placeholders for lens integration."""
+    return ["analyze_workflow", "profile_workflow"]

deep_agentic_core_mcp-0.1.0/src/deep_agentic_core_mcp/config.py

@@ -0,0 +1,5 @@
+"""Shared project constants and metadata."""
+
+SERVER_NAME = "io.github.deepagentlabs/deep-agentic-core-mcp"
+PACKAGE_NAME = "deep-agentic-core-mcp"
+VERSION = "0.1.0"

deep_agentic_core_mcp-0.1.0/src/deep_agentic_core_mcp/prompts/__init__.py

@@ -0,0 +1 @@
+"""Prompt definitions exposed by the MCP server."""

deep_agentic_core_mcp-0.1.0/src/deep_agentic_core_mcp/prompts/registry.py

@@ -0,0 +1,15 @@
+"""Reusable prompt catalog placeholders."""
+
+
+def list_prompts() -> list[dict[str, str]]:
+    """Return the initial prompt registry."""
+    return [
+        {
+            "name": "lens.workflow_summary",
+            "description": "Summarize an analyzed workflow for a human operator.",
+        },
+        {
+            "name": "chaos.experiment_brief",
+            "description": "Explain the intent and expected impact of a chaos run.",
+        },
+    ]

deep_agentic_core_mcp-0.1.0/src/deep_agentic_core_mcp/resources/__init__.py

@@ -0,0 +1 @@
+"""Resource catalogs exposed by the MCP server."""

deep_agentic_core_mcp-0.1.0/src/deep_agentic_core_mcp/resources/catalog.py

@@ -0,0 +1,17 @@
+"""Placeholder resource catalog."""
+
+
+def list_resources() -> list[dict[str, str]]:
+    """Return the initial resource inventory."""
+    return [
+        {
+            "uri": "resource://examples/sample_workflow",
+            "name": "Sample workflow artifact",
+            "kind": "workflow-json",
+        },
+        {
+            "uri": "resource://catalogs/chaos_faults",
+            "name": "Chaos fault catalog",
+            "kind": "reference",
+        },
+    ]

deep_agentic_core_mcp-0.1.0/src/deep_agentic_core_mcp/schemas/__init__.py

@@ -0,0 +1 @@
+"""Typed contracts for MCP-facing operations."""

deep_agentic_core_mcp-0.1.0/src/deep_agentic_core_mcp/schemas/tooling.py

@@ -0,0 +1,26 @@
+"""Core schema definitions for early tool contracts."""
+
+from pydantic import BaseModel, Field
+
+
+class ToolDescriptor(BaseModel):
+    """Basic metadata describing an MCP tool."""
+
+    name: str
+    title: str
+    description: str
+
+
+class ResourceDescriptor(BaseModel):
+    """Basic metadata describing an MCP resource."""
+
+    uri: str
+    name: str
+    kind: str = Field(description="Broad classification for the resource payload.")
+
+
+class PromptDescriptor(BaseModel):
+    """Basic metadata describing an MCP prompt."""
+
+    name: str
+    description: str

deep_agentic_core_mcp-0.1.0/src/deep_agentic_core_mcp/server.py

@@ -0,0 +1,117 @@
+"""MCP server entrypoint using the official MCP Python SDK (stdio transport)."""
+
+import asyncio
+import json
+from collections.abc import Callable
+from typing import Any
+
+from mcp.server import Server
+from mcp.server.stdio import stdio_server
+from mcp.types import Resource, TextContent, Tool
+from pydantic import AnyUrl
+
+from deep_agentic_core_mcp.config import SERVER_NAME
+from deep_agentic_core_mcp.resources.catalog import list_resources as _catalog_resources
+from deep_agentic_core_mcp.tools.core import health, version
+from deep_agentic_core_mcp.tools.registry import list_tools as _registry_tools
+
+# ---------------------------------------------------------------------------
+# Server instance
+# ---------------------------------------------------------------------------
+
+server = Server(SERVER_NAME)
+
+# ---------------------------------------------------------------------------
+# Tool dispatch
+# ---------------------------------------------------------------------------
+
+_TOOL_DISPATCH: dict[str, Callable[[], dict[str, str]]] = {
+    "core.health": health,
+    "core.version": version,
+}
+
+# ---------------------------------------------------------------------------
+# Tool definitions (derived from the canonical registry)
+# ---------------------------------------------------------------------------
+
+
+def _build_tools() -> list[Tool]:
+    """Build Tool objects from the central tool registry.
+
+    Only tools with a registered handler are advertised.
+    """
+    return [
+        Tool(
+            name=entry["name"],
+            description=entry["description"],
+            inputSchema={"type": "object", "properties": {}, "additionalProperties": False},
+        )
+        for entry in _registry_tools()
+        if entry["name"] in _TOOL_DISPATCH
+    ]
+
+
+def _build_resources() -> list[Resource]:
+    """Build Resource objects from the central resource catalog."""
+    return [
+        Resource(
+            uri=AnyUrl(entry["uri"]),
+            name=entry["name"],
+            mimeType="application/json",
+        )
+        for entry in _catalog_resources()
+    ]
+
+
+TOOLS: list[Tool] = _build_tools()
+RESOURCES: list[Resource] = _build_resources()
+
+# ---------------------------------------------------------------------------
+# Handlers
+# ---------------------------------------------------------------------------
+
+
+@server.list_tools()  # type: ignore[no-untyped-call, untyped-decorator]
+async def handle_list_tools() -> list[Tool]:
+    """Advertise available tools."""
+    return TOOLS
+
+
+@server.call_tool()  # type: ignore[untyped-decorator]
+async def handle_call_tool(name: str, arguments: dict[str, Any] | None) -> list[TextContent]:
+    """Dispatch tool calls and return JSON results."""
+    handler = _TOOL_DISPATCH.get(name)
+    if handler is None:
+        return [TextContent(type="text", text=json.dumps({"error": f"Unknown tool: {name}"}))]
+    result = handler()
+    return [TextContent(type="text", text=json.dumps(result))]
+
+
+@server.list_resources()  # type: ignore[no-untyped-call, untyped-decorator]
+async def handle_list_resources() -> list[Resource]:
+    """Advertise available resources."""
+    return RESOURCES
+
+
+# ---------------------------------------------------------------------------
+# Entrypoint
+# ---------------------------------------------------------------------------
+
+
+async def run_server() -> None:
+    """Start the MCP server over stdio."""
+    async with stdio_server() as (read_stream, write_stream):
+        await server.run(
+            read_stream,
+            write_stream,
+            server.create_initialization_options(),
+        )
+
+
+def main() -> None:
+    """Synchronous entrypoint for console_scripts."""
+    asyncio.run(run_server())
+
+
+if __name__ == "__main__":
+    main()

deep_agentic_core_mcp-0.1.0/src/deep_agentic_core_mcp/services/__init__.py

@@ -0,0 +1 @@
+"""Shared orchestration services."""

deep_agentic_core_mcp-0.1.0/src/deep_agentic_core_mcp/services/registry.py

@@ -0,0 +1,25 @@
+"""Service helpers for server-side registries."""
+
+from deep_agentic_core_mcp.prompts.registry import list_prompts
+from deep_agentic_core_mcp.resources.catalog import list_resources
+from deep_agentic_core_mcp.schemas.tooling import (
+    PromptDescriptor,
+    ResourceDescriptor,
+    ToolDescriptor,
+)
+from deep_agentic_core_mcp.tools.registry import list_tools
+
+
+def tool_descriptors() -> list[ToolDescriptor]:
+    """Return typed tool metadata."""
+    return [ToolDescriptor(**tool) for tool in list_tools()]
+
+
+def resource_descriptors() -> list[ResourceDescriptor]:
+    """Return typed resource metadata."""
+    return [ResourceDescriptor(**resource) for resource in list_resources()]
+
+
+def prompt_descriptors() -> list[PromptDescriptor]:
+    """Return typed prompt metadata."""
+    return [PromptDescriptor(**prompt) for prompt in list_prompts()]

deep_agentic_core_mcp-0.1.0/src/deep_agentic_core_mcp/tools/__init__.py

@@ -0,0 +1 @@
+"""Tool group modules for the MCP server."""

deep_agentic_core_mcp-0.1.0/src/deep_agentic_core_mcp/tools/chaos.py

@@ -0,0 +1,8 @@
+"""Chaos tool placeholders."""
+
+from deep_agentic_core_mcp.adapters.agentic_chaos import describe_capabilities
+
+
+def capabilities() -> dict[str, list[str]]:
+    """Return placeholder chaos capabilities."""
+    return {"chaos": describe_capabilities()}

deep_agentic_core_mcp-0.1.0/src/deep_agentic_core_mcp/tools/core.py

@@ -0,0 +1,13 @@
+"""Core server tool stubs."""
+
+from deep_agentic_core_mcp.config import SERVER_NAME, VERSION
+
+
+def health() -> dict[str, str]:
+    """Return a basic health payload."""
+    return {"status": "ok", "server": SERVER_NAME}
+
+
+def version() -> dict[str, str]:
+    """Return the current package version."""
+    return {"version": VERSION}

deep_agentic_core_mcp-0.1.0/src/deep_agentic_core_mcp/tools/lens.py

@@ -0,0 +1,8 @@
+"""Lens tool placeholders."""
+
+from deep_agentic_core_mcp.adapters.agenticlens import describe_capabilities
+
+
+def capabilities() -> dict[str, list[str]]:
+    """Return placeholder lens capabilities."""
+    return {"lens": describe_capabilities()}

deep_agentic_core_mcp-0.1.0/src/deep_agentic_core_mcp/tools/registry.py

@@ -0,0 +1,27 @@
+"""Central tool metadata registry."""
+
+
+def list_tools() -> list[dict[str, str]]:
+    """Return the initial tool inventory for the server."""
+    return [
+        {
+            "name": "core.health",
+            "title": "Health Check",
+            "description": "Return the basic health status of the MCP server.",
+        },
+        {
+            "name": "core.version",
+            "title": "Server Version",
+            "description": "Return the current server package version.",
+        },
+        {
+            "name": "lens.analyze_workflow",
+            "title": "Analyze Workflow",
+            "description": "Analyze an AgenticLens-compatible workflow artifact.",
+        },
+        {
+            "name": "chaos.list_faults",
+            "title": "List Chaos Faults",
+            "description": "List the supported fault types for chaos experiments.",
+        },
+    ]

deep_agentic_core_mcp-0.1.0/tests/test_imports.py

@@ -0,0 +1,18 @@
+from deep_agentic_core_mcp.tools.chaos import capabilities as chaos_capabilities
+from deep_agentic_core_mcp.tools.core import health, version
+from deep_agentic_core_mcp.tools.lens import capabilities as lens_capabilities
+
+
+def test_health_payload() -> None:
+    payload = health()
+    assert payload["status"] == "ok"
+
+
+def test_version_payload() -> None:
+    payload = version()
+    assert "version" in payload
+
+
+def test_capability_placeholders() -> None:
+    assert "chaos" in chaos_capabilities()
+    assert "lens" in lens_capabilities()

deep_agentic_core_mcp-0.1.0/tests/test_registry.py

@@ -0,0 +1,27 @@
+from deep_agentic_core_mcp.prompts.registry import list_prompts
+from deep_agentic_core_mcp.resources.catalog import list_resources
+from deep_agentic_core_mcp.services.registry import (
+    prompt_descriptors,
+    resource_descriptors,
+    tool_descriptors,
+)
+from deep_agentic_core_mcp.tools.registry import list_tools
+
+
+def test_tool_registry_has_core_health() -> None:
+    names = {tool["name"] for tool in list_tools()}
+    assert "core.health" in names
+
+
+def test_resource_registry_not_empty() -> None:
+    assert list_resources()
+
+
+def test_prompt_registry_not_empty() -> None:
+    assert list_prompts()
+
+
+def test_typed_descriptors_build() -> None:
+    assert tool_descriptors()
+    assert resource_descriptors()
+    assert prompt_descriptors()

deep_agentic_core_mcp-0.1.0/tests/test_server.py

@@ -0,0 +1,59 @@
+"""Smoke tests for MCP server boot and tool discovery."""
+
+import json
+
+import pytest
+
+from deep_agentic_core_mcp.server import _TOOL_DISPATCH, TOOLS, server
+
+
+def test_server_has_name() -> None:
+    assert server.name == "io.github.deepagentlabs/deep-agentic-core-mcp"
+
+
+def test_tools_registered() -> None:
+    tool_names = {t.name for t in TOOLS}
+    assert "core.health" in tool_names
+    assert "core.version" in tool_names
+
+
+def test_tool_dispatch_covers_all_tools() -> None:
+    for tool in TOOLS:
+        assert tool.name in _TOOL_DISPATCH, f"No handler for {tool.name}"
+
+
+@pytest.mark.asyncio
+async def test_handle_list_tools() -> None:
+    from deep_agentic_core_mcp.server import handle_list_tools
+
+    tools = await handle_list_tools()
+    names = {t.name for t in tools}
+    assert "core.health" in names
+    assert "core.version" in names
+
+
+@pytest.mark.asyncio
+async def test_handle_call_tool_health() -> None:
+    from deep_agentic_core_mcp.server import handle_call_tool
+
+    result = await handle_call_tool("core.health", {})
+    payload = json.loads(result[0].text)
+    assert payload["status"] == "ok"
+
+
+@pytest.mark.asyncio
+async def test_handle_call_tool_version() -> None:
+    from deep_agentic_core_mcp.server import handle_call_tool
+
+    result = await handle_call_tool("core.version", {})
+    payload = json.loads(result[0].text)
+    assert "version" in payload
+
+
+@pytest.mark.asyncio
+async def test_handle_call_tool_unknown() -> None:
+    from deep_agentic_core_mcp.server import handle_call_tool
+
+    result = await handle_call_tool("nonexistent.tool", {})
+    payload = json.loads(result[0].text)
+    assert "error" in payload