langwatch-scenario 0.1.0__tar.gz

langwatch_scenario-0.1.0/PKG-INFO

@@ -0,0 +1,192 @@
+Metadata-Version: 2.4
+Name: langwatch-scenario
+Version: 0.1.0
+Summary: The end-to-end agent testing library
+Author-email: LangWatch Team <support@langwatch.ai>
+License: MIT
+Project-URL: Homepage, https://github.com/langwatch/scenario
+Project-URL: Bug Tracker, https://github.com/langwatch/scenario/issues
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+Requires-Dist: pytest>=8.1.1
+Requires-Dist: litellm>=1.49.0
+Requires-Dist: python-dotenv>=1.0.1
+Requires-Dist: termcolor>=2.4.0
+Requires-Dist: pydantic>=2.7.0
+Requires-Dist: joblib>=1.4.2
+Requires-Dist: wrapt>=1.17.2
+Requires-Dist: pytest-asyncio>=0.26.0
+Requires-Dist: rich>=14.0.0
+Provides-Extra: dev
+Requires-Dist: black; extra == "dev"
+Requires-Dist: isort; extra == "dev"
+Requires-Dist: mypy; extra == "dev"
+Requires-Dist: pytest-cov; extra == "dev"
+
+![scenario](./assets/scenario-wide.webp)
+
+<div align="center">
+<!-- Discord, PyPI, Docs, etc links -->
+</div>
+
+# Scenario: Use an Agent to test your Agent
+
+Scenario is a library for testing agents end-to-end as a human would, but without having to manually do it. The automated testing agent covers every single scenario for you.
+
+You define the scenarios, and the testing agent will simulate your users as it follows them, it will keep chatting and evaluating your agent until it reaches the desired goal or detects an unexpected behavior.
+
+## Getting Started
+
+Install pytest and scenario:
+
+```bash
+pip install pytest langwatch-scenario
+```
+
+Now create your first scenario:
+
+```python
+import pytest
+
+from scenario import Scenario, TestingAgent
+
+Scenario.configure(testing_agent=TestingAgent(model="openai/gpt-4o-mini"))
+
+
+@pytest.mark.agent_test
+@pytest.mark.asyncio
+async def test_vegetarian_recipe_agent():
+    def vegetarian_recipe_agent(message, context):
+        # Call your agent here
+        response = "<Your agent's response>"
+
+        return {"message": response}
+
+    scenario = Scenario(
+        "User is looking for a dinner idea",
+        agent=vegetarian_recipe_agent,
+        success_criteria=[
+            "Recipe agent generates a vegetarian recipe",
+            "Recipe includes step-by-step cooking instructions",
+        ],
+        failure_criteria=[
+            "The recipe includes meat",
+            "The agent asks more than two follow-up questions",
+        ],
+    )
+
+    result = await scenario.run()
+
+    assert result.success
+```
+
+Save it as `tests/test_vegetarian_recipe_agent.py` and run it with pytest:
+
+```bash
+pytest -s tests/test_vegetarian_recipe_agent.py
+```
+
+Once you connect to callback to a real agent, this is how it will look like:
+
+[![asciicast](https://asciinema.org/a/nvO5GWGzqKTTCd8gtNSezQw11.svg)](https://asciinema.org/a/nvO5GWGzqKTTCd8gtNSezQw11)
+
+You can find a fully working example in [examples/test_vegetarian_recipe_agent.py](examples/test_vegetarian_recipe_agent.py).
+
+## Customize strategy and max_turns
+
+You can customize how should the testing agent go about testing by defining a `strategy` field. You can also limit the maximum number of turns the scenario will take by setting the `max_turns` field (defaults to 10).
+
+For example, in this Lovable Clone scenario test:
+
+```python
+scenario = Scenario(
+    "user wants to create a new landing page for their dog walking startup",
+    agent=lovable_agent,
+    strategy="send the first message to generate the landing page, then a single follow up request to extend it, then give your final verdict",
+    success_criteria=[
+        "agent reads the files before go and making changes",
+        "agent modified the index.css file",
+        "agent modified the Index.tsx file",
+        "agent created a comprehensive landing page",
+        "agent extended the landing page with a new section",
+    ],
+    failure_criteria=[
+        "agent says it can't read the file",
+        "agent produces incomplete code or is too lazy to finish",
+    ],
+    max_turns=5,
+)
+
+result = await scenario.run()
+```
+
+You can find a fully working Lovable Clone example in [examples/test_lovable_clone.py](examples/test_lovable_clone.py).
+
+## Debug mode
+
+You can enable debug mode by setting the `debug` field to `True` in the `Scenario.configure` method or in the specific scenario you are running.
+
+Debug mode allows you to see the messages in slow motion step by step, and intervene with your own inputs to debug your agent from the middle of the conversation.
+
+```python
+Scenario.configure(testing_agent=TestingAgent(model="openai/gpt-4o-mini"), debug=True)
+```
+
+## Cache
+
+Each time the scenario runs, the testing agent might chose a different input to start, this is good to make sure it covers the variance of real users as well, however we understand that the non-deterministic nature of it might make it less repeatable, costly and harder to debug. To solve for it, you can use the `cache_key` field in the `Scenario.configure` method or in the specific scenario you are running, this will make the testing agent give the same input for given the same scenario:
+
+```python
+Scenario.configure(testing_agent=TestingAgent(model="openai/gpt-4o-mini"), cache_key="42")
+```
+
+To bust the cache, you can simply pass a different `cache_key`, disable it, or delete the cache files located at `~/.scenario/cache`.
+
+To go a step further and fully cache the test end-to-end, you can also wrap the LLM calls or any other non-deterministic functions in your application side with the `@scenario_cache` decorator:
+
+```python
+class MyAgent:
+    @scenario_cache(ignore=["self"])
+    def invoke(self, message, context):
+        return client.chat.completions.create(
+            # ...
+        )
+```
+
+This will cache any function call you decorate when running the tests and make them repeatable, hashed by the function arguments, the scenario being executed, and the `cache_key` you provided. You can exclude arguments that should not be hashed for the cache key by naming them in the `ignore` argument.
+
+## Disable Output
+
+You can remove the `-s` flag from pytest to hide the output during test, which will only show up if the test fails. Alternatively, you can set `verbose=False` in the `Scenario.configure` method or in the specific scenario you are running.
+
+## Running in parallel
+
+As the number of your scenarios grows, you might want to run them in parallel to speed up your whole test suite. We suggest you to use the [pytest-asyncio-concurrent](https://pypi.org/project/pytest-asyncio-concurrent/) plugin to do so.
+
+Simply install the plugin from the link above, then replace the `@pytest.mark.asyncio` annotation in the tests with `@pytest.mark.asyncio_concurrent`, adding a group name to it to mark the group of scenarions that should be run in parallel together, e.g.:
+
+```python
+@pytest.mark.agent_test
+@pytest.mark.asyncio_concurrent(group="vegetarian_recipe_agent")
+async def test_vegetarian_recipe_agent():
+    # ...
+
+@pytest.mark.agent_test
+@pytest.mark.asyncio_concurrent(group="vegetarian_recipe_agent")
+async def test_user_is_very_hungry():
+    # ...
+```
+
+Those two scenarios should now run in parallel.
+
+## License
+
+MIT License

langwatch_scenario-0.1.0/README.md

@@ -0,0 +1,159 @@
+![scenario](./assets/scenario-wide.webp)
+
+<div align="center">
+<!-- Discord, PyPI, Docs, etc links -->
+</div>
+
+# Scenario: Use an Agent to test your Agent
+
+Scenario is a library for testing agents end-to-end as a human would, but without having to manually do it. The automated testing agent covers every single scenario for you.
+
+You define the scenarios, and the testing agent will simulate your users as it follows them, it will keep chatting and evaluating your agent until it reaches the desired goal or detects an unexpected behavior.
+
+## Getting Started
+
+Install pytest and scenario:
+
+```bash
+pip install pytest langwatch-scenario
+```
+
+Now create your first scenario:
+
+```python
+import pytest
+
+from scenario import Scenario, TestingAgent
+
+Scenario.configure(testing_agent=TestingAgent(model="openai/gpt-4o-mini"))
+
+
+@pytest.mark.agent_test
+@pytest.mark.asyncio
+async def test_vegetarian_recipe_agent():
+    def vegetarian_recipe_agent(message, context):
+        # Call your agent here
+        response = "<Your agent's response>"
+
+        return {"message": response}
+
+    scenario = Scenario(
+        "User is looking for a dinner idea",
+        agent=vegetarian_recipe_agent,
+        success_criteria=[
+            "Recipe agent generates a vegetarian recipe",
+            "Recipe includes step-by-step cooking instructions",
+        ],
+        failure_criteria=[
+            "The recipe includes meat",
+            "The agent asks more than two follow-up questions",
+        ],
+    )
+
+    result = await scenario.run()
+
+    assert result.success
+```
+
+Save it as `tests/test_vegetarian_recipe_agent.py` and run it with pytest:
+
+```bash
+pytest -s tests/test_vegetarian_recipe_agent.py
+```
+
+Once you connect to callback to a real agent, this is how it will look like:
+
+[![asciicast](https://asciinema.org/a/nvO5GWGzqKTTCd8gtNSezQw11.svg)](https://asciinema.org/a/nvO5GWGzqKTTCd8gtNSezQw11)
+
+You can find a fully working example in [examples/test_vegetarian_recipe_agent.py](examples/test_vegetarian_recipe_agent.py).
+
+## Customize strategy and max_turns
+
+You can customize how should the testing agent go about testing by defining a `strategy` field. You can also limit the maximum number of turns the scenario will take by setting the `max_turns` field (defaults to 10).
+
+For example, in this Lovable Clone scenario test:
+
+```python
+scenario = Scenario(
+    "user wants to create a new landing page for their dog walking startup",
+    agent=lovable_agent,
+    strategy="send the first message to generate the landing page, then a single follow up request to extend it, then give your final verdict",
+    success_criteria=[
+        "agent reads the files before go and making changes",
+        "agent modified the index.css file",
+        "agent modified the Index.tsx file",
+        "agent created a comprehensive landing page",
+        "agent extended the landing page with a new section",
+    ],
+    failure_criteria=[
+        "agent says it can't read the file",
+        "agent produces incomplete code or is too lazy to finish",
+    ],
+    max_turns=5,
+)
+
+result = await scenario.run()
+```
+
+You can find a fully working Lovable Clone example in [examples/test_lovable_clone.py](examples/test_lovable_clone.py).
+
+## Debug mode
+
+You can enable debug mode by setting the `debug` field to `True` in the `Scenario.configure` method or in the specific scenario you are running.
+
+Debug mode allows you to see the messages in slow motion step by step, and intervene with your own inputs to debug your agent from the middle of the conversation.
+
+```python
+Scenario.configure(testing_agent=TestingAgent(model="openai/gpt-4o-mini"), debug=True)
+```
+
+## Cache
+
+Each time the scenario runs, the testing agent might chose a different input to start, this is good to make sure it covers the variance of real users as well, however we understand that the non-deterministic nature of it might make it less repeatable, costly and harder to debug. To solve for it, you can use the `cache_key` field in the `Scenario.configure` method or in the specific scenario you are running, this will make the testing agent give the same input for given the same scenario:
+
+```python
+Scenario.configure(testing_agent=TestingAgent(model="openai/gpt-4o-mini"), cache_key="42")
+```
+
+To bust the cache, you can simply pass a different `cache_key`, disable it, or delete the cache files located at `~/.scenario/cache`.
+
+To go a step further and fully cache the test end-to-end, you can also wrap the LLM calls or any other non-deterministic functions in your application side with the `@scenario_cache` decorator:
+
+```python
+class MyAgent:
+    @scenario_cache(ignore=["self"])
+    def invoke(self, message, context):
+        return client.chat.completions.create(
+            # ...
+        )
+```
+
+This will cache any function call you decorate when running the tests and make them repeatable, hashed by the function arguments, the scenario being executed, and the `cache_key` you provided. You can exclude arguments that should not be hashed for the cache key by naming them in the `ignore` argument.
+
+## Disable Output
+
+You can remove the `-s` flag from pytest to hide the output during test, which will only show up if the test fails. Alternatively, you can set `verbose=False` in the `Scenario.configure` method or in the specific scenario you are running.
+
+## Running in parallel
+
+As the number of your scenarios grows, you might want to run them in parallel to speed up your whole test suite. We suggest you to use the [pytest-asyncio-concurrent](https://pypi.org/project/pytest-asyncio-concurrent/) plugin to do so.
+
+Simply install the plugin from the link above, then replace the `@pytest.mark.asyncio` annotation in the tests with `@pytest.mark.asyncio_concurrent`, adding a group name to it to mark the group of scenarions that should be run in parallel together, e.g.:
+
+```python
+@pytest.mark.agent_test
+@pytest.mark.asyncio_concurrent(group="vegetarian_recipe_agent")
+async def test_vegetarian_recipe_agent():
+    # ...
+
+@pytest.mark.agent_test
+@pytest.mark.asyncio_concurrent(group="vegetarian_recipe_agent")
+async def test_user_is_very_hungry():
+    # ...
+```
+
+Those two scenarios should now run in parallel.
+
+## License
+
+MIT License

langwatch_scenario-0.1.0/langwatch_scenario.egg-info/PKG-INFO

@@ -0,0 +1,192 @@
+Metadata-Version: 2.4
+Name: langwatch-scenario
+Version: 0.1.0
+Summary: The end-to-end agent testing library
+Author-email: LangWatch Team <support@langwatch.ai>
+License: MIT
+Project-URL: Homepage, https://github.com/langwatch/scenario
+Project-URL: Bug Tracker, https://github.com/langwatch/scenario/issues
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+Requires-Dist: pytest>=8.1.1
+Requires-Dist: litellm>=1.49.0
+Requires-Dist: python-dotenv>=1.0.1
+Requires-Dist: termcolor>=2.4.0
+Requires-Dist: pydantic>=2.7.0
+Requires-Dist: joblib>=1.4.2
+Requires-Dist: wrapt>=1.17.2
+Requires-Dist: pytest-asyncio>=0.26.0
+Requires-Dist: rich>=14.0.0
+Provides-Extra: dev
+Requires-Dist: black; extra == "dev"
+Requires-Dist: isort; extra == "dev"
+Requires-Dist: mypy; extra == "dev"
+Requires-Dist: pytest-cov; extra == "dev"
+
+![scenario](./assets/scenario-wide.webp)
+
+<div align="center">
+<!-- Discord, PyPI, Docs, etc links -->
+</div>
+
+# Scenario: Use an Agent to test your Agent
+
+Scenario is a library for testing agents end-to-end as a human would, but without having to manually do it. The automated testing agent covers every single scenario for you.
+
+You define the scenarios, and the testing agent will simulate your users as it follows them, it will keep chatting and evaluating your agent until it reaches the desired goal or detects an unexpected behavior.
+
+## Getting Started
+
+Install pytest and scenario:
+
+```bash
+pip install pytest langwatch-scenario
+```
+
+Now create your first scenario:
+
+```python
+import pytest
+
+from scenario import Scenario, TestingAgent
+
+Scenario.configure(testing_agent=TestingAgent(model="openai/gpt-4o-mini"))
+
+
+@pytest.mark.agent_test
+@pytest.mark.asyncio
+async def test_vegetarian_recipe_agent():
+    def vegetarian_recipe_agent(message, context):
+        # Call your agent here
+        response = "<Your agent's response>"
+
+        return {"message": response}
+
+    scenario = Scenario(
+        "User is looking for a dinner idea",
+        agent=vegetarian_recipe_agent,
+        success_criteria=[
+            "Recipe agent generates a vegetarian recipe",
+            "Recipe includes step-by-step cooking instructions",
+        ],
+        failure_criteria=[
+            "The recipe includes meat",
+            "The agent asks more than two follow-up questions",
+        ],
+    )
+
+    result = await scenario.run()
+
+    assert result.success
+```
+
+Save it as `tests/test_vegetarian_recipe_agent.py` and run it with pytest:
+
+```bash
+pytest -s tests/test_vegetarian_recipe_agent.py
+```
+
+Once you connect to callback to a real agent, this is how it will look like:
+
+[![asciicast](https://asciinema.org/a/nvO5GWGzqKTTCd8gtNSezQw11.svg)](https://asciinema.org/a/nvO5GWGzqKTTCd8gtNSezQw11)
+
+You can find a fully working example in [examples/test_vegetarian_recipe_agent.py](examples/test_vegetarian_recipe_agent.py).
+
+## Customize strategy and max_turns
+
+You can customize how should the testing agent go about testing by defining a `strategy` field. You can also limit the maximum number of turns the scenario will take by setting the `max_turns` field (defaults to 10).
+
+For example, in this Lovable Clone scenario test:
+
+```python
+scenario = Scenario(
+    "user wants to create a new landing page for their dog walking startup",
+    agent=lovable_agent,
+    strategy="send the first message to generate the landing page, then a single follow up request to extend it, then give your final verdict",
+    success_criteria=[
+        "agent reads the files before go and making changes",
+        "agent modified the index.css file",
+        "agent modified the Index.tsx file",
+        "agent created a comprehensive landing page",
+        "agent extended the landing page with a new section",
+    ],
+    failure_criteria=[
+        "agent says it can't read the file",
+        "agent produces incomplete code or is too lazy to finish",
+    ],
+    max_turns=5,
+)
+
+result = await scenario.run()
+```
+
+You can find a fully working Lovable Clone example in [examples/test_lovable_clone.py](examples/test_lovable_clone.py).
+
+## Debug mode
+
+You can enable debug mode by setting the `debug` field to `True` in the `Scenario.configure` method or in the specific scenario you are running.
+
+Debug mode allows you to see the messages in slow motion step by step, and intervene with your own inputs to debug your agent from the middle of the conversation.
+
+```python
+Scenario.configure(testing_agent=TestingAgent(model="openai/gpt-4o-mini"), debug=True)
+```
+
+## Cache
+
+Each time the scenario runs, the testing agent might chose a different input to start, this is good to make sure it covers the variance of real users as well, however we understand that the non-deterministic nature of it might make it less repeatable, costly and harder to debug. To solve for it, you can use the `cache_key` field in the `Scenario.configure` method or in the specific scenario you are running, this will make the testing agent give the same input for given the same scenario:
+
+```python
+Scenario.configure(testing_agent=TestingAgent(model="openai/gpt-4o-mini"), cache_key="42")
+```
+
+To bust the cache, you can simply pass a different `cache_key`, disable it, or delete the cache files located at `~/.scenario/cache`.
+
+To go a step further and fully cache the test end-to-end, you can also wrap the LLM calls or any other non-deterministic functions in your application side with the `@scenario_cache` decorator:
+
+```python
+class MyAgent:
+    @scenario_cache(ignore=["self"])
+    def invoke(self, message, context):
+        return client.chat.completions.create(
+            # ...
+        )
+```
+
+This will cache any function call you decorate when running the tests and make them repeatable, hashed by the function arguments, the scenario being executed, and the `cache_key` you provided. You can exclude arguments that should not be hashed for the cache key by naming them in the `ignore` argument.
+
+## Disable Output
+
+You can remove the `-s` flag from pytest to hide the output during test, which will only show up if the test fails. Alternatively, you can set `verbose=False` in the `Scenario.configure` method or in the specific scenario you are running.
+
+## Running in parallel
+
+As the number of your scenarios grows, you might want to run them in parallel to speed up your whole test suite. We suggest you to use the [pytest-asyncio-concurrent](https://pypi.org/project/pytest-asyncio-concurrent/) plugin to do so.
+
+Simply install the plugin from the link above, then replace the `@pytest.mark.asyncio` annotation in the tests with `@pytest.mark.asyncio_concurrent`, adding a group name to it to mark the group of scenarions that should be run in parallel together, e.g.:
+
+```python
+@pytest.mark.agent_test
+@pytest.mark.asyncio_concurrent(group="vegetarian_recipe_agent")
+async def test_vegetarian_recipe_agent():
+    # ...
+
+@pytest.mark.agent_test
+@pytest.mark.asyncio_concurrent(group="vegetarian_recipe_agent")
+async def test_user_is_very_hungry():
+    # ...
+```
+
+Those two scenarios should now run in parallel.
+
+## License
+
+MIT License

langwatch_scenario-0.1.0/langwatch_scenario.egg-info/SOURCES.txt

@@ -0,0 +1,19 @@
+README.md
+pyproject.toml
+setup.py
+langwatch_scenario.egg-info/PKG-INFO
+langwatch_scenario.egg-info/SOURCES.txt
+langwatch_scenario.egg-info/dependency_links.txt
+langwatch_scenario.egg-info/entry_points.txt
+langwatch_scenario.egg-info/requires.txt
+langwatch_scenario.egg-info/top_level.txt
+scenario/__init__.py
+scenario/cache.py
+scenario/config.py
+scenario/error_messages.py
+scenario/pytest_plugin.py
+scenario/result.py
+scenario/scenario.py
+scenario/scenario_executor.py
+scenario/testing_agent.py
+scenario/utils.py

langwatch_scenario-0.1.0/langwatch_scenario.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

langwatch_scenario-0.1.0/langwatch_scenario.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[pytest11]
+scenario = scenario.pytest_plugin

langwatch_scenario-0.1.0/langwatch_scenario.egg-info/requires.txt

@@ -0,0 +1,15 @@
+pytest>=8.1.1
+litellm>=1.49.0
+python-dotenv>=1.0.1
+termcolor>=2.4.0
+pydantic>=2.7.0
+joblib>=1.4.2
+wrapt>=1.17.2
+pytest-asyncio>=0.26.0
+rich>=14.0.0
+
+[dev]
+black
+isort
+mypy
+pytest-cov

langwatch_scenario-0.1.0/langwatch_scenario.egg-info/top_level.txt

@@ -0,0 +1 @@
+scenario

langwatch_scenario-0.1.0/pyproject.toml

@@ -0,0 +1,58 @@
+[build-system]
+requires = ["setuptools>=42", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "langwatch-scenario"
+version = "0.1.0"
+description = "The end-to-end agent testing library"
+readme = "README.md"
+authors = [
+    {name = "LangWatch Team", email = "support@langwatch.ai"}
+]
+license = {text = "MIT"}
+requires-python = ">=3.9"
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "Intended Audience :: Developers",
+    "License :: OSI Approved :: MIT License",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.8",
+    "Programming Language :: Python :: 3.9",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+]
+dependencies = [
+    "pytest>=8.1.1",
+    "litellm>=1.49.0",
+    "python-dotenv>=1.0.1",
+    "termcolor>=2.4.0",
+    "pydantic>=2.7.0",
+    "joblib>=1.4.2",
+    "wrapt>=1.17.2",
+    "pytest-asyncio>=0.26.0",
+    "rich>=14.0.0",
+]
+
+[project.optional-dependencies]
+dev = [
+    "black",
+    "isort",
+    "mypy",
+    "pytest-cov",
+]
+
+[project.urls]
+"Homepage" = "https://github.com/langwatch/scenario"
+"Bug Tracker" = "https://github.com/langwatch/scenario/issues"
+
+[tool.pytest.ini_options]
+markers = [
+    "agent_test: marks tests as agent scenario tests",
+]
+
+[dependency-groups]
+dev = [
+    "pydantic-ai>=0.0.52",
+    "pytest-asyncio-concurrent>=0.4.1",
+]

langwatch_scenario-0.1.0/scenario/__init__.py

@@ -0,0 +1,26 @@
+"""
+Scenario: A testing library for conversational agents.
+"""
+
+# First import non-dependent modules
+from .result import ScenarioResult
+from .config import ScenarioConfig
+
+# Then import modules with dependencies
+from .testing_agent import TestingAgent
+from .scenario import Scenario
+from .cache import scenario_cache
+
+# Import pytest plugin components
+from .pytest_plugin import pytest_configure, scenario_reporter
+
+__all__ = [
+    "Scenario",
+    "TestingAgent",
+    "ScenarioResult",
+    "ScenarioConfig",
+    "pytest_configure",
+    "scenario_reporter",
+    "scenario_cache",
+]
+__version__ = "0.1.0"