elasticdash-sdk 0.1.2a2__py3-none-any.whl

elasticdash_sdk-0.1.2a2.dist-info/METADATA

@@ -0,0 +1,500 @@
+Metadata-Version: 2.4
+Name: elasticdash-sdk
+Version: 0.1.2a2
+Summary: Elasticdash AI test framework for Python
+Author-email: Elasticdash <contact@elasticdash.com>
+License-File: LICENSE
+Requires-Python: >=3.10
+Requires-Dist: aiohttp>=3.9
+Requires-Dist: click>=8.0
+Requires-Dist: httpx>=0.27
+Requires-Dist: python-dotenv>=1.0
+Provides-Extra: extras
+Requires-Dist: colorama>=0.4; extra == 'extras'
+Requires-Dist: requests>=2.32; extra == 'extras'
+Provides-Extra: observability
+Requires-Dist: python-socketio[asyncio-client]>=5.10; extra == 'observability'
+Provides-Extra: test
+Requires-Dist: pytest-asyncio>=0.23; extra == 'test'
+Requires-Dist: pytest>=7.4; extra == 'test'
+Requires-Dist: respx>=0.21; extra == 'test'
+Description-Content-Type: text/markdown
+
+# elasticdash_test
+
+An AI-native test runner for ElasticDash workflow testing. Built for async AI pipelines — not a general-purpose test runner.
+
+- Trace-first: every test receives a `ctx.trace` to record and assert on LLM calls and tool invocations
+- Automatic interception for OpenAI, Gemini, and Grok via `httpx`/`requests` — no manual instrumentation required
+- AI-specific matchers: `to_have_llm_step`, `to_call_tool`, `to_match_semantic_output`, `to_have_custom_step`, `to_have_prompt_where`, `to_evaluate_output_metric`
+- Sequential execution, no parallelism overhead
+- No pytest dependency
+
+---
+
+## Installation
+
+```bash
+pip install elasticdash_test
+```
+
+Requires Python 3.10+.
+
+---
+
+## Quick Start
+
+**1. Write a test file** (`my_flow.ai_test.py`):
+
+```python
+from elasticdash_test import ai_test, expect
+
+@ai_test("checkout flow")
+async def test_checkout(ctx):
+    await run_checkout(ctx)
+
+    expect(ctx.trace).to_have_llm_step(model="gpt-4o", contains="order confirmed")
+    expect(ctx.trace).to_call_tool("chargeCard")
+```
+
+**2. Run it:**
+
+```bash
+elasticdash test              # discover all *.ai_test.py files
+elasticdash test ./ai_tests   # discover in a specific directory
+elasticdash run my_flow.ai_test.py  # run a single file
+elasticdash dashboard         # open workflows dashboard
+```
+
+**3. Read the output:**
+
+```
+  ✓ checkout flow (1.2s)
+  ✗ refund flow (0.8s)
+    → Expected tool "chargeCard" to be called, but no tool calls were recorded
+
+2 passed
+1 failed
+Total: 3
+Duration: 3.4s
+```
+
+---
+
+## Writing Tests
+
+See the full guide in [docs/test-writing-guidelines.md](docs/test-writing-guidelines.md).
+
+### Decorators
+
+Import from `elasticdash_test` and apply to functions — no global injection needed:
+
+| Decorator | Description |
+|---|---|
+| `@ai_test(name)` | Register a test |
+| `@before_all` | Run once before all tests in the file |
+| `@before_each` | Run before every test in the file |
+| `@after_each` | Run after every test in the file (runs even if the test fails) |
+| `@after_all` | Run once after all tests in the file |
+
+### Test context
+
+Each test function receives a `ctx: AITestContext` argument:
+
+```python
+@ai_test("my test")
+async def test_my_flow(ctx):
+    # ctx.trace — record and inspect LLM steps and tool calls
+```
+
+### Recording trace data
+
+**Automatic interception (recommended):** Call `install_ai_interceptor()` once in `@before_all` and the runner patches `httpx`/`requests` to record LLM steps for OpenAI, Gemini, and Grok calls automatically. See [Automatic AI Interception](#automatic-ai-interception) below.
+
+**Manual recording:** Use this for providers not covered by the interceptor, when testing against stubs/mocks, or to capture custom workflow steps:
+
+```python
+ctx.trace.record_llm_step(
+    model="gpt-4o",
+    prompt="What is the order status?",
+    completion="The order has been confirmed.",
+)
+
+ctx.trace.record_tool_call(
+    name="chargeCard",
+    args={"amount": 99.99},
+)
+
+# Record custom workflow steps (RAG fetches, code/fixed steps, etc.)
+ctx.trace.record_custom_step(
+    kind="rag",              # 'rag' | 'code' | 'fixed' | 'custom'
+    name="pokemon-search",
+    tags=["sort:asc", "source:db"],
+    payload={"query": "pikachu attack"},
+    result={"ids": [25]},
+    metadata={"latency_ms": 120},
+)
+```
+
+### Matchers
+
+#### `to_have_llm_step(config?)`
+
+Assert the trace contains at least one LLM step matching the given config. All fields are optional and combined with AND logic.
+
+```python
+expect(ctx.trace).to_have_llm_step(model="gpt-4o")
+expect(ctx.trace).to_have_llm_step(contains="order confirmed")        # searches prompt + completion
+expect(ctx.trace).to_have_llm_step(prompt_contains="order status")    # searches prompt only
+expect(ctx.trace).to_have_llm_step(output_contains="order confirmed") # searches completion only
+expect(ctx.trace).to_have_llm_step(provider="openai")
+expect(ctx.trace).to_have_llm_step(provider="openai", prompt_contains="order status")
+expect(ctx.trace).to_have_llm_step(prompt_contains="retry", times=3)      # exactly 3 matching steps
+expect(ctx.trace).to_have_llm_step(provider="openai", min_times=2)        # at least 2 matching steps
+expect(ctx.trace).to_have_llm_step(output_contains="error", max_times=1)  # at most 1 matching step
+```
+
+| Field | Description |
+|---|---|
+| `model` | Exact model name match (e.g. `'gpt-4o'`) |
+| `contains` | Substring match across prompt + completion (case-insensitive) |
+| `prompt_contains` | Substring match in prompt only (case-insensitive) |
+| `output_contains` | Substring match in completion only (case-insensitive) |
+| `provider` | Provider name: `'openai'`, `'gemini'`, or `'grok'` |
+| `times` | Exact match count (fails unless exactly this many steps match) |
+| `min_times` | Minimum match count (steps matching must be ≥ this value) |
+| `max_times` | Maximum match count (steps matching must be ≤ this value) |
+
+#### `to_call_tool(tool_name)`
+
+Assert the trace contains a tool call with the given name.
+
+```python
+expect(ctx.trace).to_call_tool("chargeCard")
+```
+
+#### `to_match_semantic_output(expected, **options)`
+
+LLM-judged semantic match of combined LLM output vs. the expected string. Defaults to OpenAI GPT-4.1 with `OPENAI_API_KEY`.
+
+```python
+# Minimal, using default OpenAI model
+await expect(ctx.trace).to_match_semantic_output("order confirmed")
+
+# Use a different provider
+await expect(ctx.trace).to_match_semantic_output(
+    "attack stat",
+    provider="claude",
+    model="claude-3-opus-20240229",
+)
+
+# OpenAI-compatible endpoint (e.g., Moonshot/Kimi) via base_url + api_key
+await expect(ctx.trace).to_match_semantic_output(
+    "order confirmed",
+    provider="openai",
+    model="kimi-k2-turbo-preview",
+    api_key=os.environ["KIMI_API_KEY"],
+    base_url="https://api.moonshot.ai/v1",
+)
+```
+
+Environment keys by provider: `OPENAI_API_KEY`, `ANTHROPIC_API_KEY`, `GEMINI_API_KEY` (or `GOOGLE_API_KEY`), `GROK_API_KEY`.
+
+#### `to_evaluate_output_metric(config)`
+
+Evaluate one LLM step's prompt or result using an LLM and assert a numeric metric condition in the range 0.0–1.0. Defaults: target=`result`, condition=`at_least 0.7`, provider=`openai`, model=`gpt-4.1`.
+
+```python
+# Evaluate the last LLM result; default condition at_least 0.7
+await expect(ctx.trace).to_evaluate_output_metric(
+    evaluation_prompt="Rate how well this answers the user question.",
+)
+
+# Check a specific step (3rd LLM prompt), target the prompt text, require >= 0.8
+await expect(ctx.trace).to_evaluate_output_metric(
+    evaluation_prompt="Score coherence of this prompt between 0 and 1.",
+    target="prompt",
+    nth=3,
+    condition={"at_least": 0.8},
+    provider="claude",
+    model="claude-3-opus-20240229",
+)
+
+# Custom comparator: score must be < 0.3
+await expect(ctx.trace).to_evaluate_output_metric(
+    evaluation_prompt="Rate hallucination risk (0=none, 1=high).",
+    condition={"less_than": 0.3},
+)
+```
+
+Options:
+- `evaluation_prompt` (required): your scoring instructions; model is asked to return only a number between 0 and 1.
+- `target`: `'result'` (default) or `'prompt'`. Evaluates that text only.
+- `nth`: pick which LLM step to score (1-based). Defaults to the last LLM step.
+- `condition`: one of `greater_than`, `less_than`, `at_least`, `at_most`, `equals`; default is `{"at_least": 0.7}`. Fails if the score is outside 0.0–1.0 or cannot be parsed.
+- `provider` / `model` / `api_key` / `base_url`: supports OpenAI, Claude, Gemini, Grok, and OpenAI-compatible endpoints via `base_url`.
+
+#### `to_have_custom_step(config?)`
+
+Assert a recorded custom step (RAG/code/fixed/custom) matches filters.
+
+```python
+expect(ctx.trace).to_have_custom_step(kind="rag", name="pokemon-search")
+expect(ctx.trace).to_have_custom_step(tag="sort:asc")
+expect(ctx.trace).to_have_custom_step(contains="pikachu")
+expect(ctx.trace).to_have_custom_step(result_contains="25")
+expect(ctx.trace).to_have_custom_step(kind="rag", min_times=1, max_times=2)
+```
+
+#### `to_have_prompt_where(config)`
+
+Filter prompts, then assert additional constraints. Example: "all prompts containing A must also contain B".
+
+```python
+# Prompts that contain "order" must also contain "confirmed"
+expect(ctx.trace).to_have_prompt_where(filter_contains="order", require_contains="confirmed")
+
+# Prompts containing "retry" must NOT contain "cancel"
+expect(ctx.trace).to_have_prompt_where(filter_contains="retry", require_not_contains="cancel")
+
+# Control counts on the filtered subset
+expect(ctx.trace).to_have_prompt_where(
+    filter_contains="order",
+    require_contains="confirmed",
+    min_times=1,
+    max_times=3,
+)
+
+# Check a specific prompt position (1-based nth)
+expect(ctx.trace).to_have_prompt_where(
+    filter_contains="order",
+    require_contains="confirmed",
+    nth=3,  # the 3rd prompt among those containing "order"
+)
+```
+
+---
+
+## Automatic AI Interception
+
+Call `install_ai_interceptor()` in a `@before_all` hook and the runner patches `httpx` and `requests` before tests run, automatically recording LLM steps for:
+
+| Provider | Endpoints intercepted |
+|---|---|
+| **OpenAI** | `api.openai.com/v1/chat/completions`, `/v1/completions` |
+| **Gemini** | `generativelanguage.googleapis.com/.../models/...:generateContent` |
+| **Grok** (xAI) | `api.x.ai/v1/chat/completions` |
+
+Each intercepted call records `model`, `provider`, `prompt`, and `completion` into `ctx.trace` automatically. Your workflow code needs no changes.
+
+```python
+from elasticdash_test import ai_test, before_all, after_all, install_ai_interceptor, uninstall_ai_interceptor, expect
+
+@before_all
+def setup():
+    install_ai_interceptor()
+
+@after_all
+def teardown():
+    uninstall_ai_interceptor()
+
+@ai_test("user lookup flow")
+async def test_user_lookup(ctx):
+    # This makes a real OpenAI call — intercepted automatically
+    await my_workflow.run("Find all active users")
+
+    # Works without any ctx.trace.record_llm_step() in your workflow
+    expect(ctx.trace).to_have_llm_step(prompt_contains="Find all active users")
+    expect(ctx.trace).to_have_llm_step(provider="openai")
+```
+
+**Streaming:** When `stream=True` is set on a request, the completion is recorded as `"(streamed)"` — the prompt and model are still captured.
+
+### Recording trace steps without passing `ctx.trace` (contextvars)
+
+The runner sets a per-test `current_trace` using Python's `contextvars`, so your app code can record steps without threading `ctx.trace` through every function:
+
+```python
+# In your test
+from elasticdash_test import ai_test, set_current_trace, expect
+
+@ai_test("flow test")
+async def test_flow(ctx):
+    set_current_trace(ctx.trace)        # bind the trace to the current async context
+    await run_flow_without_trace_arg()  # your existing code
+    expect(ctx.trace).to_have_custom_step(kind="rag", name="pokemon-search")
+
+# In your app/flow code (called during the test)
+from elasticdash_test import get_current_trace
+
+async def run_flow_without_trace_arg():
+    trace = get_current_trace()
+    if trace:
+        trace.record_custom_step(
+            kind="rag",
+            name="pokemon-search",
+            payload={"query": "pikachu attack"},
+            result={"ids": [25]},
+            tags=["source:db", "sort:asc"],
+        )
+```
+
+---
+
+## Configuration
+
+Create an optional `elasticdash.config.py` at the project root:
+
+```python
+config = {
+    "test_match": ["**/*.ai_test.py"],
+    "trace_mode": "local",
+}
+```
+
+| Option | Default | Description |
+|---|---|---|
+| `test_match` | `['**/*.ai_test.py']` | Glob patterns for test discovery |
+| `trace_mode` | `'local'` | `'local'` (stub) or `'remote'` (future ElasticDash backend) |
+
+### `ed_agents.py`, `ed_workflows.py`, `ed_tools.py`
+
+These optional files are thin wrappers that bundle and re-export existing functions from your codebase. Load them automatically during test runs to provide agents, workflows, and tools to your test environment.
+
+#### `ed_agents.py`
+
+Re-export agent functions or create a config dict for easy reference:
+
+```python
+# ed_agents.py — import from your app
+from my_app.agents import checkout_agent, payment_agent
+
+config = {
+    "checkout": checkout_agent,
+    "payment": payment_agent,
+}
+```
+
+Access in tests:
+
+```python
+@ai_test("checkout flow")
+async def test_checkout(ctx, config):
+    agents = config.get("agents", {})
+    result = await agents["checkout"]("order-123")
+```
+
+#### `ed_workflows.py`
+
+Re-export workflow functions from your application:
+
+```python
+# ed_workflows.py
+from my_app.workflows import order_workflow, refund_workflow
+
+# Re-export directly — the runner will import this module
+```
+
+Access in tests:
+
+```python
+@ai_test("full order workflow")
+async def test_workflow(ctx):
+    from ed_workflows import order_workflow
+    result = await order_workflow("order-123", "cust-456")
+    expect(ctx.trace).to_call_tool("chargeCard")
+```
+
+#### `ed_tools.py`
+
+Re-export tool functions that agents or workflows can invoke:
+
+```python
+# ed_tools.py
+from my_app.tools import charge_card, fetch_order_status, send_notification
+```
+
+Access in tests or workflows:
+
+```python
+@ai_test("tool integration")
+async def test_tools(ctx):
+    from ed_tools import fetch_order_status
+    status = await fetch_order_status("order-123")
+    expect(ctx.trace).to_have_custom_step(kind="external", name="fetch_order_status")
+```
+
+These files are loaded automatically if present in the project root.
+
+## Workflows Dashboard
+
+Browse and search all available workflow functions in your project:
+
+```bash
+elasticdash dashboard         # open dashboard at http://localhost:4573
+elasticdash dashboard --port 4572  # use custom port
+elasticdash dashboard --no-open    # skip auto-opening browser
+```
+
+The dashboard scans `ed_workflows.py` and displays:
+- **Function names** — all callable functions in the module
+- **Signatures** — function parameters and return types
+- **Async indicator** — marks async vs sync functions
+- **Source module** — where the function is imported from (if not locally defined)
+- **File path** — location of `ed_workflows.py`
+
+Use the search field to filter workflows by:
+- **Name** — find workflow by function name (e.g., `checkout_flow`)
+- **Source module** — find all workflows from a specific module (e.g., `app_workflows`)
+- **File path** — filter by location in your codebase
+
+This is useful for discovering available workflows, understanding their signatures, and identifying where functions are defined before calling them in tests.
+
+## Project Structure
+
+```
+elasticdash_test/
+  cli.py                CLI entry point (click + glob)
+  runner.py             Sequential test runner engine
+  reporter.py           Color-coded terminal output
+  registry.py           ai_test / before_all / after_all registry
+  trace.py              TraceHandle, AITestContext, contextvars support
+  matchers.py           Custom expect matchers
+  interceptors/
+    ai_interceptor.py   Automatic httpx/requests interceptor for OpenAI / Gemini / Grok
+```
+
+---
+
+## Programmatic API
+
+```python
+from elasticdash_test import install_ai_interceptor, uninstall_ai_interceptor
+from elasticdash_test.runner import run_files
+from elasticdash_test.reporter import print_results
+
+install_ai_interceptor()  # patch httpx/requests for automatic LLM tracing
+
+results = await run_files(["./tests/flow.ai_test.py"])
+print_results(results)
+
+uninstall_ai_interceptor()  # restore original transports when done
+```
+
+---
+
+## Non-Goals
+
+This runner intentionally does not support:
+
+- Parallel execution
+- Watch mode
+- Snapshot testing
+- Coverage reporting
+- pytest compatibility
+
+---
+
+## License
+
+MIT

elasticdash_sdk-0.1.2a2.dist-info/RECORD

@@ -0,0 +1,66 @@
+elasticdash_test/__init__.py,sha256=-NioHH3beMyZtbZjRIDu-R9N4IgwsZLE7rdUmsahA1c,834
+elasticdash_test/browser_ui.py,sha256=GawLSFIoEDJYDx_EVVZERgSbyntN1nKaJl81kLg9GoA,6483
+elasticdash_test/cli.py,sha256=WL1LVTycrv1QCvwpvdsUxztal2Mzz_aTft6ig8XdQ9E,16992
+elasticdash_test/dashboard.py,sha256=tCynZF3EguNu5l6sM4hSFt4NtJz_ld9EfYlpr5VVcbY,38542
+elasticdash_test/matchers.py,sha256=dKlnzKDhnL79x2eY32rqyf8__Vs6-WcZtM25HJ-T0jA,12908
+elasticdash_test/observability.py,sha256=QnPz2wgcLkgIViNFt_8uZZvTSKFKBAsieAA7qjJJocI,6734
+elasticdash_test/portal_executor.py,sha256=NcaYL8cFCTjQwk0KuoKr7AYzdDOOY91iE8ObPyprbWM,9667
+elasticdash_test/portal_server.py,sha256=zEVSBmBCRk5aPymMXYC1Qyk3RR-Bb2GHzKYJTZlsqfI,6258
+elasticdash_test/registry.py,sha256=GJ7g4F7wxrWhzCcgHJdV8NWVmdejVzV8zilYEHPF34c,3374
+elasticdash_test/reporter.py,sha256=w1YZMUz68le3sSafcNnpzDVTTXERV9qNmXxPKK0NnlA,2651
+elasticdash_test/runner.py,sha256=ps7y-dNaFZggwI_xEHPEKwzy1D2aXdYV4xoAQCrW74A,4096
+elasticdash_test/socket_connector.py,sha256=1kZDSsU4dL8CIs6k9Rzhuj0Yy2MoYdi92Ii-nJw-Mr0,2642
+elasticdash_test/telemetry_batcher.py,sha256=mbvcU0V-pmxMgPlvzBeasTVyZN6S4VeZ3xVpsY_80q8,6720
+elasticdash_test/tool_registry.py,sha256=RviGd-NtkeAhgN4253S0Wb7Pyfclbs8uZ6c-zsuHnZQ,3157
+elasticdash_test/trace.py,sha256=e7eo4FW6_QKqcg-Qrd3F1biC6xuzWu4zSzJLTuRIy-4,2403
+elasticdash_test/tracing.py,sha256=ga5eU7Sq9P_bovbQIjqbmCvLpIjQu9stJM03zXIWNB0,1342
+elasticdash_test/trigger_executor.py,sha256=xugvTyT2daWKmcia_Tf-Sfag8HYYdSgsoFOQsthzIUg,3530
+elasticdash_test/workflow_runner.py,sha256=xaeP2CAhI1V39LG-KCeZGidI6vnsJXYMD-5OZxoteIM,2354
+elasticdash_test/capture/__init__.py,sha256=n6Zf778m0uUvCvAJYt4f6JOHjsGb-ROXrOoCznFP6y0,409
+elasticdash_test/capture/event.py,sha256=G2Xf_LTYzJb-eZPik3mkSzwVY_lg1wiEx7E-HOAZ01o,953
+elasticdash_test/capture/recorder.py,sha256=5FrwtjevmLYJdeo_6cfxLqJCJowNDFFLh4oirdnr2T0,2609
+elasticdash_test/capture/replay.py,sha256=OfGLvqNcoQjPSLqPgK4b6NjyifH3mLiS6BeB_5PlqNQ,2673
+elasticdash_test/ci/__init__.py,sha256=HKqcnFkRLMK33tL99jZcQ1yPOYksl7OotGn46C6X0xM,510
+elasticdash_test/ci/api_client.py,sha256=GC5yEcfuVSFbKWZVxwiqSQ0uqqFm3HRhjmOYFC3rXK8,4132
+elasticdash_test/ci/benchmark.py,sha256=-uv_uF9RFTdtENvoAtmp5a0ha-TioewBkOSmPCh3V9I,7352
+elasticdash_test/ci/ed_runner.py,sha256=GJjfbFDE9roqTKO28nGBdcsUs0VfwPIqaGNFGPm5Ogk,6295
+elasticdash_test/ci/executor.py,sha256=Td2E4vUB-PHA9XHD7J_-EsJaBWSSpNjeg3HfRrOUbYw,13088
+elasticdash_test/ci/git_info.py,sha256=5dQpZ2snFV3hp8uC02hDy25GI4l6DfbPj256RkeYg00,4228
+elasticdash_test/ci/measurement.py,sha256=lWOPQhO7rdGge1LnSG8Bga3SL2d0ERB_tMq264xc0hA,651
+elasticdash_test/ci/replay.py,sha256=qIQY29ok2g__82gCwaJMMnEprG2p8WiUlGrnLa9w8Ls,3009
+elasticdash_test/ci/runner.py,sha256=NVJ7bdAxQjGyjKo8OVZMIDnLrAOd4PJmLqkAhILEQC0,4163
+elasticdash_test/ci/test_discovery.py,sha256=ymxtZcR-IV2NTb1mbDAVG_UuCKVoImGIhgnLO9FFFYE,759
+elasticdash_test/ci/test_loader.py,sha256=RcIBu6qv6LBQHFhImv8C7soU4bRpOeEZ0O8paIEWMmM,3287
+elasticdash_test/ci/test_registry.py,sha256=gMEcIacMFoIOceEiVpZI3aR0Kh1JGbVakuD_SG36tLo,913
+elasticdash_test/ci/trace_schema.py,sha256=CD6i2zYEwpk-dhJUVYFWx6A-iCQs2Dafq0t4wbmdRHA,2614
+elasticdash_test/ci/trace_writer.py,sha256=ZUMluX8pXqSEUyQTS-LHgSeZfAov8u5Pkuf1skp6VL0,1319
+elasticdash_test/ci/types.py,sha256=rSdtQ96U0eYks0BbT5QhIXk6afa1z8jHudLUinFn6Dw,4864
+elasticdash_test/ci/upload_client.py,sha256=xtGAKkKt82UXMNFNg1M7mgqy9NkKUiarIimeiuL8Kp0,4064
+elasticdash_test/ci/reporters/__init__.py,sha256=xIobkO-GXwu_ZblgSo-DDM9-i3mgTRy_QWhL1XELMY4,856
+elasticdash_test/ci/reporters/default.py,sha256=zeidIOhJocjBZNHiOzBM0MkFgK8fPB4VjhUAuRsPZoM,1423
+elasticdash_test/ci/reporters/json_reporter.py,sha256=-hSS9Ni4P_gJDnVc9UU6k0fLUSQE2u7KbYMZ6rE5Sfc,612
+elasticdash_test/ci/reporters/junit.py,sha256=hK3CE63SlF2yjca3VlljgUu7zLijcjN9fdywfxIu_Ac,1613
+elasticdash_test/core/__init__.py,sha256=UPh2la5hMoc41Cplqu5Vkp3eMAaOx1tH9SB2ZXArgpA,541
+elasticdash_test/core/agent_state.py,sha256=AKaeHcqDrFmP1TWLOG4YZtuEdvc_jD4rB4YgvgWVQM4,5697
+elasticdash_test/core/judge_utils.py,sha256=H480cIvvAKkpHLIEdgMTP2Vwzyq_7Kc9CVpiSM-1D4c,6591
+elasticdash_test/execution/__init__.py,sha256=MHsJ6WAP3TTxZSsx0BQ3AtKsySoONYQPOuMAs-H00R4,392
+elasticdash_test/execution/tool_runner.py,sha256=fbpEHBsdle0D9un7MJGvQDNVPLkdz1k6KqYg2tsEoVs,6807
+elasticdash_test/interceptors/__init__.py,sha256=8Ik3Nvoi0XWSko3_I6XPdR_SZfx1Ot72ovk_n2GNo2w,1764
+elasticdash_test/interceptors/ai_interceptor.py,sha256=he11MK5cpMPtpVrHRaLyqgXTet7hiSub7GMw6HxliLA,16821
+elasticdash_test/interceptors/db.py,sha256=rs66SOYNsCyJk5wCJCVOGFohPHVGVJeKWDIBZHyizfY,6764
+elasticdash_test/interceptors/db_auto.py,sha256=EvjVAmUSsmiGCz5bH0ul9T5h5_Rcjgg-QoMM7Sa94Fw,5881
+elasticdash_test/interceptors/http.py,sha256=yjKxAlky0dEpQZ6RrTAtRuTVrrGfInsV4Lfy8N-jONA,8112
+elasticdash_test/interceptors/side_effects.py,sha256=USOOJiNt645EY53lWKblX2iEFogmqbUHA_5xrch_aQk,4294
+elasticdash_test/interceptors/telemetry_push.py,sha256=arNXp5KjfSfUbwtWh1N1p15427ndElVuOjffCEurMJU,6971
+elasticdash_test/interceptors/tool.py,sha256=KzjhpgEHiGAdgl5n7VSOxqf_NPhTlI2lYQlCazVxHAM,6649
+elasticdash_test/interceptors/workflow_ai.py,sha256=cDYl1vfjh1TmXEvc6ti38yQK7GBtVSwks4zYB6o-pVU,6200
+elasticdash_test/proxy/__init__.py,sha256=8nL8R5kEg2K4Wbb_X_rEWEZAyFjaQPdkZ50OECWGaYU,176
+elasticdash_test/proxy/llm_capture.py,sha256=0hFkuuLoZbPaMrLT997c5-MjSzbkmm5jDszt12PfhN8,6030
+elasticdash_test/utils/__init__.py,sha256=aHhNPw0ecJ58ZpuAOZYQ5T0k2BpPE2tb4DTioTrlv4M,178
+elasticdash_test/utils/debug.py,sha256=gLmOg9tJl-6Q6hwmahcvQXidJBH_pIiAY2j1R_-K3m8,886
+elasticdash_test/utils/redact.py,sha256=NVfrqiwU8jM7Dk7U886na9mceX0EVTzb2woaZUUZ4oc,1147
+elasticdash_sdk-0.1.2a2.dist-info/METADATA,sha256=ggbn1583f6tQijRNpxY_IcpjfxISKVM972UzhnMfWwQ,16301
+elasticdash_sdk-0.1.2a2.dist-info/WHEEL,sha256=QccIxa26bgl1E6uMy58deGWi-0aeIkkangHcxk2kWfw,87
+elasticdash_sdk-0.1.2a2.dist-info/entry_points.txt,sha256=Qd-5AP5vimmIVpUlmzHz4Itg24Cvu3ztTBhcHMmRm6g,58
+elasticdash_sdk-0.1.2a2.dist-info/licenses/LICENSE,sha256=1mOjzaqLsqw8szofGZHOx-Z6pNvBAKoJUNaHeA7XZ3I,1068
+elasticdash_sdk-0.1.2a2.dist-info/RECORD,,

elasticdash_sdk-0.1.2a2.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.29.0
+Root-Is-Purelib: true
+Tag: py3-none-any

elasticdash_sdk-0.1.2a2.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+elasticdash = elasticdash_test.cli:main

elasticdash_sdk-0.1.2a2.dist-info/licenses/LICENSE

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

elasticdash_test/__init__.py

@@ -0,0 +1,36 @@
+"""Elasticdash AI test framework Python port."""
+
+from .registry import ai_test, before_all, after_all, before_each, after_each, clear_registry, get_registry
+from .matchers import expect
+from .trace import (
+    LLMStep,
+    ToolCall,
+    CustomStep,
+    TraceHandle,
+    AITestContext,
+    set_current_trace,
+    get_current_trace,
+)
+from .interceptors.ai_interceptor import install_ai_interceptor, uninstall_ai_interceptor
+from .tool_registry import ed_tool
+
+__all__ = [
+    "ai_test",
+    "before_all",
+    "after_all",
+    "before_each",
+    "after_each",
+    "expect",
+    "LLMStep",
+    "ToolCall",
+    "CustomStep",
+    "TraceHandle",
+    "AITestContext",
+    "set_current_trace",
+    "get_current_trace",
+    "install_ai_interceptor",
+    "uninstall_ai_interceptor",
+    "clear_registry",
+    "get_registry",
+    "ed_tool",
+]